Votre défi est simple: écrire tant d'un programme vierge que possible dans la langue de votre choix en utilisant uniquement les octets uniques. (La définition complète d'un programme vierge, copiée à partir de ce lien, se trouve au bas de cette question.)

C'est vrai, sans aucune condition. Votre code n'a rien à faire, il suffit de l'exécuter sans erreur, de répondre aux exigences d'un programme vierge (lié ci-dessus) et d'inclure aucun octet en double dans le codage que vous utilisez.

Aux fins de l'explication ci-dessus et de la définition associée de «programme vierge», une erreur est définie comme tout ce qui empêche le programme de s'exécuter complètement ou de se terminer par un code de sortie non nul après un laps de temps déterminé.

Comme il s'agit d'un code bowling , le code le plus long , pas le plus court, est gagné (mesuré par le nombre d'octets). Le score maximal théoriquement possible est de 256, car il y a 256 octets distincts possibles. En cas d'égalité, la première réponse au score le plus élevé l'emporte.

Voici la définition complète d'un programme vierge, copiée à partir du lien ci-dessus:

Définissons un programme vierge comme un programme qui ne contient aucune erreur, mais qui commettra une erreur si vous le modifiez en supprimant toute sous-chaîne contiguë de N caractères, où 1 <= N < program length.

Par exemple, le programme Python 2 à trois caractères

`8`

est un programme vierge car tous les programmes résultant de la suppression de sous-chaînes de longueur 1 provoquent des erreurs (les erreurs de syntaxe en fait, mais tout type d'erreur suffira):

8`
``
`8

ainsi que tous les programmes résultant de la suppression de sous-chaînes de longueur 2 provoquent des erreurs:

`
`

Si, par exemple, `8il s’agissait d’un programme `8`ne faisant pas d’ erreur, il ne serait pas parfait, car tous les résultats de la suppression de la sous-chaîne doivent être erronés.

Gelée , 253 254 256 octets

M“¢£¥¦©¬®µ½¿€ÆÇÐÑ×ØŒÞßæçðıȷñ÷øœþ !"#%&'()*+,-./0145689:;<=>?@ABCDEFGHIJKNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|~¶°¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḤỊḲḶṂṆỌṚṢṬỤṾẈỴẒȦḂĊḊĖḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż”L»«’Ɗạ‘}237$¤¡

Essayez-le en ligne! ou le vérifier!

Il s'avère que les langues de golf peuvent jouer ...

• +1 octet en travaillant dans ‘. Maintenant seulement ne «»sont pas utilisés
• +2 octets avec avec «». Maintenant, avoir le score optimal!

Comment?

La caractéristique cruciale de Jelly qui rend cela possible est que les caractères d'ouverture et de fermeture des littéraux de chaîne ne sont pas les mêmes que dans presque toutes les autres langues.

La structure du programme est la suivante:

M <239 character long string> L»«’Ɗạ‘}237$¤¡

Mtrouve les indices de son argument qui pointent vers des éléments maximaux. Tout ce qui compte, c’est que, sans argument, Jelly attribue 0à la chaîne les erreurs chaîne et Jelly lorsqu’il Mest appliqué 0.

Pour éviter Md’agir 0dans le programme complet, nous utilisons le ¡rapide, qui applique Mun nombre de fois déterminé par le résultat du lien le précédant immédiatement. Dans ce cas, ce lien est <239 character long string> L»«’Ɗạ‘}237$¤.

Lprend la longueur de cette chaîne (239) et la »«’Ɗdécrémente en 238. La »«partie ne fait rien sauf Ɗ(les trois derniers liens en tant que monade) font en sorte que s'ils sont supprimés, une erreur se produise. Prend ensuite ạla différence absolue entre le résultat de »«’Ɗet la monade ‘}237$appliquée à la chaîne. ‘incrémente et est une monade, mais le }transforme en une dyade et l’applique à son bon argument 237, cédant 238. Ainsi, les ạrendements 0dans le programme complet.

¤renvoie au littéral de chaîne formant un nilad. Le résultat de ceci est 0, donc Mn'est pas appliqué du tout, empêchant toute erreur.

Sous-programmes possibles:

• Si une partie de la chaîne est supprimée, <string>..¤sera différente de zéro et sera Mappliquée 0, provoquant une erreur.
• Si une partie de L»«’Ɗạ‘}237$est supprimée, elle Msera appliquée 0ou il y aura des opérations entre la chaîne et un nombre, ce qui entraînera un TypeError.
• Si l'un des éléments ¤¡est supprimé, Mest appliqué à 0.
• Si le caractère de fermeture de la chaîne ”et les deux ’‘sont supprimés et “ne le sont pas, tout Mse transformera ensuite en une chaîne, de manière à Magir 0.
  • Si la chaîne ferme le caractère ”et ’est supprimée et “ne disparaît pas, tout se trouve entre ”et ‘se transforme en une liste d'entiers.
• Si Mseul est supprimé, il y a un EOFErrorcar ¡attend un lien avant le nilad précédent.
• Si M“et un nombre quelconque de caractères après sa suppression, il y en aura un EOFErrorcar la ¤recherche d'un nilad le précédant mais n'en trouve pas. 238ne compte pas car il fait partie d'une monade.

Cela couvre à peu près tout.

Je n'avais pas utilisé auparavant, «»‘car les deux derniers ne peuvent pas être inclus dans la chaîne, car ils correspondent au “caractère pour former des éléments autres que des chaînes. «ne peut pas être dans une “”chaîne non plus mais je ne sais pas pourquoi.

Haskell , 39 45 50 52 60 octets

main=do{(\𤶸	陸 ⵙ商ߜ 新->pure fst)LT
EQ[]3
2$1}

L'identifiant maindoit avoir un type IO apour un type a. Lorsque le programme est exécuté, le calcul mainest effectué et son résultat est ignoré. Dans ce cas, son type est IO ((a,b)->a).

Le résultat est une application de la fonction (λ a b c d e f → return fst), une fonction constante à six arguments renvoyant la fonction fst (qui donne le premier élément d'un tuple à 2), injectée dans la monade IO. Les six arguments sont LT(ENUM pour moins), EQ(ENUM pour l' égalité), liste vide [], 3, 2et 1.

Quels seraient les espaces sont remplacés par des caractères uniques qui comptent comme des espaces: une tabulation, un espace insécable, un saut de page, une tabulation verticale, OGHAM SPACE MARK, une espace normal, une nouvelle ligne et un retour à la ligne. Si l'un de ces éléments manque, le nombre d'arguments sera différent. Les noms de paramètre sont choisis en tant que caractères UTF-8 à trois ou quatre octets 𤶸陸ⵙ商ߜ新, en choisissant avec soin les caractères qui ne génèrent pas d'octets en double.

Merci à @BMO pour ses précieuses contributions.

Décharge Hex:

00000000: 6d61 696e 3d64 6f7b 285c f0a4 b6b8 09ef  main=do{(\......
00000010: a793 c2a0 e2b5 990c e595 860b df9c e19a  ................
00000020: 80e6 96b0 2d3e 7075 7265 2066 7374 294c  ....->pure fst)L
00000030: 540a 4551 5b5d 330d 3224 317d            T.EQ[]3.2$1}

Essayez-le en ligne!

Python 2 ,  20 21 33 39 45  50 octets

Maintenant, un effort de collaboration!

+2 grâce à Aidan F. Pierce (remplace sorted({0})par map(long,{0}))

+8 grâce à dylnan (utilisation de \et newline pour remplacer l’espace; suggestions pour passer d’ 0une expression mathématique -1à la place de -True; utilisation de; utilisation d’hexadécimal)

+11 grâce à Angs ( 4*23+~91-> ~4836+9*1075/2puis plus tard ~197836254+0xbCABdDF-> ~875+0xDEAdFBCbc%1439/2*6)

if\
map(long,{~875+0xDEAdFBCbc%1439/2*6})[-True]:q

Essayez-le en ligne! Ou voir la suite de confirmation

0xDEAdFBCbcest hexadécimal et est évalué à 59775106236.
~est un complément binaire pour être ~875évalué -876.
%est l'opérateur modulo pour être 0xDEAdFBCbc%1439évalué à 293.
/est la division entière alors 0xDEAdFBCbc%1439/2évalue à 146.
*est la multiplication alors xDEAdFBCbc%1439/2*6évalue à 876.
+est l'addition alors ~875+xDEAdFBCbc%1439/2*6évalue à 0.
... aucune version dépouillée n'évalue également 0.

{0}est un setcontenant un seul élément, 0.

L'appel sortedavec a setcomme argument donne une liste, qui peut être indexée avec [...].

Sans pour autant sorted le code, on ({0})obtiendrait simplement le setet cela ne pourrait pas être indexé de la même manière, if({0})[-True]:qcela augmenterait un TypeError.

L'indexation en Python est basée sur 0 et permet une indexation négative à partir de l'arrière et Trueest équivalente à 1, sorted({0})[-True]trouve donc l'élément0 , tandis que la syntaxe sorted({0})[True]sera générée IndexErrorcomme elle le sera sorted({})[-True]et sorted({0})[]est invalide.

le 0 qui se trouve est falsey donc le corps de la if, qn'est jamais exécuté, mais il risquerait de lever un NameErrordepuis car il qn'a pas été défini.

Puisqu'une liste non vide est la vérité, nous ne pouvons pas réduire à l'un if[-1]:qou à l' autre.

Voir la suite de confirmation pour voir: confirmation que les octets sont uniques; toutes les erreurs; et le succès du code lui-même.

C (tcc) , x86_64, 29 31 33 39 40 octets

main[]={(23*8),-~0xABEDFCfebdc%95674+1};

Retourne 0 . Merci à @feersum pour avoir suggéré les chiffres hexadécimaux majuscules.

Essayez-le en ligne!

Comment ça fonctionne

L'affectation écrit deux ints ( 184 et 49664 ) dans l'emplacement de mémoire de main . Avec les bits 32 bits et l’ordre des octets little-endian, les octets exacts sontb8 00 00 00 00 c2 00 00 .

Puisque tcc ne déclare pas le tableau défini en tant que .data (la plupart des compilateurs le feraient), le fait de sauter à main exécute le code machine vers lequel il pointe.

• b8 00 00 00 00( mov eax, imm32) enregistre l'int 0 dans le registre eax.

• c2 00 00( ret imm16) supprime 0 octet supplémentaire de la pile et retourne. (La valeur dans le registre eax est la valeur de retour de la fonction).

> <> , 122 octets

e"~l=?!z6-d0p}xwutsrqonmkjihgfcba`_]\[>ZYXWVUTSRQPONMLKJIHGFEDCB@<:98754321/,+*)('&%$# .	|{Ay

Essayez-le en ligne!

Ne fait rien. Basé sur le même format que celui de ma réponse Programmer un monde vierge.

Premièrement, nous vérifions que la longueur du code est 122 et une erreur si ce n’est pas le cas. ><>les programmes ne peuvent pas se terminer sans l'utilisation de la ;commande, mais si cette commande est dans le programme, nous pouvons simplement supprimer tout ce qui la précède pour que le programme se termine immédiatement. Pour lutter contre cela, nous utilisons la pcommande pour placer un ;dans le code pendant l'exécution. Pour ce faire, on soustrait 6 de Aet on le place après le p.

J'ajouterai probablement la plupart des autres valeurs supérieures à 127 une fois les valeurs correctes sur deux octets. Les 5 valeurs manquantes sont v^;et les deux nouvelles lignes.

Parmi les 7502 sous-programmes, 7417 d'entre eux sont erronés à partir d'instructions non valides, 72 à partir de mémoire insuffisante et 13 à court de mémoire.

JavaScript, 42 octets

if([0XacdCADE*Proxy.length]!=362517948)田

• Enlever i, fou ifva causer SyntaxError: missing ; before statement;
• Enlever 田va causer SyntaxError: expected expression, got end of script;
• La suppression de 1 ou 2 octets 田causera Invalid or unexpected token;
• Modifier l’expression booléenne provoquera une erreur de syntaxe ou une erreur de référence le 田

00000000: 6966 285b 3058 6163 6443 4144 452a 5072  if([0XacdCADE*Pr
00000010: 6f78 792e 6c65 6e67 7468 5d21 3d33 3632  oxy.length]!=362
00000020: 3531 3739 3438 29e7 94b0                 517948)...

(function () {
  let valid = code => { try { eval(code); return true; } catch (e) { return false; } };
  let test = P => {
    for (let i = 0; i < P.length; i++) for (j = i + 1; j <= P.length; j++) {
      let Q = P.slice(0,i) + P.slice(j);
      if (Q && valid(Q)) {
        console.log(Q);
        return false;
      }
    }
    return true;
  };
  let unique = P => !/(.).*\1/.test(P);
  let P = 'if([0XacdCADE*Proxy.length]!=362517948)田';
  console.log(unescape(encodeURIComponent(P)).length);
  console.log(valid(P));
  console.log(unique(P));
  console.log(test(P));  
}());

Brain-Flak , 2 octets

<>

Essayez-le en ligne!

Alternativement [], {}ou (). Si vous enlevez un support, l’autre support devient inégalé.

Preuve qu'il s'agit de la solution optimale:

Un programme Brain-Flak est constitué de nilads (une paire de crochets isolés) ou de monades (une paire de crochets contenant un ou plusieurs nilads). Une monade ne peut pas être dans un programme vierge, vous pouvez simplement supprimer un ou plusieurs nilads. De même, vous ne pouvez pas avoir plus d'un nilad dans le programme, car vous pouvez en supprimer un sans casser le programme.

En tant que tel, cela pourrait être le langage le moins optimal pour une programmation vierge ou unique.

Ada, 110 octets (latin1)

Probablement la meilleure réponse que vous puissiez tirer de n’importe quelle langue utilisée dans l’industrie?

Hexdump:

0000000: 7061 636b 4167 4520 6266 686a 6c6d 6f71  packAgE bfhjlmoq
0000010: 7274 7576 7778 797a e0e1 e2e3 e4e5 e6e7  rtuvwxyz........
0000020: e8e9 eaeb eced eeef f0f1 f2f3 f4f5 f6f8  ................
0000030: f9fa fbfc fdfe 0d69 730b 656e 6409 4246  .......is.end.BF
0000040: 484a 4c4d 4f51 5254 5556 5758 595a c0c1  HJLMOQRTUVWXYZ..
0000050: c2c3 c4c5 c6c7 c8c9 cacb cccd cecf d0d1  ................
0000060: d2d3 d4d5 d6d8 d9da dbdc ddde 3b0a       ............;.

Compiler en enregistrant dans n'importe quel fichier se terminant .adset en cours d'exécution gcc -c <filename>. Produit un exécutable qui ne fait rien. (Impossible de fournir le lien TIO car TIO place le code dans un .adbfichier et gcctente par défaut de trouver une spécification correspondante pour celui-ci.)

Déclare fondamentalement un paquet avec un nom abusant des lettres majuscules / minuscules latines1. Nécessite un caractère d'espacement différent pour chacun des espaces. Par conséquent, il utilise les espaces, CR, LF et TAB.

A quoi ça ressemble dans la version vim:

packAgE bfhjlmoqrtuvwxyzàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþ^Mis^Kend^IBFHJLMOQRTUVWXYZÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ;

Comment ça fonctionne

Dans Ada, même les spécifications peuvent être compilées. Les spécifications ressemblent aux fichiers d’en-tête de c, mais sont plus complètes et peuvent compiler du code de base. Pour être valide, toute spécification doit avoir le format: package <NAME> is ... end <NAME>;avec <NAME>correspondance. La bonne chose à propos de Ada est qu’il est totalement insensible à la casse. Ainsi, tant que votre nom contient des variantes majuscules et minuscules, vous serez prêt à partir!

La partie difficile devenait une unité compilable. Normalement, les programmes Ada ont une procédure ou une fonction "principale" se trouvant en dehors de tout paquet qui deviendra l'exécutable final. Malheureusement, les procédures requièrent le beginmot - clé, ce qui entraîne trop de es (deux cas seulement sont connus), tandis que les fonctions requièrent le returnmot - clé, ce qui conduit à trop de ns. Je devais donc juste compiler un paquet.

C, 8 octets

main(){}

Ne fait rien.

Essayez-le en ligne!

JavaScript, 22 octets

with(0xF?JSON:[])parse

Essayez-le en ligne!

Erreurs possibles

Une fois modifié, il générera l'une des erreurs suivantes ¹ :

[some_identifier] is not defined
expected expression, got ')'
expected expression, got ':'
expected expression, got '?'
expected expression, got ']'
expected expression, got end of script
identifier starts immediately after numeric literal
missing ( before with-statement object
missing ) after with-statement object
missing : in conditional expression
missing ] after element list
missing exponent
missing hexadecimal digits after '0x'
missing octal digits after '0o'
unexpected token: ')'
unexpected token: ']'
unexpected token: identifier

_{1. Le nombre exact d’erreurs distinctes dépend du moteur. Cette liste a été générée avec SpiderMonkey (Firefox).}

Python 3 + Flask-Env , 7 13 14 17 octets

import\
flask_env

Pas de TIO car il n'en a pas flask-env.

Vous importavez trouvé le nom de module le plus long qui n'a pas d'intersection ni de numéro à la fin du nom. _sha256est plus long mais 256seul ne fait pas d'erreur. J'ai trouvé une bibliothèque, b3j0f.syncc'est un octet de plus mais je ne pouvais pas l'importer correctement.

• +1 octet en remplaçant un espace après importavec \<newline>. Supprimer l'une ou les deux provoque une erreur.

Il y a peut-être encore des options plus longues que flask_env, je n'ai pas vraiment fait de recherche exhaustive, mais j'ai parcouru environ 70 000 modules. Ouvert aux suggestions.

R , 14 octets

(Sys.readlink)

Essayez-le en ligne!

Cela peut être le plus long possible dans R. L'appel de toute fonction est voué à l'échec, car vous pourriez tout supprimer sauf le nom de la fonction, ce qui entraînerait simplement l'impression du code source de la fonction. Il s’agit de l’objet nommé le plus long de la configuration R par défaut, sans caractères en double ni nom d’objet lors de la suppression des caractères contigus.

Ce premier essai n'a pas fonctionné, mais j'ai beaucoup appris en essayant!

dontCheck({family;NROW})

Perl 5, 3 octets

y=>

=>est la "grosse virgule", qui cite le mot simple à gauche. Donc, cela équivaut à

"y",

qui ne fait rien.

Sans la grosse virgule, y l’opérateur de translittération est invalide sans que trois caractères identiques ne se répètent plus tard.

La grosse virgule seule est également invalide, telle quelle =et >seule.

brainfuck , 2 octets

[]

Essayez-le en ligne!

Inspiré par la réponse Brain-Flak de Jo King . Ceci est optimal car la seule erreur de brainfuck réside dans des parenthèses incomparables. (Encore merci à Jo King pour cette info.)

Ruby , 28 octets

(?2*0xA)[%r<\d{1}>].unpack$/

Essayez-le en ligne!

Vérifiez le!

ML standard , 22 octets

val 1089=op-(765,~324)

Essayez-le en ligne! op-(a,b)est la forme décapée de a-b. ~dénote le moins unaire, donc nous calculons réellement 765+324. Cette expression correspond à un motif sur la constante 1089. Cette correspondance réussit si le programme n'a pas été falsifié et le fait - eh bien, rien.

Si la correspondance échoue parce que certains chiffres ont été supprimés, on obtient un unhandled exception: Bind. La suppression des op-résultats entraîne une erreur de type car un tuple est associé à un int. Toutes les autres suppressions doivent entraîner une erreur de syntaxe.

Swift 4 , 19 octets

[].contains{1 !=
0}

Essayez-le en ligne!

Toutes les erreurs possibles que j'ai trouvées sont:

• Suppression de l' une des [, ], {ou }entraînera une erreur de syntaxe
• Enlever [].aura comme conséquenceUse of unresolved identifier 'contains'
• Enlever .aura comme conséquenceConsecutive statements on a line must be separated by ';'
• Enlever []aura comme conséquenceReference to member 'contains' cannot be resolved without a contextual type
• Enlever {1 !=␊0}aura comme conséquenceExpression resolves to an unused function
• Enlever 1 !=␊0aura comme conséquenceMissing return in a closure expected to return 'Bool'
  • La suppression de la nouvelle ligne entraînera '!=' is not a prefix unary operator
  • Supprimer l’espace entraînera '=' must have consistent whitespace on both sides
  • Enlever !=aura comme conséquenceMissing return in a closure expected to return 'Bool'
    • Si vous supprimez également la nouvelle ligne, vous obtiendrez Consecutive statements on a line must be separated by ';'
    • Si vous supprimez l’espace et la nouvelle ligne (et zéro ou l’un des chiffres), Contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored
• Enlever [].containsaura comme conséquenceClosure expression is unused

Quelques autres programmes intéressants sont (un sur chaque ligne):

[].isEmpty
[:].values
[1:2]

Tcl , 6 octets

puts a

Essayez-le en ligne!

pwd

Essayez-le en ligne!

cd

Essayez-le en ligne!

Lot, 7 octets

set/px=

Un bon début

Rétine , 2 octets

Je ne serais pas surpris si cela est optimal ...

()

Essayez-le en ligne!

La regex contient un groupe vide. La suppression de l'un des parens provoquera une erreur d'analyse due à des parenthèses non appariées.

D' autres solutions sont: \(, \), \[, \], \*, \+, \?,a]