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

Julia, 27 bytes

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

Try it online!

Answer 2

AutoHotkey, 36 bytes

Loop
Loop,%A_Index%
Send,%A_Index%`t

Output is via keyboard simulation so it will print in whatever the active window is.
Numbers are separated by tabs.

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   1   2   3   4   5   6   7   8   9   10  1   2   3   4   5   6   7   8   9   10  11  1   2   3   4   5   6   7   8   9   10  11  12  1   2   3   4   5   6   7   8   9   10  11  12  13  1   2   3   4   5   6   7   8   9   10  11  12  13  14  1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  

---

Alternatively - and not in compliance with the challenge spec - if you prefer your numbers to be spoken rather than printed:

Loop
Loop,%A_Index%
ComObjCreate("SAPI.SpVoice").Speak(A_Index)

Answer 3

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 4

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 5

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 6

Perl 5, 22 20 bytes

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

Try it online!

Answer 7

Rust, 50 bytes

||for i in(1..).flat_map(|n|1..n){print!("{} ",i)}

Try it online!

I know there are a couple of rust answers already, but this one is deterministic and takes a different (and shorter) approach to the problem. explanation:

||for i in(1..).flat_map(|n|1..n){print!("{} ",i)} //anonymous function
          (1..)                                    //for evey n from 1..infinite
               .flat_map(|n|1..n)                  //map to range from 1..n and flatten
  for i in                       {print!("{} ",i)} //print with a trailing space

Answer 8

AWK, 34 bytes

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

Try it online!

Answer 9

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 10

PHP, 30 bytes

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

Try it online!

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

Answer 11

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 12

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 13

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 14

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 15

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 16

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 17

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 18

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 19

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 20

PowerShell Core, 14 bytes

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

Try it online!

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

Answer 21

Python 3, 36 bytes (including newline)

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

Try it online!

Answer 22

Vyxal, 5 bytes

{nɾṄ,

Try it Online! The 5 flag makes the online interpreter time out after 5 seconds.

Explanation:

{      # Open a(n infinite) while loop
 n     # Get the loop variable's value
  ɾ    # Push the range from 1 to n
   Ṅ   # Join by spaces (ɾ creates a list)
    ,  # Print

Answer 23

Appleseed, 16 bytes

(q(_(map 1to(1to

Anonymous function that can be called with no arguments and returns an infinite nested list ((1) (1 2) (1 2 3) ...). Try it online!

Explanation

(q           ; Anonymous function
 (_          ; that takes any number of arguments:
  (map 1to   ; Inclusive range from 1 to N for each N in
   (1to))))  ; numbers from 1 to infinity

Answer 24

Scala, 23 bytes

Stream from 1 map(1 to)

Try it online

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

Answer 25

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 26

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 27

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 28

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 29

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 30

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.