Count up forever

Question

Write a program that counts up forever, starting from one.

Rules:

• Your program must log to STDOUT or an acceptable alternative, if STDOUT is not available.
• Your program must be a full, runnable program, and not a function or snippet.
• Your program must output each number with a separating character in between (a newline, space, tab or comma), but this must be consistent for all numbers.
• You may print the numbers in decimal, in unary or in base 256 where each digit is represented by a byte value.
• Your program must count at least as far as 2¹²⁸ (inclusive) without problems and without running out of memory on a reasonable desktop PC. In particular, this means if you're using unary, you cannot store a unary representation of the current number in memory.

• Unlike our usual rules, feel free to use a language (or language version) even if it's newer than this challenge. Languages specifically written to submit a 0-byte answer to this challenge are fair game but not particularly interesting.

  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.

• This is not about finding the language with the shortest solution for this (there are some where the empty program does the trick) - this is about finding the shortest solution in every language. Therefore, no answer will be marked as accepted.

Catalogue

The Stack Snippet at the bottom of this post generates the catalogue 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: 290px; 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 = 63834; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 39069; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "//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 "//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(42), 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

Matlab, 95 bytes

   for n=1:128;sym(sym(2^n)-1),for i=1:n sym(2^n+sym(sum(power(2,nchoosek(1:n,i)-1),2)-1)),end,end

---

• This program can count over 2^128 just try with these parameters if you have doubts.

  for n=200:200;sym(sym(2^n)-1),for i=1:n sym(2^n+sym(sum(power(2,nchoosek(1:n,i)-1),2)-1)),end,end
  

• This can be golfed more if I could figure out a way to combine two loops in one single executive loop, thats because the code skips one integer per 2^k the case of one loop.

Answer 2

Y, 9 bytes

0C:' gghX

Simple three-link program. 0C initializes the stack with a 0 and moves to the next link, : duplicates the current value ' pushes a space for a separator, gg prints twice, and h increments it. X is an unconditional wrap-around, so we go to the beginning of the link. Try it here!

Answer 3

D, 56 57 bytes

import std.stdio;void main(){for(real i;;writeln(i++)){}}

Pretty straightforward. D != Python.

The shortest while-loop version I can think of is longer, at 59 bytes:

import std.stdio;void main(){real i;while(++i){writeln(i);}}

Answer 4

ForceLang, 35 bytes

label l
io.writeln set a 1+a
goto l

ForceLang uses BigRationals as the default number type.

Also, in the latest revision, 1+nil yields 1, which is what allows this version to work (previously it would have yielded the string "1<nil>".)

nil+1, however, still triggers a null pointer exception.

Answer 5

UberGenes, 33 30 bytes

I'm giving two versions here, just to demonstrate the lang. Integers and memory in UberGenes are bounded only by computer memory, so both versions meet the "forever" requirement. This first one is for score:

=ii+a1=pa=q5=bi-p1=oQ:bp=oI=i0

It prints numbers in unary separated by '=' characters. Explanation (indents indicate a loop start):

=ii                                  NOP
   +a1                               INC a (initially 0)
   =pa                               COPY a INTO p
   =q5                               SET q=5 so it points to '1'
   =bi                               SET b to this location (15)
      -p1                            DEC p
      =oQ                            OUTPUT '1'
      :bp                            JUMP to b's location while p>0
   =oI                               OUTPUT the contents of this location ('=')
   =i0                               JUMP to the beginning of main loop.

The second version is more interesting (66 bytes):

=ii+a1=l0-l2=pa=z8*z6=t5*t2=bi=qp%qt+qz=Lq-l1/pt:bp=bi=oL+l1:bL=i0

It prints the numbers in decimal separated by NULLs.

How it works (indents indicate a loop start):

=ii                                  NOP
   +a1                               INC a (initially 0)
   =l0-l2                            SET l=-2
   =pa                               COPY a INTO p
   =z8*z6                            SET z=48 ('0')
   =t5*t2                            SET t=10
   =bi                               SET b to this location (27)
      =qp                            COPY p INTO q
      %qt                            MOD q BY 10
      +qz                            ADD 48 to q (turn it into character)
      =Lq                            PUT q AT MEM[l]
      -l1                            DEC l
      /pt                            DIVIDE p by 10
      :bp                            JUMP back to b's location if p>0
   =bi                               SET b to this location (51)
      =oL                            OUTPUT the character in MEM[l]
      +l1                            INC l
      :bL                            JUMP back to b's location if MEM[l]>0
   =i0                               JUMP back to beginning of main loop

Answer 6

Molecule, 7 bytes (6 chars)

0(1+~)

Explanation:

0(1+~)
0      add 0 to stack
 (     begin while statement
  1+   add one
    ~  print
     ) goto the beginning of while statement.

Answer 7

AutoHotKey, 34 bytes

Golfed and Ungolfed is the same.

Golfed:

c:=0
Loop {
    c:=c+1
    tooltip %c%
}

Ungolfed:

c:=0
Loop {
    c:=c+1
    tooltip %c%
}

