Scénario

Un de vos amis a du mal à faire ses devoirs. Il a besoin d’un programme simple qui affiche les 404 premiers nombres naturels:

1 2 3 4 5 6 7 8 9 10 11 ... 401 402 403 404

Votre défi est simple: écrivez ce programme pour lui.

Cependant, votre connexion est terrible, donc 1 caractère aléatoire est perdu chaque fois que vous envoyez le programme. Pour éviter que cela ne casse votre programme, vous devez faire en sorte que la suppression d' un seul caractère n'ait aucun effet: le programme fonctionne, peu importe. (Le programme original doit également fonctionner.)

Comme la connexion est trop faible pour envoyer des fichiers volumineux, votre code doit être aussi court que possible.

_{TL: DR - crée un programme de radiocommunication pour sortir les nombres de 1 à 404}

Règles / Détails

• Le résultat peut être une liste d'entiers dans un format raisonnable (séparés par des espaces, des nouvelles lignes, des virgules, etc.). Cependant, votre sortie doit être cohérente et ne pas changer lorsque le programme est modifié.
• Les indicateurs de ligne de commande contenant de la logique, l'exécution du code réel, la génération de la liste de numéros, etc. sont interdits.
• C'est du code-golf , donc la soumission la plus courte (en octets) gagne!

05AB1E , 12 octets

Code:

XX440044ÔÔŸŸ

Explication de code normale:

X             # Pushes the number 1.
 X            # Pushes the number 1 again.
  440044      # Pushes the number 440044.
        Ô     # Connected uniquify.
         Ô    # Connected uniquify.
          Ÿ   # Inclusive range of the top two elements.
           Ÿ  # Inclusive range on the array, which leaves it intact.

Cela conduit au code golfé suivant:, X404Ÿce que nous voulons atteindre.

Le nombre 404 est généré par l'une des variantes suivantes:

440044ÔÔ
40044ÔÔ
44044ÔÔ
44004ÔÔ
440044Ô

La plage inclusive fonctionne comme suit sur deux nombres:

`1 5Ÿ`             ->    [1, 2, 3, 4, 5]
[1, 5]Ÿ            ->    [1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]Ÿ   ->    [1, 2, 3, 4, 5]

Ce qui rend toujours la seconde Ÿun non-op .

Utilise le codage CP-1252 . Essayez-le en ligne!

JavaScript, 228 octets

etInterval=stInterval=seInterval=setnterval=setIterval=setInerval=setIntrval=setInteval=setInteral=setIntervl=setInterva=top=>4

setInterval
`405>(i=this.i?i:1)?alert(i++):0`///`
setInterval
`405>(i=this.i?i:1)?alert(i++):0`///`

Explication

L'évaluation du code dans a setIntervalpermet au programme de continuer même s'il y a une erreur. Nous nous assurons que le code transmis générera une erreur si un seul caractère est supprimé. La syntaxe de la chaîne de modèle peut être utilisée pour appeler setIntervalavec une chaîne constante sans parenthèses. Heureusement, même si la chaîne de modèle se trouve sur la ligne suivante, elle est toujours analysée comme un appel de fonction avec une telle syntaxe.

Le premier problème que nous rencontrons est qu’il setIntervals’agit d’une fonction. Par conséquent, si un personnage est supprimé et que le programme essaie d’appeler à la setIntevalplace, il se trompera. Bien sûr, comme il y a deux invocations identiques du setInterval, nous n'avons pas à nous soucier de son fonctionnement correct tant que nous évitons l'erreur. Ainsi, la première ligne définit chaque "faute d’orthographe" possible setTimeouten une fonction valide.

La première ligne fonctionne en attribuant toutes ces "fautes d'orthographe" à la fonction top=>4. Notez la syntaxe ES6, cela prend simplement un paramètre nommé "top" et renvoie 4. Pourquoi "top"? Eh bien, la première ligne ne doit jamais générer d'erreur, même si un personnage est supprimé. Si un =est supprimé pour faire top>4, cette expression booléenne sera valide car topest prédéfinie dans les navigateurs, cédant simplement false. Si le 4 est supprimé, le corps de la fonction devient simplement le premier setIntervalsegment et le second fonctionne sans dommage.

