163
\$\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
  • \$\begingroup\$ Can we assume that the program halts when the processor finishes executing the written code, for a machine code entry? \$\endgroup\$
    – lirtosiast
    Nov 3 '15 at 16:58
  • 3
    \$\begingroup\$ Assuming any behaviour is fine for all invalid inputs? \$\endgroup\$
    – Cruncher
    Nov 3 '15 at 17:33
  • 3
    \$\begingroup\$ @Cruncher Yes, the only inputs you should expect to get are 0 and 1. \$\endgroup\$ Nov 3 '15 at 17:38
  • 4
    \$\begingroup\$ Catalog is borked. \$\endgroup\$ Nov 6 '15 at 15:18
  • 2
    \$\begingroup\$ Catalog appears to consider Bf and bf to be different languages. \$\endgroup\$ Nov 10 '15 at 1:13

451 Answers 451

1
4 5
6
7 8
16
2
\$\begingroup\$

C, 41, 40 bytes

main(c){for(c=getchar();putchar(c)&1;);}

Reads a single character from stdin, writes to stdout.

This version is 1 byte longer than feersum's solution, but removes his/her assumptions onstdin.

\$\endgroup\$
2
  • \$\begingroup\$ Would putchar(c)&1 work? \$\endgroup\$
    – Dennis
    Aug 29 '16 at 16:41
  • \$\begingroup\$ Yes, you are right! One byte saved, thanks @Dennis. \$\endgroup\$ Aug 29 '16 at 16:51
2
\$\begingroup\$

PHP, 34 bytes

<?for($f=fgetc(STDIN);$f;?>1<?)?>0

Wanted to try to get rid of the print but not sure it's worth it since you have to reintroduce the <? tags

\$\endgroup\$
2
\$\begingroup\$

Java, 143 141 125 88 bytes

interface T {static void main(String[]a){System.out.print(a[0]);main(a[0].split("0"));}}

Ungolfed Test Code

interface T {

    static void main(String[] a) {
        System.out.print(a[0]);
        main(a[0].split("0"));
    }
}
\$\endgroup\$
4
  • \$\begingroup\$ That's 143 characters. \$\endgroup\$
    – clismique
    Sep 1 '16 at 8:49
  • \$\begingroup\$ Why did you even check? \$\endgroup\$
    – Shaun Wild
    Sep 1 '16 at 8:51
  • \$\begingroup\$ I'm using a userscript for PPCG, and it tells me how many bytes there are. (You should totally use it, it's worth it) \$\endgroup\$
    – clismique
    Sep 1 '16 at 8:54
  • \$\begingroup\$ Ahh ok. It's shorter now anyway :P \$\endgroup\$
    – Shaun Wild
    Sep 1 '16 at 8:55
2
\$\begingroup\$

dc, 13 12 bytes

?[pd1=@]ds@x

Run:

dc -f truth_machine.dc <<< "1"

Adding to the diversity of languages used, I present a dc solution that works as follows:

?              # reads the input and pushes it on top of the stack
[pd1=@]ds@x    # stores the macro command [pd1=@] into register '@' and executes it
   p           # prints the value on top of the stack
   d           # makes a duplicate that is pushed on top
   1=@         # pushes 1, pops two numbers and if they are equal, the macro from
               #register '@' is executed (again), thus making an infinite cycle
\$\endgroup\$
2
\$\begingroup\$

Lua, 34 Bytes

repeat print(arg[2])until arg[2]<1

arg[2] contains the first command line argument, (arg[1] contains the filename)

Give an input through the command line, and it shall spam it if it's 1, or once if it's not.

Simple enough.

\$\endgroup\$
2
\$\begingroup\$

Copy, 67 59 bytes

My new esolang :D

getch a
add b a
add b -48
print a
skip b
skip 1
copy -4 0 1

Explanation:

getch a     Take input in variable 'a'
add b a     Set 'b' to 'a'
add b -48   Substract 48 from 'b'
print a     Print 'a'
skip b      Skip the copy if 'a' is not zero
skip 1      ^
copy -4 0 1 Copy the code block from the print to this instruction after this instruction
\$\endgroup\$
2
  • \$\begingroup\$ protip: *subtract \$\endgroup\$ Sep 25 '16 at 9:22
  • \$\begingroup\$ @DestructibleWatermelon No \$\endgroup\$ Sep 25 '16 at 9:26
2
\$\begingroup\$

Crystal, 48 37 36 bytes

y=gets;y=="0\n"&&(p 0;exit);y=="1\n"&&loop{p 1}
y=gets;y=="0\n"&&(p 0;exit);loop{p 1}
y=gets;y=="0\n"&&(p 0;1/0);loop{p 1}

Edit: Shaved off 10 bytes because the post doesn't specify what should happen on invalid input (like 2). If it does and I misunderstood, let me know.

Edit: Shaved off 1 byte by dying with an error instead of normal exit.

Crystal is statically typed, so I couldn't just do gets.chomp (gets can return nil, and nil doesn't have chomp). The alternative was gets.try &.chomp, but that takes much more space than just having the newlines.

