Einfaches Katzenprogramm

84

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

Martin Ender
quelle
52
Bash, 3 Bytes :cat
TheDoctor
3
@TheDoctor Ich denke, dies würde in die Regel "Verwenden Sie keine eingebauten Funktionen, die genau das tun, was benötigt wird" fallen.
Paŭlo Ebermann
5
@ PaŭloEbermann Es gibt keine solche Regel und die entsprechende Standardlücke wird nicht mehr akzeptiert. (In der Tat gibt es bereits eine shAntwort mit, catdie auch eine kürzere Lösung mit enthält dd.)
Martin Ender
1
Wenn nur Standardmethoden für Ein- und Ausgabe verwendet würden: ///, 0 Bytes .
Genosse SparklePony
1
@SparklePony Nur müssen Sie Schrägstriche und umgekehrte Schrägstriche vermeiden.
Martin Ender

Antworten:

73

sed, 0


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

$ printf "abc\ndef" | sed ''
abc
def$ 
Digitales Trauma
quelle
3
Was passiert, wenn man schreibt yes | tr -d \\n | sed ''?
BenGoldberg
@BenGoldberg Standardmäßig arbeitet sed zeilenweise. In diesem Fall wird es weiter yesin einen Musterpuffer geschlürft, bis der Speicher voll ist . Eine Einschränkung, nehme ich an ...
Digitales Trauma
POSIX schreibt vor, dass der Musterbereich eine Größe von mindestens 8192 Byte (IIRC) haben muss. Ich weiß, dass die GNU-Implementierung einen dynamischen Musterraum hat, der nur durch den verfügbaren Speicher begrenzt ist, so dass Sie in diesem relativ sicher sind.
Toby Speight
59

Ziim , 222 201 196 185 182 Bytes

    ↓ ↓

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

   ⤡

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

Bildbeschreibung hier eingeben

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.
Martin Ender
quelle
29
Wie kannst du überhaupt ein solches Programm schreiben, ohne dass dein Gehirn in eine Million kleiner Gewebestücke explodiert?
Ashwin Gupta
40

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:

Bildbeschreibung hier eingeben

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:

Bildbeschreibung hier eingeben

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:

Bildbeschreibung hier eingeben

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 .

Martin Ender
quelle
2
Die 6-Byte-Version ist sehr, sehr clever. Brute-Forcer können unglaublich genial sein.
ETHproductions
Hast du einen Link zu deinem Brute-Forcer?
MD XF
@MDXF Ich behalte die verschiedenen Versionen nicht bei, aber es ist immer eine Modifikation dieses Ruby-Skripts .
Martin Ender
36

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

Downgoat
quelle
Ich wollte das hier posten :)
Kritixi Lithos 30.10.15
5
Hah, ich dachte "Alternativ" wäre ein Sprachname ...
Quelklef
28

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

Martin Ender
quelle
25

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.

nimi
quelle
23

sh + binutils, 3 2 Bytes

dd

Nicht ganz so offensichtlich. Von @ Random832

Original:

cat

Das schmerzlich Offensichtliche ...: D

kirbyfan64sos
quelle
12
Ich werde ein besser machen: dd.
Random832
Ich wollte Katze machen ... D:
ev3commander
1
Ja, das ist großartig und alles ... aber 170 Wiederholungen zum Tippen cat???
MD XF
1
@MDXF was ist mit wer weiß wie viel rep von einem segfault? ;)
Caird Coinheringaahing
23

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.

Timwi
quelle
19

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.

Zach Gates
quelle
1
-1 kein Screenshot, Beispiel oder Try It Online-Link: P (jk)
MD XF
2
+1. Die einzige Möglichkeit, dies weiter zu optimieren, besteht darin, den Eingangsstift an den Ausgangsstift anzulöten und den Chip aus der Buchse zu nehmen: P
Wossname
16

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.

Pfeffer
quelle
15

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.

Lynn
quelle
1
VERDAMMT! Du hast mich 5 Minuten geschlagen!
kirbyfan64sos
Wenn das erste Zeichen NULL ist, wird dies nicht korrekt ausgeführt. Also sollte es +[,.]richtig sein?
Shelvacu
6
@Shel Dies verwendet 0x00 als EOF-Byte. Wenn das erste Zeichen EOF ist, wird nichts gedruckt, was wie erwartet funktioniert.
Mego
2
"Pseudocode" oh komm schon, das ist eindeutig nur ohne Klammer, ohne Semikolon C: P
MD XF
14

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

