167
\$\begingroup\$

A truth-machine (credits goes to this guy for coming up with it) is a very simple program designed to demonstrate the I/O and control flow of a language. Here's what a truth-machine does:

  • Gets a number (either 0 or 1) from STDIN.

  • If that number is 0, print out 0 and terminate.

  • If that number is 1, print out 1 forever.

Challenge

Write a truth-machine as described above in your language of choice. The truth-machine must be a full program that follows these rules:

  • take input from STDIN or an acceptable alternative
    • If your language cannot take input from STDIN, it may take input from a hardcoded variable or suitable equivalent in the program
  • must output to STDOUT or an acceptable alternative
    • If your language is incapable of outputting the characters 0 or 1, byte or unary I/O is acceptable.
  • when the input is 1, it must continually print 1s and only stop if the program is killed or runs out of memory
  • the output must only be either a 0 followed by either one or no newline or space, or infinite 1s with each 1 followed by either one or no newline or space. No other output can be generated, except constant output of your language's interpreter that cannot be suppressed (such as a greeting, ANSI color codes or indentation). Your usage of newlines or spaces must be consistent: for example, if you choose to output 1 with a newline after it all 1s must have a newline after them.

  • if and only if your language cannot possibly terminate on an input of 0 it is acceptable for the code to enter an infinite loop in which nothing is outputted.

Since this is a catalog, languages created after this challenge are allowed to compete. Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language. Other than that, all the standard rules of must be obeyed. Submissions in most languages will be scored in bytes in an appropriate preexisting encoding (usually UTF-8).

Catalog

The Stack Snippet at the bottom of this post generates the catalog from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

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

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

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

You can also make the language name a link which will then show up in the snippet:

## [><>](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>

\$\endgroup\$
18
  • 3
    \$\begingroup\$ Assuming any behaviour is fine for all invalid inputs? \$\endgroup\$
    – Cruncher
    Nov 3, 2015 at 17:33
  • 3
    \$\begingroup\$ @Cruncher Yes, the only inputs you should expect to get are 0 and 1. \$\endgroup\$ Nov 3, 2015 at 17:38
  • 5
    \$\begingroup\$ Catalog is borked. \$\endgroup\$ Nov 6, 2015 at 15:18
  • 2
    \$\begingroup\$ Catalog appears to consider Bf and bf to be different languages. \$\endgroup\$ Nov 10, 2015 at 1:13
  • 1
    \$\begingroup\$ Is one allowed to print an infinite number of 1s? That is, not print out 1s forever, but print out an infinite list of 1s all at once? This would be theoretically demonstrated, but the language has no notion of printing more than once. It just generates an output. So is it okay if it runs indefinitely, but would print infinite 1s given infinite time (to finish executing)? \$\endgroup\$
    – AviFS
    Apr 26, 2020 at 1:42

458 Answers 458

1
7 8
9
10 11
16
1
\$\begingroup\$

Piet, 16 14 codels

codel size 10 for better visibility

enter image description here

Pseudocode:

INN → DUP → PTR → OUN → END
       ↑     ↓  
      PSH ← OUN

Old solution (16 codels)

Truth Machine Piet version

Pseudocode:

INN → DUP → DUP → PTR → OUN → END
             ↑     ↓
            DUP ← OUN

Much simpler than the oddly complicated Piet truth machine on esolangs.org.

Works on PietDev and with npiet 1.3a

\$\endgroup\$
1
\$\begingroup\$

Gogh, 8 7 6 bytes

Saved a byte thanks to @ZachGates

{ƤØ}?x

Run this in the command line like:

$ ./gogh nio '{ƤØ}?x:' <input>

Explanation

     Input is implicit
{    Push this code block
 Ƥ    Print TOS
 Ø    Loop forever
}
?    If STOS is falsy, remove the codeblock from the stack
x    run the code block if there is one, else do nothing
     If there is no codeblock, the program will implicitly output 0
\$\endgroup\$
1
\$\begingroup\$

Wierd, 225 bytes

Unlike other languages where the symbols in a program determine which instructions are executed, in Wierd, it is the bends in the chain of arbitrary symbols that determine which instructions are executed.

From the website:

First, a Riddle:
Q: What do you get when you put three marginally-sane programmers on a mailing list with the Befunge and BrainF*** programming languages?
A: You get BeF***, and then they get Wierd.
...
Chris Pressey then jumped on it, created the angle-to-instruction mapping, and christened the entire mess "Wierd"--a cross between the words "weird" (which the language seemed to be) and "wired" (which would describe the appearance of programs written in the language).

Try it online at http://catseye.tc/installation/Wierd_(John_Colagioia)

0           +  ++++ ++++++++++ ++++
1+  +++ +++  ++  +  +        ++  +
  ++ +  + +  +  +   +        +  +
     +  +  +   +    +          +
      ++++  +++     +     ++  +
        +            +  ++  ++
         +++++++++++++++
\$\endgroup\$
1
\$\begingroup\$

Come Here, 29 bytes

0ASKaCOME FROMa-48 1TELLaNEXT
\$\endgroup\$
1
\$\begingroup\$

Befunge, 7 x 2 = 14 bytes

~:#v_.@
   >:.
\$\endgroup\$
1
  • \$\begingroup\$ There's a lot of answers in this question so you might have missed it, but for comparison here are the links to two other Befunge answers :) link1, link2 (these are accessible via the leaderboard snippet) \$\endgroup\$
    – Sp3000
    Mar 30, 2016 at 15:38
1
\$\begingroup\$

Pylongolf2, 11 bytes

1r1=?1>~<¿

Explanations:

1           push 1 to the stack
 r          pick a random number between 0 and 1
  0=        push 1 to the stack and compare them
    ?1>~<¿  if true, push 1 to the stack then print it forever.
            terminate
\$\endgroup\$
1
\$\begingroup\$

Oration, 101 bytes

start a function t with x
inhale
to iterate, 1
literally, print x
if not x:break#
invoke t with input

Very long. Starts a function called t with arguments x.

Inhale is a command used to keep the program running, you need oxygen to execute. :P

to iterate, starts a while $1 loop, so this becomes while 1:.

literally, print x just prints x, the function input.

if not x:break# is a simple if statement. The # is there because the compiler appends a : to it, so that becomes if not x:break#:. It happens to be golfier than the following good code with normal syntax.

if not x
goodbye

invoke t with input calls the function.

Transpiles to:

#!/usr/bin/env python3
def t(x):
    while 1:
        print x
        if not x:break#:
t(input("~> "))
\$\endgroup\$
2
  • \$\begingroup\$ Could you include the transpiled source? \$\endgroup\$ Apr 8, 2016 at 17:34
  • \$\begingroup\$ @CᴏɴᴏʀO'Bʀɪᴇɴ sure. BTW, there might be a bug about the function call before 2 backtrackings. \$\endgroup\$
    – Riker
    Apr 8, 2016 at 17:42
1
\$\begingroup\$

Reng v.3.3, 6 bytes

i:n?~!

Try it here!

This takes input I, duplicates, outputs as number, ? skips if true. If false, ~ is met and the program ends. Otherwise, we skip ~ then skip i with !, and it repeats.

\$\endgroup\$
1
\$\begingroup\$

JavaScript, 27 29 bytes

for(x=prompt();alert(x),+x;);

The only interesting part is the +x which converts x to a number, otherwise the string '0' would return true.

\$\endgroup\$
4
  • \$\begingroup\$ @intrepidcoder Not to steal your thunder, but... :) \$\endgroup\$
    – Adam Dally
    Nov 24, 2015 at 2:36
  • \$\begingroup\$ +1 Clever way to get rid of that trailing ; \$\endgroup\$ Nov 26, 2015 at 3:52
  • \$\begingroup\$ But it doesn't output 0... \$\endgroup\$
    – Qwertiy
    Apr 11, 2016 at 17:06
  • \$\begingroup\$ I completely didn't realize I wasn't following the prompt correctly..oops. You just almost beat me out, ha ha, but not quite. Thanks for pointing it out. \$\endgroup\$
    – Adam Dally
    Apr 16, 2016 at 3:42
1
\$\begingroup\$

Pyke, 4 bytes

​
I1r

Explanation:

print(top_of_stack) (if first run, print input())
if pop(stack):
    top_of_stack = 1
    goto_start()

Try it here!

\$\endgroup\$
1
\$\begingroup\$

Tellurium, 11 bytes

I?1|[i|^;]^

