Eine der häufigsten Standardaufgaben (insbesondere bei der Präsentation von esoterischen Programmiersprachen) ist die Implementierung eines "cat-Programms" : Lesen Sie STDIN vollständig aus und drucken Sie es in STDOUT aus. Obwohl dies nach dem Unix-Shell-Dienstprogramm benannt ist cat, ist es natürlich viel weniger leistungsfähig als das Original, das normalerweise zum Drucken (und Verketten) mehrerer von der Disc gelesener Dateien verwendet wird.

Aufgabe

Sie sollten ein vollständiges Programm schreiben , das den Inhalt des Standardeingabestreams liest und ihn wörtlich in den Standardausgabestream schreibt. Wenn und nur dann, wenn Ihre Sprache keine Standardeingabe- und / oder -ausgabestreams unterstützt (wie in den meisten Sprachen verstanden), können Sie diese Begriffe stattdessen so verstehen, dass sie in Ihrer Sprache am ähnlichsten sind (z. B. JavaScript promptund alert). Dies sind die einzigen zulässigen E / A-Formen, da jede andere Schnittstelle die Art der Aufgabe erheblich verändern und die Vergleichbarkeit der Antworten erheblich beeinträchtigen würde.

Die Ausgabe sollte genau die Eingabe enthalten und sonst nichts . Die einzige Ausnahme von dieser Regel ist die konstante Ausgabe des Interpreters Ihrer Sprache, die nicht unterdrückt werden kann, z. B. eine Begrüßung, ANSI-Farbcodes oder Einrückungen. Dies gilt auch für nachfolgende Zeilenumbrüche. Wenn die Eingabe keine nachgestellte Zeile enthält, sollte die Ausgabe auch keine enthalten! (Die einzige Ausnahme ist, wenn Ihre Sprache nach der Ausführung immer eine abschließende neue Zeile ausgibt.)

Die Ausgabe in den Standardfehlerstrom wird ignoriert, solange der Standardausgabestrom die erwartete Ausgabe enthält. Dies bedeutet insbesondere, dass Ihr Programm beim Erreichen des Endes des Streams (EOF) mit einem Fehler beendet werden kann, sofern der Standardausgabestream nicht verschmutzt wird. In diesem Fall empfehle ich Ihnen, Ihrer Antwort ebenfalls eine fehlerfreie Version hinzuzufügen (als Referenz).

Da dies eine Herausforderung für jede Sprache und nicht für jede Sprache darstellt, gibt es einige sprachspezifische Regeln:

• Wenn es in Ihrer Sprache überhaupt möglich ist, Nullbytes im Standardeingabestream von der EOF zu unterscheiden, muss Ihr Programm Nullbytes wie alle anderen Bytes unterstützen (dh, sie müssen auch in den Standardausgabestream geschrieben werden).
• Wenn es in Ihrer Sprache überhaupt möglich ist, einen beliebigen unendlichen Eingabestream zu unterstützen (dh wenn Sie vor dem Drücken von EOF in der Eingabe mit dem Drucken von Bytes an die Ausgabe beginnen können), muss Ihr Programm in diesem Fall ordnungsgemäß funktionieren. Als Beispiel yes | tr -d \\n | ./my_catsoll ein unendlicher Strom von ys ausgegeben werden. Es liegt an Ihnen, wie oft Sie den Standardausgabestream drucken und leeren, es muss jedoch garantiert sein, dass er nach einer begrenzten Zeitspanne unabhängig vom Stream erfolgt (dies bedeutet insbesondere, dass Sie nicht auf ein bestimmtes Zeichen wie warten können einen Zeilenvorschub vor dem Drucken).

Fügen Sie Ihrer Antwort einen Hinweis zum genauen Verhalten in Bezug auf Null-Bytes, unendliche Streams und irrelevante Ausgaben hinzu.

Zusätzliche Regeln

• Hier geht es nicht darum, die Sprache mit der kürzesten Lösung dafür zu finden (es gibt einige, bei denen das leere Programm den Trick macht) - hier geht es darum, die kürzeste Lösung in jeder Sprache zu finden. Daher wird keine Antwort als angenommen markiert.

• Einsendungen in den meisten Sprachen werden in Bytes in einer geeigneten, bereits vorhandenen Codierung bewertet, normalerweise (aber nicht unbedingt) in UTF-8.

  Einige Sprachen, wie Ordner , sind etwas schwierig zu bewerten. Im Zweifelsfall bitte nach Meta fragen .

• Sie können auch eine Sprache (oder Sprachversion) verwenden, die neuer als diese Herausforderung ist. Sprachen, die speziell geschrieben wurden, um eine 0-Byte-Antwort auf diese Herausforderung zu senden, sind fair, aber nicht besonders interessant.

  Beachten Sie, dass ein Dolmetscher vorhanden sein muss, damit die Einreichung getestet werden kann. Es ist erlaubt (und sogar empfohlen), diesen Dolmetscher für eine zuvor nicht implementierte Sprache selbst zu schreiben.

  Beachten Sie auch , dass Sprachen Sie müssen erfüllen unsere üblichen Kriterien für Programmiersprachen .

• Wenn Ihre bevorzugte Sprache eine triviale Variante einer anderen (möglicherweise populäreren) Sprache ist, die bereits eine Antwort hat (denken Sie an BASIC- oder SQL-Dialekte, Unix-Shells oder triviale Brainfuck-Derivate wie Headsecks oder Unary), sollten Sie der vorhandenen Antwort eine Anmerkung hinzufügen Die gleiche oder eine sehr ähnliche Lösung ist auch in der anderen Sprache die kürzeste.

• Sofern sie nicht zuvor außer Kraft gesetzt wurden, gelten alle Standardregeln für Code-Golf , einschließlich der http://meta.codegolf.stackexchange.com/q/1061 .

