Eine Wahrheitsmaschine (das Verdienst dieses Mannes ) ist ein sehr einfaches Programm, das entwickelt wurde, um die E / A und den Kontrollfluss einer Sprache zu demonstrieren. Das macht eine Wahrheitsmaschine:

• Ruft eine Zahl (entweder 0 oder 1) von STDIN ab.

• Wenn diese Zahl 0 ist, drucken Sie 0 aus und beenden Sie den Vorgang.

• Wenn diese Zahl 1 ist, drucken Sie 1 für immer aus.

Herausforderung

Schreiben Sie eine Wahrheitsmaschine wie oben beschrieben in die Sprache Ihrer Wahl. Die Wahrheitsmaschine muss ein vollständiges Programm sein, das diesen Regeln folgt:

• Nehmen Sie eine Eingabe von STDIN oder einer akzeptablen Alternative
  • Wenn Ihre Sprache keine Eingabe von STDIN erhalten kann, wird möglicherweise eine Eingabe von einer fest codierten Variablen oder einer geeigneten Entsprechung im Programm verwendet
• muss auf STDOUT oder eine akzeptable Alternative ausgegeben werden
  • Wenn Ihre Sprache nicht in der Lage ist, die Zeichen 0oder auszugeben 1, sind Byte- oder unäre E / A-Vorgänge zulässig.
• Wenn die Eingabe " s" lautet 1, muss sie fortlaufend gedruckt werden 1und muss nur angehalten werden, wenn das Programm beendet wird oder nicht mehr genügend Arbeitsspeicher vorhanden ist

• Die Ausgabe darf entweder nur ein 0gefolgt von einem oder keinem Zeilenumbruch oder Leerzeichen sein, oder unendlich viele 1s mit jedem 1gefolgt von einem oder keinem Zeilenumbruch oder Leerzeichen. Es kann keine andere Ausgabe generiert werden, außer der konstanten Ausgabe des Interpreters Ihrer Sprache, die nicht unterdrückt werden kann (z. B. eine Begrüßung, ANSI-Farbcodes oder Einrückungen). Ihre Verwendung von Zeilenumbrüchen oder Leerzeichen muss konsistent sein. Wenn Sie beispielsweise eine Ausgabe 1mit einer neuen Zeile vornehmen, müssen alle Zeilenumbrüche mit einer neuen 1Zeile versehen sein.

• Nur wenn Ihre Sprache bei einer Eingabe möglicherweise nicht enden kann, kann 0der Code in eine Endlosschleife eingegeben werden, in der nichts ausgegeben wird.

Da es sich um einen Katalog handelt, dürfen Sprachen, die nach dieser Herausforderung erstellt wurden, miteinander konkurrieren. 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. Ansonsten müssen alle Standardregeln des Code-Golfs eingehalten werden. Einreichungen in den meisten Sprachen werden in Bytes in einer entsprechenden zuvor vorhandenen Codierung (normalerweise UTF-8) bewertet.

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: 320px; 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 = 62732; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 12012; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://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 "https://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(), 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>

Sechseck , 6 Bytes

Das war überraschend schwierig und ich bin nicht überzeugt, dass es optimal ist ...

<.@!$?

Nach dem Auffüllen und Entfalten des Codes stellt dies das folgende Hex-Raster dar:

Dies verwendet einen ähnlichen Steuerungsfluss wie mein kürzlich erstelltes fehlerfreies Katzenprogramm , das sich entlang von Antidiagonalen bewegt. Um dies zu erreichen, lenken wir den Anweisungszeiger (IP) nach links, wobei der violette Pfad in die untere linke Ecke übergeht.

?Liest die Eingabe als Ganzzahl. !druckt es zurück. .ist nur ein No-Op. Jetzt fungiert die Ecke des Rasters als Zweig:

Wenn die Eingabe war 0, wird die IP auf dem roten Pfad fortgesetzt, wodurch das Programm einfach mit beendet wird @.

Wenn die Eingabe war 1, wird die IP auf dem grünen Pfad fortgesetzt. Auch dies .ist nur ein No-Op, $entspricht jedoch Befunges Trampolin: Die nächste Anweisung wird übersprungen. Nach dem Umbruch wäre die nächste Anweisung die, die ?aber aufgrund der $Ausführung tatsächlich auf dem blauen Pfad fortgesetzt wird, beginnend mit !dem Drucken einer weiteren Kopie der 1. Diese Schleife, die nur enthält, !..$wird jetzt auf unbestimmte Zeit wiederholt.

Eine Studie zum Kontrollfluss in Hexagony ...

Ich halte die obige Lösung für optimal. Ich habe einen Brute Forcer geschrieben, die alle 6-Byte Hexagony Programme überprüft, die mindestens eine jeweils enthalten ?!@(die notwendig sind , um, ich habe auch überprüft :und %anstelle des @mit einer Division durch Null Fehler zu beenden, aber das hat auch nicht geholfen). Die Prüfung gibt alle Programme aus, die a) 0bei Eingabe 0und Beendigung erzeugen und b) mindestens zwei 1Sekunden (und sonst nichts ) erzeugen und nicht innerhalb der ersten 60 Ticks des Programms enden (200 Ticks für 5-Byte-Lösungen). . Ich bezweifle, dass eine gültige Lösung mehr als 200 Ticks benötigt, um die erste 0oder die zweite 1auf einem so kleinen Raster korrekt auszudrucken. Daher habe ich keine potenziellen Lösungen verpasst.

