Implement a Truth-Machine

Question

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 code-golf 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>

Answer 1

Acc!!, 39 37 bytes

N
Count i while _%2-i%2+1 {
Write _
}

Try it online!

This takes input through N, then prints the input _ until the equation _%2-i%2+1 is 0. This looks like:

48
  48%2-0%2+1 => 1
  48%2-1%2+1 => 0
  48%2-2%2+1 => 1
  48%2-3%2+1 => 0
49
  49%2-0%2+1 => 2
  49%2-1%2+1 => 1
  49%2-2%2+1 => 2
  49%2-3%2+1 => 1

This is shorter than the easy approach (39 bytes):

N
Write _
Count i while _%2 {
Write _
}

Try it online!

Answer 2

AWK, 20 bytes

{do{print}while($0)}

This is the first thing I came up with. I tried to come up with something clever more clever but they were all longer.

Try it online!

Answer 3

Forked, 22 21 bytes

^{-1 thanks to BMO}

v >%&
$ |
>-:
  |
 %<

The IP path looks like this if the inputted integer is truthy:

v
|
>-v
  |
 %<

Upon hitting % (print as integer), it goes off the edge of the playing field and wraps around, running >% infinitely.

It takes this path if the inputted integer is falsy:

v >%&
| |
>-^

It prints % 0 and then exits &.

Answer 4

ORK, 395 bytes

There is such a thing as a m.
A m can p a word.

When a m is to p a word:
I have a scribe called W.
W is to write the word.
I have a linguist called C.
C's first operand is the word.
C's second operand is "1".
C is to compare.
If C says it's equal then I am to loop.

When this program starts:
I have a inputter called R.
I have a word called N.
R is to read N.
I have a m called M.
M is to p N.

Try it online!

---

Here's the ungolfed version, which is not a whole lot different:

There is such a thing as a truth machine.
A truth machine can process a word.

When a truth machine is to process a word:
There is a scribe called Keymaker.
Keymaker is to write the word.
There is a linguist called Chomsky.
Chomsky's first operand is the word.
Chomsky's second operand is "1".
Chomsky is to compare.
If Chomsky says it's equal then I am to loop.

When this program starts:
I have an inputter called Dave.
I have a word called Input.
Dave is to read Input.
I have a truth machine called Hal.
Hal is to process Input.

The first paragraph defines a truth machine class with one member function, process, which takes a string (i.e. word).

The second paragraph defines process: write the string out, and then compare it against "1". If it's equal, loop.

The third paragraph defines our main function: read a string in, instantiate a truth machine, and have the machine process the string.

Simple, really.

Answer 5

Stax, 5 4 3 bytes

_{Crossed out 4 is still 4 ;(}

wQc

Try it at staxlang.xyz!

 w      Until popping results in a falsy value:
  Q       Peek and print with a newline.
   c      Copy the value atop the stack.

I'm loving this new language.

Thanks to @Weijun Zhou for reminding me of implicit input.

Answer 6

Reflections, 26 bytes

  _:#_: _<
/#_v     /
\: /

Test it!

Explanation:

The _ at position (2|0) reads a line from input, : doubles the first character. Then, # redefines zero and _ at (1|0) prints that character. : doubles the first character again, _ at (4|0) converts a digit to a number. < tests this number, if it's 0, the IP is directed upwards (out of the program). Else it's directed downwards, then left by the /, and down again by the v, left by the /. The : doubles the character again. Then, the \ reflects the IP upwards and the / right again, where # redefines zero and the _ at (1|0) prints the character. The v then directs it down into the loop again.

Answer 7

Python 2, 59 51 49 33 bytes

i=input()
while i:print 1
print 0

Explanation:

input()             # take input from STDIN
while i:print 1     # print 1 if the argument is anything other than 0... input() evaluates the string and returns a value
print 0             # print 0 and exit if input() returns 0

EDIT: Saved 8 bytes thanks to @EsolangingFruit

EDIT 2: Coupla more bytes thanks to @HyperNeutrino

EDIT 3: Saved 16 bytes thanks to @HyperNeurtrino

Answer 8

Rust, 90 bytes

use std::io::*;fn main(){let
b=&mut[0];stdin().read(b);while{stdout().write(b);b==b"1"}{}}

Try it online!

Answer 9

MATL, 4 bytes

`GtD

Relevant MATL features ^*

To explain the code, the following MATL features need to be presented first.

• ` ...] is a "do ...while" loop. The top of the stack is consumed at the end of each iteration, and used to decide whether to go on with a new iteration or not. The last ] can be omitted if it's at the end of the program (loops are implicitly closed).
• G works as follows:
  • When there has been no user-input it does nothing;
  • When there has been one user-input it pushes it onto the stack
  • When there has been more than one user-input it takes a numeric argrument and pushes one of those user-inputs onto the stack
