Bedarf:

• Nehmen Sie eine Eingabe für stdin vor, einschließlich neuer Zeilen / Zeilenumbrüche mit unbegrenzter Länge (nur begrenzt durch den Systemspeicher; das heißt, das Programm hat keine inhärente Beschränkung.)
• Geben Sie die Umkehrung der Eingabe auf stdout aus.

Beispiel:

Eingang:

Quick brown fox
He jumped over the lazy dog

Ausgabe:

god yzal eht revo depmuj eH
xof nworb kciuQ

Kürzeste Siege.

Bestenliste:

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 Zeichen

-1%

verschleierte Version ist auch 3 Zeichen

0(%

Hier ist eine Erklärung, wie % funktioniert

Bash - 7

tac|rev

tacKehrt die Zeilenreihenfolge um, während revdie Zeichenreihenfolge umgekehrt wird.

BrainFuck, 10 Zeichen

,[>,]<[.<]

Beats eine gute Menge von Antworten für eine so einfache Sprache.

C 37 Bytes

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

Haskell - 21

main=interact reverse

Python, 41 bis 40 Bytes

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

41 -> 40 - Semikolon am Programmende entfernt.

Könnte wohl optimiert werden!

Pfannkuchenstapel , 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!

Es wird davon ausgegangen, dass die Eingabe durch ein Nullzeichen ( ^@in der Befehlszeile) abgeschlossen wird. Beispiellauf mit dem Interpreter :

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

APL, 2

⊖⍞

Oder CircleBar QuoteQuad, wenn die Zeichen nicht durchkommen, was einfach bedeutet: Umgekehrte Zeicheneingabe über die Tastatur.

Perl - 23

print scalar reverse <>

Ruby - 19 Zeichen

puts$<.read.reverse

C - 47 Zeichen

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

Beachten Sie, dass dies O (n) Stapelspeicherplatz verwendet. Probieren Sie es online!

Windows PowerShell, 53 54

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

2011-01-30 (54) - Erster Versuch

2011-01-30 (53) - Inline-Zeilenumbrüche machen Spaß.

2011-01-3- (52) - Inline-Variablenzuweisungen ebenfalls.

Perl 5.1, 14

say~~reverse<>

Befunge-93 - 11x2 (22 Zeichen)

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

Getestet mit diesem Interpreter .

Binäre Lambda-Rechnung - 9 Bytes

16 46 80 17 3E F0 B7 B0 40

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

Spaltung , 16 14 12 Bytes

DY$\
?
[Z~K!

Erläuterung

Der Kontrollfluss beginnt Dmit einem absteigenden (1,0)Atom. Das ?liest von STDIN, ein Zeichen nach dem anderen, die Masse auf den gelesenen Zeichencode und die Energie auf 0. Sobald wir EOF drücken, ?wird stattdessen die Energie auf eingestellt 1. Das [leitet das Atom auf einen ZSchalter um. Solange wir Zeichen lesen, wird die Energie so groß sein 0, dass das Atom von der nach oben abgelenkt wird Z. Wir klonen das Atom und schleifen eine Kopie in das zurück ?, um die Eingabe weiterzulesen. Wir erhöhen die Energie der anderen Kopie 1mit $und schieben Sie es auf den Stapel K. Die Eingabeschleife lautet also:

DY$\
?
[Z K

Wenn die Energie 1auf EOF zurückzuführen ist, lässt der ZWille stattdessen das Atom geradewegs durch und dekrementiert die Energie auf 0erneut. ~dekrementiert die Energie weiter auf -1. Atome mit negativer Energie Pop aus dem Stapel, so können wir die Zeichen in umgekehrter Reihenfolge und drucken Sie sie mit abrufen !. Beachten Sie nun, dass das Gitter toroidal ist, sodass das Atom am linken Rand derselben Zeile wieder erscheint. Denken Sie daran, dass wir die Energie der gedrängten Atome früher mit erhöht haben $, sodass die Atome jetzt 1genau wie die letzte Ausgabe von ?und wieder direkt durch die haben Z. Der Weg nach EOF ist also

?
[Z~K!

Diese Schleife in der unteren Reihe wird fortgesetzt, bis der Stapel leer ist. In diesem Fall wird das Atom von der reflektiert Kund seine Energie wird positiv ( +1). Das ~dekrementiert es noch einmal (nach links), so dass wir das nun Zmit kraftschlüssiger Energie treffen . Dies lenkt das Atom nach unten ab, so dass es in dem Keil landet, in dem Yes gespeichert ist, und da sich keine Atome mehr bewegen, wird das Programm beendet.

> <>, _{16 bis} 14 Bytes

-2 Bytes von @JoKing

Zwei Jahre (!) später wird der zusätzliche Wert -1 aus der Leseeingabe entfernt, indem die Logik für das Anhalten geändert wird.

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

Probieren Sie es online!

Ähnlich wie bei der anderen Antwort> <> muss der Stapel nicht umgekehrt werden, da die Eingabe in der ersten Zeile gelesen wird. Ich bin mir eigentlich nicht sicher, ob dies ein Vorschlag für die andere> <> Antwort sein soll oder nicht, da es in der Erscheinung ganz anders ist, aber im Konzept ähnlich.

Der Hauptunterschied besteht darin, dass meine Antwort die Eingabe mit 0 vergleicht. Wenn sie kleiner ist (dh es gibt keine Eingabe - igibt -1 zurück, wenn es keine Eingabe gibt), springt sie zu (1,7), wenn nicht, (0, 7). Springt es zu ersteren, wird der oberste Wert (-1) angezeigt und eine Druckschleife gestartet. Springt es zu letzterem, setzt es die Eingabeschleife fort.

11 Bytes, wird mit einem Fehler beendet

Mit freundlicher Genehmigung von @JoKing

i:0(7$.
~o!

Probieren Sie es online!

Ich glaube, dass dies jetzt über einen Metakonsens gültig ist.

Vorherige Antwort (14 Bytes)

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

PHP - 38 17 Zeichen

<?=strrev(`cat`);

Stapel Katzen , 7 Bytes

<!]T[!>

Probieren Sie es online!

Es gibt eine Reihe von Alternativen für dieselbe Byteanzahl, von denen die meisten in ihrer Funktionsweise im Wesentlichen gleichwertig sind:

Erläuterung

Ein kurzer Stack Cats Primer:

• Jedes Programm muss spiegelsymmetrisch sein, und durch Spiegeln eines Codes erhalten wir neuen Code, der die Umkehrfunktion berechnet. Daher machen die letzten drei Zeichen des obigen Programms die ersten drei rückgängig, wenn der Befehl nicht in der Mitte wäre.
• Das Speichermodell ist ein unendliches Band von Stapeln, die implizit unendlich viele Nullen enthalten. Der anfängliche Stapel hat ein -1Oben auf diesen Nullen und dann die Eingangsbytes darüber (mit dem ersten Byte ganz oben und dem letzten Byte über dem -1).
• Für die Ausgabe nehmen wir einfach den letzten Stapel, verwerfen einen, -1falls vorhanden , am unteren Rand und geben dann alle Werte als Bytes an STDOUT aus.

Nun zum eigentlichen Programm:

<    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 hat seine Brute-Force-Suche so eingestellt, dass alle anderen 7-Byte-Lösungen gefunden werden. Hier einige Alternativen:

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

Diese drei Varianten sind im Wesentlichen gleich, außer dass sie sich unterscheiden, wenn das bitweise NICHT berechnet wird und ob wir den leeren Stapel links oder rechts verwenden.

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

Wie ich in der obigen Erklärung sagte, Tmacht es nichts, wenn die Spitze des Stacks Null ist. Das heißt, wir können das eigentlich !in die Mitte legen . Das heißt, das erste Tist ein No-Op, dann wandeln wir die Null oben in ein -1und dannT führt das zweite die Umkehrung durch. Dies bedeutet natürlich, dass der endgültige Speicherstatus -1neben dem ursprünglichen einen auf dem Stapel hat, aber das spielt keine Rolle, da nur der Stapel an der aktuellen Bandkopfposition die Ausgabe beeinflusst.

<*ITI*>

Diese Variante verwendet *(XOR 1) anstelle von !, so dass die Null in umgewandelt +1wird. Dies Iist ein bedingter Push, der positive und rechte sowie negative Werte nach links schiebt und sie in beiden Fällen negiert (so dass wir immer noch mit a enden) -1auf dem Originalstapel , wenn wir begegnen T), so funktioniert dies letztlich das gleiche wie die ursprüngliche <!]T[!>Lösung.

PHP, 82 29 24 29 28 Zeichen

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

82 -> 29: Das neue Zeilenzeichen bleibt beim Umkehren mit erhalten strrev.
29 -> 24: Verwendet jetzt die Shortcut-Syntax.
24 -> 29: Liest jetzt alle Zeilen anstelle einer einzelnen Zeile

Befunge-98 - 11 10

#v~
:<,_@#

(Getestet mit cfunge)

Die folgende Variante verletzt die Anforderung geringfügig: Sie führt die Aufgabe aus, gibt danach jedoch einen unendlichen Strom von Null-Bytes aus (und endet nicht).

~#,

Die Art und Weise, wie es funktioniert, ist, dass es wiederholt ~Zeichen für Zeichen Eingaben in den Stack ( ) liest und dabei über #das Komma springt ( ). Wenn EOF erreicht ist, ~fungiert es als Reflektor und der PC dreht sich um, wobei er wiederholt ein Zeichen ( ,) aufnimmt und ausgibt, während er über #die Tilde springt ( ).

Pyth - 3 5 4 Bytes

Die ursprüngliche 3-Zeichen-Version hat also nicht die Zeilenreihenfolge umgekehrt, sondern nur die Zeilen. Ich habe mir dann diese 5-Zeichen-Version ausgedacht:

_jb.z

Ich habe 1 Byte dank @FryAmTheEggman gespeichert, um das Ergebnis zu erzielen:

_j.z

Live-Demo.

Erläuterung:

  .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

Ursprüngliche (falsche) Lösung:

Technisch gesehen zählt dies nicht, da Pyth im Jahr 2014 erstellt wurde, aber es ist immer noch gut, dass es mit GolfScript verknüpft ist.

#_w

Erläuterung:

#    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

Vielen Dank an Martin Ender für diesen Golf:

w;o@i.?\

Sehen Sie, wie es online funktioniert!

Dies wird zum folgenden Würfel ( >zeigt den anfänglichen Anweisungszeiger an):

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

Der erste Schritt des Programms besteht darin, alle Eingaben zu übernehmen. ilegt 1 Byte Eingabe auf den Stapel. Wenn die Eingabe nicht abgeschlossen ist, ?dreht sich die IP nach rechts und umschließt den Würfel, bis sie erreicht wist. Dadurch wird sie zurück an gesendet i.

Wenn die Eingabe beendet ist, ?bewegt sich die IP nach Norden und tritt in die Ausgabeschleife ein:

• o: drucke das Zeichen oben auf dem Stapel
• w: 'sidestep' den Zeiger nach rechts
• ;: Pop das Zeichen, das gerade gedruckt wurde
• \: reflektiere die IP und sende sie nach Osten
• ?: Wenn noch Zeichen zu drucken sind, biegen Sie rechts ab und kehren Sie in die Schleife zurück.

Das letzte Mal ?, wenn nichts mehr auf dem Stack ist, wird die IP weitergeleitet:

• i: Nehmen Sie ein Byte der Eingabe. Dies wird sein, -1wenn die Eingabe beendet ist.
• \: Geben Sie die IP an, indem Sie sie nach Norden senden, in:
• @: Programm beenden.

9-Byte-Lösung

..o;i?@!/

Sehen Sie, wie es online funktioniert!

In Würfelform:

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

Das erste gefundene Zeichen ist i, das einen Zeichencode für die Eingabe annimmt. Wenn keine Eingabe mehr vorhanden ist, ist dies -1.

Das nächste Zeichen ist ?- eine Entscheidung. Wenn der obere Teil des Stapels positiv ist, dreht er sich nach rechts und umschließt den Würfel, bis er trifft, /wodurch er an den zurückgeschickt wird i, wodurch eine Eingabeschleife erstellt wird. Wenn der TOS jedoch negativ ist, ist die Eingabe beendet und geht nach links in die Ausgabeschleife über.

Die Ausgangsschleife ist einfach. o;gibt das TOS aus und öffnet es. Das erste Mal, wenn dies ausgeführt wird, -1befindet sich am Anfang des Stapels, ist jedoch keinem Zeichen zugeordnet und wird daher ignoriert. /Gibt die IP an, die nach links verschoben werden soll, wo sie gefunden wird. Dies !@beendet das Programm, wenn der Stapel leer ist. Andernfalls geht die IP weiter und schlägt ?erneut zu - da der Stack nicht leer ist, muss der TOS ein Zeichencode sein, der alle positiv ¹ ist. Dadurch wird die IP nach rechts gedreht und die Ausgabeschleife fortgesetzt.

^{1 Bei} beiden Lösungen wird davon ausgegangen, dass die Eingabe keine Nullbytes enthält.

05AB1E, 1 Byte

R

R kehrt die Eingabe um.

Wumpus , 12 Bytes

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

Probieren Sie es online!

Martins Antwort zeigt Wumpus 'Dreiecksgitter-Kontrollfluss gut, aber ich dachte, ich würde diese Herausforderung mit einem Einzeiler versuchen.

Die verständlichere Version (ein Byte länger) ist:

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

was so funktioniert:

[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

Schauen wir uns nun die Golfversion an, die sich in der Mitte unterscheidet:

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

Die Golf-Version spart ein Byte, indem sie keinen expliziten Befehl benötigt, ;um das fremde -1 zu setzen. Auf EOF springt dieses Programm zu der (4, 0)Stelle, an der (8, 0)es 4*0.erneut ausgeführt wird - außer, dass diesmal das überflüssige -1 oben steht! Dies veranlasst uns zu springen (-4, 0), was aufgrund der Umhüllung dasselbe ist wie (8, 0)für dieses Gitter, und uns zu bringen, wo wir wollen, während wir gleichzeitig den Fremdwert verbrauchen.

Wumpus , 13 11 Bytes

)?\;l&o@
=i

Probieren Sie es online!

Erläuterung

Da Wumpus eine stapelbasierte Sprache ist, besteht die Grundidee darin, alle STDIN in den Stapel einzulesen und dann nur den gesamten Stapel von oben nach unten zu drucken. Der interessante Teil hier ist der Kontrollfluss durch das Gitter.

Um den Kontrollfluss zu verstehen, müssen wir uns das tatsächliche dreieckige Gitterlayout ansehen:

Die IP beginnt in der oberen linken Ecke und geht nach Osten. Wir können sehen, dass es eine Schleife durch die Gruppe von sechs Zellen auf der linken Seite und einen Abzweig von der gibt \. Wie zu erwarten, liest die Schleife alle Eingaben und der lineare Abschnitt am Ende schreibt das Ergebnis zurück nach STDOUT.

Schauen wir uns zuerst die Schleife an. Es ist sinnvoller, sich die erste )?\als nicht Teil der Schleife vorzustellen, wobei die eigentliche Schleife an der beginnt i. Also hier ist der Anfang:

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

Dann beginnt die Schleife:

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.

Damit bleibt der lineare Abschnitt am Ende:

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

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

Perl

print scalar reverse for reverse(<STDIN>);

Fission , 20 15 Bytes

KX$ \
!
SR?J%
~

Der Algorithmus ist dem von Martin sehr ähnlich, die Implementierung unterscheidet sich jedoch erheblich.

Wie es funktioniert

Alles beginnt bei R, was ein nach Osten gerichtetes Atom mit Masse 1 und Energie 0 freisetzt.

Bei einem Treffer ?wird ein eingegebenes Zeichen als Atommasse gespeichert und die Energie bei 0 belassen, es sei denn, stdin gibt EOF zurück. In diesem Fall wird die Energie zu 1.

Jist Fissions Sprungbefehl und springt ein Atom um eine Anzahl von Zellen vorwärts, die seiner aktuellen Energie entspricht, wobei das Atom mit 0 Energie belassen wird. Im Moment hat unser Atom 0 Energie und ignoriert diesen Befehl.

Wir schlagen dann zu %, was ein Schalter ist. Mit mehr als 0 Energie würde unser Atom nach unten gerichtet sein (als würde es von einem \Spiegel reflektiert ), aber da wir genau 0 Energie haben, werden wir vom gegenüberliegenden Spiegel nach oben geschickt /.

Unser Atom fährt fort, bis es auf einen zweiten Spiegel trifft und ihn \dieses Mal nach links lenkt.

Wir erhöhen die Energie des Atoms mit auf 1 $und Xduplizieren das Atom mit. Eine Kopie wird zum $Befehl zurückgespiegelt (wobei diese Kopie mit 2 Energiepunkten belassen wird), und die andere Kopie wird auf den Stapel geschoben K.

Unsere reflektierte Kopie wandert von ihrem Ursprung zurück, bis sie erneut auf den %Schalter trifft . Jetzt, da wir eine positive Energie haben, reflektieren wir, als hätten wir einen \Spiegel getroffen, wickeln das Brett auf das nächste Sund dekrementieren unsere Energie auf 1.

Der SBefehl verbraucht 1 Energie, um unsere Richtung zu erhalten. Hätten wir keine Energie, wäre das Atom abgelenkt worden, als ob es von einem \Spiegel nach unten geschlagen worden wäre. Stattdessen bewegen wir uns wieder nach rechts und nehmen mehr Eingaben mit auf ?und der Zyklus wiederholt sich.

Sobald unser Atom EOF erreicht, ?speichert der Befehl 1 Energie im Atom. Wenn wir Jdieses Mal den Befehl drücken, überspringen wir den %Schalter vollständig und landen Smit 0 Energie auf dem Schalter.

Jetzt, da unsere Energie im Sprung verbraucht wurde, wird unsere Richtung durch den Schalter nicht bewahrt S, sondern wir sind eher nach unten gerichtet. Dann dekrementieren wir unsere Energie mit dem ~Befehl auf -1 und wickeln uns um das Brett. Bei einem Treffer mit einer negativen Energie sprengt der KBefehl ein Atom, anstatt eines zu drücken. Wir geben unser neu aufgetauchtes Atom mit aus und verwenden die 1-Energie dieses Atoms, um den Schalter zu umgehen , und der Zyklus ist abgeschlossen.!S

Wenn der Stapel Kleer war, wird die Energie unseres Atoms negiert (was zu +1 Energie führt) und es wird zurück auf den ~Befehl reflektiert , wobei es mit Energie 0 belassen wird. Wenn Swir erneut treffen , werden wir nach rechts abgelenkt, bis der ?getroffen wird. Da EOF erreicht wurde, ?zerstört der das Atom und beendet das Programm.

Labyrinth , 10 Bytes

,)";@
:".(

Normalerweise sollten Labyrinth-Programme wie Labyrinthe aussehen, aber ich konnte die Schleifen in dieser so stark komprimieren, dass der Code als einzelner Block (Raum?) Endete. Hier ist eine etwas erweiterte Version, die es einfacher macht, dem Kontrollfluss zu folgen:

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

,Liest jeweils ein Byte von STDIN, bis es auf EOF trifft und zurückkehrt -1. Das )erhöht diesen Wert, so dass wir für jedes gelesene Byte und Null bei EOF etwas Positives erhalten. Die :Duplikate jedes gelesenen Bytes.

Sobald wir EOF erreicht haben, geht der Befehlszeiger zur zweiten Schleife über, in der er wiederholt einen Wert mit ;(anfangs den EOF, später die zweite Kopie jedes Bytes) verwirft , dann den nächsten Wert mit dekrementiert (und mit druckt .. Aufgrund dieser zweiten Kopie (die immer positiv ist) wissen wir, dass die IP oben rechts abbiegen und in dieser Schleife fortfahren wird.

Nachdem alle Bytes gedruckt wurden, ist der obere Bereich des Stapels wieder Null, und die IP-Adresse wird direkt bis zum fortgesetzt, @und das Programm wird beendet.

Die scheinbar unnötige Verdoppelung jedes Bytes ermöglicht es mir, sicherzustellen, dass die IP (auch in den engen Schleifen der Golf-Version) immer die richtige Kurve nimmt und niemals von einer Schleife zur anderen wechselt.

Ein gutes Beispiel für TheNumberOne und Sp3000, deren eigene Versuche bei der Suche nach dieser hochkomprimierten Lösung sehr hilfreich waren.