Requisiti:

• Prendi un input su stdin inclusi nuovi ritorni a capo / a capo di lunghezza illimitata (limitato solo dalla memoria di sistema; cioè, non c'è limite intrinseco nel programma.)
• Emette il retro dell'input su stdout.

Esempio:

Ingresso:

Quick brown fox
He jumped over the lazy dog

Produzione:

god yzal eht revo depmuj eH
xof nworb kciuQ

Vittorie più brevi.

Classifica:

var QUESTION_ID=242,OVERRIDE_USER=61563;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Golfscript - 3 caratteri

-1%

versione offuscata è anche 3 caratteri

0(%

ecco una spiegazione di come funziona %

Bash - 7

tac|rev

tacinverte l'ordine delle linee, mentre revinverte l'ordine dei caratteri.

BrainFuck, 10 personaggi

,[>,]<[.<]

Batte molte risposte per un linguaggio così semplice.

C, 37 byte

main(_){write(read(0,&_,1)&&main());}

Haskell - 21

main=interact reverse

Stack di pancake , 342 316 byte

Put this nice pancake on top!
[]
Put this  pancake on top!
How about a hotcake?
If the pancake is tasty, go over to "".
Put this delightful pancake on top!
[#]
Eat the pancake on top!
Eat the pancake on top!
Show me a pancake!
Eat the pancake on top!
If the pancake is tasty, go over to "#".
Eat all of the pancakes!

Presuppone che l'input sia terminato da un carattere null ( ^@sulla riga di comando). Esempio di esecuzione, utilizzando l' interprete :

Put this nice pancake on top!
[]
Put this  pancake on top!
How about a hotcake?
If the pancake is tasty, go over to "".
Put this delightful pancake on top!
[#]
Eat the pancake on top!
Eat the pancake on top!
Show me a pancake!
Eat the pancake on top!
If the pancake is tasty, go over to "#".
Eat all of the pancakes!
~~~~~~~~~~~~~~~~~~~~~~~~
Hello, World!^@
!dlroW ,olleH

Python, 41 40 byte

import sys;print sys.stdin.read()[::-1]

41 -> 40 - punto e virgola rimosso alla fine del programma.

Probabilmente potrebbe essere ottimizzato!

APL, 2

⊖⍞

Oppure CircleBar QuoteQuad se i caratteri non arrivano, significa semplicemente: immissione dei caratteri da tastiera inversa.

Perl - 23

print scalar reverse <>

Rubino - 19 personaggi

puts$<.read.reverse

C - 47 caratteri

main(c){if(c=getchar(),c>=0)main(),putchar(c);}

Si noti che questo utilizza O (n) stack stack. Provalo online!

Windows PowerShell, 53 54

-join($x=[char[]]($($input)-join'
'))[($x.count)..0]

30/01/2011 (54) - Primo tentativo

30/01/2011 (53) - Le interruzioni di riga in linea sono divertenti.

2011-01-3- (52) - Anche assegnazioni di variabili incorporate.

Perl 5.1, 14

say~~reverse<>

Befunge-93 - 11x2 (22 caratteri)

>~:0`v >:v
^    _$^,_@

Testato usando questo interprete .

Calcolo lambda binario - 9 byte

16 46 80 17 3E F0 B7 B0 40

Fonte: http://ioccc.org/2012/tromp/hint.html

Fissione , 16 14 12 byte

DY$\
?
[Z~K!

Spiegazione

Il flusso di controllo inizia Dcon un (1,0)atomo discendente . Le ?letture da STDIN, un carattere alla volta, impostano la massa sul codice del carattere letto e l'energia su 0. Una volta che colpiamo EOF, ?imposteremo invece l'energia su 1. Il [reindirizza l'atomo su un Zinterruttore. Finché stiamo leggendo personaggi, l'energia sarà 0, quindi l'atomo viene deviato verso l'alto dal Z. Cloniamo l'atomo, eseguendo il looping di una copia nel file ?per continuare a leggere l'input. Aumentiamo l'energia dell'altra copia 1con $e la spingiamo sulla pila K. Quindi il ciclo di input è questo:

DY$\
?
[Z K

Quando l'energia è 1dovuta a EOF, la Zvolontà invece lascia passare l'atomo attraverso e diminuisce 0nuovamente l'energia . ~diminuisce ulteriormente l'energia -1. Gli atomi con energia negativa spuntano dalla pila, quindi possiamo recuperare i personaggi in ordine opposto e stamparli con !. Ora nota che la griglia è toroidale, quindi l'atomo riappare sul bordo sinistro della stessa riga. Ricorda che abbiamo incrementato l'energia degli atomi spinti in precedenza con $, quindi gli atomi ora hanno energia 1proprio come l'ultima uscita da ?e passeranno di nuovo attraverso Z. Il percorso dopo EOF è quindi

?
[Z~K!

Questo ciclo nella riga inferiore continua fino a quando lo stack è vuoto. Quando ciò accade, l'atomo viene riflesso indietro da Ke la sua energia diventa positiva ( +1). La ~diminuisce ancora una volta (spostandosi a sinistra), in modo che ora colpiamo l' Zenergia non positiva. Questo devia l'atomo verso il basso, in modo tale da finire nel cuneo di Ydove è immagazzinato, e poiché non ci sono più atomi in movimento, il programma termina.

> <>, ₁₆ 14 byte

-2 byte di @JoKing

due anni (!) più tardi, rimuove il -1 in più dalla lettura dell'input spostando la logica per l'arresto.

i:0(7$.
0=?;ol

Provalo online!

Simile all'altra> <> risposta, non è necessario invertire lo stack a causa del modo in cui l'input viene letto nella prima riga. In realtà non sono troppo sicuro se questo dovrebbe essere un suggerimento per l'altra> <> risposta, poiché è piuttosto diverso nell'aspetto ma simile nel concetto.

La differenza principale è che la mia risposta confronta l'input con 0, e se è inferiore (cioè non c'è input - irestituisce -1 se non c'è input) passa a (1,7), in caso contrario, (0, 7). Se passa al primo, apre il valore più alto (-1) e avvia un ciclo di stampa. Se passa a quest'ultimo, continua il ciclo di input.

11 byte, esce con un errore

Per gentile concessione di @JoKing

i:0(7$.
~o!

Provalo online!

Credo che questo sia valido ora tramite meta consenso.

Risposta precedente (14 byte)

i:0(7$.
~ol0=?;!

PHP - 38 17 caratteri

<?=strrev(`cat`);

Stack Cats , 7 byte

<!]T[!>

Provalo online!

Esistono molte alternative per lo stesso numero di byte, la maggior parte delle quali sono essenzialmente equivalenti nel modo in cui funzionano:

Spiegazione

Un breve primer Stack Cats:

• Ogni programma deve avere una simmetria speculare e specchiando qualsiasi parte di codice otteniamo un nuovo codice che calcola la funzione inversa. Pertanto gli ultimi tre caratteri del programma sopra annullano i primi tre, se non fosse per il comando al centro.
• Il modello di memoria è un nastro infinito di pile, che contengono una quantità implicita e infinita di zeri nella parte inferiore. Lo stack iniziale ha una -1sopra quegli zeri e poi i byte di input sopra (con il primo byte in cima e l'ultimo byte sopra il -1).
• Per l'output, prendiamo semplicemente lo stack finale, scartiamo a -1in fondo se ce n'è uno, quindi stampiamo tutti i valori come byte su STDOUT.

Ora per il programma attuale:

<    Move the tape head one stack left (onto an empty stack).
!    Bitwise NOT of the implicit zero on top, giving -1.
]    Move back to the original stack, taking the -1 with the tape head.
     We're now back to the original situation, except that we have a -1
     on top.
T    Reverse the stack down to the -1 at the bottom. One of the reasons
     we needed to move a -1 on top is that T only works when the top of
     the stack is nonzero. Since the first byte of the input could have
     been a null-byte we need the -1 to make sure this does anything at
     all.
[    Push the -1 to the stack on the left.
!    Bitwise NOT, turning it back into 0 (this is irrelevant).
>    Move the tape head back onto the original stack.

Sp3000 ha impostato la sua ricerca della forza bruta per trovare tutte le altre soluzioni a 7 byte, quindi ecco alcune alternative:

<]!T![>
>![T]!<
>[!T!]<

Queste tre varianti sono essenzialmente le stesse, tranne per il fatto che differiscono quando viene calcolato il NOT bit per bit e se si usa lo stack vuoto a sinistra o a destra.

<]T!T[>
>[T!T]<

Come ho detto nella spiegazione sopra, Tnon fa nulla quando la parte superiore della pila è zero. Ciò significa che possiamo effettivamente mettere !nel mezzo invece. Ciò significa che il primo Tè un no-op, quindi si gira lo zero sopra in una -1e poi poi secondo Tesegue l'inversione. Ovviamente, questo significa che lo stato di memoria finale ha uno -1stack vicino a quello originale, ma questo non ha importanza poiché solo lo stack nella posizione corrente della testina influisce sull'output.

<*ITI*>

Questa variante utilizza *(XOR 1) invece di !, in modo da trasformare lo zero in +1, e Iè una spinta condizionale che spinge i valori positivi e i valori positivi, a sinistra a sinistra, e li nega in entrambi i casi (in modo tale da finire ancora con un -1in cima allo stack originale quando ci imbattiamo T), quindi alla fine funziona allo stesso modo della <!]T[!>soluzione originale .

PHP, 82 29 24 29 28 caratteri

<?=strrev(fread(STDIN,2e9));

82 -> 29: il nuovo carattere di linea viene conservato quando viene invertito con strrev.
29 -> 24: ora utilizza la sintassi del collegamento
24 -> 29: ora legge tutte le righe anziché un'unica riga

Befunge-98 - 11 10

#v~
:<,_@#

(Testato con cfunge)

La variante seguente rompe leggermente il requisito: esegue l'attività ma in seguito emette un flusso infinito di byte null (e non termina).

~#,

Il modo in cui funziona è che legge ripetutamente l'input nello stack ( ~) un carattere alla volta, saltando sopra ( #) la virgola. Quando viene raggiunto l'EOF, ~agisce come un riflettore e il PC si capovolge, ,saltando fuori e ripetutamente emettendo un personaggio ( ) mentre si salta sopra ( #) la tilde.

Pyth - 3 5 4 byte

Quindi, la versione originale a 3 caratteri non ha invertito l'ordine delle linee, ma solo le linee. Ho quindi pensato a questa versione a 5 caratteri:

_jb.z

Ho salvato 1 byte grazie a @FryAmTheEggman per ottenerlo:

_j.z

Dimostrazione dal vivo.

Spiegazione:

  .w  read all the input into a list of strings
 j    join (j) by using a newline character
_     reverse the result
      Pyth implicitly prints the result on an expression

Soluzione originale (errata):

Questo tecnicamente non conta perché Pyth è stato creato nel 2014, ma è comunque pulito e legato a GolfScript.

#_w

Spiegazione:

#    loop while no errors
  w  read a line of input (throws an error on end-of-file or Control-C)
 _   reverse the input line
     Pyth implicitly prints the result on an expression

Cubix , 9 8 byte

Mille grazie a Martin Ender per questo golf:

w;o@i.?\

Guardalo funzionare online!

Questo diventa il cubo seguente ( >indica il puntatore dell'istruzione iniziale):

      w ;
      o @
> i . ? \ . . . .
  . . . . . . . .
      . .
      . .

Il primo passo del programma è prendere tutti gli input. imette 1 byte di input nello stack. A meno che l'input non sia terminato, ?l'IP gira a destra, avvolgendosi attorno al cubo fino a raggiungere w, a cui lo rimanda i.

Al termine dell'input, l' ?IP si sposta verso nord, entrando nel loop di output:

• o: stampa il personaggio in cima alla pila
• w: 'elimina' il puntatore a destra
• ;: pop il personaggio che è stato appena stampato
• \: riflette l'IP, inviandolo a est
• ?: se ci sono caratteri rimanenti da stampare, girare a destra, di nuovo nel ciclo.

Il tempo finale ?viene raggiunto, quando nulla è lasciato nello stack, invece l'IP continua in avanti:

• i: accetta un byte di input. Questo sarà -1quando l'input è terminato.
• \: riflette l'IP, inviandolo a nord, in:
• @: termina il programma.

Soluzione a 9 byte

..o;i?@!/

Guardalo funzionare online!

In forma di cubo:

      . .
      o;
> io? @! /. . .
  . . . . . . . .
      . .
      . .

Il primo personaggio incontrato è i, che accetta un codice di input. Se non è rimasto alcun input, questo è -1.

Il prossimo personaggio è ?- una decisione. Se la parte superiore dello stack è positiva, gira a destra, avvolgendosi attorno al cubo fino a quando non colpisce, /che lo rimanda al i, creando un ciclo di input. Tuttavia, se il TOS è negativo, l'input è terminato e quindi si trasforma a sinistra nel loop di output.

Il loop di output è semplice. o;genera e visualizza i TOS. La prima volta che viene eseguito, -1è in cima allo stack, ma non viene mappato su un personaggio e viene quindi ignorato. /riflette l'IP per spostarsi a sinistra, dove si incontra !@- il che termina il programma se lo stack è vuoto. Altrimenti, l'IP continua, colpendo di ?nuovo - poiché lo stack non è vuoto, il TOS deve essere un charcode, tutti positivi ¹ , quindi l'IP gira a destra e continua il ciclo di output.

¹ Entrambe le soluzioni presuppongono che l'input non conterrà byte null.

05AB1E, 1 byte

R

R inverte l'ingresso.

Wumpus , 12 byte

i=)!4*0.l&o@

Provalo online!

La risposta di Martin mostra bene il flusso di controllo della griglia triangolare di Wumpus, ma ho pensato di provare questa sfida con un solo strato.

La versione più semplice da comprendere (un byte più lungo) è:

i=)!8*0.;l&o@

che funziona così:

[Input loop]
i        Read a byte of input (gives -1 on EOF)
=)!      Duplicate, increment then logical not (i.e. push 1 if EOF, else 0)
8*       Multiply by 8 (= x)
0        Push 0 (= y)
.        Jump to (x, y), i.e. (8, 0) if EOF else (0, 0) to continue input loop 

[Output]
;        Pop the extraneous -1 at the top from EOF
l&o      Output <length of stack> times
@        Terminate the program

Ora diamo un'occhiata alla versione golf, che differisce nel mezzo:

i=)!4*0.l&o@

La versione golfata salva un byte non avendo bisogno di un comando esplicito ;per far apparire l'estraneo -1. Su EOF, questo programma salta (4, 0)invece di (8, 0)dove viene eseguito di 4*0.nuovo - tranne che questa volta l'estraneo -1 è in cima! Questo ci porta a saltare a (-4, 0), che a causa del wrapping è lo stesso (8, 0)di questa griglia, portandoci dove vogliamo consumando allo stesso tempo il valore estraneo.

Wumpus , 13 11 byte

)?\;l&o@
=i

Provalo online!

Spiegazione

Poiché Wumpus è un linguaggio basato sullo stack, l'idea di base è leggere tutto lo STDIN nello stack e quindi stampare l'intero stack dall'alto verso il basso. La parte interessante qui è il flusso di controllo attraverso la griglia.

Per comprendere il flusso di controllo, dobbiamo esaminare il layout della griglia triangolare attuale:

L'IP inizia nell'angolo in alto a sinistra in direzione est. Possiamo vedere che c'è un ciclo attraverso il gruppo di sei celle a sinistra e un ramo al di fuori di \. Come prevedibile, il loop legge tutti gli input e la sezione lineare alla fine scrive il risultato su STDOUT.

Diamo un'occhiata prima al loop. Ha più senso pensare al primo )?\come non essere parte del loop, con il loop effettivo che inizia con i. Quindi ecco il bit iniziale:

)   Increment an implicit zero to get a 1.
?\  Pop the 1 (which is truthy) and execute the \, which reflects the IP
    to move southwest.

Quindi inizia il ciclo:

i   Read one byte from STDIN and push it to the stack (or -1 at EOF).
    Note that Wumpus's grid doesn't wrap around, instead the IP reflects
    off the bottom edge.
=   Duplicate the byte we've read, so that we can use it for the condition
    later without losing it.
)   Increment. EOF becomes zero (falsy) and everything else positive (truthy).
?\  If the incremented value is non-zero, execute the \ again, which 
    continues the loop. Otherwise (at EOF), the \ is skipped and the
    IP keeps moving east.

Questo lascia la sezione lineare alla fine:

;   Get rid of the -1 we read at EOF.
l   Push the stack depth, i.e. the number of bytes we've read.
&o  Print that many bytes.

PHP - 44 caratteri

<?=strrev(file_get_contents('php://stdin'));

Perl

print scalar reverse for reverse(<STDIN>);

Fissione , 20 15 byte

KX$ \
!
SR?J%
~

L'algoritmo è molto simile a quello di Martin, ma l'implementazione differisce in modo significativo.

Come funziona

Tutto inizia da R, che rilascia un atomo verso est con massa 1 ed energia 0.

Quando si colpisce ?, un carattere di input viene salvato come massa dell'atomo e l'energia viene lasciata a 0 a meno che lo stdin non restituisca EOF, nel qual caso l'energia diventa 1.

Jè il comando di salto di Fission e fa avanzare un atomo di un numero di celle equivalente alla sua energia attuale, lasciando l'atomo con energia 0. Per ora, il nostro atomo ha energia 0 e ignora questo comando.

Quindi colpiamo %, che è un interruttore. Con energia maggiore di 0, il nostro atomo sarebbe diretta verso il basso (come se riflessa da uno \specchio), ma poiché abbiamo esattamente 0 energia, siamo inviati verso l'alto dallo specchio opposto /.

Il nostro atomo continua fino a quando non colpisce un secondo specchio, \questa volta dirigendolo a sinistra.

Aumentiamo l'energia dell'atomo a 1 con $e usiamo Xper duplicare l'atomo. Una copia rifletterà nuovamente al $comando (lasciando quella copia con 2 energia) e l'altra copia sarà spinto alla pila, K.

La nostra copia riflessa viaggia all'indietro da dove è arrivata fino a quando non preme %nuovamente l' interruttore. Ora che abbiamo un'energia positiva, riflettiamo come se avessimo colpito uno \specchio, avvolgendoci attorno alla tavola successiva Se diminuendo la nostra energia a 1.

Il Scomando consumerà 1 energia per preservare la nostra direzione. Se non avessimo energia, l'atomo avrebbe deviato come se fosse stato colpito da uno \specchio, verso il basso. Invece, ci spostiamo di nuovo a destra e prendiamo più input con ?e il ciclo si ripete.

Una volta che il nostro atomo raggiunge EOF, il ?comando memorizzerà 1 energia nell'atomo. Pertanto, quando premiamo il Jcomando questa volta, saltiamo completamente %sull'interruttore e atterriamo Ssull'interruttore con energia 0.

Ora, poiché la nostra energia è stata consumata nel salto, la nostra direzione non è preservata Sdall'interruttore, ma siamo piuttosto diretti verso il basso. Riduciamo quindi la nostra energia a -1 con il ~comando e avvolgiamo il tabellone. Quando viene colpito con un'energia negativa, il Kcomando fa scoppiare un atomo invece di spingerne uno. Trasmettiamo il nostro atomo appena spuntato con !e utilizziamo l'energia di quell'atomo per bypassare l' Sinterruttore e il ciclo termina.

Se la pila Kera vuota, l'energia del nostro atomo viene negata (risultando in +1 energia) e viene riflessa sul ~comando, lasciandola con energia 0. Quando colpiamo di Snuovo, siamo deviati a destra, finché non ?viene colpito. Dal momento che EOF è stato raggiunto, questo ?distrugge l'atomo e termina il programma.

Labirinto , 10 byte

,)";@
:".(

Normalmente, i programmi Labyrinth dovrebbero assomigliare a labirinti, ma sono stato in grado di comprimere i loop in questo così strettamente, che il codice è finito come un singolo blocco (room?). Ecco una versione leggermente espansa che rende più semplice seguire il flusso di controllo:

,""")""""""";""@
"   "   "   "
:""""   ."""(

,legge un byte alla volta da STDIN fino a quando non colpisce EOF e ritorna -1. Gli )incrementi questo valore in modo da ottenere qualcosa di positivo per ogni byte di lettura e zero in EOF. I :duplicati di ogni byte letto.

Una volta premuto EOF, il puntatore dell'istruzione procede al secondo ciclo, dove scarta ripetutamente un valore con ;(inizialmente l'EOF, successivamente la seconda copia di ogni byte), quindi diminuisce il valore successivo con (e lo stampa con .. A causa di quella seconda copia (che è sempre positiva) sappiamo che l'IP girerà a destra in alto e continuerà in questo ciclo.

Dopo che tutti i byte sono stati stampati, la parte superiore dello stack è di nuovo zero e l'IP continua dritto fino al termine @del programma.

La duplicazione apparentemente non necessaria di ciascun byte è ciò che mi consente di garantire che (anche negli anelli stretti della versione golfata) l'IP faccia sempre la svolta corretta e non attraversi mai da un loop all'altro.

Un suggerimento per TheNumberOne e Sp3000 i cui tentativi hanno aiutato molto a trovare questa soluzione altamente compressa.