• t by default duplicates the top element of the stack
• D by default displays the top element of the stack, and consumes it.
• If a function requires more inputs than currently are in the stack, user-input is implicitly triggered. The entered elements are placed below the current bottom of the stack.

Code explanation

` enters the loop. At the first iteration, G does nothing. t implicitly asks for user input and duplicates it. D displays and consumes the duplicate, leaving the original input on the stack. If this input is 0 the loop is exited and the program finishes (a single 0 has been displayed). If the input is 1, control goes to the beginning of the loop again. Now G pastes the input, t duplicates it, D displays and consumes that duplicate, and again there's a 1 to be used as loop condition, so the loop begins again, indefinitely (an infinite number of 1 is displayed).

---

_{^* at the time of writing. The behaviour of G has changed since then: G now triggers implicit input when there has been no user-input yet. However, this doesn't affect the code, which works the same. The only difference is that in the first iteration the implicit input is now triggered by G, not by t.}

Answer 10

Pepe, 15 bytes

REeErEErReEEree

Try it online!

Explanation:

REeErEErReEEree  # Full program
REeE             # Take input as number
    rEE          # Create label 0
       rReEE     # Output number -r (preserve)
            ree  # Goto label 0 if [input] != 0

Answer 11

Self-modifying Brainfuck, 30 19 bytes

Similar method to my BF answer. Input and print, subtract the 0 (the source's last byte) from the input, so cell is 0 or 1. Loop printing if input cell is 1. Tested on my Python interpreter.

,.<[->-<]>[<<.>>]10

You can also run it on TIO.

Answer 12

Flobnar, 10 bytes

<1._
|@&
0

Try it online!

Answer 13

AlgiX with -x, 3 bytes

[.]

Explanation

AlgiX takes each character of input (converts it to charcode if it's not a digit) and runs the entire code for each value, initializing the accumulator to that value each run.

In this case, there's only 1 input, a 1 or a 0, so the code runs once.

[.] - Implicit a = input
[   - If a == 0, skip to ]
 .  - Print value of a
  ] - If a != 0, jump back to [
    - Implicit output value of a

Normally, the implicit output after each run would output a as a character, however the -x flag overrides that and outputs its value instead.

Answer 14

VSL, 36 32 bytes

fn main(){do{print(i)}while i>0}

This is probably familiar to anyone who knows any C-esque language but this takes input using a global variable i.

Try it online!

Answer 15

NuStack, 82 bytes

putchar(c:char):int;f(i:int):int{if(i>0)putchar('1');else while(1>0)putchar('0');}

Been working on this compiler for a month and a half. Still very much a WIP, but finally at a point where I can do some PPCG with it :D

Unlike all of my other languages, this isn't some toy, esoteric, interpreted language.
It's a serious language that compiles directly to assembly (nasm syntax).

I'll probably opt to get NuStack on TIO once it's notably more feature-complete than it currently is.

Explanation:

Ungolfed version:

putchar(c: char): int;

f(i: int): int {
    if(i > 0)
        putchar('1');
    else 
        while(1 > 0)
            putchar('0');
}

The first line is a function prototype that allows you to call a function defined elsewhere (think C header files)

putchar in particular is currently the only function in libns, the language's standard library. It takes a single char, and outputs it to stdout. libns is currently available for 64bit linux, so it just makes a syscall using sys_write(), and 32bit "raw", ie not running on a kernel or operating system, where putchar will use the int 0x10 interrupt to print the character in TTY mode

NuStack uses post-fix types, similar to TypeScript, and there is no type inference, so types must always be explicitly declared.

NuStack also doesn't have type casts yet, or do..while loops, so this is, as far as I know, the golfiest way to do it.

Answer 16

Ruby + -np, 16 12 bytes

p 1while~/1/

Try it online!

~/1/ matches the last line of input to the regular expression /1/

Edit: replaced ;p 0 with the -p flag making the answer -np complete, thanks to @ValueInk

Answer 17

Befunge, 4 bytes

&:.%

Try it online!

Please note: this answer is no longer valid with this particular interpreter. At the time of writing, the interpreter used had a quirk where trying to read more integers when there weren’t any would return the last integer. I believe that this was “fixed” in some interpreter update. (Thanks to @osuka_ for realizing that this answer no longer works)

Explanation:

&       Take number input
 :.     Duplicate and print input
   %    Mods the second from-the-top with the top number in the stack
        This means that if the top is 1, it will yield 0 % 1 = 0,
        But if it is a 0, it errors out and stops execution because you are
        trying to divide by 0
        
&       The program wraps back around if it didn't error, and the & takes
        the last number in the input if it has already taken them all, yielding
        the original 1 or 0

Coincidentally, this doesn't also work for /, because it strangely asks you what you want the answer to be.

Answer 18

Verbosity v2, 290 bytes

IncludeTypePackage<OutputSystem>
IncludeTypePackage<InputSystem>
IncludeStructurePackage<Loops>
input=InputSystem:NewInput<DEFAULT>
outpu=OutputSystem:NewOutput<DEFAULT>
condi=InputSystem:ReadEvaluatedLineOfInput<input>
Loops:ConstructLoop<Do;condi>[OutputSystem:DisplayAsText<outpu;condi>]

Try it online!

First non-trivial Verbosity v2 answer! Although how it works is very trivial, as you can see from the ungolfed version:

IncludeTypePackage<OutputSystem>
IncludeTypePackage<InputSystem>
IncludeStructurePackage<Loops>

input  = InputSystem:NewInput<DEFAULT>
output = OutputSystem:NewOutput<DEFAULT>

condition = InputSystem:ReadEvaluatedLineOfInput<input>

Loops:ConstructLoop<Do; condition> [
	OutputSystem:DisplayAsText<output; condition>
]

Try it online!

Simply enter a do...while loop, which prints the input at least once, then terminates if it's falsey (i.e. 0).

Answer 19

MathGolf, 5  4  3 2 bytes

-1 for dropping block marker

q▲

Explanation

Implicit input
Starts a block
q  Output TOS without a newline.
 ▲ Execute the code block while the TOS is true. Executes at least once.
Implicit output

Try it online!

Answer 20

tq, 3 bytes

?(?

Explanation

?,   # Take an input
  (? # Extend the array while
     # the input is not false

Answer 21

AWK, 17 bytes

{while($0)print}1

Try it online!

Answer 22

MAWP v1.1, 18 14 bytes

@A{1A:.}1M[!:]

-4 bytes with integer input.

Try it!

Answer 23

MarioLang, 25 bytes

   >:<
   "==
 ;[!:
===#=

Answer 24

NDBall, 57 chars, 8 cells in 2 dimentions

(0)>0
(1)%
(2)Y[1,>0,>1]
(3)P
(4)E
(2,1)>1
(2,2)P
(2,3)<1

Visual representation of code (hand made by me)

Checked in NDBallSim V1.0.1

Answer 25

05AB1E, 3 bytes

i[?

Try it online!

i[?  # full program
i    # if...
     # implicit input...
i    # is 1...
  ?  # output...
     # implicit output...
  ?  # without trailing newline...
 [   # forever
     # implicit end loop
     # implicit end if
     # implicit output

Answer 26

Python 3, 35 bytes

n=input()
while 1:print(n);0/int(n)

Answer 27

convey, 10 bytes

{,!"}
 >"^

Try it online!

There's a few ten-byters i've found, but I can't see any way to get lower. I was thinking of this. but unfortunately that doesn't parse.

Answer 28

v³, 6 bytes

;@=.$#

Unwrapped:

  ;
@ = . $
  #

The IP starts at the top cell. ; takes the input as a numeric value. The IP then falls to =, printing the value. It hits ground (#) and starts moving to the right. . is a no-op. $ ignores the next command if the value is not zero. The IP wraps around to @, which terminates the program. The program repeats from = if it hasn't terminated.

Answer 29

Built-out, 5 bytes

truth

Yay, built-ins! ...just kidding.

Before running: push input to stack 2

truth

t      - not last 't': swap stacks 1 and 2
 r     - convert character (1-9) at top of stack 1 to integer
  u    - toggle EOF loop if top item of stack 1 is falsy (0)
    h  - duplicate top of stack 1
       - implicit: pop item of stack 1 if not empty, then go to previous 't' if stack 1 is still not empty AND 'u' did not toggle it off, terminate otherwise
   t   - last 't': return here if stack 1 is not empty

Try it online! (fork the project)

Answer 30

Grok, 10 bytes

:}1j
z}zhq

Explanation:

:}      # If input is 0, goes down and to the left, outputs 0, 
z}  q     wraps to the right, and terminates.

:}1j    # If input is non-zero, goes to the right, pushes 1,
 }zh      prints 1, and loops indefinitely.