Scenario

Uno dei tuoi amici sta lottando per un compito a casa. Ha bisogno di un semplice programma che stampi i primi 404 numeri naturali:

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

La tua sfida è semplice: scrivi questo programma per lui.

Tuttavia, la tua connessione è terribile, quindi 1 carattere casuale viene perso ogni volta che invii il programma. Per evitare che ciò interrompa il programma, è necessario farlo in modo che la rimozione di ogni singolo carattere non abbia alcun effetto: il programma funziona, indipendentemente. (Anche il programma originale deve funzionare.)

Poiché la connessione è troppo scarsa per inviare file di grandi dimensioni, il codice deve essere il più breve possibile.

_{TL: DR - crea un programma indurito per radiazione per produrre i numeri da 1 a 404}

Regole / Dettagli

• L'output può essere un elenco di numeri interi in qualsiasi formato ragionevole (separato da spazi, newline, virgole, ecc.). Tuttavia, l' output deve essere coerente e non cambiare quando il programma viene modificato.
• I flag della riga di comando che contengono la logica, eseguono il codice effettivo, generano l'elenco dei numeri e così via, sono vietati.
• Questo è code-golf , quindi vince l'invio più breve (in byte)!

05AB1E , 12 byte

Codice:

XX440044ÔÔŸŸ

Spiegazione del codice 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.

Questo porta al seguente codice golf: X404Ÿche è ciò che vogliamo ottenere.

Il numero 404 è generato da una di queste varianti:

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

L'intervallo compreso funziona come segue su due numeri:

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

Il che rende sempre il secondo Ÿun no-op .

Utilizza la codifica CP-1252 . Provalo online!

JavaScript, 228 byte

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

Spiegazione

La valutazione del codice in a setIntervalconsente al programma di continuare anche se si verifica un errore. Ci assicuriamo che il codice trasmesso sbaglierà se un singolo carattere viene rimosso. È possibile abusare della sintassi della stringa modello per chiamaresetInterval con una stringa costante senza parentesi. Fortunatamente, anche se la stringa del modello si trova sulla riga successiva, viene comunque analizzata come una chiamata di funzione con tale sintassi.

Il primo problema che incontriamo è che setIntervalè una funzione, e quindi se un personaggio viene rimosso e il programma tenta di chiamare setIntevalinvece, si risolve in errore. Naturalmente, poiché ci sono due invocazioni indentiche di setInterval, non dobbiamo preoccuparci che funzioni correttamente fino a quando evitiamo l'errore. Quindi, la prima riga definisce ogni possibile "errore ortografico" di setTimeoutuna funzione valida.

La prima riga funziona assegnando tutti questi "errori ortografici" alla funzione top=>4. Nota la sintassi ES6, questo prende semplicemente un parametro chiamato "top" e restituisce 4. Perché "top"? Bene, la prima riga non deve mai generare un errore anche se un personaggio viene rimosso. Se un =viene rimosso per creare top>4, questa espressione booleana sarà valida poiché topè predefinita nei browser, semplicemente cedendo false. Se il 4 viene rimosso, il corpo della funzione diventa semplicemente il primo setIntervalsegmento e il secondo viene eseguito incolume.