Die Suche ergab keine Ergebnisse für 5 Bytes, aber 57 Ergebnisse für 6 Bytes (mit @; Sie müssen nicht mit einem Fehler abbrechen, wenn Sie dies sauber in der gleichen Anzahl von Bytes lösen können). Von diesen 57 waren nur 6 falsch positive Ergebnisse, die tatsächlich nur zwei 1s druckten und dann in eine Endlosschleife eintraten, ohne mehr zu drucken. Eine Lösung wurde zweimal aufgeführt, da sie zwei !Befehle enthielt . Damit bleiben genau 50 gültige Lösungen.

Es gibt eine gewisse Degeneriertheit zwischen den Lösungen, bei denen ein oder zwei Zeichen nicht wesentlich sind, z. B. weil sie sowieso praktisch keine Aktionen sind. Die Lösungen können in 23 Gruppen von wirklich unterschiedlichen Programmen gruppiert werden (in einigen Fällen gibt es nur einen einzigen Zeichenunterschied zwischen zwei Gruppen, aber dies ändert den Kontrollfluss erheblich, sodass ich sie separat gezählt habe). Zwei der Gruppen verwenden sogar auf sehr unerwartete Weise mehrere Befehlszeiger. Da ich mir die meisten dieser Möglichkeiten, die Äste und Spiegel zu verwenden, niemals ausgedacht hätte, machen sie eine sehr interessante Untersuchung darüber, welche Arten von Kontrollfluss in Hexagony möglich sind, und ich habe definitiv einige neue Tricks für zukünftige Golfer gelernt.

Der gesamte Kontrollfluss ist fast immer der gleiche: Eine Zahl lesen, ausdrucken. Wenn Sie 0einen Weg zum finden @, durchlaufen Sie die Schleife, !während Sie den Kantenwert von beibehalten 1. Es gibt vier bemerkenswerte Ausnahmen:

• Eine Lösung (die mit zwei !) druckt zwei 1Sekunden pro Iteration durch das Raster und damit ungefähr doppelt so schnell wie die meisten Programme. Ich habe dieses mit x2unten markiert .
• Einige Lösungen (diejenigen, die ein enthalten o) ersetzen das 1durch ein 111(den Zeichencode von o), sodass drei 1 s pro Iteration ausgegeben werden, was sie ungefähr dreimal so schnell wie die meisten Programme macht. Ich habe diese mit x3unten markiert .
• Zwei Lösungen fügen1 in jeder Iteration ein an den Kantenwert an (so 1-> 11-> 111-> ...). Diese werden sehr schnell gedruckt , aber ihnen wird irgendwann der Speicher ausgehen. Ich habe diese mit OoMunten markiert .
• Zwei Lösungen treten in eine sehr enge Schleife ein, die lediglich über den !anderen Ticks hin und her springt (anstelle von etwa jedem fünften), wodurch sie etwas schneller (und sauberer) werden. Ich habe diese mit ><unten markiert .

Also hier ist der gesamte Zoo:

#1                #5                #12                #19
?!/$.@            ?$!>$@            .?!/$@             |!|?$@  # ><
?!/$1@  # OoM     ?$!|$@            =?!/$@
?!/$=@                                                 #20
?!/$\@            #6                #13                $@.?<!
?!/$o@  # x3      ?/!<|@            .?/!$@             $@1?<!  # OoM
?!/$!@  # x2                        =?/!$@             $@=?<!
                  #7                                   $@o?<!  # x3
#2                ?\!<|@            #14
?!>$)@                              \!?__@             #21
?!>$1@            #8                                   _>_!?@
?!>$o@  # x3      ?<!>$@  # ><      #15
?!|$)@                              \_?!$@             #22
?!|$1@            #9                                   <!@.$?
?!|$o@  # x3      ?\$!@$            #16                <!@/$?
                                    \_?!_@             <!@=$?
#3                #10                                  <$@!$?
?!|)$@            ?~#!@)            #17                <.@!$?
?!|1$@            ?~#!@1            $$?\@!             </@!$?
?!|o$@  # x3                                           <=@!$?
                  #11               #18
#4                ?$)\@!            \$?\@!             #23
?_!<@>            ?$1\@!                               <<@]!?
                  ?$o\@!  # x3

Das Folgende ist eine kurze exemplarische Vorgehensweise für eine Handvoll der repräsentativeren Gruppen. Besonders die Gruppen 10 und 23 sind einen Besuch wert. Es gibt viele andere interessante und manchmal verschlungene Wege in den anderen Gruppen, aber ich denke, ich habe dich am Ende genug gelangweilt. Für alle, die Hexagony wirklich lernen möchten, sind diese definitiv eine Untersuchung wert, da sie noch mehr Verwendungsmöglichkeiten für die Spiegel und aufweisen $.

Gruppe 1

Dieser ist nicht viel ausgefeilter als meine ursprüngliche Lösung, aber die Wege gehen in verschiedene Richtungen. Es erlaubt auch die größte Anzahl von Variationen in einer einzelnen Zelle, da das No-Op ganz rechts durch 5 verschiedene Befehle ersetzt werden kann, die dies weiterhin gültig machen, ohne die Struktur zu ändern:

Gruppe 2

Dieser ist sehr interessant, weil er sich nur horizontal bewegt. Nach dem Wickeln in die >kehrt sich die IP sofort um und nimmt den Zweig in der Ecke. Es ist nicht ganz gut sichtbar, kein Diagramm, aber im Falle der 1wir die erste Reihe wieder durchlaufen, aber diesmal rückwärts. Dies bedeutet auch, dass wir ?erneut darauf 0stoßen , was jetzt zurückkehrt (EOF). Dies ist mit )(Inkrement) festgelegt, um den Druckvorgang 1fortzusetzen. Dies hat auch 5 Variationen, wie )auch 1oder o, und >könnte auch sein |:

