Infinitely many ℕ

Question

Background:

A sequence of infinite naturals is a sequence that contains every natural number infinitely many times.

To clarify, every number must be printed multiple times!

The Challenge:

Output a sequence of infinite naturals with the shortest code.

Rules:

1. Each number must be separated by a (finite) amount of visible, whitespace or new line characters that aren't a digit.
2. The program cannot terminate (unless you somehow wrote all numbers).
3. Any way of writing such a sequence is acceptable.

Examples:

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
...

1, 1, 2, 1, 2, 3, 1, 2, 3, 4...

Notice that we write all naturals from 1 to N for all N ∈ ℕ.

Feedback and edits to the question are welcome. Inspired by my Calculus exam.

Answer 1

Java (JDK), 61 bytes

v->{for(int i,j=2;;j++)for(i=0;++i<j;)System.out.println(i);}

Try it online!

Edit: Thanks @user for shaving off a few bytes and helping me learn something today! Big thanks to @KevinCruijssen for -2 bytes.

Answer 2

Rust + rand crate, 43 bytes

||loop{print!("{} ",rand::random::<u32>())}

Uses the rand crate to output random numbers, meaning every number is printed infinitely many times.

Answer 3

Zsh, 29 .. 19 bytes

Solution by @AdamKatz: Try it Online!

for ((;++i;))seq $i

_{19 bytes, port from bash : s(){seq $[++n];s};s
25 bytes (per @AdamKatz) : for ((;++i;))echo {1..$i}
25 bytes : for ((;;i++))shuf -i 1-$i
26 bytes (per @AdamKatz) : for ((;;))echo {1..$[++i]}
29 bytes : for ((i=1;;))echo {1..$[i++]}
I tried to use /dev/random for an alternative but it was a mess!}

Answer 4

Perl 5, 22 20 bytes

say while$_.=++$i.$"

Try it online!

Answer 5

AWK, 34 bytes

{for(;;++i)for(j=0;j++<i;)print j}

Try it online!

Answer 6

APL (Dyalog Unicode), 12 11 bytes (SBCS)

Saved 1 byte thanks to @ovs

{∇1+⍴⎕←⍳⍵}1

Try it online!

This one also uses the sequence from the question.

Answer 7

PHP, 30 bytes

<?for(;;)echo--$j?:$j=++$i,~_;

Try it online!

The numbers are separated by a no-break space (U+00A0).

Answer 8

Stax, 5 bytes

VImRJ

Run and debug it

Explanation

VImRJ
VIm   map 1..infinity to
   R  range 1..i
    J join with spaces
  m   print each iteration

Answer 9

JavaScript (V8), 34 bytes

Saved 2 bytes thanks to @tsh

for(n=k=0;;)print(n=n<k?n+1:++k/k)

Try it online!

Returning the n-th term would be 31 bytes:

n=>(m=(8*n+1)**.5-1>>1)*~m/2-~n

Try it online!

Answer 10

Wolfram Language (Mathematica), 31 bytes

Print@Floor[Sec@n^2]~Do~{n,∞}

Try it online!

Not quite as short as the other Mathematica answer, but implements a different and more mathematically interesting sequence, namely the integer part of \$\sec^2n\$; the fact that this includes every natural number infinitely often follows from the fact that the integers are uniformly distributed modulo \$\pi\$.

Answer 11

Icon, 46 bytes

procedure f()
i:=0;|1&write(1to(i+:=1))&\z
end

Try it online!

Of course procedure ... end block makes it very verbose.

Too bad seq() doesn't work with bigints - otherwise I could've saved some bytes with

procedure f()
|1&write(1to seq())&\z
end

Answer 12

Julia, 27 bytes

f(n=1)=println.(1:n),f(n+1)

Try it online!

Answer 13

Burlesque, 6 bytes

,r1)ro

Try it online!

Explanation:

,       # Don't take implicit input from stdin
 r1     # Range from 1 to infinity
   )    # Map each value to
    ro  # Range from 1 to value 

Answer 14

Java (JDK), 54 bytes

A b;{b=(s,i)->{System.out.print(s+=i+++s);b.B(s,i);};}

Try it online!

Usually in lambda functions, this website doesn't include the "interface name =" part, but my answer was a declaration statement without the initialization, so I decided to include it. I couldn't find a rule about it.

My older, wrongly counted, 47 byte solution: Try it online!

(forced) inputs: a String with any delimiter (" "), and 1, where Y is the class it's in, b is the name of the interface object, and B is the method in the interface being used.

Answer 15

Bash, 21 bytes

s(){ seq $[++n];s;};s

1
1
2
1
2
3
…

Run the 21B version on Try It Online

This defines a function s that runs seq NUMBER where NUMBER starts at 1 and increments with each run, then it runs itself recursively. After the definition, we run s.

For the cost of 5B to specify -s\ (separator is a space character), it can be adapted to a one answer per line solution at 26 bytes:

s(){ seq -s\  $[++n];s;};s

1
1 2
1 2 3
…

Run the 26B version on Try It Online

Answer 16

jq, 24 bytes

range(range(infinite))+1

Try it online! (requires the -n flag)

JQ is a stream-based language: every expression can return multiple values and when expressions are combined together the second one is flat-mapped over everything returned by the first. This makes it very easy to express infinite sequences.

infinite is a filter that ignores its input and returns a single infinite floating-point value.
range(n) is a filter that ignores its input and returns every positive integer smaller than n.
+1 adds one to each value in the result.

By default if we run this program it will try to read from STDIN (because each filter needs to take an input, even if it is ignored). Therefore we pass the -n flag to tell the interpreter to pass a single null value as the input to the filter.

