Stdin umkehren und auf stdout legen

58

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>

Thomas O.
quelle
5
Erlauben Sie Standard-Bibliotheksfunktionen wie PHPstrrev
Ming-Tang
Darf die Ausgabe den letzten Zeilenumbruch der Eingabe am Anfang statt am Ende setzen?
Joey Adams
@ Joey Adams, yep, es sollte die Eingabe genau replizieren.
Thomas O
53
Ihr Beispiel ist etwas falsch. Die Umkehrung Ihrer Eingabe wäre: ƃop ʎzɐʃ ǝɥʇ ɹǝʌo pǝdɯnɾ ǝH xoɟ uʍoɹq ʞɔınΌ;-P
ninjalj
Muss ich nur Zeichen unterstützen, die in das System eingegeben werden können, das den Code ausführt?
Goldener Schnitt

Antworten:

25

Golfscript - 3 Zeichen

-1%

verschleierte Version ist auch 3 Zeichen

0(%

Hier ist eine Erklärung, wie % funktioniert

Knabberzeug
quelle
9
Wie können wir jemals mit Golfscript konkurrieren?
Thomas O
12
@Thomas: Mit FlogScript, denke ich. Wenn Sie eine einfache Aufgabe veröffentlichen, sollten Sie in jedem Fall davon ausgehen, dass die Lösungen ebenso einfach sind. Und wenn es in Python drei Methodenaufrufe braucht, können es in Golfscript genauso gut drei Zeichen sein.
Joey
1
@ Thomas: Sorry, das war nicht so offensichtlich. Angesichts der Tatsache, dass einige Mitglieder bereits heftige Diskussionen über diese Sprache geführt hatten, die anscheinend keinen Humor hatten, war es nicht allzu unvernünftig, hier ähnliche Aussagen zu treffen.
Joey
3
@Joey Es war eher eine humorvolle Verzweiflung, da GolfScript für das ungeübte Auge wie ein Geräusch erscheint.
Thomas O
36
Der zweite ist also verschleiert, der erste nicht. Erwischt.
C0deH4cker
44

Bash - 7

tac|rev

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

marcog
quelle
Lass uns einfach den nächsten Schritt machen und das mit einem einzigen Buchstaben-Bash-Befehl aliasen! alias z='tac|rev'
Daniel Standage
18
@Diniel Das ist ungefähr dasselbe wie die Verwendung von Compiler-Flags, um Makros zu definieren, dh gegen den Geist des Code-Golfs.
Marcog
Ich hatte rev|tacfür die gleiche Punktzahl - nur eine Anmerkung hinzufügen, um zu sagen, dass dies für jede POSIX-Shell funktioniert, nicht nur für Bash.
Toby Speight
35

BrainFuck, 10 Zeichen

,[>,]<[.<]

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

Kevin Brown
quelle
2
Die DNA kehrt ihre Reihenfolge ständig um. Vielleicht liegt etwas Grundlegendes an der Art der Information und der Berechnung in dem, was Sie beobachtet haben. Ich bin auf diese Lösung gestoßen, als ich Probleme auf rosalind.info mit Shell-Einzeilern löste.
ixtmixilix
9
@ixtmixilix Es sagt eigentlich nur etwas Grundlegendes über Stacks und das Umkehren von Dingen.
Cruncher
23

C 37 Bytes

main(_){write(read(0,&_,1)&&main());}
Quixotic
quelle
Cool, aber bei mir funktioniert es nicht.
Joey Adams
@ Joey Adams: Probieren Sie es hier aus .
Quixotic
Ah, ich musste ohne Optimierung kompilieren.
Joey Adams
21

Haskell - 21

main=interact reverse
Konstantin
quelle
3
Nicht nur kurz, sondern auch ganz idiomatisch :)
Hammar
16

Python, 41 bis 40 Bytes

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

41 -> 40 - Semikolon am Programmende entfernt.

Könnte wohl optimiert werden!