Martin Ender
quelle
13

C 40 Bytes

main(i){while(i=~getchar())putchar(~i);}
Dennis
quelle
main () {while (255-putchar (getchar ()));} ist einige Bytes kürzer.
Alchymist
1
Leider wird dies bei 0xFF-Bytes vorzeitig beendet und ein 0xFF-Byte an die Eingabe angehängt, wenn es dieses nicht enthält.
Dennis
Was ist mit den folgenden 36 Bytes: main () {for (;; putchar (getchar ()));};
Johan du Toit
@ user2943932 Wenn es EOF trifft, getchargibt -1 , so dass Ihr Code einen unendlichen Strom von 0xFF Bytes nach dem (endlichen) Eingang gedruckt wird.
Dennis
12

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

DanTheMan
quelle
Oh Mann, ich hatte gehofft, die> <> Antwort zu posten ...: P (+1!)
El'endia Starman
1
io(2 Bytes) macht dasselbe, stürzt jedoch ab und schreibt something smells fishy...am Ende der Ausführung nach STDERR, was zulässig ist.
Lynn
@ Mauris, der Online-Interpreter, gibt nur Null-Bytes aus, anstatt mit einem Fehler zu enden.
DanTheMan
11

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
kirbyfan64sos
quelle
1
Also, objdumpzerlegt es als 32-Bit - Code, während Sie als 16-Bit kompiliert zu haben scheinen. Was zu glauben Da Sie verwenden int 0x80, denke ich, dass es für Linux gedacht ist, aber warum dann als 16-Bit kompilieren?
Ruslan
@ Ruslan Ich wusste nicht einmal, dass es in 16-Bit kompiliert wurde ...
kirbyfan64sos
11

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.

Lynn
quelle
1
Aber !ist 0x21nicht 0x4_?
wchargin
Fest. --------
Lynn
10

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

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.

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

AdmBorkBork
quelle
Vergessen Sie nicht Ihre eingebauten Aliase!
Chad Baxter
10

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)
ETHproductions
quelle
Bitte bearbeite nicht ein Dutzend Beiträge auf einmal. Sie überschwemmen die Titelseite. 3 auf einmal ist kein Problem, aber wenn Sie mehr als das tun müssen, nehmen Sie die Änderungen bitte alle 12 Stunden oder so in kleinen Stapeln vor.
Martin Ender
@MartinEnder Sorry, das habe ich gerade gemerkt. Ich werde sie in Zukunft ausräumen.
ETHproductions
9

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.
Addison Crump
quelle
2
^ _ ^ Habe trotzdem eine +1! :)
El'endia Starman
Schade Stimmen, mein Favorit!
Addison Crump
Warum die Abstimmungen? Dies scheint ein vollkommen gültiger Eintrag zu sein
Conor O'Brien
1
Es ist gültig für alle Spezifikationen.
Addison Crump
9

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.

Martin Ender
quelle
8

rs , 0 bytes


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

kirbyfan64sos
quelle
7

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.

Lynn
quelle
7

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.

Sp3000
quelle
7

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.

El'endia Starman
quelle
2
Grar! Du hast meine Sprache geschlagen! NICHT AKZEPTIERBAR! +1
Addison Crump
7

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
TuxCrafting
quelle
Es sieht so aus, als ob jemand wirklich in einer rein golferfeindlichen Sprache Golf spielt ... 133-116 = 17
Erik der Outgolfer 16.06.16
@ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Da das Katzenprogramm ziemlich einfach ist, ist dies nicht bei allen Programmen der Fall ... codegolf.stackexchange.com/a/82748/53745
TuxCrafting
Die Person, die die Sprache gemacht hat, um römische Ziffern zu verwenden, aber wenn es der Fall wäre, um zu drucken 500(nicht sicher), wäre es PRINT Drichtig? (ohne den Header)
Erik der Outgolfer
@ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Nein, INTERCALL kann nur ASCII-Zeichen drucken und einen Stapel verwenden, um beispielsweise das Zeichen mit dem ASCII-Wert 20 zu drucken, das der Code ist PUSH XX<newline>PRINToder PUSH XX AND PRINT. Oh und ich bin der Schöpfer von INTERCALL
TuxCrafting
7

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.

DJMcMayhem
quelle
6

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
Türknauf
quelle
5

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!

kirbyfan64sos
quelle
5

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

Martin Ender
quelle
5

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.

Calvins Hobbys
quelle