Bitte stimmen Sie langweiligen (aber gültigen) Antworten in Sprachen nicht ab, in denen es nicht viel zum Golfen gibt. Diese sind für diese Frage nach wie vor hilfreich, da versucht wird, einen Katalog so vollständig wie möglich zusammenzustellen. Stimmen Sie Antworten jedoch in erster Linie in Sprachen ab, in denen sich der Autor tatsächlich um das Golfen des Codes bemühen musste.

Katalog

Das Stapel-Snippet am Ende dieses Beitrags generiert den Katalog aus den Antworten a) als Liste der kürzesten Lösungen pro Sprache und b) als Gesamt-Bestenliste.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

## Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

## Perl, 43 + 2 (-p flag) = 45 bytes

Sie können den Namen der Sprache auch als Link festlegen, der dann im Snippet angezeigt wird:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><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="language-list"> <h2>Shortest Solution 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> <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> <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><script>var QUESTION_ID = 62230; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 8478; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(42), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

sed, 0

Das leere sedProgramm macht genau das, was hier benötigt wird:

$ printf "abc\ndef" | sed ''
abc
def$ 

Ziim , 222 201 196 185 182 Bytes

    ↓ ↓

 ↓ ↓     ↓
 ↗ ↗↙↔↘↖ ↖
 ↓↓⤡⤢  ⤢↙
↘ ↖⤡ ↖
  ↙
  ↕↘ ↑ ↙
→↘↖↑ ↙ ↑
→↖   ↑
→↖↘ ↙
  ↑↓↑

   ⤡

Dies wird wahrscheinlich in Ihrem Browser nicht korrekt angezeigt. Hier ist ein Diagramm des Codes:

Ich kann mir keine einfachere Struktur vorstellen, um das Problem in Ziim zu lösen, aber ich bin mir sicher, dass der eigentliche Code immer noch ziemlich gut ist.

Ziim kann unmöglich mit unendlichen Streams umgehen, da es nur möglich ist, irgendetwas am Ende des Programms zu drucken.

Erläuterung

Da Ziim ein ziemlich einzigartiges deklaratives Kontrollflussmodell hat, wird es hier nicht durch einen imperativen Pseudocode-Algorithmus gekürzt. Stattdessen erkläre ich die Grundlagen von Ziim und präsentiere die aufgeräumte Struktur des obigen Codes (auf ähnliche grafische Weise) wie ASCII-Kunst.

Kontrollfluss in Ziim findet überall statt: Jeder Pfeil, auf den kein anderer Pfeil zeigt, initialisiert einen "Thread", der unabhängig von den anderen verarbeitet wird (nicht wirklich parallel, aber es gibt keine Garantien, in welcher Reihenfolge sie verarbeitet werden (es sei denn, Sie synchronisieren sie über eine Verkettung). Jeder dieser Threads enthält eine Liste von Binärziffern, beginnend mit {0}. Jetzt ist jeder Pfeil im Code eine Art Befehl, der einen oder zwei Eingänge und einen oder zwei Ausgänge hat. Der genaue Befehl hängt davon ab, wie viele Pfeile aus welchen Richtungen darauf zeigen.

Hier ist die Liste der Befehle, in der m -> nangegeben wird, dass der Befehl mEingaben entgegennimmt und nAusgaben erzeugt .

• 1 -> 1, no-op : Leitet den Thread einfach um.
• 1 -> 1, invertieren : negiert jedes Bit im Thread (und leitet es auch um).
• 1 -> 1, read : Ersetzt den Wert des Threads durch das nächste Bit von STDIN oder durch die leere Liste, wenn wir EOF getroffen haben.
• 2 -> 1, verketten : Dies ist die einzige Möglichkeit, Threads zu synchronisieren. Wenn ein Thread auf eine Seite des Pfeils trifft, wird er angehalten, bis ein anderer Thread auf die andere Seite trifft. An diesem Punkt werden sie zu einem einzelnen Thread verkettet und setzen die Ausführung fort.
• 2 -> 1, label : Dies ist die einzige Möglichkeit, verschiedene Ausführungspfade zu verbinden. Dies ist einfach ein No-Op mit zwei möglichen Eingängen. Threads, die über eine der beiden Routen in das "Label" eingehen, werden einfach in dieselbe Richtung umgeleitet.
• 1 -> 2, split : Nimmt einen einzelnen Thread und sendet zwei Kopien in verschiedene Richtungen.
• 1 -> 1, isZero? : verbraucht das erste Bit des Threads und sendet den Thread in eine von zwei Richtungen, abhängig davon, ob das Bit 0 oder 1 war.
• 1 -> 1ist leer? : verbraucht die gesamte Liste (dh ersetzt sie durch eine leere Liste) und sendet den Thread in eine von zwei Richtungen, abhängig davon, ob die Liste bereits leer war oder nicht.

In diesem Sinne können wir eine allgemeine Strategie entwickeln. Mit verketten wollen wir wiederholt neue Bits an einen String anhängen, der die gesamte Eingabe darstellt. Wir können dies einfach tun, indem wir die Ausgabe der Verkettung in eine ihrer Eingaben zurückschleifen (und dies zu einer leeren Liste initialisieren, indem wir ein {0}mit isEmpty? Löschen ). Die Frage ist, wie wir diesen Prozess beenden können.

Zusätzlich zum Anhängen des aktuellen Bits wird eine 0 oder 1 vorangestellt, die angibt, ob wir EOF erreicht haben. Wenn wir unseren String durch isZero schicken ? , es wird dieses Bit wieder los, aber lassen Sie uns das Ende des Streams unterscheiden. In diesem Fall lassen wir den Thread einfach den Rand des Gitters verlassen (was Ziim veranlasst, den Inhalt des Threads an STDOUT zu drucken und das Programm zu beenden). .

Ob wir EOF erreicht haben oder nicht, kann mit isEmpty ermittelt werden . auf eine Kopie der Eingabe.

Hier ist das Diagramm, das ich versprochen habe:

              +----------------------------+   {0} --> isEmpty --> label <--+
              |                            |                    n    |      |
              v                            |                         v      |
    {0} --> label --> read --> split --> split ------------------> concat   |
                                 |                                   |      |
                           n     v     y                             |      |
 inv --> label --> concat <-- isEmpty --> concat <-- label <-- {0}   |      |
  ^        ^          |                     |          ^             |      |
  |        |          v                     v          |             |      |
 {0}       +------- split ---> label <--- split -------+             |      |
                                 |                                   |      |
                                 +-------------> concat <------------+      |
                                                   |                        |
                                              y    v                        |
                         print and terminate <-- isZero --------------------+

Einige Hinweise, wo Sie anfangen sollen zu lesen:

• Die {0}linke obere Ecke ist der erste Trigger, der die Eingangsschleife startet.
• Die {0}obere rechte Ecke wird sofort zu einer leeren Liste gelöscht und stellt die anfängliche Zeichenfolge dar, die wir nach und nach mit der Eingabe füllen.
• Die anderen beiden {0}s werden in eine "Producer" -Schleife eingespeist (eine invertiert, eine nicht), um uns einen unbegrenzten Vorrat an 0s und 1s zu geben, die wir dem String voranstellen müssen.

Sechseck , 6 Bytes

Früher waren das 3 Bytes (siehe unten), aber diese Version funktioniert seit dem letzten Update der Sprache nicht mehr. Da ich den von dieser Version verwendeten Fehler nie absichtlich eingeführt habe, habe ich beschlossen, ihn nicht zu zählen.

Eine fehlerfreie Lösung (dh eine, die mit dem festen Interpreter funktioniert) erweist sich als viel kniffliger. Ich hatte einige Probleme, es in ein 2x2-Gitter zu packen, aber ich habe jetzt eine Lösung gefunden, obwohl ich die vollen 7 Bytes brauche :

<)@,;.(

Nach dem Entfalten erhalten wir:

Da die anfängliche Speicherflanke 0 ist, <lenkt die den Befehlszeiger bedingungslos in die Nordostdiagonale um, wo er auf den grauen Pfad übergeht. Das .ist ein No-Op. Nun ,liest ein Byte, )inkrementiert sie derart , dass gültige Bytes (einschließlich Null - Bytes) sind positive und EOF gleich 0 ist .