Thomas O.
quelle
Ich wünschte, ich hätte eine einfache Möglichkeit, etwas in PowerShell rückgängig zu machen ;-)
Joey
6
Marsmenschen, immer nützlich. [:: - 1]
Wok
1
Also print raw_input()[::~0]]? Es ist immer noch Python 2 wegenprint
CalculatorFeline
Hier ist ein Code Golf Eintrag Formatierungstipp. Schreiben Sie immer die Sprache, mit der Sie das Programm geschrieben haben, in diesem Format:# Language Name, Character/Byte Count
dorukayhan
15

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
Justin
quelle
12

APL, 2

⊖⍞

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

jpjacobs
quelle
Halbieren Sie Ihre Byteanzahl! Sie brauchen nicht einmal die . ist eine anonyme Funktion , die zugewiesen und verwendet werden kann: f←⌽ f 'The quick brown fox'.
Adám
^^^^ Gewinner ^^^^
CalculatorFeline
@ Nᴮᶻ: Nun, die Spezifikation sagte, die Eingabe von stdin zu bekommen, nicht von einem String-Literal :)
jpjacobs
@jpjacobs Gängige PPGC-Praxis besteht darin, Inline-Argumente anstelle von stdin für Sprachen zuzulassen, die stdin nicht unterstützen (oder für die es unnatürlich ist, stdin zu verwenden).
Adám,
11

Perl - 23

print scalar reverse <>
Andrew
quelle
6
Sie können das dritte Leerzeichen entfernen.
Timwi
6
In der Tat print"".reverse<>ist nur 17 Zeichen. Und mit Perl 5.10+ können Sie zwei weitere Zeichen speichern, indem Sie sayanstelle von verwenden print.
Ilmari Karonen
4
Ich weiß, dass dies sehr alt ist, aber Sie könnten es auch tun: print~~reverse<>für 16 Zeichen
Dom Hastings
5
@DomHastings Und mit Perl 5.10+ say~~reverse<>würde das funktionieren? 14 Zeichen.
Timtech
10

Ruby - 19 Zeichen

puts$<.read.reverse
Nemo157
quelle
10

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!

Joey Adams
quelle
Einfach toll!
st0le
1
Nur Ihre Idee, aber das spart 2-3 Tastenanschläge:main(c){(c=getchar())>0&&main(),putchar(c);}
Quixotic
2
Wertet C Zahlen als Boolesche Werte aus? Wenn ja, c>=0kann werden~c
Cyoce
9

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.

Joey
quelle
-join($a="$args")[$a.Length..0]allein scheint für das angegebene Beispiel zu funktionieren, ich habe keine Probleme mit den Zeilenumbrüchen, die mit Windows ausgeführt werden crlf.
Colsw
@ConnorLSW: Das liest nicht mal von stdin. Und $inputist ein Enumerator, der Zeilen hervorbringt, so dass Sie ihn nicht so aufreihen können.
Joey
8

Perl 5.1, 14

say~~reverse<>
Timtech
quelle
8

Befunge-93 - 11x2 (22 Zeichen)

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

Getestet mit diesem Interpreter .

MiffTheFox
quelle
19
Sind Sie sicher, dass Sie nicht nur zufällige Tasten auf Ihrer Tastatur gedrückt haben?
Thomas O
@Thomas - Bist du sicher, dass du den verlinkten Interpreter nicht ausprobiert hast? Es ist webbasiert, falls Sie Bedenken hatten, etwas herunterzuladen.
MiffTheFox
4
Ich mach nur Spaß. Ich bin mir sicher, dass es funktionieren wird, aber es sieht so aus, als hätten Sie zufällig einige Tasten gedrückt. Das deutet auf eine sehr kompakte Sprache hin.
Thomas O
1
nicht immer : P
klatschen
7

Binäre Lambda-Rechnung - 9 Bytes

16 46 80 17 3E F0 B7 B0 40

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

C0deH4cker
quelle
Kennen Sie gute Orte, um BLC zu lernen? Es sieht aus wie eine so lustige Sprache!
Phase
1
@phase Das sieht nützlich aus, wenn Sie die Menge der Logiktheorie
C0deH4cker
6

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.