Maintenant, tout ce qui reste à s’inquiéter, c’est si un `est supprimé.

Si elle est retirée dès le début, setIntervalne fait simplement rien, s’évaluant comme sa propre expression. Ensuite, le reste de la deuxième ligne exécute simplement une seule itération de la boucle, laissant l'autre setIntervalfragment terminer le travail. Si retiré de la fin, le backtick restant est repris à la fin du commentaire.

Les nouvelles lignes sont placées de manière à ce que la suppression n’affecte pas le comportement du programme, mais évite les erreurs lors de certaines suppressions de caractères telles que le backtick principal.

Pyth - 16 octets

L'idée de base est que lorsque vous enlevez un chiffre 404, cela ne fait que réduire le nombre. Nous devons donc obtenir le maximum de deux 404pour avoir le bon nombre. De toute évidence, il y a beaucoup plus de licenciements.

SSsetSS[404  404

Explication:

SS                       First one does 1-index range, second one sorts, which is no-op 
 s                       If the e is there, this is no-op, if only t is there, it sums a one element list, which is the item
  et                     e picks last element in list, and if e is gone, then t gets you the list without the first element which is good enough when combined with s
   SS                    Sorting twice is no-op
    [                    Start list, this can't be two element because if we get rid of initial 4, the 0 becomes third element which neeeds to be captured
     404                 One of the 404's
     <space><space>404   Need two spaces for redundancy, because 404404 *is* bigger than 404

Essayez-le en ligne ici .

Befunge-98 , 37 octets

20020xx##;;11++::''ee44**``kk@@::..;;

Essayez-le en ligne!

Explication

Créer du code durci avec les radiations dans Befunge-98 n'est pas si mal que ça, car vous pouvez régler le "delta" (c'est-à-dire la taille de pas du pointeur d'instruction) manuellement avec x. Donc, si vous définissez le delta sur (2,0), à partir de là, tous les autres caractères sont ignorés et nous pouvons simplement doubler toutes les commandes. La difficulté est 2 0d’atteindre le sommet de la pile de manière fiable. Nous aurons besoin 0 2 0du reste pour que le programme fonctionne correctement, mais nous le ferons gratuitement. Voici comment nous faisons cela:

20020xx

Notez que chaque chiffre se répète, donc dans le programme complet, il y aura un début 2 0que nous ignorerons tout simplement.

Par conséquent, supprimer le premier ou le second caractère du programme n'a aucune importance, car nous n'utiliserons pas ces chiffres de toute façon. De même, supprimer le troisième caractère est identique à supprimer le deuxième, nous n’avons donc pas à nous en préoccuper.

Considérons ce qui se passe dans les deux autres cas. Lâcher le quatrième personnage:

2000xx

Notez que le delta est défini sur (0,0). Mais cela ne déplace pas du tout le point d’instruction, la même chose xest exécutée immédiatement et cette fois-ci apparaît (2,0)et tout va bien (il existe des zéros implicites au bas de la pile pour nos besoins ultérieurs).

Laissons le cinquième caractère à la place:

2002xx

Maintenant, le delta est réglé sur (0,2). Cependant, il n'y a toujours pas de mouvement horizontal. Par conséquent, l'adresse IP est renvoyée immédiatement xet le delta correct est défini.

À partir de ce moment, nous pouvons pratiquement ignorer la duplication de caractères ainsi que cette partie initiale car elle sera toujours ignorée:

...#;1+:'e4*`k@:.;

Le ;est une sorte de commande de commentaire qui ignore tout jusqu'à la prochaine ;rencontre. Cependant, nous sautons par-dessus le premier, ;de #sorte que seule la partie entre le ;sera exécutée à partir de ce point.