Bei EOF wird die IP in einen roten Pfad umgebrochen, in dem @das Programm beendet wird. Wenn wir jedoch immer noch ein Byte lesen, wird der IP-Zeilenumbruch auf den grünen Pfad angewendet, (in dem die Kante auf den ursprünglichen Wert dekrementiert wird, bevor ;sie an STDOUT ausgegeben wird. Die IP wird nun bedingungslos auf den grauen Pfad zurückgeschrieben und der Vorgang wiederholt.

Nachdem ich ein Brute-Force-Skript für meine Truth-Machine-Antwort geschrieben hatte, stellte ich es so ein, dass auch für das cat-Programm eine fehlerfreie 6-Byte- Lösung gefunden wurde. Erstaunlicherweise fand es eine - ja, genau eine Lösung in allen möglichen 6-Byte-Hexagony-Programmen. Nach den 50 Lösungen von der Wahrheitsmaschine war das ziemlich überraschend. Hier ist der Code:

~/;,@~

Entfaltung:

Die Verwendung von ~(unäre Negation) anstelle von ()ist interessant, weil a) es ein No-Op auf Null ist, b) es die Seiten des Zweigs vertauscht, c) in einigen Codes ein einzelnes ~zweimal verwendet werden kann, um die Operation mit sich selbst rückgängig zu machen . Also hier ist was los ist:

Das erste Mal (violetter Pfad), dass wir es passieren ~, ist ein No-Op. Der /spiegelt die IP in die Nordwestdiagonale. Der graue Pfad liest nun ein Zeichen und multipliziert seinen Zeichencode mit -1. Dadurch wird aus dem EOF ( -1) ein wahrer (positiver) Wert und aus allen gültigen Zeichen ein falscher (nicht positiver) Wert. Im Fall von EOF nimmt die IP den roten Pfad und der Code wird beendet. Im Falle eines gültigen Zeichens nimmt die IP den grünen Pfad, ~macht die Negation rückgängig und ;druckt das Zeichen aus. Wiederholen.

Hier ist schließlich die 3-Byte-Version, die in der Originalversion des Hexagony-Interpreters funktioniert hat.

,;&

Wie die Labyrinth-Antwort endet diese mit einem Fehler, wenn der Eingabestream endlich ist.

Nach dem Aufklappen des Codes entspricht es dem folgenden Hex-Raster:

Das .sind No-Ops. Die Ausführung beginnt auf dem violetten Pfad.

,liest ein Byte, ;schreibt ein Byte. Dann wird die Ausführung auf dem Lachspfad (ish?) Fortgesetzt. Wir müssen die &aktuelle Speicherflanke auf Null zurücksetzen, so dass die IP zur violetten Reihe zurückspringt, wenn wir die Ecke am Ende der zweiten Reihe treffen. Sobald ,EOF gedrückt wird -1, wird es zurückgegeben , was einen Fehler verursacht, wenn ;versucht wird, es zu drucken.

Mit Timwis erstaunlichem HexagonyColorer erstellte Diagramme .

TeaScript , 0 Bytes

TeaScript ist eine prägnante Golfsprache, die mit JavaScript kompiliert wurde

In einem kürzlich durchgeführten Update wird die Eingabe implizit als erste Eigenschaft hinzugefügt.

Probieren Sie es online aus

Alternativ 1 Byte

x

xenthält die Eingabe in TeaScript. Die Ausgabe ist implizit

Brian & Chuck , 44 Bytes