Gruppe 3

Dieser sieht fast identisch mit dem vorherigen aus, ist aber höllisch chaotisch. Bis zum Schlagen |und Überqueren der unteren oder oberen Reihe ist es dasselbe. Aber im Falle einer Schleife $überspringt die nun ) auf den Spiegel. So folgen wir dem türkisfarbenen Weg nach rechts, jetzt dem Zuwachs getroffen, überspringen die @bevor wir wickeln um auf die | wieder und dann auf den grünen Weg an der Spitze zurück.

Gruppe 4

Ich dachte, dass dieser besonders geschickt war:

Der _Spiegel in der oberen rechten Ecke ist anfangs ein No-Op, also drucken wir mit !und drücken die <. Der 0Pfad trifft jetzt auf den horizontalen Spiegel und endet. Der 1Weg führt eine wirklich obwohl interessante Bahn: es lenkt ab, um die Wraps !, wird in Richtung der horizontalen umgeleitet und dann auf die Packungen zurück ! wieder . Es bewegt sich dann weiter in dieser Rhombusform und druckt zweimal pro Iteration (jeder dritte Tick).

Gruppe 8

Dies ist eine der beiden Lösungen mit einer sehr engen Druckschleife:

Der <fungiert als Abzweig. Nach zweimaligem Umwickeln 0Treffer @. 1Überspringt andererseits zuerst das ?, und >sendet es dann $erneut an das, so dass das übersprungen wird @. Dann wird die IP in den türkisfarbenen Pfad gewickelt , wo sie zwischen >und hin und her springt <(um den Rand dazwischen wickeln).

Gruppe 10

Eine von zwei Gruppen, die andere Anweisungszeiger verwenden, und es ist absolut schön. Hexagony hat 6 - jede beginnt an einer anderen Ecke im Uhrzeigersinn, aber immer nur eine davon ist aktiv.

Wie immer lesen wir mit ?. Jetzt ~ist unäre Verneinung: es verwandelt sich 1in eine -1. Als nächstes schlagen wir die #. Dies ist eine Möglichkeit, zwischen IPs zu wechseln: Es wird der aktuelle Flankenwert modulo 6 verwendet und auf die entsprechende IP umgeschaltet (IPs werden 0im Uhrzeigersinn nummeriert ). Wenn also die Eingabe war 0, dann bleibt die IP einfach gleich und wandert langweilig geradeaus hinein !@. Aber wenn die Eingabe war 1, dann ist der aktuelle Wert -1der, der ist 5 (mod 6). Also wechseln wir zu der IP, die in derselben Zelle beginnt (dem grünen Pfad). Jetzt #ist ein No-Op und ?setzt den Speicherrand auf 0. )Inkremente so !druckt ein 1. Jetzt schlagen wir noch ~einmal zu, um das sicherzustellen#ist immer noch ein No-Op (im Gegensatz dazu, dass wir zu IP 1 wechseln, was das Programm beenden würde). Es ist umwerfend, wie gut in diesem kleinen Programm alles zusammenpasst.

Gruppe 22

Zu beachten ist, dass dies die Gruppe ist, in der sich meine ursprüngliche Lösung befindet. Es handelt sich auch zufällig um die größte Gruppe, da sich das No-Op an zwei verschiedenen Stellen befinden kann und es mehrere Auswahlmöglichkeiten für den tatsächlichen (effektiven No-Op) Befehl gibt.

Gruppe 23

Dies ist die andere Gruppe, die mehrere IPs verwendet. In der Tat verwendet dieser 3 verschiedene IPs. Die obere rechte Ecke ist ein bisschen chaotisch, aber ich werde versuchen, Sie durch Folgendes zu führen:

Also, der Anfang, den Sie schon gesehen haben: <lenkt den Nordosten ab, ?liest Eingaben. Jetzt ]gibt es eine andere Möglichkeit, zwischen IPs zu wechseln: Die Steuerung wechselt im Uhrzeigersinn zur nächsten IP. Also schalten wir die Kontrolle auf den türkisfarbenen Pfad um, der (wie ich weiß, schwer zu erkennen ist) in der nordöstlichen Ecke in südöstlicher Richtung beginnt. Es wird sofort von der reflektiert, <so dass es sich in die südöstliche Ecke nach Nordwesten wickelt. Es auch trifft das ]so wir an den Schalter neben IP. Dies ist der graue Pfad, der in der östlichen Ecke beginnt und nach Südwesten führt. Die Eingabe wird gedruckt und dann in die nordöstliche Ecke umgebrochen. <Leitet den Pfad in die Horizontale um, wo er vom anderen reflektiert wird <. Jetzt die rechte Hand<fungiert als Verzweigung: Wenn die Eingabe war 0, wird die IP nach Nordosten verschoben und in die umbrochen @. Wenn die Eingabe war 1, bewegt sich die IP zum !, springt zum Lef-Thand, <wo sie reflektiert wird ... jetzt in der Ecke, springt sie zurück zum !, wird von der Rechten abgelenkt <, von der Linken reflektiert <und der Pfad beginnt Über...

Ein ziemliches Durcheinander, aber ein schönes Durcheinander. :)

Mit Timwis erstaunlichem HexagonyColorer erstellte Diagramme .

Motorola MC14500B Maschinencode, 2 Byte

In hex:

58EC

Erläuterung:

5  OR the register with input from the data bus
8  Write the register to the data bus
E  Skip next instruction if register is zero
C  Jump

Der Motorola MC14500B ist ein 1-Bit-Mikrocontroller. es hat ein 1-Bit-Register und einen 1-Bit-Datenbus. Da die Opcodes jeweils 4 Bits sind, gibt es nur 16; Die Hälfte von ihnen führt eine logische Operation zwischen dem Register und dem Bit auf dem Datenbus aus.