This program asks for input and converts it to an integer (I). After that, it checks if the input is 1. If it's 1, output 1 forever ([i|^;). If it's 0, output 0.

\$\endgroup\$
1
\$\begingroup\$

eacal, 58 bytes

label l
put set n cast number arg number 0
if get n
goto l

put outputs n, which is cast to the first argument. Call like:

node eacal.js tm.eaa <input>
\$\endgroup\$
1
\$\begingroup\$

Racket, 36 bytes

(do([n(read)])((= n 0)n)(println n))
\$\endgroup\$
1
\$\begingroup\$

JQuery, 63 57 Bytes

if($("input").val()==1){while(1){alert(1)}}else{alert(0)}

Try it!

\$\endgroup\$
1
\$\begingroup\$

Perl 6, 28 bytes

{.say;.say while $_}(+slurp)
\$\endgroup\$
1
\$\begingroup\$

PowerShell, 22 21 bytes

Variable $a into the pipeline, prints once, then prints again if the input evaluates as true. Less elegant than TimmyD's but shorter.

$a|%{$_;while($_){$_}}

After looking at his though it could also be written as below, dropping it to 21 bytes

$a|%{do{$_}while($_)}
\$\endgroup\$
1
  • \$\begingroup\$ Sadly, taking input via a pre-defined variable isn't allowed here, since PowerShell can read from STDIN. \$\endgroup\$ Aug 30, 2016 at 13:33
1
\$\begingroup\$

><>, 6 bytes

Takes input from command line i.e. ./fish.py program.fish -v 1

:?!;:n

Explanation:

:   ?  !; :n      ... (Since this is fish, it wraps around and repeats)
^   ^  ^  ^
|   |  |  |
|   |  |   Duplicates topmost value on stack and outputs it
|   |  | 
|   |   Skips the next instruction
|   |    
|    Checks if topmost value is 0 and if so, skips the next instruction, going straight to the ; which terminates the program
|
 Duplicates topmost value on stack
\$\endgroup\$
1
\$\begingroup\$

Ru, 11 9 bytes

»Ϟα;¿{»α}

This look way too long

\$\endgroup\$
1
\$\begingroup\$

Python 2, 33 bytes

Golfing suggestions welcome :)

x=input()
while x:print 1
print 0
\$\endgroup\$
8
  • \$\begingroup\$ This doesn't work. \$\endgroup\$
    – ABcDexter
    Sep 1, 2016 at 9:24
  • 1
    \$\begingroup\$ @ABcDexter Ah you're right, I forgot the int. I actually initially wrote this in python2 where you don't need the int conversion and added the parentheses in later. Check it now. \$\endgroup\$
    – gowrath
    Sep 1, 2016 at 9:26
  • \$\begingroup\$ Somebody already beat you to the Python 2 solution. \$\endgroup\$
    – user45941
    Sep 1, 2016 at 9:31
  • 1
    \$\begingroup\$ @Mego Apparently, no. As the other code takes input again and again in the while condition. \$\endgroup\$
    – ABcDexter
    Sep 1, 2016 at 9:33
  • 1
    \$\begingroup\$ There's also this one \$\endgroup\$
    – user45941
    Sep 1, 2016 at 9:34
1
\$\begingroup\$

Straw, 17 bytes

(1>:&)(:&) <1='0>
\$\endgroup\$
1
\$\begingroup\$

Brainfuck, 5 Bytes Non-Competing.

,.[.]

Non Competing, because I highly doubt that SOP's count as 1, or that the input will be a SOP or NUL.

I just think it's a neat thing.

\$\endgroup\$
1
1
\$\begingroup\$

Logicode, 43 bytes

circ l(a)->1+l(a)
cond binp->out l(a)/out 0

Logicode can't output while in an infinite circuit loop, so this program will output ALL of the 1's after the infinite loop (when the program encounters a 1).

If a truth machine that goes into an infinite loop when 1 is entered and has no output is acceptable, the code can be shorter by 2 bytes:

circ l(a)->1+l(a)
cond binp->out l(a)/out 0
\$\endgroup\$
1
\$\begingroup\$

braingasm, 5 bytes

;:[:]

The braingasm instruction ; and : are very similar to the brainfuck instructions , and ..

