Guión

Uno de tus amigos está luchando en una tarea. Necesita un programa simple que imprima los primeros 404 números naturales:

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

Su desafío es simple: escriba este programa para él.

Sin embargo, su conexión es terrible, por lo que se pierde 1 carácter aleatorio cada vez que envía el programa. Para evitar que esto rompa su programa, debe hacerlo de modo que eliminar cualquier carácter individual no tenga ningún efecto: el programa funciona, independientemente. (El programa original también debe funcionar).

Debido a que la conexión es demasiado pobre para enviar archivos grandes, su código debe ser lo más corto posible.

_{TL: DR: realice un programa reforzado con radiación para generar los números del 1 al 404}

Reglas / Detalles

• El resultado puede ser una lista de enteros en cualquier formato razonable (separados por espacios, líneas nuevas, comas, etc.). Sin embargo, su salida debe ser coherente y no cambiar cuando se modifica el programa.
• Las banderas de línea de comando que contienen lógica, ejecutan código real, generan la lista de números, etc. están prohibidas.
• Este es el código de golf , por lo que gana la presentación más corta (en bytes).

05AB1E , 12 bytes

Código:

XX440044ÔÔŸŸ

Explicación del código normal:

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.

Esto lleva al siguiente código de golf: X404Ÿque es lo que queremos lograr.

El número 404 es generado por cualquiera de estas variantes:

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

El rango inclusivo funciona de la siguiente manera en dos números:

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

Lo que siempre hace que el segundo sea Ÿun no-op .

Utiliza la codificación CP-1252 . Pruébalo en línea!

JavaScript, 228 bytes

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`///`

Explicación

La evaluación del código en a setIntervalpermite que el programa continúe incluso si hay un error. Nos aseguramos de que el código aprobado tenga un error si se elimina un solo carácter. Se puede abusar de la sintaxis de cadena de plantilla para llamar setIntervalcon una cadena constante sin paréntesis. Afortunadamente, incluso si la cadena de plantilla está en la siguiente línea, todavía se analiza como una llamada de función con dicha sintaxis.

El primer problema con el que nos encontramos es que setIntervales una función y, por lo tanto, si se elimina un carácter y el programa intenta llamar en su setIntevallugar, se produce un error. Por supuesto, dado que hay dos invocaciones idénticas de la setInterval, no tenemos que preocuparnos de que realmente funcione correctamente siempre que evitemos el error. Entonces, la primera línea define cada posible "error ortográfico" de setTimeoutuna función válida.

La primera línea funciona asignando todos estos "errores ortográficos" a la función top=>4. Tenga en cuenta la sintaxis de ES6, esto simplemente toma un parámetro llamado "top" y devuelve 4. ¿Por qué "top"? Bueno, la primera línea nunca debe arrojar un error, incluso si se elimina un personaje. Si =se elimina an para crear top>4, esta expresión booleana será válida ya que topestá predefinida en los navegadores, simplemente cediendo false. Si se elimina el 4, el cuerpo de la función simplemente se convierte en el primer setIntervalsegmento y el segundo se ejecuta sin daños.

