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

Noether, 6 bytes

(!iP?)

Try it online!

The online link has a delay of 1 second added to prevent the interpreter from freezing up.

Answer 2

Momema, 17 bytes

z00+1*0-8*0-9 9z1

Try it online!

Answer 3

Yabasic, 14 bytes

Script that counts from 0 to 2^1024 then outputs Inf, infinitely. Takes no input and outputs to the console.

Do?i
i=i+1Loop

Try it online!

Far More Interesting Version, 20 bytes

For some reason, 0/0=2^1024 in Yabasic, and the language appears to have no loss of precision on this range so rather than producing an error, the following code counts exactly from 0 to 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368, which is wonderful, and stupid :P

For i=0To 0/0?i
Next

Try it online!

Answer 4

Wolfram Language (Mathematica), 18 bytes (16 characters)

Print@i~Do~{i,∞}

Try it online!

Answer 5

W, 3 bytes

iaE

Explanation

W allows infinite lists, so this simply loops over the infinite list.

i   % Unsurprisingly, a built-in for positive infinity.
  E % Foreach the infinite list
    % from 1 to infinity:
 a  % Print this item
    % with a newline

Answer 6

DIVCON, 4 bytes

S#o+

Explanation

S     No-op
 #    Skip the following:
  o       Output
   +  Increment the accumulator
  o   Output the incremented accumulator
 #    If acc != 0: (in which it already is)
S     Reverse computation

And it continues, forever ...

Answer 7

Braingolf, 15 bytes

V# R1[l!_v!@R>]

Explanation:

V# R1[l!_v!@R>]
V               Creates new stack and switches to it
 #<space>       Pushes 32 (ASCII value of a space) to stack
   R            Return to main stack
    1           Push 1
     [........] do-while loop. Will always run once, then checks if 
                first value in stack is 0 after each loop, if it is,
                breaks out of the loop
      l         Push current length of stack
       !_       Print last item on stack without popping
         v      Switch to next stack
          !@    Print last item on stack as ASCII char without popping
            R   Return to main stack
             >  Move last item to the start of the stack
         

Answer 8

Pushy, 4 bytes

1$#h

1       % Push 1
 $      % While loop (see below):
  #     %   Output last item
   h    %   Increment last item

The while loop will keep running while the last value on the stack evaluates to true. Because all values except 0 are truthy in Pushy, this loop will never exit. The ; to end the loop is assumed by the interpreter.

This should eventually reach 2^128 as specified, because Pushy uses Python 3 (arbitrary sized) integers.

Answer 9

Ace, 4 bytes (non - competing)

vIPO

Try it online!