Answer 17

Julia, 47 46 bytes

Thanks to @user recommended to change true to 1>0.

a=[1];while 1>0;println(a);push!(a,last(a)+1);end

output:

[1]
[1, 2]
[1, 2, 3]
[1, 2, 3, 4]
[1, 2, 3, 4, 5]

Python 3, 45 bytes

a=[1]
while 1:
    print(a)
    a+=[a[-1]+1]

Answer 18

PowerShell Core, 14 bytes

for(){1..++$i}

Try it online!

Will output the numbers of the sequence separated by a new line.

Answer 19

Python 3, 36 bytes (including newline)

s=[1]
while 1:print(s);s+=[s[-1]+1]

Try it online!

Answer 20

Scala, 23 bytes

Stream from 1 map(1 to)

Try it online

An infinite Stream of IntRanges. Uses the sequence from the question.

Answer 21

Python 2, 24 33 bytes

Added 9 bytes to fix an error kindly pointed out by caird coinheringaahing.

n=1
while 1:n+=1;print range(1,n)

Try it online!

Answer 22

Retina 0.8.2, 11 bytes

_
}*M!&`_+

Try it online! Outputs in unary. Explanation: The first two lines cause the number of _s to increase on each pass, while the M!&`_+ generates all suffixes, which ensures that all integers get printed. The } causes the entire script to repeat indefinitely. The * causes the suffixes to be printed and discarded, since otherwise Retina does not output until the program terminates.

18 bytes for a traditional decimal output. Each integer is printed in turn, and then for each integer all of the previous integers are printed again, so the final sequence is 1, 2, 1, 3, 2, 1, 4, 3 ...

{`^
_
*(M!&`_+
%`_

Try it online!

Answer 23

Pyth, 4 bytes

f!pS

Try it online!

Explanation

f!pS
      : lambda T:
   S  :    range(1, T)
  p   :    print and return the range
 !    :    logical negate the range
f     : Find first natural number input to function that returns a truthy value

Answer 24

Raku, 18 bytes

.say for [\,] 1..*

Try it online!

[\,] 1..* generates the list of prefixes of the sequence of naturals. .say for just prints them.

Answer 25

Nim, 47 bytes

var i=1
while true:
 for j in 1..i:echo j
 i+=1

Try it online! The footer makes it finite so the output can be observed.

Note that Nim doesn't have bigints, so this works only in theory (in accordance with our rules).

Answer 26

Common Lisp, 56 bytes

(do((i 1(1+ i)))(())(dotimes(j i)(format t"~v^~a "j j)))

Nested loop solution using the do macro for the outer loop and the dotimes macro for the inner loop. dotimes starts with 0 so format includes a specifier that checks whether it's a 0.

Answer 27

AWK, 33 bytes

An approach different from @Noodle9's, that luckly uses one less byte.

{for(;;a[++i])for(j in a)print j}

Try it online!

{
for(;;a[++i])  # by only stating the array[element], that element is created in the array.
               # all not assigned variables starts at 0.
               # at first, i++ would return 0, and increment 1 to i;
               # but ++i increments 1 to i, and then return its new value.
  for(j in a)  # for every element existing in the array,
    print j    # prints the element j.
}

---

AWK, 37 bytes

Prints numbers in one line.

{for(;;a[++i])for(j in a)printf j FS}

Try it online!

---

AWK, 51 bytes

Prints numbers in a pyramid.

{for(;;a[++i])for(j in a)printf j+1 in a?j FS:j RS}

Try it online!

Answer 28

Java (OpenJDK 8), 76 chars

void f(){for(int i=0,j;++i>0;out.println())for(j=0;j++<i;out.print(j+" "));}

Try it online!

Output (unlimited):

1 
1 2 
1 2 3 
1 2 3 4 
1 2 3 4 5 
1 2 3 4 5 6 
1 2 3 4 5 6 7 
1 2 3 4 5 6 7 8 
1 2 3 4 5 6 7 8 9 
. . .

Answer 29

sed in unary, 16 bytes

s/^/1\n1/p;h;G;D

Try it online!

Each unary natural is on its own line. Seems to increase logarithmically.

sed has two spaces: the default one is called the pattern space and is lost after processing the next of input; the other one is the hold space, which instead is retained throughout execution. Both start empty.

(sed cannot run without input, so this program is run with an empty line as input).

The idea is to have the largest number encountered so far on the first line, and then have the result of the previous iterations on the succeeding lines.

s/^/1\n1/ replaces the beginning (symbolised with ^, really just empty space) with 1 followed by a newline (\n) and another 1. The p flag then prints the pattern space. The second 1 inserted increases the maximum number by 1, which was on the first line before the substitution, and now is on the second line.

h replaces the hold space with the contents of the pattern space, after which G appends the hold space to the pattern space, joining them by a newline. This is our method to retain the previous natural numbers encountered.

D deletes the first line (which in our case is always 1 thanks to the substitution made with the s command) and the newline after it. This effectively returns the largest number encountered so far back to the first line. Then D causes the program to be run from the beginning with what remains of the pattern space because the first line was not empty. Because the s command will always make sure the first line is not empty, the initial 1\n effectively acts only for D to cause the program to loop indefinitely.

---

sed 4.2.2, 15 bytes

:;s/^/1/p;h;G;t

Try it online!

sed 4.2.2 allows empty labels, ridding the need for 1\n and D.

Answer 30

Chapel, 51 bytes

var i=1;while(i){for j in 1..i do writeln(j);i+=1;}

Try it online!