Ahora, todo lo que debe preocuparse es si se elimina un `.

Si se elimina desde el principio, setIntervalsimplemente no hace nada, evaluándose a sí mismo como su propia expresión. Luego, el resto de la segunda línea simplemente ejecuta una única iteración del bucle, dejando que el otro setIntervalfragmento finalice el trabajo. Si se elimina desde el final, el backtick restante se recoge desde el final del comentario.

Las nuevas líneas se colocan de modo que la eliminación no afecte el comportamiento del programa, pero evitan errores en el caso de algunas eliminaciones de caracteres, como el backtick principal.

Pyth - 16 bytes

La idea básica detrás de esto es que cuando quitas un dígito 404, solo reduce el número, por lo que solo tenemos que obtener el máximo de dos 404para asegurarnos de que tenemos el número correcto. Obviamente, hay muchas más redundancias.

SSsetSS[404  404

Explicación:

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

Pruébelo en línea aquí .

Befunge-98 , 37 bytes

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

Pruébalo en línea!

Explicación

Hacer código endurecido por radiación en Befunge-98 no es tan malo, porque puede configurar el "delta" (es decir, el tamaño del paso del puntero de instrucción) manualmente x. Entonces, si establece el delta en (2,0), a partir de ese momento se omite cualquier otro carácter y simplemente podemos duplicar todos los comandos. Lo complicado es llegar 2 0a la cima de la pila de manera confiable. De hecho, necesitaremos 0 2 0que el resto del programa funcione correctamente, pero lo haremos de forma gratuita. Así es como hacemos esto:

20020xx

Tenga en cuenta que cada dígito se empuja a sí mismo, por lo que en el programa completo, habrá un comienzo 2 0que simplemente ignoraremos.

En consecuencia, eliminar el primer o el segundo carácter del programa es irrelevante porque no usaremos esos dígitos de todos modos. Del mismo modo, eliminar el tercer carácter es idéntico a eliminar el segundo, por lo que tampoco debemos preocuparnos por eso.

Consideremos lo que sucede en los otros dos casos. Dejar caer el cuarto personaje:

2000xx

Tenga en cuenta que el delta está establecido en (0,0). Pero esto no mueve el puntero de instrucciones en absoluto, por lo que xse ejecuta de nuevo inmediatamente y esta vez aparece el (2,0)y todo está bien (hay ceros implícitos en la parte inferior de la pila para nuestros fines posteriores).

Dejemos caer el quinto personaje en su lugar:

2002xx

Ahora el delta se establece en (0,2). Sin embargo, todavía no hay movimiento horizontal, por lo que la IP se ajusta inmediatamente xy nuevamente, se establece el delta correcto.

A partir de este punto, básicamente podemos ignorar la duplicación de caracteres y esta parte inicial porque siempre se omitirá:

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

El ;es un tipo de comando de comentario que omite todo hasta que ;se encuentra el siguiente . Sin embargo, saltamos sobre el primero ;con #lo que solo la parte entre ;ellos se ejecutará desde ese punto en adelante.

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 bytes

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

Probado aquí.

Utiliza la misma táctica que este programa . Si se elimina un carácter en la primera línea, la segunda línea seguirá ejecutándose. Si se elimina un carácter en la segunda línea, la vejecución se moverá a la tercera línea, ya que la segunda línea es un carácter más corto. Una eliminación en la tercera línea no tiene efecto en el control del programa, ya que solo se ejecuta después de una eliminación en la línea 2.

El programa también funcionará en caso de que se elimine un salto de línea:

Caso 1:

La segunda línea se ejecutará.

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

Caso 2:

Ambas líneas se convierten en una línea con el doble de las instrucciones.

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

Explicación:

El núcleo del programa es el siguiente. Tenga en cuenta que 1la primera línea ya empuja a en la pila.

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 bytes

Pruébalo en línea!

¡Gracias a @Martin Ender y @Teal Pelican por eliminar 8 bytes!

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

Similar a la respuesta de mbomb007 , pero solo usa 2 líneas.

En lugar de contar de 1 a 404 usando un solo valor de memoria, continuamente empujé la longitud de la pila. Esto hizo que no tuviera que poner nada en la pila antes de que comenzara el ciclo, haciendo las cosas mucho más fáciles.

El código original

El <s cambia la dirección IP, y /no funciona, ya que la IP se ajusta y continúa a lo largo de su camino normal. Por lo tanto, el código relevante es:

          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

Y esto se repite.

La eliminación

La gran clave aquí es el espejo /. No hace nada si se modifica la segunda línea, solo se ajusta a sí misma y es esencialmente un no-op. Pero si se elimina un carácter de la primera línea, la línea se desplazará hacia abajo, de modo que el espejo golpee la flecha <, lo que lleva a un bucle idéntico, sin modificaciones.

La única otra eliminación significativa sería el \npersonaje. Esto también se tiene en cuenta, ya que produce este código:

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

Ahora, acabamos de agregar una copia del bucle original ;?=*4o" e"lnlla sí mismo. Como se trata de un bucle, no hace ninguna diferencia en la ejecución y se ejecuta como si nada hubiera cambiado.

Un peral , 34 bytes

El programa contiene caracteres de control, así que aquí hay un xxdvolcado:

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 peral es básicamente un derivado de Perl, con algunas características "interesantes". Lo junté como una broma (para poder decir que mi políglota se imprimió a partridgeen A Pear Tree; de ​​hecho, casi todos los programas lo hacen). Sin embargo, es Turing completo, y en realidad es bastante bueno en este tipo de desafío.

La característica que más nos importa aquí es que A Pear Tree solo ejecutará un programa si alguna subcadena del código tiene un CRC-32 00000000. El código se gira para poner la subcadena en cuestión al principio. Como sucede, las dos mitades (idénticas) del código tienen cada una el CRC-32 en cuestión (debido a ese comentario binario de aspecto sospechoso al final), por lo que si elimina un carácter de la fuente (rompiendo el CRC), la otra mitad se gira hacia el inicio y el #letrero cerca del final comentará la mitad dañada, además de la basura binaria.

Otra característica hace que el programa sea un poco más pequeño: aunque A Pear Tree se interpreta principalmente como Perl, tiene algunos cambios menores para que funcione más como Python. Uno que es relevante aquí es que, a diferencia de la printdeclaración de Perl (que solo ejecuta los números juntos), la printdeclaración de A Pear Tree separa los argumentos con espacios e imprime una nueva línea final. Eso nos da una salida bien separada por espacios, lo que significa que no tenemos que desperdiciar bytes en el formateo. (Tenga en cuenta que tendrá que darle al programa ninguna entrada; si el idioma recibe información, se supone de forma predeterminada que se supone que debe hacer algo con él).

Por supuesto, esto no puede competir con los idiomas de golf reales (ni lo esperaría), pero pensé que la gente podría encontrarlo interesante.

Befunge 98 , 34 bytes

Pruébalo en línea!

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

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

Esto funciona de manera muy similar a mi respuesta> <> , pero en lugar del espejo /, utilizo la operación de giro a la izquierda [y luego invierto la dirección IP, que es funcionalmente equivalente a un espejo en este caso.

El código original

<<                 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 eliminación

Si se elimina algo en la segunda línea, cambiará y no afectará en absoluto a la parte superior.

Si se elimina algo en la primera línea, [enviará la IP al <, que inicia un bucle idéntico (con la excepción de 2j^^que evita los ^s utilizados junto con el [)

Debido a que hay 2 líneas nuevas, no hay diferencia en el código si se elimina una (¡gracias a @ masterX244 por esto!)

Befunge-93, 54 51 bytes

Gracias a Mistah Figgins por salvarme 3 bytes.

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

Pruébalo en línea!

Este es esencialmente el mismo truco que se usó en el desafío Hello World tolerante a fallas . La primera línea comienza asegurándose de que haya un 1 en la parte superior de la pila para el inicio de la secuencia, y luego una de las vflechas al final de la línea redirige la ruta del código al inicio de la rutina principal en la línea 2 , ejecutando de derecha a izquierda.

Eliminar un carácter de la primera línea solo desplazará las vflechas una por una, pero eso aún permite que el código se redirija a la segunda línea con éxito. Al eliminar un carácter de la segunda línea, la <flecha al final de la línea se desplaza fuera de la ruta de varriba, por lo que la ruta del código se redirigirá a la rutina de respaldo en la línea 3.

Eliminar el salto de la primera línea no hace daño, porque eso solo mueve la tercera línea a su lugar para reemplazar la segunda línea. Y eliminar cualquier cosa después del final de la segunda línea no tendrá ningún efecto, porque ese es solo el código de respaldo.

JavaScript + HTML + Fragmentos de pila, 167 158 154 bytes

Abusar del hecho de que JavaScript en Stack Snippets se coloca en una página web dentro de un <script>elemento.

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 realidad , 18 bytes

:404::404kMkMMRRSS

En realidad es un lenguaje de golf basado en la pila.

Explicación de los comandos involucrados (ya que funcionan en el contexto anterior):

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])