Answer 8

Node.js + Big.js, 63 bytes

Use npm install big.js before running.

c=new require("big.js")(0);while(1)console.log(c+""),c=c.add(1)

Simple enough, and has arbitrary precision. Each number is seperated by newlines.

Answer 9

Tellurium, 6 bytes

[i|+^]

Pretty simple.

The program adds one to the selected cell (+), and then outputs it (^). Using i as a loop's value makes it run the code forever.

Answer 10

Lua, 27 Bytes

i=1::a::i=i+1print(i)goto a

Answer 11

Befunge - 4 bytes

I’m surprised there isn’t already a Befunge answer on here.

1+:.

Answer 12

Perl 6, 13 bytes

.say for 0..*

Perl 6 has lazy/infinite arrays, so I'm abusing that to create an infinite range. This will never run out of memory.

Note: as explained in the Perl 6 docs, (0..*)>>.say would print out of order.

Answer 13

Pyke, 5 3 bytes

ohr

Try it here!

Answer 14

SmileBASIC, 87 bytes

S$="0"*#Y@L
I S$,127?S$GOTO@L
DEF I S,P
IF"0"<S[P]THEN S[P]="0"I S,P-1 ELSE S[P]="1
END

Uses a recursive function to increment a binary string.

Answer 15

Swift - 32 bytes

for i in 0...Int64.max{print(i)}

Swift - 33 bytes

var i=0;while true{print(i);i+=1}

Cannot provide a testing link, because on the online environments this produces a buffer overflow. However, you can test it in Xcode / Swift Playgrounds or if you have an apple computer, you can run it in the Terminal, after typing the 'swift' command and pasting the code in.

Answer 16

APL (Dyalog APL), 13 14 10 bytes

{1+⎕←⍵}⍣≡0

Try it online!

Answer 17

Whitespace, 40 bytes

Try it online!

Outputs numbers separated by newlines. Whitespace numbers are integers of arbitrary length however certain interpreters may impose their own limits due to the implementation language. As a counterexample, whitespace.pl theoretically should be able to output forever as Perl supports arbitrary length integers.

Explanation

(s - space, t - tab, n - newline)

sssn     # push 0 - stack: [0]
nssn     # label ''
ssstn    # push 1 - stack: [<n-1>, 1]
tsss     # pop and add the top two items, push result - stack: [<n>]
sns      # duplicate the top item - stack: [<n>, <n>]
tnst     # pop, print as num - stack: [<n>]
ssststsn # push 10 - stack: [<n>, 10]
tnss     # pop, print as char (LF) - stack: [<n>]
nsnn     # jump to label ''

Answer 18

JavaScript (ES6), 74 69 chars

Output is binary.

for(r="1";;r=r.replace(/(?:(^1)|.)(?=1*$)/g,(m,f)=>f?10:m^1))alert(r)

Answer 19

Husk, 1 byte

N

Try it online!

Answer 20

Triangular, 15 10 9 bytes

^{-5 thanks to caird}

\#iA.,/%<

Try it online!

Formatted:

   \
  # i
 A . ,
/ % < ÿ

Redirects/bounces only:

   \
  . .
 . . ,
/ . <

So the code i%A# is repeated infinitely.

• i - increment top of stack
• % - print top of stack as integer
• A - push 10
• # - print top of stack as ASCII and pop

Answer 21

TI-BASIC (Z80), 152 bytes

Hex dump:

2a31323334353637383904aa003f2a3004aa013fd1313fdeaa013fbb2baa0104413f3104463fd1416c3040463fbb0caa012b412b31116a2a3904463f41713104413fd43fce463fcf3f2a313fd03fbb0caa002b3170bb2abb0caa012b4170312b3111112b313fce413fbb0caa012b312b411170723fd43fd3492b312bbb2baa0111714171b8463f72702a303fd43f7204aa013fd4

Token rendering:

"123456789→Str1
"0→Str2
While 1
Disp Str2
length(Str2→A
1→F
While A>0 and F
sub(Str2,A,1)="9→F
A-1→A
End
If F
Then
"1
Else
sub(Str1,1+expr(sub(Str2,A+1,1)),1
If A
sub(Str2,1,A)+Ans
End
For(I,1,length(Str2)-A-not(F
Ans+"0
End
Ans→Str2
End

Implements incrementing on string-based decimal arbitrary-precision nonnegative integers. I haven't put much effort into golfing this, since just working with strings in this language is already hard enough.

The program should work on the whole TI-83 through -84 series (tested on the TI-84 Plus SE).

Encoding

TI-BASIC code, like all text on the TI-8X, uses its own token-based encoding (see these token tables provided by a third party).

Output

Output is in decimal through Disp, which essentially prints a string on its own line. On the TI-83 through TI-84 Plus SE calculators, once the numbers get large enough that they no longer fit on the display they'll appear truncated with ellipses in the last column. This is by far the TI-BASIC output method closest to standard out.

Answer 22

brainfuck, 31 bytes

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

Try it online!

Prints the binary value of each number with char code 1 as 1, null byte as 0 and ÿ as the separator.

The output is the exact same as the previous brainfuck answer, however this can go as high as 2^29998 in the 300000 available brainfuck cells and is 13 bytes shorter.

Answer 23

AutoHotkey, 27 bytes

Based on Michelfrancis' answer: https://codegolf.stackexchange.com/a/78480/72779.

(Should I post this as a reply instead? Pretty new to this, but I don't have enough reputation to reply to other answers anyway.)

c=0         ; Colon-equal operator not required.       Saves one byte.
Loop{       ; Removed space between Loop and {.        Saves one byte.
c++         ; Shorter incremeting method, removed tab. Saves four bytes.
tooltip %c% ; Removed tab.                             Saves one byte.
}

Answer 24

Pyt, 6 bytes

0`⁺ĐƤł

Try it online!

0   pushes zero
`   starts a while non-zero loop (but isn't checked until close loop)
⁺   increments x
Đ   Duplicates x
Ƥ   Prints with a separating newline
ł   go back to ` and loop till top is zero

Answer 25

Stax, 4 bytes

0W^Q

Run and debug it online

Added for completeness.

Explanation

0        Pushes 0
 W       Loop forever
  ^      Increment
   Q     Peek and print with newline

Answer 26

Flobnar, 15 bytes

 \@
+_
<.9,!
>:

Try it online!

Uses the -d flag in order to output in decimal. The separator between numbers is the tab character

Answer 27

Pip, 6 bytes

W1P++i

Try it online!

Straightforward; in pseudocode, this is

while(1)
 print(++i)

where i is preinitialized to 0.

Answer 28

Alchemist, 19 bytes

0a->Out__+Out_" "+_

Try it online!

Prints numbers separated by spaces.

Explanation:

0a->                 # While there are no a atoms (i.e. always)
    Out__            # Output the number of _ atoms
         +Out_" "    # Print a space
                 +_  # Add an _ atom to the environment

Answer 29

Runic Enchantments, 446 bytes

\DB͍R"000000000000000000000000000000000000001"$
.{ww;'''''''''''''''''''''''''''''''''''''''
.10{BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
a+'0000000000000000000000000000000000000000
kk0~111111111111111111111111111111111111111
$:{~+++++++++++++++++++++++++++++++++++++++
1'~}567890123456789012345678901234567890123
J://XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
.=? 000001111111112222222222333333333344444
/\/v\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Try it online!

This one took me a while. Runic is not set up to handle arbitrarily large values. The C# interpreter is limited by the fixed bit width of the value types involved, none of which are 128 bits wide and no language commands result in a BigInt being pushed to the stack.

So, instead, I used a string. But decomposing a string into that many characters (and then concatenating them back together again) is a nightmare (especially with that many digits as the instruction pointer starts to fizzle when its stack is too big--there are limited workarounds to that, but this setup works for actually arbitrarily large values, provided that the program is made bigger to accommodate; question specification only required up to 2¹²⁸ which requires 39 digits; each additional power of 10 adds 10 bytes), so instead the storage is done inside the source code and updated with reflection. I also saw no clarification on whether or not leading 0s were allowed or not, but having them made things much easier.

_{Image depicts fewer decimal digits for brevity as well as the Red/Yellow/Purple sections offset by 1, due to an old version of the code.}

• Cyan: Entry point and output. Reads a string value, pushes it to output, prints a newline, increases mana by 1 (reflection costs 1 mana; image is missing this command), and then enters the blue section via torodial edge wrapping.
• Blue: Read character from the string, edge wrap to Green.
• Green: push x position of the read character (in a consistent format, largely for convenience of the programmer), push 1,1 and Branch to position 1,1 (Red).
• Red: rotate character to top of stack, add 1, convert to character, duplicate, compare with : ('9'+1 equals :). If true, go to Yellow. Else go to Purple.
• Yellow: Toss out the Branch return coordinates, push a 0 (y coordinate for the write command), write the value, proceed to Cyan.
• Purple: Toss out the top of the stack (the :), push a 0 (y coordinate for the write command), push a '0' character, write the 0, return to Branch entry (Salmon) using the modified form, B͍ which does not push return coordinates (so two giant rows of ~ aren't needed).
• Salmon (was supposed to be Orange): Repeat steps Blue and Green on the next power of 10.

If it ever fills the entire string with 9s, the next loop would replace it all with 0s and hit the terminator ;. As the online interpreter has a built-in arbitrary maximum execution limit (not including TIO's external limits), this will never actually occur, but that's an implementation detail and not imposed by the language specification.

Answer 30

MathGolf, 5 4 bytes

Åîo▲

Try it online.

Thanks to @maxb for explaining how to do an infinite loop in MathGolf.

Explanation:

   ▲    # Do-while true by popping the value,
Å       # with two commands within the loop-body:
 î      #  Push the 1-indexed loop-index
  o     #  Print it with a trailing newline without popping

Note that just like in Python, a positive integer is considered truthy, which is why we print the loop-index without popping so the while(true) can continue.