#{<{,+?+}_+{-?>}<?
_}>?>+<<<{>?_}>>.<+<+{<{?

Ich habe diese Sprache ursprünglich für " Erstellen einer Programmiersprache" erstellt, die nur unbrauchbar zu sein scheint . Es stellt sich jedoch heraus, dass es eine sehr schöne Übung ist, einfache Probleme darin zu golfen.

Die Grundlagen: Jede der beiden Zeilen definiert ein Brainfuck-ähnliches Programm, das mit dem Quellcode des anderen Programms arbeitet - das erste Programm heißt Brian und das zweite heißt Chuck. Nur Brian kann lesen und nur Chuck kann schreiben. Anstelle von Brainfucks Schleifen haben Sie, die ?die Steuerung an das andere Programm übergeben (und die Rollen von Anweisungszeiger und Bandkopf ändern sich ebenfalls). Ein Zusatz zu Brainfuck ist {und }welches das Band nach der ersten Nicht-Null-Zelle (oder dem linken Ende) absucht. Auch _werden durch null Bytes ersetzt.

Obwohl ich dies noch nicht für optimal halte, bin ich mit dieser Lösung ziemlich zufrieden. Mein erster Versuch war 84 Bytes, und nach mehreren Golfspielen mit Sp3000 (und einigen Inspirationen aus seinen Versuchen) gelang es mir, ihn langsam auf 44 Bytes zu bringen. Besonders der geniale +}+Trick war seine Idee (siehe unten).

Erläuterung

Die Eingabe wird in die erste Zelle auf Chucks Band eingelesen und dann sorgfältig auf das Ende von Brians Band kopiert, wo sie gedruckt wird. Durch Kopieren bis zum Ende können wir Bytes sparen, wenn wir das vorherige Zeichen auf Null setzen.

Dies #ist nur ein Platzhalter, da die Schaltsteuerung die eingeschaltete Zelle nicht ausführt. {<{stellt sicher, dass sich der Bandkopf in Chucks erster Zelle befindet. ,Liest ein Byte von STDIN oder -1wenn wir EOF drücken . Also inkrementieren wir das +, um es für EOF auf Null zu setzen und ansonsten auf einen Wert ungleich Null.

Nehmen wir an, wir sind noch nicht bei EOF. Die Zelle ist also positiv und ?wechselt die Kontrolle zu Chuck. }>bewegt den Bandkopf (auf Brian) an der +dem _und ?übergibt die Steuerung an Brian zurück.

{-verringert jetzt die erste Zelle von Chuck. Wenn es noch nicht Null ist, geben wir die Kontrolle erneut an Chuck weiter ?. Dieses Mal }>bewegt der Bandkopf Brian zwei Zellen rechts von der letzten Nicht-Null-Zelle. Anfangs ist das hier:

#{<{,+?+}_+{-?>}<?__
                   ^

Aber später werden wir dort schon einige Charaktere haben. Wenn wir zum Beispiel bereits gelesen und gedruckt haben abc, sieht das so aus:

#{<{,+?+}_+{-?>}<?11a11b11c__
                            ^

Wo die 1s tatsächlich 1 Byte sind (wir werden später sehen, worum es geht).

Diese Zelle wird immer Null sein, so dass diesmal ? die Kontrolle nicht geändert wird. >Verschiebt eine weitere Zelle nach rechts und +erhöht diese Zelle. Aus diesem Grund endet das erste Zeichen in der Eingabe drei Zellen rechts von ?(und jede nachfolgende drei Zellen weiter rechts).

<<<Geht zurück zum letzten Zeichen in dieser Liste (oder zum ?ersten Zeichen) und {>kehrt zum +Band von Brian zurück, um die Schleife zu wiederholen, die die Eingabezelle langsam auf das Ende von Brians Band überträgt.

Sobald diese Eingabezelle leer ist, schaltet der ?After {-die Steuerung nicht mehr um. Dann >}<bewegt sich der Bandkopf an der Klemme zu _und schaltet Steuerung derart , dass Chucks zweiten Hälfte wird stattdessen ausgeführt.

}>>Bewegt sich zu der Zelle, die wir jetzt hinter dem Ende von Brians Band geschrieben haben. Dies ist das Byte, das wir von STDIN gelesen haben, und wir drucken es zurück mit .. Um }an diesem neuen Zeichen auf dem Band vorbeizulaufen, müssen wir die Lücke von zwei Null-Bytes schließen und sie 1mit inkrementieren <+<+. Schließlich {<{bewegt sich zu Beginn des Brians Band zurück und ?beginnt alles von Anfang an .

Sie fragen sich vielleicht, was passiert, wenn das gelesene Zeichen ein Null-Byte ist. In diesem Fall wäre die neu geschriebene Zelle selbst Null, aber da es am Ende von Brians Band ist und es uns egal ist, wo dieses Ende ist, können wir das einfach ignorieren. Das heißt, wenn die Eingabe ab\0dewäre, würde Brians Band tatsächlich so aussehen:

#{<{,+?+}_+{-?>}<?11a11b1111d11e

Sobald wir EOF erreicht haben, wird das erste Mal ?auf Brians Band ein No-Op sein. An dieser Stelle beenden wir das Programm. Die naive Lösung wäre bis zum Ende des Chucks Band und Schaltersteuerung, so dass das Programm termiantes bewegen: >}>}<?. Hier spart die wirklich clevere Idee des Sp3000 drei Bytes:

+verwandelt Chucks erste Zelle in 1. Das heißt }hat einen Ausgangspunkt und findet den _in der Mitte von Chucks Band. Anstatt darüber hinwegzuspringen, schließen wir einfach die Lücke, indem wir sie ebenfalls in ein 1mit +umwandeln. Nun wollen wir sehen, was der Rest von Brians Code mit diesem modifizierten Chuck macht ...

{geht wie gewohnt zurück zu Chucks erster Zelle und -verwandelt sie wieder in ein Null-Byte. Das heißt, das ?ist ein No-Op. Aber jetzt >}<, wo der Bandkopf normalerweise in die Mitte von Chucks Band verschoben wird, ?läuft er direkt am Bandende vorbei und übergibt die Kontrolle an Chuck, wodurch der Code beendet wird. Es ist schön, wenn die Dinge einfach klappen ... :)