Der Sprungbefehl setzt ein Sprungflag; Wenn keine Adresse angegeben ist, wird der Programmzähler normalerweise auf 0 gesetzt. Wenn das Eingangsbit Null war, springt der Prozessor nicht. Wenn das Eingangsbit 1 war, springt der Prozessor zum Start zurück; da es sich um einen OReingang handelt, spielt es keine rolle, wie das eingangssignal danach aussieht - das register wird dann für immer 1 sein.

Wie üblich wird das Register auf 0 initialisiert.

Eine Liste der Opcodes finden Sie im Datenblatt oder hier .

Arnold C, 296 Bytes

IT'S SHOWTIME
    HEY CHRISTMAS TREE i    
    YOU SET US UP @NO PROBLEMO
    BECAUSE I'M GOING TO SAY PLEASE i
        STICK AROUND i
            TALK TO THE HAND i
        CHILL
    BULLSHIT
        TALK TO THE HAND i
    YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE BEEN TERMINATED

Nicht wirklich konkurrenzfähig, aber zum Spaß. Nicht stdin unterstützen, ersetzen Sie @NO PROBLEMOmit @I LIEDfür einen Nullwert. @No Problemoist 1.

Ausführen mit (unter der Annahme, dass die Datei truthmachine.arnoldc lautet):

wget http://lhartikk.github.io/ArnoldC.jar
java -jar ArnoldC.jar truthmachine.arnoldc
java truthmachine

Minecraft, 18 Bytes (MC Version 15w45a)

Wie Sie sehen, befindet sich ein Hebel in dem sich wiederholenden Befehlsblock, in dem sich der Befehl befindet say 1. Darüber befindet sich ein Signalumkehrbrenner, der die Leistung mit dem darin enthaltenen Befehl in den Single-Run-Befehlsblock leitet say 0.

Immer wenn der Schalter auf Wahrhaftigkeit ausgerichtet ist, verwendet der Repeater-Block den Code, say 1um unendlich viele 1s auszugeben . Wenn der Hebel auf false umgeleitet wird, wird eine einzelne ausgegeben 0.

Beachten Sie, dass dies [@]standardmäßig eine ausgibt . Wenn Sie wirklich nur Einsen und Nullen wollen, werden dies 34 Bytes, wobei der Code in den Befehlsblöcken tellraw @a [1]und ist tellraw @a [0]. Dies verwendet die von @ Cᴏɴᴏʀ O'Bʀɪᴇɴ vorgeschlagene Byteanzahl für MC, wie in Meta zu finden .

Bash + GNU Utils, 13

grep 0||yes 1

Bash, 35

read n;for((;n;));{ echo 1;};echo 0

Rubin, 20

print while/1/||gets

Führen Sie den Befehl über die Befehlszeile aus, um Warnungen zu vermeiden

ruby -e "print while/1/||gets" <<< 0
ruby -e "print while/1/||gets" <<< 1

Erläuterung:

Das ist weniger Golf

while /1/ || gets
  print
end

Wenn eine Regexp in einer Bedingung verwendet wird, wird sie als falsch ausgewertet, sofern die Variable nicht ausgefüllt $_ist und mit dem Muster übereinstimmt. Beim ersten Durchlauf der Schleife $_ist leer, sodass wir auf fallen gets, wodurch der Wert $_einer aus STDIN gelesenen Zeile festgelegt wird. printohne Argumente druckt $_. Jetzt bewerten wir die Bedingung erneut. Wenn wir 1 einlesen, schließen wir kurz und drucken nur 1 erneut und so weiter für immer. Andernfalls fallen wir durch gets, aber da es keine zweite Eingabezeile getsgibt, wird nil zurückgegeben, sodass die Schleife endet.

Mikroskript, 3 Byte

