Requisitos:

• Tome una entrada en stdin incluyendo nuevas líneas / retornos de carro de longitud ilimitada (solo limitada por la memoria del sistema; es decir, no hay un límite inherente en el programa).
• Salida del reverso de la entrada en stdout.

Ejemplo:

Entrada:

Quick brown fox
He jumped over the lazy dog

Salida:

god yzal eht revo depmuj eH
xof nworb kciuQ

Las victorias más cortas.

Tabla de clasificación:

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 caracteres

-1%

La versión ofuscada también tiene 3 caracteres

0(%

Aquí hay una explicación de cómo funciona %

Golpe - 7

tac|rev

tacinvierte el orden de las líneas, mientras que revinvierte el orden de los caracteres.

BrainFuck, 10 personajes

,[>,]<[.<]

Supera una buena cantidad de respuestas para un lenguaje tan simple.

C, 37 bytes

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

Haskell - 21

main=interact reverse

Pila de panqueques , 342 316 bytes

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!

Se supone que la entrada termina con un carácter nulo ( ^@en la línea de comandos). Ejemplo de ejecución, utilizando el intérprete :

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 bytes

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

41 -> 40 - se eliminó el punto y coma al final del programa.

¡Probablemente podría optimizarse!

APL, 2

⊖⍞

O CircleBar QuoteQuad si los caracteres no llegan, simplemente significa: invertir la entrada de caracteres del teclado.

Perl - 23

print scalar reverse <>

Ruby - 19 caracteres

puts$<.read.reverse

C - 47 caracteres

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

Tenga en cuenta que esto usa espacio de pila O (n). Pruébalo en línea!

Windows PowerShell, 53 54

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

30-01-2011 (54) - Primer intento

30-01-2011 (53) - Los saltos de línea son divertidos.

2011-01-3- (52) - Asignaciones de variables en línea también.

Perl 5.1, 14

say~~reverse<>

Befunge-93 - 11x2 (22 caracteres)

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

Probado con este intérprete .

Cálculo binario de Lambda - 9 bytes

16 46 80 17 3E F0 B7 B0 40

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

Fisión , 16 14 12 bytes

DY$\
?
[Z~K!

Explicación

El flujo de control comienza Dcon un (1,0)átomo descendente . Las ?lecturas de STDIN, un carácter a la vez, configuran la masa para el código de carácter leído y la energía para 0. Una vez que lleguemos a EOF, ?estableceremos la energía en su lugar 1. El [redirige el átomo a un Zinterruptor. Mientras leamos los caracteres, la energía será 0así que el átomo es desviado hacia arriba por el Z. Clonamos el átomo, colocando una copia de nuevo en el ?para seguir leyendo la entrada. Incrementamos la energía de la otra copia 1con $y la empujamos a la pila K. Entonces el bucle de entrada es este:

DY$\
?
[Z K

Cuando la energía se 1debe a EOF, la Zvoluntad dejará que el átomo pase directamente y disminuya la energía 0nuevamente. ~disminuye la energía más allá -1. Los átomos con energía negativa aparecen en la pila, por lo que podemos recuperar los caracteres en orden inverso e imprimirlos !. Ahora tenga en cuenta que la cuadrícula es toroidal, por lo que el átomo vuelve a aparecer en el borde izquierdo de la misma fila. Recuerde que incrementamos la energía de los átomos empujados anteriormente $, por lo que los átomos ahora tienen energía 1como la última salida de ?y pasarán de nuevo directamente a través del Z. El camino después de EOF es por lo tanto

?
[Z~K!

Este bucle en la fila inferior continúa hasta que la pila esté vacía. Cuando eso sucede, el átomo se refleja desde el Ky su energía se vuelve positiva ( +1). Lo ~decrementa una vez más (moviéndose hacia la izquierda), de modo que ahora golpeamos Zcon energía no positiva. Esto desvía el átomo hacia abajo, de modo que termina en la cuña de Ydonde está almacenado, y debido a que no hay más átomos en movimiento, el programa termina.

> <>, ₁₆ 14 bytes

-2 bytes por @JoKing

dos años (!) más tarde, elimina el -1 extra de la entrada de lectura al cambiar la lógica para detenerse.

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

Pruébalo en línea!

Similar a la otra respuesta> <>, esto no necesita revertir la pila debido a la forma en que se lee la entrada en la primera línea. En realidad, no estoy muy seguro de si esto debería ser una sugerencia para la otra respuesta> <>, ya que es bastante diferente en apariencia pero similar en concepto.

La principal diferencia es que mi respuesta compara la entrada a 0, y si es menor (es decir, no hay entrada - idevuelve -1 si no hay entrada) salta a (1,7), si no, (0, 7) Si salta al primero, muestra el valor superior (-1) e inicia un ciclo de impresión. Si salta a este último, continúa el bucle de entrada.

11 bytes, sale con un error

Cortesía de @JoKing

i:0(7$.
~o!

Pruébalo en línea!

Creo que esto es válido ahora a través del meta consenso.

Respuesta anterior (14 bytes)

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

PHP - 38 17 caracteres

<?=strrev(`cat`);

Pila de gatos , 7 bytes

<!]T[!>

Pruébalo en línea!

Hay un montón de alternativas para el mismo número de bytes, la mayoría de las cuales son esencialmente equivalentes en cómo funcionan:

Explicación

Una cartilla corta de Stack Cats:

• Cada programa debe tener simetría espejo, y al reflejar cualquier fragmento de código obtenemos un código nuevo que computa la función inversa. Por lo tanto, los últimos tres caracteres del programa anterior deshacen los primeros tres, si no fuera por el comando en el centro.
• El modelo de memoria es una cinta infinita de pilas, que contiene una cantidad implícita e infinita de ceros en la parte inferior. La pila inicial tiene un -1encima de esos ceros y luego los bytes de entrada encima de eso (con el primer byte en la parte superior y el último byte encima de -1).
• Para la salida, simplemente tomamos la pila final, descartamos a -1en la parte inferior si hay una, y luego imprimimos todos los valores como bytes en STDOUT.

Ahora para el programa actual:

<    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 configuró su búsqueda de fuerza bruta para encontrar todas las demás soluciones de 7 bytes, así que aquí hay algunas alternativas:

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

Estas tres variantes son esencialmente las mismas, excepto que difieren cuando no se calcula el NOT bit a bit y si usamos la pila vacía a la izquierda o a la derecha.

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

Como dije en la explicación anterior, Tno hace nada cuando la parte superior de la pila es cero. Eso significa que podemos poner !el medio en su lugar. Eso significa que el primero Tes un no-op, luego giramos el cero en la parte superior en una -1y luego a continuación, la segunda Trealiza la inversión. Por supuesto, esto significa que el estado de memoria final tiene una -1pila en la pila al lado de la original, pero eso no importa ya que solo la pila en la posición actual del cabezal de la cinta afecta la salida.

<*ITI*>

Esta variante usa *(XOR 1) en lugar de !, de modo que convierte el cero en +1, y Ies un impulso condicional que empuja valores positivos y derechos, valores negativos a la izquierda, y los niega en cualquier caso (de modo que todavía terminamos con un -1en la parte superior de la pila original cuando nos encontramos T), por lo que en última instancia, funciona igual que la <!]T[!>solución original .

PHP, 82 29 24 29 28 caracteres

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

82 -> 29: el nuevo carácter de línea se conserva cuando se invierte con strrev.
29 -> 24: utiliza la sintaxis de acceso directo ahora
24 -> 29: ahora lee todas las líneas en lugar de una sola línea

Befunge-98 - 11 10

#v~
:<,_@#

(Probado con cfunge)

La siguiente variante rompe ligeramente el requisito: realiza la tarea pero genera una secuencia infinita de bytes nulos después (y no termina).

~#,

La forma en que funciona es que lee repetidamente la entrada a la pila ( ~) un carácter a la vez, saltando ( #) la coma. Cuando se alcanza EOF, ~actúa como un reflector y la PC se voltea, haciendo estallar repetidamente y emitiendo un carácter ( ,) mientras salta ( #) la tilde.

Pyth - 3 5 4 bytes

Entonces, la versión original de 3 caracteres no invirtió el orden de las líneas, solo las líneas. Luego se me ocurrió esta versión de 5 caracteres:

_jb.z

Ahorré 1 byte gracias a @FryAmTheEggman para obtener el resultado:

_j.z

Demo en vivo.

Explicación:

  .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

Solución original (incorrecta):

Esto técnicamente no cuenta porque Pyth fue creado en 2014, pero aún está claro que está vinculado con GolfScript.

#_w

Explicación:

#    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 bytes

Muchas gracias a Martin Ender por este golf:

w;o@i.?\

¡Véalo trabajar en línea!

Este se convierte en el siguiente cubo ( >indica el puntero de instrucción inicial):

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

El primer paso del programa es tomar todas las entradas. ipone 1 byte de entrada en la pila. A menos que la entrada esté terminada, ?la IP gira a la derecha y se envuelve alrededor del cubo hasta que llega w, lo que lo envía de nuevo a i.

Cuando finaliza la entrada, la ?IP se dirige hacia el norte, ingresando al bucle de salida:

• o: imprime el personaje en la parte superior de la pila
• w: 'esquiva' el puntero a la derecha
• ;: resalta el carácter que acaba de imprimirse
• \: refleja la IP, enviándola al Este
• ?: si quedan caracteres para imprimir, gire a la derecha y vuelva al bucle.

La última vez que ?se golpea, cuando no queda nada en la pila, la IP continúa en su lugar:

• i: toma un byte de entrada. Esto será -1cuando la entrada haya terminado.
• \: refleja la IP, enviándola al norte, a:
• @: termina el programa.

Solución de 9 bytes

..o;i?@!/

¡Véalo trabajar en línea!

En forma de cubo:

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

El primer personaje que se encuentra es i, que toma un código de entrada de caracteres. Si no queda ninguna entrada, esta es -1.

El siguiente personaje es ?: una decisión. Si la parte superior de la pila es positiva, gira a la derecha, envolviendo el cubo hasta que golpea, lo /que lo envía de vuelta al i, creando un bucle de entrada. Sin embargo, si el TOS es negativo, la entrada ha finalizado, por lo que gira a la izquierda en el bucle de salida.

El bucle de salida es simple. o;salidas y muestra los TOS. La primera vez que se ejecuta esto, -1es la parte superior de la pila, pero no se asigna a un personaje y, por lo tanto, se ignora. /refleja la IP para moverse hacia la izquierda, donde se encuentra !@, lo que termina el programa si la pila está vacía. De lo contrario, la IP continúa, golpeando de ?nuevo, ya que la pila no está vacía, el TOS debe ser un código de acceso, todos los cuales son positivos ¹ , por lo que esto hace que la IP gire a la derecha y continúe el ciclo de salida.

¹ Ambas soluciones suponen que la entrada no contendrá bytes nulos.

05AB1E, 1 byte

R

R invierte la entrada.

Wumpus , 12 bytes

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

Pruébalo en línea!

La respuesta de Martin muestra bien el flujo de control de cuadrícula triangular de Wumpus, pero pensé en probar este desafío con una sola línea.

La versión más fácil de entender (un byte más largo) es:

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

que funciona así:

[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

Ahora echemos un vistazo a la versión de golf, que difiere en el medio:

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

La versión de golf guarda un byte al no necesitar un comando explícito ;para hacer estallar el -1 extraño. En EOF, este programa salta a (4, 0)lugar de (8, 0)donde se ejecuta 4*0.nuevamente, ¡excepto que esta vez el -1 extraño está en la parte superior! Esto hace que saltemos (-4, 0), lo que debido al ajuste es el mismo que (8, 0)para esta cuadrícula, llevándonos a donde queremos mientras consumimos el valor extraño al mismo tiempo.

Wumpus , 13 11 bytes

)?\;l&o@
=i

Pruébalo en línea!

Explicación

Dado que Wumpus es un lenguaje basado en la pila, la idea básica es leer todo el STDIN en la pila y luego simplemente imprimir la pila completa de arriba a abajo. La parte interesante aquí es el flujo de control a través de la cuadrícula.

Para comprender el flujo de control, debemos observar el diseño de la cuadrícula triangular real:

La IP comienza en la esquina superior izquierda hacia el este. Podemos ver que hay un bucle a través del grupo de seis celdas a la izquierda, y una rama de la \. Como es de esperar, el bucle lee todas las entradas y la sección lineal al final escribe el resultado en STDOUT.

Veamos primero el bucle. Tiene más sentido pensar que el primero )?\no es parte del ciclo, con el ciclo real que comienza en i. Así que aquí está el bit inicial:

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

Entonces comienza el 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.

Eso deja la sección lineal al final:

;   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 caracteres

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

Perl

print scalar reverse for reverse(<STDIN>);

Fisión , 20 15 bytes

KX$ \
!
SR?J%
~

El algoritmo es muy similar al de Martin, pero la implementación difiere significativamente.

Cómo funciona

Todo comienza en R, lo que libera un átomo hacia el este con masa 1 y energía 0.

Al golpear ?, un carácter de entrada se guarda como la masa del átomo, y la energía se deja en 0 a menos que stdin devuelva EOF, en cuyo caso la energía se convierte en 1.

Jes el comando de salto de Fission, y salta un átomo hacia adelante una cantidad de celdas equivalente a su energía actual, dejando al átomo con energía 0. Por ahora, nuestro átomo tiene energía 0 e ignora este comando.

Luego atacamos %, que es un cambio. Con una energía mayor que 0, nuestro átomo se dirigiría hacia abajo (como si fuera reflejado por un \espejo), pero como tenemos exactamente 0 energía, el espejo opuesto nos envía hacia arriba /.

Nuestro átomo continúa hasta que golpea un segundo espejo, \esta vez dirigiéndolo hacia la izquierda.

Incrementamos la energía del átomo a 1 con $, y usamos Xpara duplicar el átomo. Una copia reflejará de nuevo en el $comando (dejando esa copia con 2 energía) y la otra copia será llevado a la pila, K.

Nuestra copia reflejada viaja hacia atrás desde donde vino hasta que toca el %interruptor nuevamente. Ahora que tenemos una energía positiva, reflexionamos como si hubiéramos golpeado un \espejo, envolviendo el tablero en el siguiente Sy disminuyendo nuestra energía a 1.

El Scomando consumirá 1 energía para preservar nuestra dirección. Si no tuviéramos energía, el átomo se habría desviado como golpeado por un \espejo, hacia abajo. En cambio, nos movemos hacia la derecha nuevamente y recogemos más información con ?y el ciclo se repite.

Una vez que nuestro átomo alcanza EOF, el ?comando almacenará 1 energía en el átomo. Por lo tanto, cuando golpeamos el Jcomando esta vez, saltamos por completo el %interruptor y aterrizamos en el Sinterruptor con 0 de energía.

Ahora, dado que nuestra energía se consumió en el salto, nuestra dirección no es preservada por el Sinterruptor, sino que estamos más bien dirigidos hacia abajo. Luego disminuimos nuestra energía a -1 con el ~comando y envolvemos el tablero. Cuando se golpea con una energía negativa, el Kcomando muestra un átomo en lugar de empujar uno. Generamos nuestro átomo recientemente reventado !y usamos la energía 1 de ese átomo para evitar el Sinterruptor, y el ciclo se completa.

Si la pila Kestaba vacía, la energía de nuestro átomo se niega (lo que resulta en +1 energía) y se refleja de nuevo en el ~comando, dejándolo con energía 0. Al golpear Snuevamente, nos desviamos hacia la derecha, hasta que ?se golpea. Desde que se llegó a EOF, ?destruye el átomo y termina el programa.

Laberinto , 10 bytes

,)";@
:".(

Normalmente, se supone que los programas Labyrinth se parecen a los laberintos, pero pude comprimir los bucles en este tan fuertemente, que el código terminó como un solo bloque (¿habitación?). Aquí hay una versión ligeramente expandida que facilita el seguimiento del flujo de control:

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

,lee un byte a la vez desde STDIN hasta que alcanza EOF y regresa -1. Los )incrementos de este valor para que podamos obtener algo positivo para cada byte de lectura y cero en EOF. Los :duplicados de cada byte leído.

Una vez que presionamos EOF, el puntero de instrucción pasa al segundo ciclo, donde descarta repetidamente un valor con ;(inicialmente el EOF, luego la segunda copia de cada byte), luego disminuye el siguiente valor con (y lo imprime con .. Debido a esa segunda copia (que siempre es positiva) sabemos que la IP girará a la derecha en la parte superior y continuará en este ciclo.

Una vez que se han impreso todos los bytes, la parte superior de la pila vuelve a ser cero y la IP continúa directamente hacia adelante @y el programa finaliza.

La duplicación aparentemente innecesaria de cada byte es lo que me permite asegurar que (incluso en los circuitos cerrados de la versión de golf) la IP siempre toma el giro correcto y nunca cruza de un circuito a otro.

Un consejo para TheNumberOne y Sp3000, cuyos propios intentos ayudaron mucho a encontrar esta solución altamente comprimida.