Haskell, 16 Bytes

main=interact id

interactLiest die Eingabe, übergibt sie an die als Argument angegebene Funktion und gibt das empfangene Ergebnis aus. idist die Identitätsfunktion, dh sie gibt ihre Eingabe unverändert zurück. Dank Haskells Faulheit interactkann mit unendlichen Eingaben gearbeitet werden.

sh + binutils, 3 2 Bytes

dd

Nicht ganz so offensichtlich. Von @ Random832

Original:

cat

Das schmerzlich Offensichtliche ...: D

Funktion , 16 Bytes

╔═╗
╚╤╝

(Codiert als UTF-16 mit einer Stückliste)

Erläuterung

Die Box gibt den Inhalt von STDIN zurück. Das lose Ende gibt es aus.

Motorola MC14500B Maschinencode , 1,5 Byte

Hexadezimal geschrieben:

18F

In Binärform geschrieben:

0001 1000 1111

Erläuterung

1   Read from I/O pin
8   Output to I/O pin
F   Loop back to start

Die Opcodes sind jeweils 4 Bits.

Mornington Crescent , 41 Bytes

Take Northern Line to Mornington Crescent

Ich habe keine Ahnung, ob Mornington Crescent Null-Bytes verarbeiten kann, und alle Eingaben werden vor dem Start des Programms gelesen, da dies die Natur der Sprache ist.

Brainfuck, 5 Bytes

,[.,]

Entspricht dem Pseudocode:

x = getchar()
while x != EOF:
    putchar(x)
    x = getchar()

Dies verarbeitet unendliche Streams, behandelt aber null Bytes als EOF. Ob BF mit Null-Bytes richtig umgehen kann , hängt von Implementierung zu Implementierung ab. Hierbei wird jedoch der gängigste Ansatz angenommen.

Labyrinth , 2 Bytes

,.

Wenn der Stream endlich ist, wird dies mit einem Fehler beendet, aber alle durch den Fehler erzeugten Ausgaben gehen an STDERR, sodass der Standardausgabestream korrekt ist.

Wie in Brainfuck wird ,ein Byte gelesen (auf den Labyrinth-Hauptstapel geschoben) und .ein Byte geschrieben (vom Labyrinth-Hauptstapel abgelegt).

Der Grund dieser Schleife ist , dass beide , ,und .sind „Sackgassen“ in der (sehr trivialen) maze durch den Quellencode dargestellt ist , so dass der Befehlszeiger dreht sich einfach an Ort und Stelle um und bewegt sich zurück zu dem anderen Befehl.

Wenn wir EOF ,drücken, wird -1stattdessen .ein Fehler ausgegeben, da -1es sich nicht um einen gültigen Zeichencode handelt. Das könnte sich in Zukunft tatsächlich ändern, aber ich habe mich noch nicht entschieden.

Als Referenz können wir dies ohne einen Fehler in 6 Bytes wie folgt lösen

,)@
.(

Hier )inkrementiert sich das gelesene Byte, was 0bei EOF etwas Positives ergibt und ansonsten. Wenn der Wert ist 0, bewegt sich die IP geradeaus und trifft die, @die das Programm beendet. Wenn der Wert positiv war, dreht sich die IP stattdessen nach rechts in Richtung, (wodurch die Oberseite des Stapels auf ihren ursprünglichen Wert zurückgesetzt wird. Die IP ist jetzt in einer Ecke und macht einfach weiter Rechtskurven, druckt mit .und liest ein neues Byte mit ., bevor sie erneut auf die Gabel trifft ).

C 40 Bytes

main(i){while(i=~getchar())putchar(~i);}

> <> , 7 Bytes

