Exigences:

• Effectuez une entrée sur stdin, y compris les nouvelles lignes / retours à la chaîne de longueur illimitée (limitée uniquement par la mémoire système, c’est-à-dire qu’il n’ya pas de limite inhérente dans le programme.)
• Sortie l'inverse de l'entrée sur stdout.

Exemple:

Contribution:

Quick brown fox
He jumped over the lazy dog

Sortie:

god yzal eht revo depmuj eH
xof nworb kciuQ

Le plus court gagne.

Classement:

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 caractères

-1%

la version obfusquée est aussi 3 caractères

0(%

voici une explication de la façon dont % fonctionne

Bash - 7

tac|rev

tacinverse l'ordre des lignes, tandis que revinverse l'ordre des caractères.

BrainFuck, 10 personnages

,[>,]<[.<]

Bat beaucoup de réponses pour un langage aussi simple.

C, 37 octets

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

Haskell - 21

main=interact reverse

Pancake Stack , 342 316 octets

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!

Cela suppose que l’entrée se termine par un caractère nul ( ^@en ligne de commande). Exemple exécuté en utilisant l' interpréteur :

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 octets

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

41 -> 40 - point virgule supprimé à la fin du programme.

Probablement pourrait être optimisé!

APL, 2

⊖⍞

Ou CircleBar QuoteQuad si les caractères ne passent pas, ce qui signifie simplement: inverser la saisie de caractères au clavier.

Perl - 23

print scalar reverse <>

Ruby - 19 personnages

puts$<.read.reverse

C - 47 caractères

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

Notez que cela utilise O (n) espace de pile. Essayez-le en ligne!

Windows PowerShell, 53 à 54

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

2011-01-30 (54) - Première tentative

2011-01-30 (53) - Les sauts de ligne en ligne sont amusants.

2011-01-3- (52) - Les affectations de variables en ligne également.

Perl 5.1, 14

say~~reverse<>

Befunge-93 - 11x2 (22 caractères)

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

Testé à l'aide de cet interprète .

Lambda Calcul binaire - 9 octets

16 46 80 17 3E F0 B7 B0 40

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

Fission , 16 14 12 octets

DY$\
?
[Z~K!

Explication

Le flux de contrôle commence à Davec un (1,0)atome descendant . Les ?lectures de STDIN, un caractère à la fois, fixent la masse au code de caractère lu et à l’énergie 0. Une fois que nous avons atteint EOF, nous ?allons définir l’énergie sur 1. Le [redirige l'atome sur un Zcommutateur. Tant que nous lirons des caractères, l’énergie sera 0, de sorte que l’atome est dévié vers le haut par le Z. Nous clonons l'atome en remettant une copie dans la boucle ?pour continuer à lire les entrées. Nous incrémente l'énergie de l'autre copie 1avec $et le pousser sur la pile K. Donc la boucle d'entrée est la suivante:

DY$\
?
[Z K

Lorsque l'énergie est 1due à EOF, la Zvolonté laissera plutôt l'atome traverser et décrémenter à 0nouveau l'énergie . ~décrémente l'énergie davantage à -1. Des atomes à énergie négative jaillissent de la pile, ce qui permet de récupérer les caractères dans l’ordre opposé et de les imprimer !. Notez maintenant que la grille est toroïdale, de sorte que l'atome réapparaît sur le bord gauche de la même ligne. Rappelez-vous que nous avons incrémenté l’énergie des atomes poussés plus tôt avec $, de sorte que les atomes ont maintenant de l’énergie 1tout comme la dernière sortie de ?et passera à nouveau directement à travers le Z. Le chemin après EOF est donc

?
[Z~K!

Cette boucle sur la ligne du bas continue jusqu'à ce que la pile soit vide. Lorsque cela se produit, l'atome est réfléchi par le Ket son énergie devient positive ( +1). Le ~décrémente encore une fois (en se déplaçant vers la gauche), de sorte que nous touchons maintenant le Zavec une énergie non positive. Cela dévie l'atome vers le bas, de sorte qu'il se termine dans le coin Yoù il est stocké et, comme il n'y a plus d'atomes en mouvement, le programme se termine.

> <>, ₁₆ 14 octets

-2 octets par @JoKing

deux ans (!) plus tard, supprime le -1 supplémentaire de la lecture en déplaçant la logique d’arrêt.

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

Essayez-le en ligne!

Semblable à l'autre> <> réponse, il n'est pas nécessaire d'inverser la pile à cause de la façon dont l'entrée est lue dans la première ligne. En fait, je ne suis pas trop sûr de savoir si cela devrait être une suggestion pour l'autre réponse> <>, car son apparence est très différente mais son concept est similaire.

La principale différence est que ma réponse compare l’entrée à 0, et si elle est inférieure (c’est-à-dire qu’il n’ya pas d’entrée - irenvoie -1 si aucune entrée n’est donnée), il saute à (1,7), sinon, (0, sept). S'il passe à l'ancien, la valeur supérieure (-1) est affichée et une boucle d'impression est lancée. S'il saute à ce dernier, il continue la boucle d'entrée.

11 octets, sort avec une erreur

Gracieuseté de @JoKing

i:0(7$.
~o!

Essayez-le en ligne!

Je crois que cela est valable maintenant via le méta-consensus.

Réponse précédente (14 octets)

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

PHP - 38 17 caractères

<?=strrev(`cat`);

Stack Cats , 7 octets

<!]T[!>

Essayez-le en ligne!

Il existe de nombreuses alternatives pour le même nombre d'octets, dont la plupart sont essentiellement équivalentes par leur fonctionnement:

Explication

Un petit guide pour Stack Cats:

• Chaque programme doit avoir une symétrie miroir, et en reflétant tout morceau de code, nous obtenons un nouveau code calculant la fonction inverse. Par conséquent, les trois derniers caractères du programme ci-dessus annulent les trois premiers, s'il ne s'agissait pas de la commande au centre.
• Le modèle de mémoire est une bande infinie de piles, contenant une quantité implicite infinie de zéros au bas. La pile initiale a un -1dessus de ces zéros, puis les octets d'entrée en plus de cela (avec le premier octet tout en haut et le dernier octet au-dessus du -1).
• Pour la sortie, nous prenons simplement la pile finale, ignorons -1le bas s'il y en a une, puis imprimons toutes les valeurs sous forme d'octets dans STDOUT.

Passons maintenant au programme actuel:

<    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 a mis sa recherche de force brute à la recherche de toutes les autres solutions à 7 octets. Voici donc quelques alternatives:

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

Ces trois variantes sont essentiellement les mêmes, sauf qu'elles diffèrent par le calcul du NON au niveau du bit et par l'utilisation de la pile vide à gauche ou à droite.

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

Comme je l'ai dit dans l'explication ci-dessus, Tne fait rien lorsque le sommet de la pile est à zéro. Cela signifie que nous pouvons réellement mettre le !au centre à la place. Cela signifie que le premier Test un no-op, nous tournons le zéro sur le dessus dans un -1et puis ensuite deuxième Teffectue l'inversion. Bien entendu, cela signifie que l'état final de la mémoire a un -1sur la pile à côté de celui d'origine, mais cela n'a pas d'importance, car seule la pile à la position actuelle de la tête de la bande affecte la sortie.

<*ITI*>

Cette variante utilise *(XOR 1) au lieu de !, de manière à transformer le zéro en +1, et le Iest une poussée conditionnelle qui pousse les valeurs positives et à droite, les valeurs négatives à gauche, et les annule dans les deux cas (de sorte que nous aboutissons toujours à un -1lorsque nous rencontrons T), cela fonctionne donc de la même manière que la <!]T[!>solution originale .

PHP, 82 29 24 29 28 caractères

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

82 -> 29: Le caractère de nouvelle ligne est conservé lorsqu'il est inversé avec strrev.
29 -> 24: Utilise maintenant la syntaxe de raccourci.
24 -> 29: lit maintenant toutes les lignes au lieu d'une seule.

Befunge-98 - 11 10

#v~
:<,_@#

(Testé avec cfunge)

La variante ci-dessous rompt légèrement l'exigence: elle exécute la tâche mais génère ensuite un flux infini d'octets nuls (et ne se termine pas).

~#,

La façon dont cela fonctionne est qu’il lit de façon répétée les entrées dans la pile ( ~), caractère par caractère, en sautant ( #) la virgule. Lorsque EOF est atteint, ~agit comme un réflecteur et le PC bascule, saute et affiche de manière répétée un caractère ( ,) tout en sautant ( #) le tilde.

Pyth - 3 5 4 octets

Ainsi, la version originale à 3 caractères n'a pas inversé l'ordre des lignes, mais uniquement les lignes. Je suis alors venu avec cette version à 5 caractères:

_jb.z

J'ai sauvé 1 octet grâce à @FryAmTheEggman pour le résultat:

_j.z

Démo en direct.

Explication:

  .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

Solution originale (incorrecte):

Techniquement, cela n’a aucune importance, car Pyth a été créé en 2014, mais il n’en reste pas moins qu’il est lié à GolfScript.

#_w

Explication:

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

Merci à Martin Ender pour ce golf:

w;o@i.?\

Voir le travail en ligne!

Cela devient le cube suivant ( >indique le pointeur d'instruction initiale):

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

La première étape du programme consiste à prendre toutes les entrées. imet 1 octet d'entrée sur la pile. À moins que l’entrée ne soit terminée, ?l’IP tourne à droite, enroulant le cube jusqu’à atteindre w, ce qui le renvoie i.

Lorsque l’entrée se termine, le programme ?fait passer l’IP vers le nord en entrant dans la boucle de sortie:

• o: imprimer le personnage en haut de la pile
• w: 'sidestep' le pointeur à droite
• ;: pop le personnage qui vient d'être imprimé
• \: refléter l'adresse IP en l'envoyant vers l'est
• ?: s'il reste des caractères à imprimer, tournez à droite, revenez dans la boucle.

La dernière fois ?est atteinte, quand rien ne reste sur la pile, l’IP continue à la place:

• i: prend un octet d'entrée. Ce sera -1comme entrée a fini.
• \: reflète l'adresse IP, en l'envoyant au nord, dans:
• @: terminer le programme.

Solution de 9 octets

..o;i?@!/

Voir le travail en ligne!

Sous forme de cube:

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

Le premier caractère rencontré est celui iqui prend un charcode d’entrée. S'il n'y a plus d'entrée, c'est bien -1.

Le caractère suivant est ?- une décision. Si le haut de la pile est positif, il tourne à droite et contourne le cube jusqu'à ce qu'il frappe, /ce qui le renvoie au i, créant ainsi une boucle de saisie. Cependant, si le TOS est négatif, l’entrée est terminée et elle se tourne vers la gauche dans la boucle de sortie.

La boucle de sortie est simple. o;sorties et affiche le TOS. La première fois que cela est exécuté, -1c'est le haut de la pile, mais ne correspond pas à un personnage et est donc ignoré. /reflète l'adresse IP à déplacer à gauche, où il rencontre !@- ce qui termine le programme si la pile est vide. Sinon, l'IP continue, en tapant ?encore une fois - parce que la pile n'est pas vide, le TOS doit être un charcode, tous positifs ( ¹⁾ , ce qui fait que l'IP tourne à droite et continue la boucle de sortie.

¹ Les deux solutions supposent que l'entrée ne contiendra pas d'octets nuls.

05AB1E, 1 octet

R

R inverse l’entrée.

Wumpus , 12 octets

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

Essayez-le en ligne!

La réponse de Martin montre bien le flux de contrôle de grille triangulaire de Wumpus, mais je pensais que je tenterais ce défi avec un one-liner.

La version la plus facile à comprendre (un octet de plus) est:

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

qui fonctionne comme suit:

[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

Jetons maintenant un coup d'œil à la version avec golf, qui diffère au milieu:

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

La version avec golf enregistre un octet car elle n’a pas besoin d’une commande explicite ;pour extraire la valeur -1 superflue. Ce programme saute à la fin du fichier, au (4, 0)lieu de (8, 0)où il exécute à 4*0.nouveau - sauf que cette fois l'étranger -1 est sur le dessus! Cela nous amène à sauter (-4, 0), ce qui en raison de l’emballage est identique à celui (8, 0)de cette grille, nous amenant où nous voulons tout en consommant la valeur étrangère en même temps.

Wumpus , 13 à 11 octets

)?\;l&o@
=i

Essayez-le en ligne!

Explication

Puisque Wumpus est un langage basé sur les piles, l’idée de base est de lire tous les codes STDIN dans la pile, puis d’imprimer la pile entière de haut en bas. La partie intéressante ici est le flux de contrôle à travers la grille.

Pour comprendre le flux de contrôle, nous devons examiner la disposition actuelle de la grille triangulaire:

La propriété intellectuelle commence dans le coin supérieur gauche en direction est. Nous pouvons voir qu’il ya une boucle dans le groupe de six cellules à gauche et une branche de la \. Comme on pouvait s'y attendre, la boucle lit toutes les entrées et la section linéaire à la fin écrit le résultat dans STDOUT.

Regardons d'abord la boucle. Il est plus logique de penser que le premier )?\ne fait pas partie de la boucle, la boucle réelle commençant au début i. Alors voici le bit initial:

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

Puis la boucle commence:

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.

Cela laisse la section linéaire à la fin:

;   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 caractères

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

Perl

print scalar reverse for reverse(<STDIN>);

Fission , 20 à 15 octets

KX$ \
!
SR?J%
~

L'algorithme est très similaire à celui de Martin, mais la mise en œuvre diffère considérablement.

Comment ça fonctionne

Tout commence à R , ce qui libère un atome vers l'est de masse 1 et d'énergie 0.

En frappant ?, un caractère saisi est enregistré en tant que masse de l'atome et l'énergie est laissée à 0 sauf si stdin renvoie EOF, auquel cas l'énergie devient 1.

Jest la commande de saut de Fission, et saute un atome en avant d'un nombre de cellules équivalent à son énergie actuelle, laissant l'atome à 0 énergie. Pour l'instant, notre atome a 0 énergie et ignore cette commande.

Nous frappons ensuite %, ce qui est un commutateur. Avec plus de 0 énergie, notre atome serait dirigé vers le bas (comme si réfléchie par un \miroir), mais étant donné que nous avons exactement 0 l' énergie, nous sommes envoyés vers le haut par le miroir opposé, /.

Notre atome continue jusqu'à ce qu'il rencontre un deuxième miroir, \cette fois en le dirigeant vers la gauche.

Nous incrémentons l'énergie de l'atome à 1 avec $, et utilisons Xpour dupliquer l'atome. Une copie sera renvoyée à la $commande (en laissant cette copie avec 2 énergie) et l'autre copie sera placée dans la pile,K .

Notre copie réfléchie se déplace d’où elle vient jusqu’à ce qu’elle revienne à l’ %interrupteur. Maintenant que nous avons une énergie positive, nous réfléchissons comme si nous nous étions heurtés à un \miroir, passant d’un bord à l’autre au tableau suivant Set réduisant notre énergie à 1.

La Scommande consomme 1 énergie pour préserver notre direction. Si nous n'avions pas d'énergie, l'atome aurait dévié comme s'il était frappé par un \miroir, en bas. Au lieu de cela, nous nous déplaçons à nouveau vers la droite et prenons plus d’entrées avec ?et le cycle se répète.

Une fois que notre atome a atteint EOF, la ?commande stockera 1 énergie dans l’atome. Ainsi, lorsque nous appuyons sur la Jcommande cette fois-ci, nous sautons complètement l' %interrupteur et atterrissons sur leS avec 0 énergie.

Maintenant, puisque notre énergie a été consommée pendant le saut, notre direction n’est pas préservée par le Scommutateur, mais nous sommes plutôt dirigés vers le bas. Nous décrémentons ensuite notre énergie à -1 avec la ~commande et enveloppons le tableau. Lorsqu'elle est touchée par une énergie négative, la Kcommande fait apparaître un atome au lieu d'en pousser un. Nous produisons notre atome récemment sauté avec !, et utilisons l'énergie 1 de cet atome pour contourner le Scommutateur, et le cycle se termine.

Si la pile Kétait vide, l'énergie de notre atome est annulée (ce qui donne +1 énergie) et il est renvoyé sur la ~commande, le laissant avec l'énergie 0. En frappant à Snouveau, nous sommes déviés vers la droite, jusqu'à ce que le coup ?soit frappé. Depuis que EOF a été atteint, le ?détruit l'atome et termine le programme.

Labyrinthe , 10 octets

,)";@
:".(

Normalement, les programmes Labyrinth sont supposés ressembler à des labyrinthes, mais j’ai réussi à compresser les boucles dans celui-ci si étroitement que ce code s’est transformé en un seul bloc (pièce?). Voici une version légèrement développée qui facilite le suivi du flux de contrôle:

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

,lit un octet à la fois de STDIN jusqu'à ce qu'il atteigne EOF et revienne -1. Le )incrémente cette valeur pour que nous obtenions quelque chose de positif pour chaque octet de lecture et zéro à EOF. Les :doublons lisent chaque octet.

Une fois que nous avons atteint EOF, le pointeur d’instruction passe à la seconde boucle, où il omet de manière répétée une valeur avec ;(initialement, EOF, plus tard, la deuxième copie de chaque octet), puis décrémente la valeur suivante (et l’affiche avec. . En raison de cette deuxième copie (qui est toujours positive), nous savons que l’IP tournera à droite en haut et continuera dans cette boucle.

Une fois que tous les octets ont été imprimés, le sommet de la pile est à nouveau à zéro et l'adresse IP continue tout droit jusqu'à @et le programme se termine.

La duplication apparemment inutile de chaque octet est ce qui me permet de garantir que (même dans les boucles serrées de la version jouée au golf), l’IP prend toujours le virage correct et ne passe jamais d’une boucle à l’autre.

Coup de chapeau à TheNumberOne et à Sp3000, qui ont eux-mêmes tenté de trouver cette solution hautement compressée.