1+    Increment the top of the stack.
:     Duplicate it.
'e    Push 101.
4*    Multiply by 4 to get 404.
`     Greater-than check. Pushes 1 once the top
      reaches 405, otherwise 0.
k@    Terminate the program that many times.
:.    Print a copy of the top of the stack (and a space).

> <> , 103 60 51 octets

               vv
;?=*4o" e"n:ll<<
;?=*4o" e"n:ll<<

Testé ici.

Utilise la même tactique que ce programme . Si un caractère est supprimé dans la première ligne, la deuxième ligne sera toujours exécutée. Si un caractère de la 2ème ligne est supprimé, le vdéplacement de l'exécution sur la 3ème ligne, car la 2ème ligne est un caractère plus court. Une suppression dans la 3ème ligne n’a aucun effet sur le contrôle du programme, car elle n’est exécutée qu’après une suppression dans la ligne 2.

Le programme fonctionnera également dans le cas où un saut de ligne est supprimé:

Cas 1:

La 2ème ligne sera exécutée.

               vv;?=*4o" e"n:ll<<
;?=*4o" e"n:ll<<

Cas 2:

Les deux lignes deviennent une ligne avec deux fois les instructions.

               vv
;?=*4o" e"n:ll<<;?=*4o" e"n:ll<<

Explication:

Le noyau du programme est le suivant. Notez que a 1est déjà poussé sur la pile par la première ligne.

ll:n        Push length of the stack twice, duplicate, print as number
"e "o       Push 101, 32, output 32 as space
4*          101 * 4 is 404
=?;         Pop twice, if equal, halt
            (Execution wraps around)

> <> , 42 38 34 octets

Essayez-le en ligne!

Merci à @Martin Ender et @Teal Pelican pour avoir réduit de 8 octets!

<<;?=*4o" e"lnll/
 ;?=*4o" e"lnll<

Similaire à la réponse de mbomb007 , mais n'utilise que 2 lignes.

Au lieu de compter de 1 à 404 en utilisant une seule valeur de mémoire, j'ai continuellement poussé la longueur de la pile. Cela a fait en sorte que je n'ai rien eu à mettre sur la pile avant le début de la boucle, ce qui facilite beaucoup les choses.

Le code d'origine

Les <s tourner la propriété intellectuelle autour, et /est un non-op, comme l'IP s'enroule autour et continue son chemin le long de ce normal. Ainsi, le code pertinent est:

          lnll   Prints the size of the stack + 1 and pushes the stack size twice
     o" e"       Prints a space and pushes 101
   *4            Multiplies to get 404
;?=              If the number we just printed was 404, end the program

Et cela se répète.

La suppression

La grande clé ici est le miroir /. Cela ne fait rien si la deuxième ligne est modifiée - elle ne fait que revenir à elle-même et est essentiellement un no-op. Mais si un caractère de la première ligne est supprimé, la ligne sera rétrogradée, de sorte que le miroir heurte la flèche <et aboutisse à une boucle identique non modifiée.

La seule autre suppression significative serait le \npersonnage. Ceci est également pris en compte, car il produit ce code:

<<;?=*4o" e"lnll/ ;?)*4o" e"lnll<

Nous venons d’ajouter une copie de la boucle originale ;?=*4o" e"lnllà elle-même. Comme il s'agit d'une boucle, l'exécution ne fait aucune différence et fonctionne comme si rien n'avait changé.

Un poirier , 34 octets

Le programme contient des caractères de contrôle, alors voici un xxdcliché:

00000000: 7072 696e 7420 312e 2e34 3034 2327 108a  print 1..404#'..
00000010: af70 7269 6e74 2031 2e2e 3430 3423 2710  .print 1..404#'.
00000020: 8aaf                                     ..

Un poirier est fondamentalement un dérivé de Perl, avec quelques fonctionnalités "intéressantes". Je l'ai jeté comme une blague (pour pouvoir dire que mon polyglotte est imprimé a partridgedans A Pear Pear; en fait, presque tous les programmes le font). Cependant, c'est Turing-complet, et en fait assez bon pour ce genre de défi.

La fonctionnalité qui nous importe le plus ici est qu'un poirier n'exécutera un programme que si une sous-chaîne du code a un CRC-32 00000000. Le code est tourné pour mettre la sous-chaîne en question au début. En fait, les deux moitiés (identiques) du code ont chacune le CRC-32 en question (en raison de ce commentaire binaire à la fin suspect), donc si vous supprimez un caractère de la source (brisant le CRC), l'autre moitié est tournée au début et le #panneau vers la fin commentera la moitié endommagée, en plus de la malbouffe binaire.

Une autre fonctionnalité rend le programme légèrement plus petit: bien que A Pear Pear soit principalement interprété en Perl, il comporte quelques modifications mineures qui le rendent plus proche de Python. Ce qui est pertinent ici est que, contrairement à la printdéclaration de Perl (qui ne fait que mettre les chiffres ensemble), la printdéclaration de A Pear Tree sépare les arguments avec des espaces et affiche un retour à la ligne final. Cela nous donne une sortie joliment séparée, ce qui nous évite de gaspiller des octets lors du formatage. (Notez que vous ne devez entrer aucune information dans le programme; si la langue en reçoit, elle suppose par défaut qu’elle est supposée en faire quelque chose.)

Bien sûr, cela ne peut pas rivaliser avec les langues de golf réelles (et je ne m'y attendrais pas), mais je pensais que les gens pourraient trouver cela intéressant.

Befunge 98 , 34 octets

Essayez-le en ligne!

<<.:@k`*4e':+1[