Ora, tutto ciò che rimane di cui preoccuparsi è se un `viene rimosso.

Se rimosso dall'inizio, setIntervalsemplicemente non fa nulla, valutando se stesso come propria espressione. Quindi, il resto della seconda riga esegue semplicemente una singola iterazione del ciclo, lasciando l'altrosetInterval frammento finisca il lavoro. Se rimosso dalla fine, il backtick rimanente viene raccolto dalla fine del commento.

Le nuove righe vengono posizionate in modo che la rimozione non influisca sul comportamento del programma, ma prevengono errori nel caso di alcune rimozioni di caratteri come il backtick iniziale.

Pyth - 16 byte

L'idea alla base di questo è che quando si toglie una cifra da 404, si riduce solo il numero, quindi dobbiamo solo ottenere il massimo di due 404per assicurarci di avere il numero giusto. Ovviamente, ci sono molti altri licenziamenti.

SSsetSS[404  404

Spiegazione:

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

Provalo online qui .

Befunge-98 , 37 byte

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

Provalo online!

Spiegazione

Creare un codice temprato dalle radiazioni in Befunge-98 non è poi così male, perché è possibile impostare manualmente il "delta" (ovvero la dimensione del passo del puntatore dell'istruzione) x. Quindi, se si imposta il delta su (2,0), da allora in poi ogni altro personaggio viene saltato e possiamo semplicemente raddoppiare tutti i comandi. La cosa difficile è salire 2 0in cima allo stack in modo affidabile. In realtà avremo bisogno 0 2 0che il resto del programma funzioni correttamente, ma lo faremo gratuitamente. Ecco come lo facciamo:

20020xx

Si noti che ogni cifra si spinge da sola, quindi nel programma completo, ci sarà un inizio 2 0 che semplicemente ignoreremo.

Di conseguenza, l'eliminazione del primo o del secondo carattere dal programma è irrilevante perché non useremo comunque quelle cifre. Allo stesso modo, rimuovere il terzo personaggio è identico a rimuovere il secondo, quindi non dobbiamo preoccuparci neanche di quello.

Consideriamo cosa succede negli altri due casi. Rilasciare il quarto personaggio:

2000xx

Si noti che il delta è impostato su (0,0). Ma questo non sposta affatto il puntatore dell'istruzione, quindi lo stesso xviene eseguito di nuovo immediatamente e questa volta viene visualizzato il messaggio(2,0) tutto e va bene (ci sono zeri impliciti nella parte inferiore dello stack per i nostri scopi successivi).

Rilasciamo invece il quinto carattere:

2002xx

Ora il delta viene impostato su (0,2). Tuttavia, non c'è ancora alcun movimento orizzontale, quindi l'IP torna immediatamente ax e viene impostato il delta corretto.

Da questo punto in poi possiamo praticamente ignorare la duplicazione del personaggio e questa parte iniziale perché sarà sempre saltata:

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

Il ;è una sorta di comando di commento che salta tutto fino al prossimo ;si incontra. Tuttavia, saltiamo sopra il primo ;con #così solo la parte tra i ;sarà eseguita da quel punto in poi.

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 byte

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

Testato qui.

Usa la stessa tattica di questo programma . Se un carattere viene eliminato nella prima riga, verrà comunque eseguita la seconda riga. Se un carattere nella 2a riga viene eliminato, vsi sposta l'esecuzione sulla 3a riga, poiché la 2a riga è più breve. Una cancellazione nella terza riga non ha alcun effetto sul controllo del programma, in quanto è solo esecuzione dopo una cancellazione nella riga 2.

Il programma funzionerà anche nel caso in cui venga interrotta un'interruzione di riga:

Caso 1:

Verrà eseguita la seconda riga.

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

Caso 2:

Entrambe le righe diventano una riga con il doppio delle istruzioni.

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

Spiegazione:

Il nucleo del programma è il seguente. Si noti che a 1viene inserito nello stack già dalla prima riga.

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 byte

Provalo online!

Grazie a @Martin Ender e @Teal Pelican per la rasatura di 8 byte!

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

Simile alla risposta di mbomb007 , ma utilizza solo 2 righe.

Invece di contare da 1 a 404 usando un singolo valore di memoria, ho spinto continuamente la lunghezza dello stack. Questo ha fatto sì che non avessi bisogno di mettere nulla in pila prima dell'inizio del ciclo, rendendo le cose molto più facili.

Il codice originale

La <s gira l'IP, e /è una no-op, mentre l'IP si avvolge e continua lungo il suo percorso normale. Pertanto, il codice pertinente è:

          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

E questo si ripete.

La cancellazione

La chiave grande qui è lo specchio /. Non fa nulla se la seconda riga viene modificata - si riavvolge solo su se stessa ed è essenzialmente una no-op. Ma se un personaggio della prima linea viene rimosso, la linea si sposterà in basso, in modo che lo specchio colpisca la freccia< , conducendo in un loop identico e non modificato.

L'unica altra cancellazione significativa sarebbe il \npersonaggio. Questo è anche considerato, in quanto produce questo codice:

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

Ora, abbiamo appena aggiunto una copia del loop originale ;?=*4o" e"lnlla se stesso. Poiché si tratta di un ciclo, non fa alcuna differenza nell'esecuzione e funziona come se nulla fosse cambiato.

Un albero di pere , 34 byte

Il programma contiene caratteri di controllo, quindi ecco un xxddump:

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 albero di pere è fondamentalmente un derivato del Perl, con alcune caratteristiche "interessanti". L'ho messo insieme come uno scherzo (in modo da poter dire che il mio poliglotta stampato a partridgein A Pear Tree; in effetti, quasi tutti i programmi lo fanno). Tuttavia, è completo di Turing e in realtà un po 'buono in questo tipo di sfida.

La caratteristica che ci interessa di più qui è che A Pear Tree eseguirà un programma solo se una sottostringa del codice ha un CRC-32 di 00000000. Il codice viene ruotato per mettere la sottostringa in questione all'inizio. In effetti, le due metà (identiche) del codice hanno ciascuna il CRC-32 in questione (a causa di quel commento binario dall'aspetto sospetto alla fine), quindi se elimini un carattere dalla fonte (rompendo il CRC), l'altra metà viene ruotata all'inizio e il #segno vicino alla fine commenterà la metà danneggiata, oltre alla spazzatura binaria.

Un'altra caratteristica rende il programma leggermente più piccolo: sebbene A Pear Tree sia per lo più interpretato come Perl, ha alcune piccole modifiche per farlo funzionare come Python. Uno che è rilevante qui è che, diversamente dall'affermazione di Perl print(che fa semplicemente scorrere i numeri insieme), l' printaffermazione di A Pear Tree separa gli argomenti con spazi e stampa una nuova riga finale. Questo ci dà un output ben separato dallo spazio, il che significa che non dobbiamo sprecare byte nella formattazione. (Nota che non devi dare al programma alcun input; se la lingua riceve input, assume per impostazione predefinita che dovrebbe fare qualcosa con esso.)

Ovviamente, questo non può competere con le lingue del golf (né me lo sarei aspettato), ma pensavo che la gente potesse trovarlo interessante.

Befunge 98 , 34 byte

Provalo online!

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

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

Funziona in modo molto simile alla mia risposta> <> , ma invece del mirror /, utilizzo l'operazione svolta a sinistra [e invertisco la direzione IP, che in questo caso è funzionalmente equivalente a un mirror.

Il codice originale

<<                 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 cancellazione

Se qualcosa nella seconda riga viene eliminato, si sposterà e non avrà alcun effetto sulla parte superiore.

Se qualcosa nella prima riga viene cancellato, [invierà l'IP in <, che avvia un loop identico (ad eccezione del 2j^^quale evita gli ^s usati in tandem con il [)

Perché ci sono 2 nuove righe, non fa differenza nel codice se ne viene eliminato uno (grazie a @ masterX244 per questo!)

Befunge-93, 54 51 byte

Grazie a Mistah Figgins per avermi salvato 3 byte.

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

Provalo online!

Questo è essenzialmente lo stesso trucco usato nella sfida Hello World tollerante ai guasti . La prima riga inizia assicurandosi che ci sia un 1 nella parte superiore dello stack per l'inizio della sequenza, quindi una delle vfrecce alla fine della riga reindirizza il percorso del codice all'inizio della routine principale sulla riga 2 , eseguendo da destra a sinistra.

La rimozione di un carattere dalla prima riga sposta semplicemente le vfrecce di uno, ma ciò consente comunque al codice di reindirizzare correttamente alla seconda riga. La rimozione di un carattere dalla seconda riga fa sì che la <freccia alla fine della riga si sposti dal percorso di cui vsopra, quindi il percorso del codice verrà reindirizzato alla routine di backup sulla riga 3.

La rimozione dell'interruzione della prima riga non fa male, perché sposta la terza riga in posizione per sostituire la seconda riga. E rimuovere qualsiasi cosa dopo la fine della seconda riga non avrà alcun effetto, perché è solo il codice di backup.

JavaScript + HTML + Stack Snippet, 167 158 154 byte

Abusare del fatto che JavaScript nei frammenti di stack venga inserito in una pagina Web all'interno di 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)

In realtà , 18 byte

:404::404kMkMMRRSS

In realtà è un linguaggio da golf basato su stack.

Spiegazione dei comandi coinvolti (mentre funzionano nel contesto sopra):

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