31
\$\begingroup\$

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.

\$\endgroup\$
  • 5
    \$\begingroup\$ Welcome to the site! This is an interesting question, and a nice first attempt. In the future, we recommend using the Sandbox to get feedback before posting to main. There are a couple of clarifications needed here. It took me a few rereads to understand that each number has to appear multiple times, so I'd recommend rewording that to made it clearer. Also, I'd be surprised if this isn't a duplicate of an existing challenge, so don't be discouraged if this is closed as a duplicate (+1 if not however) \$\endgroup\$ – caird coinheringaahing Nov 30 '20 at 17:57
  • 1
    \$\begingroup\$ Are nested lists and/or non-natural numbers permitted? \$\endgroup\$ – Unrelated String Nov 30 '20 at 18:28
  • 1
    \$\begingroup\$ @UnrelatedString nested lists yes, I will edit the post but non-natural numbers are not permitted. \$\endgroup\$ – Adam Katav Nov 30 '20 at 18:30
  • 1
    \$\begingroup\$ Is it OK if the output is in random order (as long as all numbers are printed infinitely often with probability 1)? \$\endgroup\$ – Robin Ryder Nov 30 '20 at 18:39
  • 1
    \$\begingroup\$ Is it acceptable if floating-point limitations are ignored? For example, if \$r\$ is a uniformly distributed random float on \$(0,1)\$, can we assume \$1/r\$ can be arbitrarily large? (it can in theory, but not in practice due to realmin) \$\endgroup\$ – Luis Mendo Nov 30 '20 at 19:03

56 Answers 56

23
\$\begingroup\$

Scratch 3.0, 13 20 blocks/121 70 bytes

enter image description here

As SB Syntax:

define(n)(i
say(i
((n)+<(i)=(n)>)((1)+((i)*<(i)<(n

This says each term in the sequence. A delay can be added so that the numbers don't rapidly fire.

I have never seen scratch so abused. You call the empty name function with empty parameters. My goodness. Whatever saves bytes!

-51 thanks to @att

Try it on Scratch

Explanation coming soonish.

\$\endgroup\$
  • 2
    \$\begingroup\$ My favorite so far \$\endgroup\$ – Adam Katav Nov 30 '20 at 21:35
  • \$\begingroup\$ 74 bytes, but more blocks. \$\endgroup\$ – att Dec 1 '20 at 1:03
  • 1
    \$\begingroup\$ 70 \$\endgroup\$ – att Dec 1 '20 at 1:07
17
\$\begingroup\$

Husk, 2 bytes

ḣN

Try it online!

First Husk answer! Also uses the sequence in the question

How it works

ḣN - Main program
 N - The infinite list [1, 2, 3, ...]
ḣ  - Prefixes; [[1], [1, 2], [1, 2, 3], ...]
\$\endgroup\$
  • \$\begingroup\$ nice answer, gamer! Welcome to husk. \$\endgroup\$ – Razetime Dec 1 '20 at 2:29
  • \$\begingroup\$ This is 2 characters but 4 bytes: printf 'ḣN' |hd gives 00000000 e1 b8 a3 4e |...N| \$\endgroup\$ – Adam Katz Dec 3 '20 at 18:08
  • \$\begingroup\$ @AdamKatz If encoded as UTF8, then yes. However, Husk (along with a lot of other golfing languages, such as 05AB1E and Jelly) uses a custom codepage to encode it's programs. As bytes, this is DD 4E, but the code page is used to make it look nicer \$\endgroup\$ – caird coinheringaahing Dec 3 '20 at 18:10
  • \$\begingroup\$ 😯 whoa, that's neat \$\endgroup\$ – Adam Katz Dec 3 '20 at 18:13
15
\$\begingroup\$

05AB1E, 2 bytes

∞L

Try it online! The footer formats the output like the example from the post.

pushes a list of all natural numbers, L takes the range [1 .. n] for each number.

\$\endgroup\$
13
\$\begingroup\$

R, 26 25 24 bytes

-1 byte thanks to Dominic van Essen

repeat cat(rpois(9,9)+1)

Try it online!

Outputs a random infinite sequence of integers, drawn from the \$Poisson(9)\$ distribution (+1 to avoid outputting any 0s). They are output in batches of 9 at a time, for more "efficiency". Any positive value of the mean would work; using a mean of 9 maximizes the variance for 1-character numbers.

All numbers appear infinitely often in the sense that for any integer \$k\$, the expected number of occurences of \$k\$ in the first \$n\$ realizations goes to \$\infty\$ as \$n\to\infty\$:

$$E\left[\sum_{i=1}^n\mathbb{I}_{X_i=k}\right]\xrightarrow[n\to\infty]{}\infty.$$

The calls to cat mean that there integers within one batch of 9 are separated by spaces, but there is no separator between batches. The vast majority of 3- and 4-digit numbers in the output are due to this artefact, but there is a theoretical guarantee that such numbers (and larger numbers) will be output eventually, at least if we assume that the underlying random number generator is perfect.


For a larger variance, we can follow Giuseppe's suggestion for the same byte count:

repeat cat(1%/%runif(9))

Try it online!

This induces more 1s and more large numbers (including some very large numbers thanks to the cat artefact). Again, number of occurrences of any integer goes to infinity when the size of the output goes to infinity.


Two other R answers come out shorter, using deterministic methods: Giuseppe's and Dominic van Essen's

\$\endgroup\$
  • 1
    \$\begingroup\$ I suppose the negative binomial / geometric distributions would work as well, though the parameters don't quite lend themselves to as short an answer. \$\endgroup\$ – Giuseppe Nov 30 '20 at 19:06
  • 3
    \$\begingroup\$ @AdamKatav They are just less likely \$\endgroup\$ – Luis Mendo Nov 30 '20 at 19:27
  • 1
    \$\begingroup\$ @AdamKatav There will be if you wait long enough. For instance about 1 in 343 numbers is a 20. In the TIO output, a browser search reveals instances of 20, 21, 22, 23 and 24, and we would get higher numbers if more output were shown. \$\endgroup\$ – Robin Ryder Nov 30 '20 at 19:28
  • 3
    \$\begingroup\$ There's also 1%/%runif(9) which should be a bit more evenly distributed, for the same byte count. I tried all the other built-in distributions in R. I do think that %/% will give some weird results but that's due to floating point precision issues, so it's nothing your answer doesn't already suffer from! \$\endgroup\$ – Giuseppe Nov 30 '20 at 19:47
  • 1
    \$\begingroup\$ Both can be 24 bytes using repeat (without parentheses), but in the meantime I've found a different 23 byte answer... \$\endgroup\$ – Dominic van Essen Dec 1 '20 at 8:45
10
\$\begingroup\$

Python 2, 31 bytes

R=1,
while 1:print R;R+=len(R),

Try it online!

Thanks to @Danis for saving a byte here over R+=R[-1]+1,. This

Prints:

(1,)
(1, 1)
(1, 1, 2)
(1, 1, 2, 3)
(1, 1, 2, 3, 4)
(1, 1, 2, 3, 4, 5)
    ...

Accumulates a list of number from 1 to n (except 1 appears twice) each time appending the last element plus one.

32 bytes

R=[1]
for x in R:print R;R+=x+1,

Try it online!


Python 2, 30 bytes (conjectured)

n=2
while 1:print~-2**n%n;n+=1

Try it online!

The sequence of \$2^n \bmod n\$ (A015910) is conjectured to take on all values \$k \geq 0\$ except \$k=1\$. I don't know if it's also conjectured that each value appears infinitely many times, but it seems consistent with known solutions for specific values.

We instead compute \$(2^n-1) \bmod n\$, which makes \$0\$ rather than \$1\$ be the only missing value (if the conjecture holds).

Looking at the output, you might think that \$2\$ is never output, but it in fact does appear first for \$n=4700063497\$ and for progressively higher values in A050259.


Python 2, 33 bytes

R=[1]
for x in R:print x;R+=x+1,1

Try it online!

This is longer, but it's pretty nifty, printing the ABACABA sequence.

\$\endgroup\$
  • \$\begingroup\$ you can write len(R) instead of R[-1]+1, but then at the beginning there will be two ones \$\endgroup\$ – a25bedc5-3d09-41b8-82fb-ea6c353d75ae Dec 1 '20 at 7:55
  • \$\begingroup\$ the conjecture is cool but integers 2, 4, 6, 8 seem to be missing (from my brief look)?! \$\endgroup\$ – roblogic Dec 3 '20 at 2:11
  • 1
    \$\begingroup\$ @roblogic See my comments on the post about 2. The other evens should also appear in the corresponding OEIS sequences. \$\endgroup\$ – xnor Dec 3 '20 at 2:15
  • 1
    \$\begingroup\$ Side bar: Every once in a while I remember how mind-blowing it is that I can off the cuff verify your calculation for 𝑛=4700063497 in about 20 seconds on my laptop. What if Gauss had access to an iPad? :) \$\endgroup\$ – Chas Brown Dec 18 '20 at 5:46
9
\$\begingroup\$

Haskell, 17 bytes

[[1..x]|x<-[1..]]

Try it online!

Since the challenge seems to allow non-flat output, we can simply generate a list of the lists [1],[1,2],[1,2,3,],..., as suggested by @AZTECCO.

Haskell, 19 bytes

l=1:do x<-l;[x+1,1]

Try it online!

A recursively-defined infinite flat list with the ABACABA sequence 1,2,1,3,1,2,1,4,... (A001511).

A same-length variant:

l=(:[1]).succ=<<0:l

Try it online!

20 bytes

l=do x<-[1..];[1..x]

Try it online!

Counting up 1,1,2,1,2,3,1,2,3,4,..., but as a flat list.

\$\endgroup\$
  • 1
    \$\begingroup\$ Also [[1..x]|x<-[1..]] \$\endgroup\$ – AZTECCO Dec 1 '20 at 2:06
  • \$\begingroup\$ Interesting, I missed that the output doesn't have to flat. \$\endgroup\$ – xnor Dec 1 '20 at 2:11
  • \$\begingroup\$ Worth mentioning \$\endgroup\$ – AZTECCO Dec 1 '20 at 5:43
  • 1
    \$\begingroup\$ The community concensus seems to be that [[1..x]|x<-[1..]] is a valid anonymous function, which wouldn't need the l=. And I don't see how l= makes this more valid. \$\endgroup\$ – ovs Dec 1 '20 at 8:42
  • \$\begingroup\$ worth mentioning inits [1..] as well. Ofc inits requires an import so not a very good solution \$\endgroup\$ – Anvit Dec 6 '20 at 17:30
7
\$\begingroup\$

Bash + GNU Coreutils, 20

seq -fseq\ %g inf|sh

Try it online! - Times out after 60 seconds.

\$\endgroup\$
7
\$\begingroup\$

sed 4.2.2, 20

:;s/(1*).*/1\1 &/p;b

Try it online!

Output is in unary, as per this meta consensus.

\$\endgroup\$
7
\$\begingroup\$

Bash, 20 bytes

seq inf|xargs -l seq

Try it online!

\$\endgroup\$
6
\$\begingroup\$

R, 21 bytes

(also near-simultaneously identified by Robin Ryder)

while(T<-T+1)cat(T:0)

Try it online!

Similar to the example sequence, but each sub-series is reversed, and the initial value in each subseries is represented with an initial zero (so, 03 for 3, for instance).

If you don't like the initial zeros, then look at the previous version using show (below), or at Giuseppe's answer.


R, 23 22 bytes

Edit: -1 byte thanks to Robin Ryder

while(T<-T+1)show(1:T)

Try it online!

Outputs the sequence used in the example, plus an additional infinite number of copies of the number 1.
Each number is separated by either a space " " , a newline plus bracket, "\n[", or a bracket plus space "[ ".

2-bytes golfier (at time of posting, at least...) than the other two R answers...

\$\endgroup\$
  • \$\begingroup\$ 21 bytes, but some integers are prefixed with a 0; I don't know whether that is acceptable. \$\endgroup\$ – Robin Ryder Dec 1 '20 at 9:06
  • 1
    \$\begingroup\$ @RobinRyder - Yes, I got that too, but I'm waiting for the OP to clarify if this is Ok... \$\endgroup\$ – Dominic van Essen Dec 1 '20 at 9:07
  • 1
    \$\begingroup\$ If the initial 0 is ruled unacceptable, this works for 22 bytes; a rare use for show! \$\endgroup\$ – Robin Ryder Dec 1 '20 at 9:17
  • \$\begingroup\$ @RobinRyder - Super! Thanks! I don't think I've ever used show before... \$\endgroup\$ – Dominic van Essen Dec 1 '20 at 9:20
  • \$\begingroup\$ can we replace show with cat? Or am I missing something? \$\endgroup\$ – JDL Dec 1 '20 at 11:18
5
\$\begingroup\$

Jelly, 4 bytes

‘RṄß

Try it online!

I think this outputs all numbers an infinite number of times, but because it's a different output format, I'm not 100% sure

How it works

‘RṄß - Main link. Left argument is initially n = 0
‘    - Increment
 R   - Range
  Ṅ  - Print
   ß - Recursively run the main link

For n = 0, ‘RṄ outputs [1]. We then recurse, using n = [1]. ‘RṄ then outputs [[1, 2]], and we recurse again, using n = [[1, 2]], which outputs [[[1, 2], [1, 2, 3]]] etc.

\$\endgroup\$
  • \$\begingroup\$ That was very quick (5 min) \$\endgroup\$ – Adam Katav Nov 30 '20 at 18:03
  • 4
    \$\begingroup\$ @AdamKatav We have a lot of practice of finding quick answers :P \$\endgroup\$ – caird coinheringaahing Nov 30 '20 at 18:04
5
\$\begingroup\$

Octave, 29 28 bytes

do disp(fix(1/rand)) until 0

Try it online!

This outputs a sequence \$(x_k)\$ of independent, identically distributed random natural numbers. Each value \$x_k\$ is obtained as \$1/r\$ rounded towards zero, where \$r\$ has a uniform distribution on the interval \$(0,1)\$.

For a given index \$k\$, and for any \$n \in \mathbb N\$, there is a nonzero probability that \$x_k=n\$ (ignoring floating-point inaccuracies). Therefore, with probability \$1\$ every \$n\$ appears infinitely often in the sequence \$(x_k)\$.

\$\endgroup\$
  • \$\begingroup\$ "identically distributed random natural numbers", this is impossible, you can't have a uniform distribution over an infinite set. \$\endgroup\$ – Pedro A Dec 2 '20 at 13:16
  • \$\begingroup\$ @PedroA Who said uniform? :-) The distribution has the approximate form \$1/x^2\$ (which results from dividing \$1\$ by a uniform number on \$(0,1)\$), and thus larger numbers are less likely \$\endgroup\$ – Luis Mendo Dec 2 '20 at 18:02
5
\$\begingroup\$

R, 25 21 bytes

repeat T=print(T:0+1)

Try it online!

Prints 2..1, 3..1, 4..1 and so forth.

Thanks to Robin Ryder for -4 bytes.

This works because print invisibly returns its first argument.

\$\endgroup\$
  • \$\begingroup\$ 2 bytes golfier... \$\endgroup\$ – Dominic van Essen Dec 1 '20 at 8:40
  • \$\begingroup\$ (although yours would be 24 bytes using repeat )... \$\endgroup\$ – Dominic van Essen Dec 1 '20 at 8:47
  • 2
    \$\begingroup\$ 21 bytes \$\endgroup\$ – Robin Ryder Dec 1 '20 at 8:59
  • \$\begingroup\$ @RobinRyder nice, thanks! I couldn't get it to work using 0:T but didn't think of reversing it! \$\endgroup\$ – Giuseppe Dec 1 '20 at 15:07
5
\$\begingroup\$

Befunge, 5 bytes

>1+?.

Try it online!

At each output, there is a 50% chance the current number will be printed and reset to 1, and a 50% chance that 2 will be printed and the current number will increase by some random odd number (following an exponential distribution). This can happen multiple times, so odd numbers can be outputted as well.

Every natural number has a nonzero probability of occurring, so it will eventually be printed infinitely many times.

Explanation

>1+?.
>      # Go east.
 1+    # Initialize a counter to 1.
   ?   # Go in a random direction.
       # If the instruction pointer goes west:
  +    # Add the top two stack elements together.
       # If there is a 2 on top, this adds it to the counter.
       # If not, this does nothing.
 1     # Create a new 1 on the top of the stack.
>      # Go east.
 1+    # Add 1 to get 2, which remains on top of the counter.
   ?   # Repeat.
       
   ?   # If the IP goes east:
    .  # Print and delete the top of the stack.
>      # Go east.
 1+    # Add 1.
       # If there was a 2 that was printed and the counter remains, the 1 gets added to it.
       # If the counter was printed instead, this creates a new 1.
   ?   # Repeat.

   ?   # If the IP goes north or south, it wraps around to the ? instruction and repeats.

Befunge-98, 14 bytes

]:.1-:0`j
]:+!

Try it online!

A determinstic solution, printing each range from 1 to n in descending order.

Explanation

]           # Turn right (to the south) and go to the second line.

]:+!      
]           # Turn right again (to the west).
   !        # Take the logical NOT of the secondary counter (which is now 0) to get 1.
  +         # Add the 1 to the main counter.
 :          # Duplicate the main counter to form a secondary counter.
]           # Turn right (to the north) and go to the first line.

]:.1-:0`j 
]           # Turn right (to the east).
 :          # Duplicate the secondary counter.
  .         # Print and delete the duplicate.
   1-       # Subtract 1 from the secondary counter.
     0`     # Is the secondary counter greater than 0?
       j    # If so, jump over the ] instruction and repeat the first line.
]           # If not, turn right (to the south) and go to the second line.
\$\endgroup\$
4
\$\begingroup\$

convey, 27 bytes

   >v
1","@"}
^+^<#-1
1+<<<

Try it online!

enter image description here

This counts down from successive numbers.

\$\endgroup\$
4
\$\begingroup\$

Wolfram Language (Mathematica), 25 bytes

Do[Print@n,{m,∞},{n,m}]

Try it online!

-1 byte @att

\$\endgroup\$
  • \$\begingroup\$ 25 bytes \$\endgroup\$ – att Dec 24 '20 at 19:00
  • \$\begingroup\$ 24 \$\endgroup\$ – att Dec 26 '20 at 6:58
3
\$\begingroup\$

Brachylog, 4 bytes

⟦₁ẉ⊥

Try it online!

  ẉ     Print with a newline
⟦₁      the range from 1 to something,
   ⊥    then try again.
\$\endgroup\$
3
\$\begingroup\$

J, 13 bytes

$:@,~[echo@#\

Try it online!

Outputs 1, 1 2, 1 2 3 4, 1 2 3 4 5 6 7 8, etc, with every number on its own line.

  • echo@#\ Output the prefix lengths of the current list, ie, 1..n where n is the current list length. This is done as a side effect.
  • $:@,~ Append the list to itself ,~ and call the function recursively $:@.
\$\endgroup\$
3
\$\begingroup\$

Rust, 54 bytes

(2..).for_each(|x|(1..x).for_each(|y|print!("{} ",y)))

Try it online

\$\endgroup\$
  • \$\begingroup\$ Welcome to the site, nice first answer! \$\endgroup\$ – Redwolf Programs Dec 1 '20 at 0:33
3
\$\begingroup\$

Ruby, 17 bytes

loop{p *1..$.+=1}

Try it online!

\$\endgroup\$
3
\$\begingroup\$

Charcoal, 8 bytes

W¹«I⊕ⅉD⸿

Try it online! Link is to verbose version of code. Works by repeatedly printing the next number to the canvas and then dumping the entire canvas.

2 bytes for a version that prints the \$ n \$th term of a sequence:

IΣ

Try it online! Explanation: Simply prints the digital sum of the input. Given any natural number \$ n \$, all the values of the form \$ \frac { 10 ^ n - 1 } 9 10 ^ m \$ have a digital sum of \$ n \$ for every \$ m \$, thus each natural number appears infinitely often.

\$\endgroup\$
3
\$\begingroup\$

C (gcc), 43 bytes

i;main(j){for(;;)printf("%d ",j=--j?:++i);}

Try it online!

\$\endgroup\$
3
\$\begingroup\$

JavaScript (V8), 26 bytes

for(a=b='';;)write(a+=--b)

Try it online!

Character - used as a separator and the output starts with it, so I'm not really sure if this is acceptable.

\$\endgroup\$
  • 1
    \$\begingroup\$ While it is a great answer, I don't know if it valid. Quoting the first rule: "Each number must be separated by a (finite) amount of visible, whitespace or new line characters that aren't a digit.". The dash/minus symbol isn't a whitespace or a newline. And certainly seems to be part of the number, but isn't a digit. I think that more clarification is needed, as this is a possible game changing detail. This means that anyone could just do their loops in reverse and get some savings, without needing the whitespace. TL;DR: may be invalid, O.P. needs to clarify better the rules. \$\endgroup\$ – Ismael Miguel Dec 2 '20 at 12:03
  • 1
    \$\begingroup\$ @IsmaelMiguel - "visible, whitespace or new line characters". The "-" character is visible, so it seems Ok to me... \$\endgroup\$ – Dominic van Essen Dec 3 '20 at 17:58
  • \$\begingroup\$ @DominicvanEssen My advice stands. \$\endgroup\$ – Ismael Miguel Dec 3 '20 at 21:44
3
\$\begingroup\$

C (gcc), 52 49 44 bytes

Saved 5 bytes thanks to AZTECCO!!!

f(i,j){for(j=1;printf("%d ",j--);)j=j?:++i;}

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Why are you guaranteed to get i=1 when this is compiled? I see that it occurs reliably on tio, but I'm not sure why. \$\endgroup\$ – bisen2 Nov 30 '20 at 22:58
  • \$\begingroup\$ 44 \$\endgroup\$ – AZTECCO Dec 1 '20 at 2:04
  • \$\begingroup\$ @AZTECCO Nice one - thanks! :D \$\endgroup\$ – Noodle9 Dec 1 '20 at 7:05
  • \$\begingroup\$ @bisen2 It doesn't matter what i is initialised to, all the positive (nothing will be output until i is greater than 0) numbers get output infinite number of times anyway. It just so happens that i initialised to 0 at the onset. Note: the answer has been changed. \$\endgroup\$ – Noodle9 Dec 1 '20 at 7:08
3
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ Nice answer! 67 bytes by using newlines and rearranging the loop. I don't know if you need a proper method for this one. You could also use a Runnable. \$\endgroup\$ – user Nov 30 '20 at 21:44
  • \$\begingroup\$ 61 bytes by changing the ()-> to v-> (empty unused parameters are allowed by default) and putting the int i,j=2; inside the loop to save on the ;. \$\endgroup\$ – Kevin Cruijssen Dec 2 '20 at 15:40
  • \$\begingroup\$ Here's my 47 byte solution. I made a new post because the method approach was different. \$\endgroup\$ – branboyer Dec 3 '20 at 1:08
3
\$\begingroup\$

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

\$\endgroup\$
  • \$\begingroup\$ BTW, zsh can do this in 19B as s(){seq $[++n];s};s \$\endgroup\$ – Adam Katz Dec 8 '20 at 17:44
3
\$\begingroup\$

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!

\$\endgroup\$
  • 1
    \$\begingroup\$ Nice, that's fully native and without subshells! for ((;;))echo {1..$[++i]} saves you 3B by assuming i is either undefined or 0. Try it online \$\endgroup\$ – Adam Katz Dec 3 '20 at 20:48
  • \$\begingroup\$ Not any more. Saved a byte using shuf from coreutils \$\endgroup\$ – roblogic Dec 8 '20 at 15:48
  • 1
    \$\begingroup\$ cool, that gives me a way to get the native subshell-free version down to 25B as well: for ((;++i;))echo {1..$i} Try it online \$\endgroup\$ – Adam Katz Dec 8 '20 at 17:01
  • 1
    \$\begingroup\$ If you don't care about white space (this has a newline delimiter, printing each number on its own line), you can do for ((;++i;))seq $i at 19B. Try it online \$\endgroup\$ – Adam Katz Dec 8 '20 at 17:08
  • \$\begingroup\$ Thanks, will update this soon. Another one for 19B: s(){seq $[++n];s};s \$\endgroup\$ – roblogic Dec 8 '20 at 17:34
3
\$\begingroup\$

Perl 5, 22 20 bytes

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

Try it online!

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

AWK, 34 bytes

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

Try it online!

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

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.

\$\endgroup\$
  • \$\begingroup\$ 11 bytes by using the return value of . \$\endgroup\$ – ovs Nov 30 '20 at 23:14
  • \$\begingroup\$ @ovs Thanks. I'd tried reversing and then picking the first element, which wasn't any shorter, but I hadn't thought of using rho to get the number. \$\endgroup\$ – user Dec 1 '20 at 0:04

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.