i:0(?;o

Probieren Sie es hier aus . Erläuterung:

i:0(?;o
i        Take a character from input, pushing -1 if the input is empty
 :0(     Check if the input is less than 0, pushing 1 if true, 0 if false
    ?;   Pop a value of the top of the stack, ending the program if the value is non-zero
      o  Otherwise, output then loop around to the left and repeat

Wenn Sie möchten, dass es so lange weitergeht, bis Sie mehr Eingaben machen, ersetzen Sie das ;durch !.

X86-Assembly, 70 Byte

Demontage mit objdump:

00000000 <.data>:
   0:   66 83 ec 01             sub    sp,0x1
   4:   66 b8 03 00             mov    ax,0x3
   8:   00 00                   add    BYTE PTR [eax],al
   a:   66 31 db                xor    bx,bx
   d:   66 67 8d 4c 24          lea    cx,[si+0x24]
  12:   ff 66 ba                jmp    DWORD PTR [esi-0x46]
  15:   01 00                   add    DWORD PTR [eax],eax
  17:   00 00                   add    BYTE PTR [eax],al
  19:   cd 80                   int    0x80
  1b:   66 48                   dec    ax
  1d:   78 1c                   js     0x3b
  1f:   66 b8 04 00             mov    ax,0x4
  23:   00 00                   add    BYTE PTR [eax],al
  25:   66 bb 01 00             mov    bx,0x1
  29:   00 00                   add    BYTE PTR [eax],al
  2b:   66 67 8d 4c 24          lea    cx,[si+0x24]
  30:   ff 66 ba                jmp    DWORD PTR [esi-0x46]
  33:   01 00                   add    DWORD PTR [eax],eax
  35:   00 00                   add    BYTE PTR [eax],al
  37:   cd 80                   int    0x80
  39:   eb c9                   jmp    0x4
  3b:   66 b8 01 00             mov    ax,0x1
  3f:   00 00                   add    BYTE PTR [eax],al
  41:   66 31 db                xor    bx,bx
  44:   cd 80                   int    0x80

Die Quelle:

sub esp, 1
t:
mov eax,3
xor ebx,ebx
lea ecx,[esp-1]
mov edx,1
int 0x80
dec eax
js e
mov eax,4
mov ebx,1
lea ecx,[esp-1]
mov edx,1
int 0x80
jmp t
e:
mov eax,1
xor ebx,ebx
int 0x80

Universal Lambda , 1 Byte

!

Ein Universal-Lambda-Programm ist eine Kodierung eines Lambda-Terms in Binärform, die in 8-Bit-Blöcke zerlegt wird und unvollständige Blöcke mit beliebigen Bits auffüllt, die in einen Bytestrom konvertiert werden.

Die Bits werden wie folgt in einen Lambda-Term übersetzt:

• 00 führt eine Lambda-Abstraktion ein.
• 01 stellt eine Anwendung von zwei aufeinander folgenden Begriffen dar.
• 111..10bezieht sich mit n Wiederholungen des Bits 1auf die Variable des n- ten Eltern-Lambda; dh es ist ein De Bruijn-Index in unary.

Bei dieser Konvertierung 0010handelt es sich um die Identitätsfunktion λa.a, dh jedes Einzelbyte-Programm des Formulars 0010xxxxist ein catProgramm.

PowerShell, 88 41 30 Bytes

$input;write-host(read-host)-n

_{EDIT - habe vergessen, dass ich die $inputautomatische Variable für die Pipeline-Eingabe verwenden kann} ... _{EDIT2 - muss nicht auf Existenz von testen$input}

Ja, also ... STDIN in PowerShell ist ... komisch, sollen wir sagen. Mit der Annahme, dass wir Eingaben von allen Arten von STDIN akzeptieren müssen, ist dies eine mögliche Antwort auf diesen Katalog, und ich bin sicher, dass es noch andere gibt. ¹

Die Pipeline-Eingabe in PowerShell funktioniert jedoch nicht so, wie Sie denken. Da das Piping in PowerShell eine Funktion der Sprache und keine Funktion der Umgebung / Shell ist (und PowerShell ohnehin nicht wirklich nur eine Sprache ist), gibt es einige Macken im Verhalten.

Für den Anfang und am relevantesten für diesen Eintrag ist, dass die Pipe nicht sofort ausgewertet wird (meistens). Das heißt, wenn wir command1 | command2 | command3in unserer Shell haben, command2werden keine Eingaben gemacht oder die Verarbeitung gestartet, bis sie command1abgeschlossen ist ... es sei denn, Sie kapseln Ihre Eingaben command1mit einem ForEach-Object..., das anders ist als ForEach. _{(obwohl ForEaches ein Alias ​​für ist ForEach-Object, aber das ist ein separates Problem, da ich ForEachals Aussage spreche , nicht als Alias)}

Dies würde bedeuten, dass so etwas yes | .\simple-cat-program.ps1(obwohl es yeses nicht wirklich gibt, aber was auch immer) nicht funktionieren yeswürde, weil es niemals abgeschlossen würde. Wenn wir das könnten ForEach-Object -InputObject(yes) | .\simple-cat-program.ps1, müsste das (theoretisch) funktionieren.

Lernen Sie ForEach und ForEach-Object von Microsoft kennen "Hey, Scripting Guy!" Blog.

Alle diese Absätze erklären, warum es sie if($input){$input}gibt. Wir verwenden einen Eingabeparameter, der speziell automatisch erstellt wird, wenn eine Pipeline-Eingabe vorhanden ist. Testen Sie, ob er vorhanden ist, und geben Sie ihn gegebenenfalls aus.

Dann nehmen wir Eingaben vom Benutzer (read-host)über einen im Wesentlichen separaten STDIN-Stream entgegen und geben write-hostsie mit dem -nFlag ( Abkürzung für -NoNewLine) zurück. Beachten Sie, dass dies keine Eingabe beliebiger Länge unterstützt, da dies read-hostnur abgeschlossen wird, wenn ein Zeilenvorschub eingegeben wird (technisch gesehen, wenn der Benutzer "Enter" drückt, aber funktional äquivalent).

Puh.

¹ Es gibt aber noch andere Möglichkeiten:

Wenn wir uns zum Beispiel nur mit der Eingabe von Pipelines befassen und kein vollständiges Programm benötigen, können Sie so etwas tun, | $_dass nur das ausgegeben wird, was eingegeben wurde. _{(Im Allgemeinen ist das etwas redundant, da PowerShell eine implizite Ausgabe von Dingen hat, die nach Berechnungen "zurückgelassen" wurden, aber das ist eine Ausnahme.)}

Wenn es nur um interaktive Benutzereingaben geht, können wir einfach verwenden write-host(read-host)-n.

Zusätzlich bietet diese Funktion die Möglichkeit , Kommandozeilen-Eingaben zu akzeptieren, um beispielsweise .\simple-cat-program.ps1 "test"die $aVariable zu füllen (und dann auszugeben) .

Cubix , 6 5 Bytes

Verarbeitet jetzt null Bytes!

@_i?o

Cubix ist ein zweidimensionaler, stapelbasierter Esolang. Cubix unterscheidet sich von anderen 2D-langs dadurch, dass der Quellcode um die Außenseite eines Cubes gewickelt wird.

Testen Sie es online! Hinweis: Zwischen den Iterationen liegt eine Verzögerung von 50 ms.

Erläuterung

Der Interpreter ermittelt zunächst den kleinsten Würfel, auf den der Code passt. In diesem Fall ist die Kantenlänge 1. Dann wird der Code mit No-Ops .aufgefüllt, bis alle sechs Seiten gefüllt sind. Leerzeichen werden vor der Verarbeitung entfernt, sodass dieser Code mit dem oben genannten identisch ist:

  @
_ i ? o
  .

Jetzt wird der Code ausgeführt. Der IP (Anweisungszeiger) beginnt ganz links und zeigt nach Osten.

Das erste Zeichen, auf das die IP stößt _, ist ein Spiegel, der die IP umdreht, wenn sie nach Norden oder Süden zeigt. es ist derzeit nach Osten ausgerichtet, das macht also nichts. Als nächstes wird iein Byte von STDIN eingegeben. ?Dreht die IP nach links, wenn das oberste Element negativ ist, oder nach rechts, wenn es positiv ist. Hier gibt es drei mögliche Wege:

• Wenn das eingegebene Byte -1 (EOF) ist, dreht sich die IP nach links und trifft @, was das Programm beendet.
• Wenn das eingegebene Byte 0 ist (Null-Byte), fährt die IP einfach direkt fort und gibt das Byte mit aus o.
• Andernfalls dreht sich die IP nach rechts, wandert über die Unterseite und trifft auf den Spiegel _. Dies dreht es um und sendet es zurück an den ?, der es wieder nach rechts dreht und das Byte ausgibt.

Ich finde dieses Programm optimal. Bevor Cubix null Bytes verarbeiten konnte (EOF war 0, nicht -1), funktionierte dieses Programm für alles außer null Bytes:

.i!@o

Ich habe einen Brute-Forcer geschrieben , um alle 5-Byte-Cat-Programme zu finden. Obwohl es ca. 5 Minuten dauert, hat die neueste Version 5 Programme gefunden:

@_i?o   (works as expected)
@i?o_   (works in exactly the same way as the above)
iW?@o   (works as expected)
?i^o@   (false positive; prints U+FFFF forever on empty input)
?iWo@   (works as expected)

Vitsy, 2 Bytes

zZ

zRuft den gesamten Eingabestapel ab und verschiebt ihn in den aktiven Programmstapel. Zdruckt den gesamten aktiven Stapel auf STDOUT aus.

Alternative Methode:

I \ il \ O
I \ Wiederholen Sie das nächste Zeichen für die Länge des Eingabestapels.
  i Nimm einen Gegenstand aus der Eingabe.
   l \ Wiederholen Sie das nächste Zeichen für die Länge des aktuell aktiven Programmstapels.
     O Das oberste Element des Stapels als Zeichen ausgeben.

MarioLANG , 11 Bytes

,<
."
>!
=#

Ich bin nicht ganz sicher, ob dies optimal ist, aber es ist das kürzeste, das ich gefunden habe.

Dies unterstützt unendliche Streams und endet mit einem Fehler beim Erreichen von EOF (zumindest die Ruby-Referenzimplementierung).

Es gibt eine andere Version davon, die Mario in einen Ninja verwandelt, der Doppelsprung machen kann:

,<
.^
>^
==

In beiden Fällen fällt Mario in die linke Spalte, in ,der ein Byte gelesen und .ein Byte geschrieben wird (was einen Fehler bei EOF auslöst, weil ,kein gültiges Zeichen zurückgegeben wird). >sorgt dafür, dass Mario nach rechts geht ( =ist nur ein Boden, auf dem er laufen kann). Dann steigt er auf, entweder durch einen Doppelsprung mit ^oder durch einen Aufzug (das Paar "und #), bevor der <ihn auffordert, zur linken Spalte zurückzukehren.

rs , 0 bytes

Ernsthaft. rs gibt nur das aus, was es bekommt, wenn das angegebene Skript vollständig leer ist.

GolfScript, 3 Bytes

:n;

Das leere Programm gibt die Standardeingabe wieder. Die Sprache kann unmöglich mit unendlichen Streams umgehen. Es wird jedoch eine neue Zeile angehängt, wie @Dennis erwähnt. Dies geschieht, indem der gesamte Stapel in ein Array eingeschlossen und aufgerufen wird puts, das definiert ist als print n print, wo nsich eine neue Zeile befindet. Wir können jedoch neu nals STDIN definieren und dann den Stapel leeren, was genau das ist, was :n;tut.

Halb kaputtes Auto bei starkem Verkehr , 9 + 3 = 12 Bytes

#<
o^<
 v

Half-Broken Car bei starkem Verkehr (HBCHT) nimmt Eingaben als Kommandozeilenargumente entgegen, läuft also wie folgt

py -3 hbcht cat.hbc -s "candy corn"

Beachten Sie, dass +3 für das -sFlag steht, das als Zeichen ausgegeben wird. HBCHT scheint auch nicht mit NULs umzugehen, da alle Nullen aus der Ausgabe entfernt werden (z. B. 97 0 98als zwei Zeichen ausgegeben werden ab).

Erläuterung

Bei HBCHT startet Ihr Auto am ound Ihr Ziel ist die Ausfahrt #. ^>v<leitet die Bewegung des Fahrzeugs, während gleichzeitig eine BF artige Band Modifizieren ( ^>v<übersetzen zu +>-<). Wie der Name der Sprache schon sagt, kann Ihr Auto nur nach rechts abbiegen. Biegeversuche nach links werden vollständig ignoriert (einschließlich ihrer Memory-Effekte). Beachten Sie, dass dies nur zum Abbiegen dient - Ihr Auto ist perfekt in der Lage, vorwärts oder rückwärts zu fahren.

Weitere interessante Aspekte von HBCHT sind die zufällige Ausrichtung Ihres Autos und das toroidale Gitter. Wir brauchen also nur das Auto, um die Ausfahrt zu erreichen, ohne das Band für alle vier Anfangsrichtungen zu modifizieren:

• Hoch und runter sind unkompliziert und gehen direkt zum Ausgang.

• Für left wird umgebrochen und ausgeführt <und mit inkrementiert ^. Wir können nicht an den nächsten links abbiegen , <so dass wir mit wickeln und Abnahme v, vorherigen Zuwachs negiert werden. Da wir jetzt nach unten fahren, können wir nach rechts abbiegen <und beenden, nachdem wir den Zeiger zweimal bewegt und keine Zellenwerte geändert haben.

• Rechts machen wir dasselbe wie links, überspringen aber das erste, ^da wir nicht nach links abbiegen können.

Bearbeiten : Es stellt sich heraus, dass Sie mit dem HBCHT-Interpreter nur einen Pfad über ein Befehlszeilen-Flag ausführen können, z

py -3 hbcht -d left cat.hbc

Das Flag ist jedoch nicht nur für diese bestimmte Frage zu teuer (mindestens 5 Byte für " -d u"), es scheint auch, dass alle Pfade in der Lage sein müssen, zum Exit zu gelangen, damit der Code ausgeführt werden kann.

Minkolang , 5 Bytes

od?.O

Probieren Sie es hier aus.

Erläuterung

oLiest ein Zeichen aus der Eingabe ein und schiebt seinen ASCII-Code auf den Stapel ( 0wenn die Eingabe leer ist). ddupliziert dann den Anfang des Stapels (das Zeichen, das gerade eingelesen wurde). ?ist ein bedingtes Trampolin, das bei der nächsten Anweisung von der Stapelspitze nicht abspringt 0. War die Eingabe leer, wird die .nicht übersprungen und das Programm wird angehalten. Ansonsten wird Oder oberste Stapel als Zeichen ausgegeben. Die toroidale Natur von Minkolang bedeutet, dass dies zum Anfang umschlingt.

INTERCALL , 133 Bytes

wat

INTERCALL IS A ANTIGOLFING LANGUAGE
SO THIS HEADER IS HERE TO PREVENT GOLFING IN INTERCALL
THE PROGRAM STARTS HERE:
READ
PRINT
GOTO I

V , 0 Bytes

Probieren Sie es online!

Vs Vorstellung von "Gedächtnis" ist nur eine gigantische 2D-Anordnung von Zeichen. Bevor ein Programm ausgeführt wird, werden alle Eingaben in dieses Array geladen (bekannt als "The Buffer"). Am Ende eines Programms wird dann der gesamte Text im Puffer gedruckt.

Mit anderen Worten, das leere Programm ist ein Katzenprogramm.

Schneemann 1.0.2 , 15 Zeichen

(:vGsP10wRsp;bD

Genommen direkt von Schneemannexamples Verzeichnis . Liest eine Zeile, druckt eine Zeile, liest eine Zeile, druckt eine Zeile ...

Beachten Sie, dass aufgrund eines Implementierungsdetails, wenn STDIN leer ist, vg dasselbe zurückgegeben wird wie für eine leere Zeile. Daher werden beim Schließen von STDIN wiederholt Zeilenumbrüche in einer Endlosschleife gedruckt. Dies kann in einer zukünftigen Version behoben werden.

Erklärung des Codes:

(        // set two variables (a and f) to active—this is all we need
:...;bD  // a "do-loop" which continues looping as long as its "return value"
         // is truthy
  vGsP   // read a line, print the line
  10wRsp // print a newline—"print" is called in nonconsuming mode; therefore,
         // that same newline will actually end up being the "return value" from
         // the do-loop, causing it to loop infinitely

FireType , 7 Bytes

,
&
_
=

Erfordert einige Änderungen, die ich gerade gepusht habe . Die Regeln sagen:

Im Gegensatz zu unseren üblichen Regeln können Sie auch dann eine Sprache (oder Sprachversion) verwenden, wenn diese neuer als diese Herausforderung ist.

also bin ich im klaren!

Spaltung , 4 Bytes

R?J!

Ist es nicht schön, wenn Sie die Beispielprogramme im eigenen Repository schlagen? :) Als Referenz hat es die 7-Byte-Lösung

R?J0;0!

Erläuterung

So Rstartet den Steuerfluss mit einem rechten laufenden Atom. ?Liest ein Zeichen aus STDIN in die Masse des Atoms. Solange wir Zeichen lesen, bleibt die Energie Null, daher ist der JUmp ein No-Op und gibt !das Zeichen aus. Das Atom kehrt zum Start zurück (R ist jetzt ein No-Op) und wiederholt den gesamten Vorgang.

Wenn wir EOF drücken, wird ?die Energie des Atoms auf gesetzt 1, so dass der JUmp jetzt den Druckbefehl überspringt. Wenn jedoch ein Atom trifft, ? nachdem EOF bereits zurückgegeben wurde, wird stattdessen das Atom zerstört, wodurch das Programm beendet wird.

(Die Lösung des Autors der Sprache verwendet einen expliziten Befehl ;, um das Programm zu beenden, der 0ansonsten mit zwei Portalen übersprungen wird .)

Versendet , 20 Bytes

e )
"
 r )
 s )
 "
"

Dies zeigt auf freche Weise, dass nahezu jede druckbare ASCII- Zeichenfolge eine gültige Kennung in Shtriped ist.

Wie es funktioniert:

e )   \ declares a variable named )
"     \ defines a function with 0 arguments named "
 r )  \ gets a line of string input, saving it to )
 s )  \ prints ) as a string
 "    \ recursively calls ", effectively looping forever
"     \ calls " from the main scope to get things started

Es gibt keine wirkliche Möglichkeit, EOF zu erkennen, daher wird dies wie die Python-Antwort für immer wiederholt .

Sie können es leicht stoppen lassen, wenn eine leere Zeile angegeben wird (30 Bytes):

e )
"
 r )
 d ) \ tries to decrement ), if it was the empty string, aka 0, it can't, so 0 is returned all the way up
 i ) \ increment ) to put it back to normal after possibly decrementing
 s )
 "
"

Beachten Sie, dass Shtriped I / O nur druckbare ASCII-Zeichen , Tabulatoren, Zeilenvorschübe , Zeilenumbrüche, vertikale Tabulatoren und Formularvorschübe (insgesamt 100 Zeichen) unterstützt. Dies liegt daran, dass Zeichenfolgen intern als nicht negative Ganzzahlen mit willkürlicher Genauigkeit dargestellt werden und dass ein endliches Alphabet von Zeichen vorhanden sein muss, um alle Zeichenfolgen codieren zu können.