i{p

Der kürzeste, den ich kenne.

Erläuterung:

i  Takes numeric input and puts it in register 1
{  while register 1 is truthy
  p  Print the contents of register 1

Microscript 0druckt das Register 1 beim Beenden implizit aus. Dies ist der Grund, warum eine Eingabe von einmal gedruckt wird.

Turing Machine Code, 32 Bytes

Verwenden Sie die hier angegebene Regeltabellensyntax .

0 0 0 * halt
0 1 1 r 1
1 _ 1 r 1

JavaScript, 28 Bytes

For-Schleifen sind oft kürzer als while-Schleifen.

alert(x)Erträge undefined, die falsy ist, so dass die bitweise oder Operator, |wirft es 0. Wenn dies der Fall xist "0", warnen Sie einmal, andernfalls wiederholen Sie die Schleife. Verwendet alertfür STDOUT diese Antwort .

for(x=prompt();alert(x)|x;);

Python 2, 29 Bytes

a=input()
while 1:print a;1/a

Dies endet mit einem Teilungsfehler 0, der standardmäßig zulässig ist .

Brainfuck, 41 36 31 30 Bytes

Verkürzt durch einmaliges Drucken direkt nach der Eingabe und mit Hilfe von Ethan und user46915.

,.+++[->>+<-----<]>>---<-[>.<]

Vorherige Version: Subtrahieren Sie 48 von der Eingabe, und addieren Sie 1 zu 48, wenn der Wert nicht Null ist, um ASCII 1für immer zu drucken 0. Andernfalls wird gedruckt .

-[>+<-----]>--->,<[->->+<<]>[>+<]>.<[>.<]

Ich habe es hier ausgeführt , aber aufgrund der gepufferten Ausgabe können Sie keine Ausgabe sehen, da das Programm niemals beendet wird 1.

Edit: Ich hatte vergessen, 0bei der Eingabe zu drucken 0. Jetzt behoben. Ich mag die >.<Gesichter am Ende.

Piet, 27 18 16 codels

(Codel ist ein ausgefallener Name für Pixel, der verwendet wird, um Verwirrung zu vermeiden, wenn ein Bild zum Anzeigen gestreckt wird. Ich habe Codels anstelle von Bytes gezählt, da Piet-Skripte als Bilder gespeichert werden, sodass die physische Größe variieren kann. Ich denke, ein ideales Dateiformat, das speichern würde Dieser Piet benötigt so effizient wie möglich 11 Bytes. In der Praxis hat meine winzige GIF-Datei 62 Bytes mit optimalen Palettendaten. Sagen Sie mir, ob ich dies als Größe für meinen Eintrag anstelle der Codel-Menge verwenden soll.)

Original Bild:

Vergrößert:

Bei Piet hängt der Unterschied zwischen zwei Farben davon ab, welcher Befehl ausgeführt wird. Wenn Sie also dieselbe Farbe zweimal sehen, bedeutet dies nicht, dass Sie dieselbe Aktion ausführen. Die Ausführung beginnt im oberen linken Codel. Dann bewegt es sich horizontal und führt Folgendes aus:

1. Lesen Sie eine Zahl und legen Sie sie auf den Stapel
2. Duplizieren Sie die Oberseite des Stapels
3. Pop und Ausgabe der Oberseite des Stapels
4. Öffnen Sie den Stapel und drehen Sie ihn so oft im Uhrzeigersinn.

Wenn die Eingabe 1 war, bewegt sich der Cursor nach unten in den Kalkcodel, der 1 auf dem Stapel drückt. Dann geht die Hinrichtung links weiter. Wenn der Cursor von einer Farbe zu Weiß und von Weiß zu einer Farbe wechselt, geschieht nichts. Da Schwarz auch als Wand betrachtet wird, kehrt der Cursor in der obersten Zeile zum Kalkcodel zurück und wiederholt das Ganze ab Schritt 2.

Wenn die Eingabe jedoch 0 war, wird der Cursor niemals nach unten gehen und rechts im blauen J enden (Wortspiel beabsichtigt, es hat sich gelohnt), wenn er gefangen bleibt (weil oben, rechts, links und Die unteren Seiten dieses J-förmigen Blocks befinden sich neben den schwarzen Markierungen oder dem Bildrand. Da der Cursor gefangen ist, endet die Ausführung.

Unerwartete Werte:
Wenn der Benutzer eine andere Zahl schreibt, wird diese trotzdem gedruckt, und der Cursor dreht sich je nach Wert mehr oder weniger oft.

• Vielfaches von 4 oder 0: Die Ausführung wird horizontal fortgesetzt und endet.
• Vielfaches von 3: Da das Hochfahren nicht möglich ist, dreht sich der Cursor sofort im Uhrzeigersinn und fährt horizontal fort und endet dann.
• Vielfaches von 2 und kein Vielfaches von 4: Der Cursor dreht sich und bewegt sich nach links. Zum Glück müssen nur eine Reihe von Vorgängen ausgeführt werden, die den Programmablauf nicht beeinträchtigen, und am Ende wird der Stapel geleert. Wenn ein Vorgang nicht ausgeführt werden kann, weil der Stapel leer ist, wird er einfach ignoriert. Wenn es die linke obere Ecke berührt, kann der Cursor nur noch nach rechts gehen und das Programm neu starten.
• Andere Werte: Der Cursor bewegt sich nach unten wie bei einer 1, wodurch eine 1 für immer ausgegeben wird. Wenn der Eingang 5 ist, wird der Ausgang sein5111111111111...

Jeder nicht ganzzahlige Wert beendet das Programm. Die Ausführung wird normal fortgesetzt, aber alle Vorgänge werden ignoriert, da sich nichts im Stapel befindet. In gewisser Weise stürzt das Programm also nie ab - es stoppt entweder normal oder wiederholt sich für immer.

PietDev freundliche Version

PietDev (eine sehr einfache Online-Piet-IDE) scheint Probleme mit weißen Codels zu haben, daher habe ich eine neue Version erstellt, die manuell gesichert wird, anstatt sich auf die richtige automatische Drehung der weißen Codels zu verlassen. Und ich musste nicht einmal eine neue Farbe verwenden! Wenn Sie es testen möchten, stellen Sie sicher, dass Sie einen schwarzen Rand um den Code ziehen, da PietDev keine benutzerdefinierten Programmgrößen unterstützt.

ältere Versionen

Die erste Version hat 1 nicht auf den Stapel zurückgeschoben und stattdessen eine Schleife zu einer früheren Vervielfältigungsanweisung erstellt. Es hatte auch dekorative nutzlose Codels.

Dann hatte ich die Idee, 1 auf den Stapel zu schieben, um die Leerzeile zu entfernen. Es ist lustig, wie ich dank meiner dekorativen Codels darüber nachdachte.

Dann bemerkte ich, dass ich ein überflüssiges Dup hatte, das nicht mehr benötigt wurde, und reduzierte die Anzahl der Farben, um die Palettendaten im Bild zu speichern. Ich habe auch den einzigen dekorativen Codel entfernt, weil ich es nicht weiß.

Pyth, 4 3 2

Wp

Es gibt ein Nein! Leerzeichen (danke isaac :)). Der Platz, der früher benötigt wurde, um die Kompilierung der while-Schleife durchzuführen, wurde inzwischen jedoch aktualisiert. Normalerweise würde dies die Verwendung disqualifizieren, aber da dies ein Katalog ist, sollte er gültig sein.

Erläuterung:

Wp        : implicit Q = eval(input)
W         : while
 p        : print and return the value of Q, to be evaluated as the while condition
          : Functions without enough arguments automatically use Q now
          : do nothing in the body of the while loop

Chip , 6 Bytes

e*faAs

Chip ist eine 2D-Sprache, die sich ein bisschen wie eine integrierte Schaltung verhält. Die Eingabe wird byteweise ausgeführt und die Bits werden in einzelne Eingabeelemente aufgeteilt. Ausgabe fügt die Werte der Ausgabeelemente wieder zu Bytes zusammen.

Lassen Sie uns das aufschlüsseln:

*Wenn es sich um ein Quellensignal handelt, wird ein wahrer Wert an alle angrenzenden Elemente gesendet. eund fentsprechen dem fünften und sechsten Bit der Ausgabe. So e*ferzeugt binäre 00110000, das ASCII - Zeichen "0" ist.

Ist jetzt Adas erste Bit der Eingabe und adas erste Bit der Ausgabe, aAkopiert dieses Bit von Eingabe zu Ausgabe. In Kombination mit e*fergibt eine Eingabe von ASCII "0" "0" und "1" "1". (Es gibt keine Wechselwirkung zwischen fund a, da beide kein Signal erzeugen.)

Die sam Ende, wenn sie von einem echten Signal aktiviert, wird verhindert , dass eine Eingabe von auf das nächste Byte voran, was bedeutet , dass das Ganze wieder mit dem gleichen Eingang laufen.

Da das erste Byte von "0" Null ist, aktiviert es dieses Element nicht und das Programm gibt "0" aus und erschöpft dadurch seine Eingabe, wodurch es beendet werden kann. "1" aktiviert jedoch dieses Element, was bedeutet, dass "1" ausgegeben, aber nicht am Eingang verbraucht wird, wodurch der Zyklus unbegrenzt wiederholt werden kann.

Wenn für die Ausgabe die Werte 0x0 und 0x1 anstelle von ASCII verwendet werden, können wir den e*fTeil entfernen , was nur 3 Bytes ergibt :

aAs

Wenn sich die Null selbst beenden muss, anstatt zu erwarten, dass stdin geschlossen wird, erhalten wir Folgendes, das das erste Byte mit invertiert ~und das Ergebnis an übergibt t, wodurch das Programm beendet wird ( 10 Byte ):

aA~te*f
 s

( tErzeugt auch kein Signal, daher gibt es keine Interaktion zwischen tund e.)

Brainbool , 5 Bytes

,.[.]

Brainbool ist Brainfuck, arbeitet jedoch nur mit Bits und führt E / A-Vorgänge 0und 1Zeichen aus.

LOLCODE, 119 Bytes

GIMMEH n
n R SUM OF n AN 0
BOTH SAEM n AN 0, O RLY?
YA RLY
 VISIBLE 0
NO WAI
 IM IN UR l
  VISIBLE 1
 IM OUTTA UR l
OIC

Ungolfed:

HAI

BTW, Read n as a string from STDIN and convert to an integer
GIMMEH n
n R SUM OF n AN 0

BTW, Test n for equality with 0
BOTH SAEM n AN 0, O RLY?
YA RLY
    BTW, Write 0 to STDOUT and exit
    VISIBLE 0
NO WAI
    BTW, Loop forever, printing 1
    IM IN YR l
        VISIBLE 1
    IM OUTTA YR l
OIC

KTHXBYE

C 37 Bytes

Eine andere Art, wie man es in C macht.

main(c){for(gets(&c);putchar(c)&1;);}

cstandardmäßig auf einen intWert 1. gets(&c)bekommt einen String aus stdin, hier den Wert von clobbering c, hackishly da ckeine ist char*. putchar(c)gibt den Wert von cbis aus stdoutund kehrt zurück c. Da in ASCII '0'48 und '1'49 ist, können wir das letzte Bit ( &1) verwenden, um zu bestimmen, um welches es sich handelt. Wenn dies '0'der Fall ist , wird die Schleife unterbrochen. Ansonsten geht es für immer.

Kompiliert (mit Warnung gets) und läuft unter gcc-4.8Linux.

Labyrinth , 7 Bytes

 ?+
@!:

Labyrinth ist eine auf 2D-Stapeln basierende Sprache, bei der der Steuerungsfluss vom Vorzeichen des obersten Elements des Stapels abhängt, das nach jeder Anweisung überprüft wird. Die Ausführung beginnt ab der ersten gültigen Anweisung in der obersten Zeile, die hier die ist, nach rechts ?.

Die relevanten Anweisungen sind:

?      Input integer
+      Add top two elements (Labyrinth's stack has infinite 0s on the bottom)
:      Duplicate top element
!      Output as number
@      Terminate program

Wenn die Eingabe 0 ist, liest die IP die Eingabe mit ?, addiert die oberen beiden des Stapels ( 0 + 0 = 0), dupliziert :und gibt !eine 0 aus. Hier treffen wir auf die einzige Junction im Programm und müssen die Oberseite des Stapels überprüfen, um zu bestimmen wo hin. Da die Spitze 0 ist, bewegen wir uns vorwärts und enden mit @.

Wenn andererseits die Eingabe 1 ist, führen wir den gleichen Befehl wie zuvor aus (geben jedoch eine 1 aus), bevor wir die Kreuzung am Punkt erreichen !. Jetzt ist die Spitze des Stapels positiv und wir biegen rechts in die ein ?. Auf EOF drückt Labyrinth 0, also machen wir 0 + 1 = 1das +, duplizieren :und geben aus !. Wieder haben wir eine 1 oben auf dem Stapel und die Schleife geht weiter.

Als Bonus gibt es @ MartinBüttners 7-Byte-Lösung, die ähnlich funktioniert:

?+!@
1!

Beachten Sie, dass im Gegensatz zu den meisten Sprachen der Stapel 1tatsächlich nabgebrochen und verschoben wird n*10 + 1, was den Aufbau großer Zahlen vereinfacht. Da jedoch die Oberseite des Stapels zu diesem Zeitpunkt leer ist, unterscheidet es sich nicht von dem bloßen Drücken von 1.

> <> , 7 Bytes

i2%:n:,

Dies basiert auf der Tatsache, dass> <> -1 auf EOF drückt, was 1 mod 2 ist. Außerdem wird zum Beenden das Teilen durch 0 verwendet (was anscheinend in Ordnung ist, da der Konsens darin besteht, dass die STDERR-Ausgabe ignoriert wird).

Das fehlerfreie Beenden ist nur zu Referenzzwecken ein zusätzliches Byte:

i2%:n?!;

APL, 6 Bytes

→⎕←⍣⍲⎕

Erläuterung:

     ⎕ Read the input, then
 ⎕←    write it out
   ⍣   repeatedly
    ⍲  until NAND of it with itself becomes true.
→      Branch to zero to avoid printing the result again.

Brian & Chuck , 21 Bytes

,}<-{-?<SOH>_{+?
_>+{?<.p

Hier <SOH>sollte durch das entsprechende Steuerzeichen (0x01) ersetzt werden.

Erläuterung

Die Grundidee besteht darin, den Zeichencode der Eingabe (48 oder 49) vom pEnde von Chuck zu subtrahieren , wodurch entweder ein ?(was ein gültiger Befehl ist) oder ein ( @was ein No-Op ist) ausgegeben wird.

,Liest das eingegebene Zeichen in Chucks erste Zelle (markiert mit _). Wir möchten diesen Wert 0in einer Schleife dekrementieren und dabei einige andere Änderungen vornehmen:

}<bewegt sich zu pund -dekrementiert es. Dann {geht es zurück zu den Eingabezellendekrementen -. Solange dies noch nicht Null ist, ?gibt Chuck die Kontrolle. Jetzt >bewegt sich Brians Bandkopf eine Zelle nach rechts (die initialisiert 1) und +erhöht das. Dann setzen wir die Schleife mit zurück {?.

Bis die erste Zelle auf Chuck trifft 0, wird die <SOH>Zelle auf das Zeichen erhöht, das wir aus STDIN gelesen haben, und pwird ?zur Eingabe 1oder @zur Eingabe verwendet 0.

Jetzt ?schaltet die Kontrolle nicht mehr. Das 0oder 1danach ist ein No-Op, ebenso wie das Null-Byte (dargestellt durch _). {Geht zurück zu Chucks erster Zelle und +erhöht sie, um sicherzustellen, dass sie positiv ist, sodass ?Chuck die Kontrolle hat.

Diese Zeit >+erhöht die Zelle nach dem Ende von Brians ursprünglichem Band. Diese Zelle ist Müll, aber wir werden sie nie benutzen. {Scannen Sie jetzt nicht mehr bis zur Vorderseite von Brians Band, sondern nur noch bis zur _. Daher ?ist es ein No-Op, da die aktuelle Zelle Null ist. Dann <.bewegt man sich nach links (die Kopie des Eingabezeichen) und druckt sie.

Schließlich begegnen wir dem ?oder @. Wenn die Eingabe war 0und diese Zelle @ein No-Op ist, wird das Programm beendet. Aber wenn die Eingabe war 1und diese Zelle ist, übergeben ?wir sie an Brian {+?, der die Schleife auf Chuck zurücksetzt, und jetzt drucken wir 1s für immer (bis die Ganzzahl in der Zelle am Ende von Brians Band nicht mehr in den Speicher passt) mehr nehme ich an ...).

Bonus

Sp3000 und ich haben mehrere Tage damit verbracht, Golf zu spielen. Wir begannen mit ungefähr 40 Bytes und kamen zu zwei völlig unterschiedlichen, aber gebundenen Lösungen mit 26 Bytes. Erst als ich anfing, meine Erklärung aufzuschreiben, kam mir die 21-Byte-Lösung in den Sinn. Vielen Dank an Sp, dass sie sich mit Ideen beschäftigt und sich gegenseitig einige Golf-Tricks in B & C beigebracht haben. :)

Dies ist seine 26-Byte-Lösung:

>,----{?{>1?0
#I<?_}<.<<<?

Und das ist meins:

,{>-<-?_0+?_1{<?
_®{?_{>.?

Wo ®ist ein Byte mit dem Wert 174 (z. B. einfach die Datei als ISO 8859-1 speichern).

Im Kern wirkt Mine ähnlich zu der 21-Byte - Lösung, dadurch ®wird }für die Eingabe 1und ~(no-op) für die Eingabe 0, aber die Ausführung ist viel weniger elegant.

Seine Lösung ist insofern recht ordentlich, als der Quellcode nur ASCII-Code ist und keine Schleife zur Verarbeitung der Eingabe erforderlich ist. Verwandelt ----sich stattdessen 1in -und 0in ,(ein No-Op für Chuck). Das -ändert dann den ersten ?auf Brians Band in einen >, wodurch ein anderer Kontrollfluss für den 1-Fall entsteht.

Bitweises zyklisches Tag , 3 Bits oder <1 Byte

Bitwise Cyclic Tag ist eine der einfachsten Sprachen von Turing-complete. Es funktioniert mit zwei Bitstrings, dem Programm und den Daten . Die Bits des Programms werden zyklisch gelesen und wie folgt interpretiert:

• 0: Löschen Sie das erste Datenbit (und geben Sie es in Implementierungen mit Ausgabe aus).
• 1x: Wenn das erste Datenbit ist 1, wird an das Ende der Daten angehängt x(entweder 0oder 1). (Wenn das erste Datenbit ist 0, nichts tun.)

Das Programm läuft solange, bis der Datenstring leer ist.

Wahrheitsmaschine

110

Wenn die Datenzeichenfolge auf Folgendes festgelegt ist 0:

• 11fügt nichts an, da das erste Datenbit nicht ist 1.
• 0löscht / gibt aus 0.
• Der Datenstring ist jetzt leer und das Programm wird angehalten.

Wenn die Datenzeichenfolge auf Folgendes festgelegt ist 1:

• 11fügt ein 1.
• 0löscht / gibt aus 1.
• Der Datenstring ist wieder ein Single 1und das Programm ist wieder da, wo es gestartet wurde.

GNU sed, 10

:;/1/{p;b}

Erläuterung

• : Definieren Sie ein unbenanntes Label
• /1/Wenn die Eingabe mit dem regulären Ausdruck übereinstimmt 1, dann
• p drucke den Musterraum (dh 1)
• b und zurück zum unbenannten Label springen (für immer)
• Wenn die Eingabe nicht 1 (dh 0) war, wird der Musterbereich unverändert gedruckt und das Programm beendet.

Im Ernst , 4 3 Bytes

_{Durchgestrichene 4 ist immer noch 4 :(}

,W■

,liest einen Wert aus STDIN. WStartet eine Schleife, die ausgeführt wird, während der Wert oben auf dem Stapel mit dem Körper übereinstimmt ■. ■druckt das oberste Stapelelement ohne zu platzen. Die Schleife wird implizit bei EOF geschlossen.

Bei der Eingabe von 0wird die Schleife nie ausgeführt (da dies 0falsch ist), und das Programm endet bei EOF, wobei automatisch jeder Wert auf dem Stapel abgelegt und gedruckt wird. Am Eingang des 1(oder einem Wert, der nicht der Fall ist 0, ""oder []), läuft die Schleife unendlich.

In der Tat , der führende ,nicht (dank implizite Eingabe) benötigt wird , die Kerbe auf 2 Bytes zu bringen.

Thue, 34 Bytes

1::=12
2::=~1
0::=~0
@::=:::
::=
@

Erläuterung:

1::=12 Instanzen der Teilzeichenfolge "1" können zu "12" werden

2::=~1 Instanzen der Teilzeichenfolge "2" können entfernt werden, wobei "1" gedruckt wird

0::=~0 Instanzen der Teilzeichenfolge "0" können entfernt werden, wobei "0" gedruckt wird

@::=::: Instanzen der Teilzeichenfolge "@" können durch Zeichenfolgen aus der Eingabe ersetzt werden

::= Liste der Ersetzungsregeln beenden

@ Die Anfangszeichenfolge lautet "@".

Arnold C, 134 Bytes

IT'S SHOWTIME
HEY CHRISTMAS TREE i
YOU SET US UP 0         //or 1
STICK AROUND i
TALK TO THE HAND 1
CHILL
TALK TO THE HAND 0
YOU HAVE BEEN TERMINATED

Dies ist zwar nicht so unterhaltsam wie die andere ArnoldC- Antwort , aber es ist Golf. Einrückungen sind beispielsweise nicht erforderlich, ebenso wie die Makros @NO PROBLEMOund @I LIED.

Getestet mit dieser Version der Sprache , die keine Eingabe annehmen kann.

Cubix , 5 6 Bytes

Cubix ist @ETHproductions neue zweidimensionale Sprache, in der die Befehle um die Flächen eines Cubes gewickelt werden. Online-Dolmetscher Vielen Dank an @ETHproductions für das Speichern.

!I\@O

Dies wird zum Würfel erweitert

  !
I \ @ O
  .

Dies beginnt mit dem IBefehl. Geben Sie eine Ganzzahl in den Stapel ein.
\, lenkt den Anweisungszeiger nach unten über das No-Op.
O, gibt den numerischen Wert der Stapelspitze aus.
!Überspringen Sie den nächsten Befehl ( @), wenn oben im Stapel true ist. Dadurch wird die \Umleitung bei 1
\übersprungen und der Anweisungszeiger auf das @Exit-Programm umgeleitet .

Dies nutzt die Tatsache aus, dass der Stapel nicht von den O ? !Befehlen gepoppt wird .

Foo , 6 Bytes

&1($i)

Die Eingabe wird als zweites Zeichen fest codiert, da Foo keine STDIN-Eingabe hat. Sind wir uns nicht einig, dass Foo jetzt großartig ist? :)

Erläuterung

&1          Set current cell to 1
  (  )      Do-while loop (or, at least according to the interpreter)
   $i       Print current cell as int

Perl, 18 + 1 = 19 13 + 1 = 14 Bytes

print while$_

Laufen Sie wie folgt:

echo -n NUM | perl -p truth.pl

Vielen Dank an ThisSuitIsBlackNot (der bei Perl viel besser als ich ist) für das Abschlagen von fünf Bytes.

> <> , 6 Bytes

::n?!;

Schiebt die Eingabe auf den Stapel, um zu starten

:        copy top element on stack
 :       copy top element on stack again
  n      pop and outputs top element
   ?     condition trampoline - pops top element, if it is zero skips next instruction
    !    trampoline skips next instruction
     ;   finish execution