Martin Ender
quelle
lol warum erinnert mich das an minecraft?
Don Bright
Wow, und ich dachte, meine Implementierung in den Sprachbeispielen war mit 16 Zeichen die kürzeste. Beeindruckend!
C0deH4cker
6

> <>, 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=?;!
cole
quelle
2
-5 Bytes durch Beenden mit einem Fehler. Ansonsten -2 Byte (Fehler bei Leereingabe). Auch die ursprünglichen Fehler bei Leereingaben, die durch Verschieben der onach dem;
Jo King
1
@JoKing Guter Fang von der oSeite; habe das damals nicht bemerkt. Und danke für das Speichern. Clevere Verwendung des Vergleichs mit Null, um das letzte -1 loszuwerden.
Cole
1
Hmm, eigentlich dies funktioniert genauso gut für 13 Bytes (kann nicht glauben , dass ich das einfach Swap verpasster 0=?zu ?!)
Jo König
@JoKing -1 Byte Das? Zeichen prüft die Stapeloberseite, wenn 0, so dass ein Vergleich mit der Länge nicht erforderlich ist, nur das l.
Teal Pelikan
@TealPelican Ja, das habe ich in meinem zweiten Kommentar erwähnt
Jo King,
5

PHP - 38 17 Zeichen

<?=strrev(`cat`);
Arnaud Le Blanc
quelle
Was ist cat??
Xanderhall
1
@Xanderhall liest wahrscheinlich ausstdin
Pavel
5

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.

Martin Ender
quelle
4

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

Kevin Brown
quelle
Ein Problem: fgets(STDIN)Liest nur die erste Zeile.
PleaseStand
Der Code wurde aktualisiert und liest nun alle Zeilen.
Kevin Brown
Außer Sie haben ein künstliches Limit von 1000 Zeichen
anonymer Feigling
Das Limit wurde aktualisiert und entspricht nun dem von Python. Ich kann mir jedoch nicht vorstellen, dass jemand so viel verwendet.
Kevin Brown
4

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 ( ).

FireFly
quelle
Hier ist eine kürzere Version (10 Zeichen): Linie 1: #v~Linie 2: :<,_@#. Komisch, dass die Verwendung jes hier nicht verbessert.
Justin
@Quincunx das ist clever, die IP-Richtung als eine Art implizite Negation zu verwenden.
FireFly
4

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
kirbyfan64sos
quelle
2
Entspricht leider nicht der Spezifikation - die Reihenfolge der Zeilen muss ebenfalls umgekehrt werden.
DLosc
Fk_.z_kIch bin mir sicher, dass jemand etwas kürzeres bekommen kann, aber genau das habe ich bekommen.
GCQ
@gcq Ich habe eine kürzere Version (5 Zeichen), aber ich habe keine Chance, sie zu bearbeiten.
kirbyfan64sos
@ DLosc behoben! Ich habe gerade alle Eingaben gelesen, über Zeilenumbrüche verbunden und das umgekehrt.
kirbyfan64sos
@FryAmTheEggman Ah ja! Das wusste ich nicht, als ich das vor ein paar Monaten gepostet hatte.
kirbyfan64sos
4

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 1 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.

FlipTack
quelle
4

05AB1E, 1 Byte

R

R kehrt die Eingabe um.

penalosa
quelle
1
Danke, dass du 05AB1E benutzt :). Sie brauchen das ,am Ende nicht, da die Oberseite des Stapels automatisch gedruckt wird, wenn nichts gedruckt wurde.
Adnan
@Adnan Danke für den Tipp.
Penalosa
4

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.

Sp3000
quelle
4

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:

Bildbeschreibung hier eingeben

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.
Martin Ender
quelle
3

PHP - 44 Zeichen

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

Perl

print scalar reverse for reverse(<STDIN>);
Huntar
quelle
3

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.

BrainSteel
quelle
3

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.

Martin Ender
quelle