In Crystal (and Ruby) you can do something like puts 0 if y=="0\n", however you can also shave off 2 bytes by doing y=="0\n"&&puts 0 as the && operator returns the last object it tests for truthiness.

loop is a method in the standard lib that infinitely runs the block. It's a much shorter way of writing while true;CODE;end.

p prints the result of .inspect on its arguments to the output. Here I abuse it as a shorter puts because for numbers it'll just return the number.

\$\endgroup\$
2
\$\begingroup\$

Valve scripting language, 38 bytes

alias 0 echo 0
alias 1 "echo 1;wait;1"

This defines two commands, 0 and 1. Type 0 into the console for the zero case, and 1 for the 1 case.

\$\endgroup\$
2
  • \$\begingroup\$ Could I just try this in half life's console, or do I need the source SDK? \$\endgroup\$
    – Pavel
    Dec 21 '16 at 1:56
  • \$\begingroup\$ @Pavel I tested it on the TF2 console, so that should be fine. \$\endgroup\$ Dec 21 '16 at 2:02
2
\$\begingroup\$

Underload, 16 bytes

((1)S:^)~^:^(0)S

Underload has no way to take input from standard input. The most natural way to take input is therefore from the initial stack: () for 1, (!()) for 0 (this is the normal way to represent numbers in Underload).

Here are Try It Online links for 0 and for 1 (be prepared to kill this one quickly; the infinite loop runs very quickly and will spam up your browser window).

This program didn't need much effort to golf; the most idiomatic way to do things is almost the shortest (I just had to be careful not to let the input get buried too far on the stack). It's easiest to read if I translate the code to a hypothetical functional language:

function x(y)
    print(1)
    x(x)
end
x = x^(input)
x(x)
print(0)

The only weird thing happening here is being able to exponentiate functions, but it's a fairly easy-to-understand operation; for example, raising a function f to the power 3 would produce f compose f compose f, i.e. lambda x.f(f(f(x))). Raising a function to the power 1 does nothing (just like if you'd raised an integer to the power 1); and raising a function to the power 0 gives you the identity function (just like raising a number to the power 0 gives you 1). Actually, the integers in Underload are defined in terms of their effect exponentiating functions, rather than the other way round; the operation is fundamental enough to Underload that you use it to construct most flow control.

\$\endgroup\$
2
\$\begingroup\$

Jelly, 3 bytes

Ṅ¹¿

If reading from STDIN is absolutely required:

ƈOḂṄ¹¿`

I'm not sure which since "Jelly's main input method is via command line arguments, although reading input from STDIN is also possible."

\$\endgroup\$
1
  • \$\begingroup\$ Your second version can also be ƓṄ¹¿, where it reads a line instead of a single character. \$\endgroup\$ Mar 12 '17 at 15:33
2
\$\begingroup\$

SmileBASIC, 23 22 bytes

INPUT N@L?N?N/N
GOTO@L

Ends the program with a divide by 0 error.

If this isn't allowed, here's a 23 byte solution:

INPUT N@L?N
IF N GOTO@L
\$\endgroup\$
2
\$\begingroup\$

WireWorld (It doesnt have a scoring method yet :\)

 ████ █ <= this pixel will be the input. if it is a electron head (1), 
█    █     It will loop forever as 1. if its a wire (0), it will do nothing.
█ ██ █
 ██ █
  ██
\$\endgroup\$
2
\$\begingroup\$

Common Lisp, 30

(do((x(read)))((=(print x)0)))

Common Lisp's print function returns the object that was printed. This reads a value from the user, then prints the value until the return value of the call to print returns 0.

\$\endgroup\$
2
\$\begingroup\$

BitCycle, 7 bytes

Golfed 4 bytes off my example program!

?~<
!~+

Provide input as 0 or 1 on the command-line. The -s or -p debug options are recommended, especially when dealing with infinite output.

Explanation

BitCycle is a 2D language that works by moving bits around a playfield. Commands used in this program are:

  • ? puts input bit(s) onto the playfield, moving east
  • ~ duplicates and negates a bit, turning the original right and the negated copy left
  • < sends bits westward
  • + turns 1-bits right and 0-bits left
  • ! outputs bits

The input hits the first ~. A negated copy turns left (north) off the playfield and is discarded. The original bit turns right (south).

At the second ~, the original bit turns west into the ! and is output. A negated copy turns east.

If the original bit was 0, the negated copy is 1; it turns south at the +, goes off the playfield, and is discarded.

If the original bit was 1, the negated copy is 0; it turns north at the + and then west at the <. The 0 hits the first ~ again, where it turns right (north) off the playfield and is discarded. The negated copy (1) turns left (south), leading to an infinite loop.

\$\endgroup\$
1
  • \$\begingroup\$ Alternative 7 byter ?v~ newline !~+ \$\endgroup\$
    – Jo King
    Mar 26 '19 at 9:38
2
\$\begingroup\$

Aceto, 11 10 bytes

X
p|1
rip^

reads a string and converts it to an integer. | tests for truthiness (1 is truthy, 0 is not) and mirrors horizontally if truthy (in that case moving to the 1). Otherwise, we'll go to 0, which pushes the 0, we print implicit zero and eXit.

If the number was truthy (e.g. 1), we got mirrored to the 1, which pushes a 1, prints, and goes one cell up (^), going into an infinite loop.

\$\endgroup\$
2
\$\begingroup\$

MarioLANG, 11 bytes

;>:[<
=====

Explanation:

;        Get numerical input and save in current cell
 >       Move left (Required to make an infinite loop)
  :      Output the current cell
   [     Skip next command if cell is 0
    <    Move right

Basically, it loops infinitely unless input = 0

\$\endgroup\$
2
\$\begingroup\$

Wise, 3 bytes

[:]

Try it online!

Wise cannot actually output whenever you want, it only outputs the entire stack when the program terminates. So the solution to infinitely output is to simply infinitely fill the stack. When the program eventually halts (never), it will output the stack that, at that theoretical point in time, will have infinite values in it.

Explanation

[:]  Implicit input from command-line arg
[    If last value is != 0..
 :   ..Duplicate last value on stack
  ]  If last value is != 0, jump back to [

Given a non-zero number, will infinitely duplicate the input on the stack, after an infinite amount of time, will terminate and output the entire stack.

Given zero, jumps to the end of the program and immediately terminates, outputting the stack, which contains only the input.

\$\endgroup\$
2
\$\begingroup\$

Python 2, 50 39 bytes

Don't know why nobody mentioned I could just write input()

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

Very simple, if the input is 1, will continuously print 1 and cannot reach the print 0. If it is 0, the while will never fire.

Try it online!

\$\endgroup\$
4
  • \$\begingroup\$ You can save a few bytes by using stdin instead of command line args. \$\endgroup\$ Aug 6 '17 at 23:04
  • \$\begingroup\$ 29 bytes, you don't need to cast the input to an int because the input function in Python 2 does eval on the input before returning. You also don't need parentheses around the input call. \$\endgroup\$
    – LyricLy
    Sep 29 '17 at 22:02
  • \$\begingroup\$ Oh, actually... This code doesn't even work. Theoretically, it would work if infinite 1's were given as input, but that doesn't meet the spec. Since while is calling the input function every time, it will just print one 1 and then reach the end of the input and error. Your earlier solution with command line args did work, or you can assign the input to a variable before looping. \$\endgroup\$
    – LyricLy
    Sep 29 '17 at 22:13
  • \$\begingroup\$ @LyricLy yeah, I tried that once. Thanks! \$\endgroup\$
    – Stan Strum
    Sep 30 '17 at 19:14
2
\$\begingroup\$

JavaScript, 26 bytes - Variation of Solomon Ucko's answer

I find it weird how I can't comment, but I can edit his answer...

for(;alert(i=prompt())|i;)
\$\endgroup\$
2
\$\begingroup\$

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!

\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
0
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
5
  • \$\begingroup\$ I am glad to find another user of Stax writing impressive answers. Maybe you should check out the chat as well although there are not much to see at the moment. \$\endgroup\$ Mar 3 '18 at 20:57
  • \$\begingroup\$ You don't need the comma at the beginning. There is implicit input. \$\endgroup\$ Mar 3 '18 at 21:03
  • \$\begingroup\$ Also I suggest you use this link: staxlang.xyz/#c=wQc&i=0%0A1&a=1&m=2. It automatically runs your program. \$\endgroup\$ Mar 3 '18 at 21:14
  • \$\begingroup\$ @WeijunZhou Whoops, thanks! \$\endgroup\$ Mar 3 '18 at 21:14
  • \$\begingroup\$ generator version(5 bytes) \$\endgroup\$
    – Razetime
    Feb 23 '21 at 6:54
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
6
  • 1
    \$\begingroup\$ You don't need to have str(1), you can just do print"1", etc. \$\endgroup\$ Mar 6 '18 at 2:57
  • \$\begingroup\$ remove the space between print and ' (this is Esolanging Fruit's suggestion but you added an extra space so credit them instead for 8 bytes) \$\endgroup\$
    – hyper-neutrino
    Mar 6 '18 at 3:28
  • \$\begingroup\$ also, don't take arguments, use input. k=input()>"0" and then while k:print 1 and then print 0 (note that you don't even need to do print"1", just do print 1 \$\endgroup\$
    – hyper-neutrino
    Mar 6 '18 at 3:29
  • \$\begingroup\$ @HyperNeutrino Thanks. Fixed the first thing... still looking at input() it's not doing what I expect it to. \$\endgroup\$ Mar 6 '18 at 4:42
  • \$\begingroup\$ @HyperNeutrino This is Python 2, so input() returns an evaluated value instead of a string. This means that input() already returns the number. \$\endgroup\$ Mar 6 '18 at 5:06
2
\$\begingroup\$

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!

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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
\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

Flobnar, 10 bytes

<1._
|@&
0

Try it online!

\$\endgroup\$
1
4 5
6
7 8
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.