; gets some input from stdin, reads it as an integer, and stores the integer value in the current cell. : prints the value of the current formatted as an integer. Like in brainfuck, [] loops while the current cell is non-zero.

\$\endgroup\$
1
\$\begingroup\$

reticular, 8 6 bytes

[do?!]

Try it online!

This is a function. g calls the function with the TOS as input. do outputs without popping, ?! skips the next char if it's 1. Because of the way functions work, the actual constructed function is:

do?!;

This is made in a child instance of the program. Thus, if the TOS is 0, then it terminates (exits function).


Previous versions:

8 bytes:

indp?!;!

11 bytes:

in@@p;
p1 <

This goes right by @@ if 0, and up if 1 (wrapping around to <) and prints 1 infinitely. It's in better style to do it this way, y'know, more readable. Because 2D languages are easy to read.

\$\endgroup\$
1
\$\begingroup\$

PHP, 30 33 bytes

do{echo$o=$argv[1];}while($o);

Oops, didn't see the 7 other pages, one of which contains a better PHP entry.

Old 1

do{echo$argv[1];}while($argv[1]);
\$\endgroup\$
1
\$\begingroup\$

Javascript, 33 32 Bytes

i=prompt();do{alert(i)}while(+i)

uses the +i syntax (thanks ETHproductions)

Old 1

i=prompt();do{alert(i)}while(i>0)
\$\endgroup\$
2
  • 1
    \$\begingroup\$ 0 is a falsy value in JavaScript, so you can shorten this by one byte with i=prompt();do{alert(i)}while(+i) \$\endgroup\$ Nov 1, 2016 at 16:26
  • \$\begingroup\$ Nice one, wasn't aware of that short cut! \$\endgroup\$
    – CT14.IT
    Nov 1, 2016 at 16:31
1
\$\begingroup\$

D - 87 bytes

void main(){import std.stdio,std.conv;int i=readln[0..$-1].to!int;do i.write;while(i);}
\$\endgroup\$
1
\$\begingroup\$

Fuzzy Octo Guacamole, 8 bytes

^X({@}X)

^ pushes input, X prints the top item on the stack. ( starts an infinite loop. {@} ends the program (@) only if the top item on the stack is falsy, like 0. The X prints the top item on the stack (again), and the ) ends the loop.

So it repeats, printing and checking forever.

\$\endgroup\$
1
  • \$\begingroup\$ "languages created after this challenge are allowed to compete" \$\endgroup\$ Nov 17, 2016 at 8:27
1
\$\begingroup\$

PHP, 20 bytes

<?L:echo$i;if($i)goto L;# 24 bytes
<?do echo$i;while($i);  # Martijn´s first version golfed 24->22 bytes
<?=$i;while($i)echo$i;  # Martijn´s second version golfed 24->22 bytes
<?while($i|!print$i);   # 21 bytes
<?while($i&print$i);    # 20 bytes

Requires PHP <4.2 or PHP<7 with --d register_globals=0.
Save to file, call in browser with <scriptpath>?i=<value>.

explanation for the last version:

print$i is evaluated in any case (no short circuit for bitwise operations).
print always returns true, which, when cast to int (by the bitwise and) evaluates to 1.
For $i=0, 0&1 is 0, hence false and the loop exits. for $i=1, 1&1 is 1 and the loop continues.

shortest version(s) for current PHP, 29 bytes:

while(($i=$argv[1])&print$i);
while((print$i=$argv[1])&$i);
for($i=$argv[1];$i&print$i;);

Run with php -r '<code>' <value>.

\$\endgroup\$
1
\$\begingroup\$

Haystack, 9 bytes

id?v
|o<o

Try it online!

I'm aware that there already is a Haystack answer, but that answer uses the older version of Haystack, this answer uses Haystack 2016 (and it's much shorter)

Explanation

id           Take input and duplicate it
  ?          If input is truthy (1) continue, otherwise (0) go down

If input is truthy...

?v           Go down
 o           Output number
             Since this is a 2D language, the IP wraps around and does this infinitely
             Also since Haystack (new) doesn't pop the top of stack after outputting
              1 can be printed forever without needing to duplicate it

Otherwise...

  ?
  <          Go left
 o           Output number
|            Exit program
\$\endgroup\$
1
7 8
9
10 11
16

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.