This is a new language I am (was, :() working on.

Answer 10

Factor + lists.lazy, 19 bytes

1 lfrom [ . ] leach

Try it online!

Answer 11

Racket – 45 bytes

#!racket
(for([n(in-naturals)])(displayln n))

Try it online!

Explanation

Racket provides us with a neat little function called in-naturals that receives an optional argument which tells it where to begin. Since it is a stream (generator, in other languages), we can use it with Racket's for loop to display each number followed by a newline.

Documentation for in-naturals also says the following:

An in-naturals application can provide better performance for integer iteration when it appears directly in a for clause.

Which I assume means that the loop will be more faster to evaluate?

#lang racket

(for ([n (in-naturals)])
  (displayln n))

Another cool thing about for is that it has a keyward argument called #:when that will only run the code in the loop if the condition is met:

#lang racket

; Code to print all numbers divisible by 31:
(for ([n (in-naturals)] #:when (zero? (modulo n 31)))
  (displayln n))

Try it online!

Compilation on a machine

• Once Racket is set up, store this code as a file with the extension .rkt.
• Open a terminal of your choice.
• Check if Racket is in your path via racket -v, if so, you can either:
  • Run the code directly via racket filename.rkt (replace filename.rkt with your file.
  • Compile the code to an executable using raco exe filename.rkt. Once compiled, you'll have an executable in the current directory alongside the source file.

Documentation

• Racket documentation
• for documentation
• in-naturals documentation

Answer 12

ForWhile, 66 bytes

(!;$1-:){}9+:66(.:@;66-$1-:).9@1+:0;(.;10%48+'1+3,10/';)+(.#)9#$66

infinitly prints numbers in decimal separated by tabs.

In ForWhile every loop will exit after a finite number of iterations, and recursion is limited to a fixed depth (3), this means that every finite ForWhile program will terminate after a finite number of steps.

The only way to circumvent this is to write an "infinite" program by continuously generating more source-code at runtime.

The above program repeatedly copies its source code to a location right of the instruction pointer and the deletes the old source code (to prevent memory overflow).

online interpreter

Explanation

\ ignored in first iteration
(!;$1-:)
\ push current instruction pointer, offset it to point at the start of the current code-section
        {}9+
\ copy the code to the address immediately after the current source-code 
            :66(.:@;66-$1-:).
\ load the value at address 9 and increment it
                             9@1+
\ print the integer converted to a decimal string
                                 :0;(.;10%48+'1+3,10/';)+(.#)
\ print a tab and store the new value of the integer at address 9
                                                             9#$
\ push the length of the code
                                                                66
\ clear the previous code-section
(!;$1-:)                                                            
...

---

Shorter but less interesting solution (20 bytes)

2 129`:(;'-(.48#)9#)

prints the first 2¹²⁹-1 numbers in unary separated by tabs.

online interpreter

Answer 13

{,}, 31 Chars or \$31\log_{256}(4)\approx\$ 7.75 Bytes

((()()()),(),((()()()),())())()

Log base 4 because there are (, {, commas, and closing brackets (which are unambiguous because the code is balanced)

Answer 14

Dart, 30 bytes

main(i){for(i=0;;print(i++));}

Try it online!

It's equivalent to the following Dart code:

dynamic main(dynamic i) {
    for (i = 0;; print(i++));
}

i starts as a List<String>, equivalent to Java's args. But omitting its type makes it dynamic, making it assignable to any type. Inside the loop, it changes its type to an integer and sets it to zero.

Answer 15

Rust, 51 49 bytes

fn main(){let mut x=1;loop{print!("{}",x);x+=1;}}

Try it online!

Answer 16

Swift, 24 21 bytes

(1...).map{print($0)}

Pretty self-explanatory, I feel. Numbers are separated by newlines.

Answer 17

Octave, 29 bytes

j=0;while 1
j=vpa(j,39)+1
end

Try it online!

This makes use of the vpa function for variable precision numbers. I set the precision at 39 based on the minimum value of \$2^{128}\$ from the question, but it can be increased arbitrarily.

Answer 18

Bash, 29 bytes

while echo $((++n));do :;done

Explanation: repeatedly increment n (from 0), then print it. This always succeeds, so the loop condition is always true.

Note that this has side-effects. If you cancel the program, n will still be set in the current shell, so it will continue where it left off. You can reset by running unset n first.

Answer 19

JavaScript (Node.js), 31 bytes

for(n=1n;;n++)console.log(n+'')

Try it online!

Answer 20

C#, 83 Bytes

using System;class C{static void Main(){double x=0;for(;;)Console.WriteLine(x++);}}

Un-golfed:

using System;
class C {
  static void Main(){
    double b=0;
    for(;;)Console.WriteLine(b++);
  }
}

Note: C#'s double type can store values up to approximately 1.79769313486232x10³⁰⁸.

Answer 21

C++, 72 bytes

Different from the other C++ answer, as it only uses the std library.

Golfed:

#include<iostream>
int main(){for(int c=0;c>=0;c++,std::cout<<c<<"\n");}

Ungolfed:

#include<iostream>
int main(){
    for(int c = 0; c >= 0; c++){
        std::cout<<c<<"\n";
    }
}

Answer 22

Bash, 25 bytes, possibly invalid

while :;do echo -n 1;done

Try it online!

Outputs infinite 1s. In other words, outputs all numbers 1.. in unary, separated by 1 :^)

This is definitely dubious, but I see nothing in the rules or comments that disallows it. I also didn't see an existing submission that uses this gimmick.

This solution could be smaller in other languages, but we need bash in order to be able to output in unary. Since bash has no numbers, I feel it qualifies.

It could probably be smaller in bash too. Unfortunately, I don't know much bash.