2.:@k`*4e':+1<^^j

Cela fonctionne de manière très similaire à ma réponse> <> , mais au lieu du miroir /, j'utilise l'opération de rotation à gauche [, puis l'inverse de la direction IP, qui est fonctionnellement équivalente à un miroir dans ce cas.

Le code d'origine

<<                 Reverses code direction, sending IP to right
               [   Turns the IP left, into the ^, which reverses it.
                   It then hits this again, turning left to go West. (No-op)
            :+1    Adds 1 to the sum
        *4e'       Pushes 404
     @k`           Ends the program if (sum > 404)
   .:              Prints the sum

La suppression

Si quelque chose dans la deuxième ligne est supprimé, cela changera et n'affectera pas du tout le haut.

Si quelque chose dans la première ligne est supprimé, le [va envoyer l'adresse IP dans le <, ce qui lance une boucle identique (à l'exception de 2j^^ce qui évite le ^s utilisé en tandem avec le [)

Comme il y a 2 nouvelles lignes, cela n’a aucune incidence sur le code s’il est supprimé (merci à @ masterX244 pour cela!)

Befunge-93, 54 51 octets

Merci à Mistah Figgins de m'avoir sauvé 3 octets.

111111111111111vv
+1_@#-*4"e":.:<<
+1_@#-*4"e":.:<<

Essayez-le en ligne!

C'est essentiellement le même truc que celui utilisé dans le défi Hello World tolérant aux pannes . La première ligne commence par s'assurer qu'il y a un 1 en haut de la pile pour le début de la séquence, puis une des vflèches à la fin de la ligne redirige le chemin du code au début de la routine principale sur la ligne 2 , exécutant de droite à gauche.

Supprimer un caractère de la première ligne ne fera que déplacer les vflèches de un, mais cela permet toujours au code de rediriger avec succès vers la deuxième ligne. Si vous supprimez un caractère de la deuxième ligne, la <flèche située à la fin de la ligne se déplacera hors du chemin situé au- vdessus de celle-ci, de sorte que le chemin du code sera redirigé vers la routine de sauvegarde de la ligne 3.

Supprimer la première ligne ne fait pas de mal car cela ne fait que déplacer la troisième ligne pour remplacer la deuxième. Et supprimer quoi que ce soit après la fin de la deuxième ligne n'aura aucun effet, car il ne s'agit que du code de sauvegarde.

JavaScript + HTML + extraits de pile, 167 158 154 octets

Abuser du fait que JavaScript dans Stack Snippets soit placé dans une page Web à l'intérieur d'un <script>élément.

or(x="",i=405,d=document;--i;)d[i]||(x=d[i]=i+' '+x);d.write(x)</script></script><script>for(x="",i=405,d=document;--i;)d[i]||(x=d[i]=i+' '+x);d.write(x)

En fait , 18 octets

:404::404kMkMMRRSS

Est en fait une langue de golf à base de pile.

Explication des commandes impliquées (car elles fonctionnent dans le contexte ci-dessus):

Numbers are indicated by round brackets () and lists by square brackets []

:         - pushes the longest string of characters in '0123456789+-.ij' as a numeric
k         - pop all the elements on the stack into a list [l] and push [l]
M         - pop [l], push max([l])
            pop (a), push (a)
R         - pop [l], push reverse([l])
            pop (a), push range([1,a])
S         - pop [a], push sorted([a])