Infinitamente muitos ℕ
Fundo:
Uma sequência de naturais infinitos é uma sequência que contém cada número natural infinitamente muitas vezes.
Para esclarecer, cada número deve ser impresso várias vezes!
O desafio:
Produza uma sequência de naturais infinitos com o código mais curto.
Regras:
- Cada número deve ser separado por uma quantidade (finita) de caracteres visíveis, de espaço em branco ou de nova linha que não sejam dígitos.
- O programa não pode terminar (a menos que você de alguma forma tenha escrito todos os números).
- Qualquer forma de escrever tal sequência é aceitável.
Exemplos:
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...
Observe que escrevemos todos os naturais de 1 a N para todos N ∈ ℕ.
Comentários e edições à pergunta são bem-vindos. Inspirado no meu exame de cálculo.
Respostas
Scratch 3.0 , 13 blocos de 20/121 70 bytes

Como Sintaxe SB:
define(n)(i
say(i
((n)+<(i)=(n)>)((1)+((i)*<(i)<(n
Diz cada termo na sequência. Um atraso pode ser adicionado para que os números não disparem rapidamente.
Nunca vi scratch tão abusado. Você chama a função de nome vazia com parâmetros vazios . Minha nossa. O que quer que economize bytes!
-51 graças a @att
Experimente no Scratch
Explicação em breve.
Husk , 2 bytes
ḣN
Experimente online!
Primeira resposta do Husk! Também usa a sequência na pergunta
Como funciona
ḣN - Main program
N - The infinite list [1, 2, 3, ...]
ḣ - Prefixes; [[1], [1, 2], [1, 2, 3], ...]
05AB1E , 2 bytes
∞L
Experimente online! O rodapé formata a saída como o exemplo da postagem.
∞
empurra uma lista de todos os números naturais, L
pega o intervalo [1 .. n]
de cada número.
R , 26 25 24 bytes
-1 byte graças a Dominic van Essen
repeat cat(rpois(9,9)+1)
Experimente online!
Produz uma sequência infinita aleatória de inteiros, extraída da \$Poisson(9)\$distribuição (+1 para evitar a produção de 0s). Eles são produzidos em lotes de 9 de cada vez, para maior "eficiência". Qualquer valor positivo da média funcionaria; usar uma média de 9 maximiza a variância para números de 1 caractere.
Todos os números aparecem com frequência infinita no sentido de que, para qualquer inteiro \$k\$, o número esperado de ocorrências de \$k\$no primeiro \$n\$as realizações vão para \$\infty\$como \$n\to\infty\$:
$$E\left[\sum_{i=1}^n\mathbb{I}_{X_i=k}\right]\xrightarrow[n\to\infty]{}\infty.$$
As chamadas cat
significam que há inteiros em um lote de 9 são separados por espaços, mas não há separador entre os lotes. A grande maioria dos números de 3 e 4 dígitos na saída são devidos a este artefato, mas há uma garantia teórica de que tais números (e números maiores) serão produzidos eventualmente, pelo menos se assumirmos que o gerador de números aleatórios subjacente é perfeito.
Para uma variação maior, podemos seguir a sugestão de Giuseppe para a mesma contagem de bytes:
repeat cat(1%/%runif(9))
Experimente online!
Isso induz mais 1
s e mais números grandes (incluindo alguns números muito grandes graças ao cat
artefato). Novamente, o número de ocorrências de qualquer número inteiro vai para o infinito quando o tamanho da saída vai para o infinito.
Duas outras respostas R são mais curtas, usando métodos determinísticos: Giuseppe e Dominic van Essen
Python 2 , 31 bytes
R=1,
while 1:print R;R+=len(R),
Experimente online!
Obrigado a @Danis por salvar um byte aqui R+=R[-1]+1,
. este
Impressões:
(1,)
(1, 1)
(1, 1, 2)
(1, 1, 2, 3)
(1, 1, 2, 3, 4)
(1, 1, 2, 3, 4, 5)
...
Acumula uma lista de números de 1 a n (exceto 1 aparece duas vezes) cada vez acrescentando o último elemento mais um.
32 bytes
R=[1]
for x in R:print R;R+=x+1,
Experimente online!
Python 2 , 30 bytes (conjecturado)
n=2
while 1:print~-2**n%n;n+=1
Experimente online!
A sequência de \$2^n \bmod n\$( A015910 ) é conjecturado para assumir todos os valores \$k \geq 0\$exceto \$k=1\$. Não sei se também se conjectura que cada valor aparece infinitamente muitas vezes, mas parece consistente com soluções conhecidas para valores específicos .
Em vez disso, calculamos \$(2^n-1) \bmod n\$, o que torna \$0\$ao invés de \$1\$ ser o único valor ausente (se a conjectura for válida).
Olhando para a saída, você pode pensar que \$2\$nunca é impresso, mas de fato aparece primeiro para \$n=4700063497\$e para valores progressivamente maiores em A050259 .
Python 2 , 33 bytes
R=[1]
for x in R:print x;R+=x+1,1
Experimente online!
Este é mais longo, mas é bem bacana, imprimir a sequência ABACABA .
Haskell , 17 bytes
[[1..x]|x<-[1..]]
Experimente online!
Como o desafio parece permitir uma saída não plana, podemos simplesmente gerar uma lista das listas [1],[1,2],[1,2,3,],...
, conforme sugerido por @AZTECCO.
Haskell , 19 bytes
l=1:do x<-l;[x+1,1]
Experimente online!
Uma lista plana infinita definida recursivamente com a sequência ABACABA1,2,1,3,1,2,1,4,...
( A001511 ).
Uma variante do mesmo comprimento:
l=(:[1]).succ=<<0:l
Experimente online!
20 bytes
l=do x<-[1..];[1..x]
Experimente online!
Contando 1,1,2,1,2,3,1,2,3,4,...
, mas como uma lista plana.
Bash + GNU Coreutils, 20
seq -fseq\ %g inf|sh
Experimente online! - Tempo limite após 60 segundos.
sed 4.2.2 , 20
:;s/(1*).*/1\1 &/p;b
Experimente online!
A saída é unária, de acordo com este meta consenso .
Bash , 20 bytes
seq inf|xargs -l seq
Experimente online!
R , 21 bytes
(também quase simultaneamente identificado por Robin Ryder)
while(T<-T+1)cat(T:0)
Experimente online!
Semelhante à sequência de exemplo, mas cada sub-série é invertida e o valor inicial em cada subsérie é representado por um zero inicial (portanto, 03
para 3, por exemplo).
Se você não gosta dos zeros iniciais, olhe para a versão anterior usando show
(abaixo) ou na resposta de Giuseppe .
R , 23 22 bytes
Editar: -1 byte graças a Robin Ryder
while(T<-T+1)show(1:T)
Experimente online!
Produz a sequência usada no exemplo, além de um número infinito adicional de cópias do número 1
.
Cada número é separado por um espaço "
", uma nova linha mais colchete, " \n[
" ou um colchete mais espaço " [
".
Golfier de 2 bytes (no momento da postagem, pelo menos ...) do que as outras duas respostas R ...
Gelatina , 4 bytes
‘RṄß
Experimente online!
Acho que isso gera todos os números um número infinito de vezes, mas como é um formato de saída diferente, não tenho 100% de certeza
Como funciona
‘RṄß - Main link. Left argument is initially n = 0
‘ - Increment
R - Range
Ṅ - Print
ß - Recursively run the main link
Para n = 0
, ‘RṄ
saídas [1]
. Em seguida, recurse, usando n = [1]
. ‘RṄ
em seguida [[1, 2]]
, produz , e recursamos novamente, usando n = [[1, 2]]
, que produz, [[[1, 2], [1, 2, 3]]]
etc.
Octave , 29 28 bytes
do disp(fix(1/rand)) until 0
Experimente online!
Isso gera uma sequência \$(x_k)\$de números naturais aleatórios independentes e idênticos. Cada valor \$x_k\$é obtido como \$1/r\$arredondado para zero, onde \$r\$tem uma distribuição uniforme no intervalo \$(0,1)\$.
Para um determinado índice \$k\$, e para qualquer \$n \in \mathbb N\$, há uma probabilidade diferente de zero de que \$x_k=n\$(ignorando imprecisões de ponto flutuante). Portanto, com probabilidade \$1\$todo \$n\$aparece infinitamente frequentemente na sequência \$(x_k)\$.
R , 25 21 bytes
repeat T=print(T:0+1)
Experimente online!
Impressões 2..1, 3..1, 4..1
e assim por diante.
Agradecimentos a Robin Ryder por -4 bytes.
Isso funciona porque print
retorna invisivelmente seu primeiro argumento.
Befunge , 5 bytes
>1+?.
Experimente online!
Em cada saída, há uma chance de 50% de o número atual ser impresso e redefinido para 1, e de 50% de chance de 2
ser impresso e o número atual aumentar em algum número ímpar aleatório (seguindo uma distribuição exponencial). Isso pode acontecer várias vezes, portanto, números ímpares também podem ser exibidos.
Todo número natural tem uma probabilidade diferente de zero de ocorrer, então, eventualmente, será impresso infinitas vezes.
Explicação
>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
]:+!
Experimente online!
Uma solução determinística, imprimindo cada faixa de 1 a n
em ordem decrescente.
Explicação
] # 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.
transmitir , 27 bytes
>v
1","@"}
^+^<#-1
1+<<<
Experimente online!

Esta contagem regressiva a partir de números sucessivos.
Linguagem Wolfram (Mathematica) , 25 bytes
Do[Print@n,{m,∞},{n,m}]
Experimente online!
-1 byte @att
Brachylog , 4 bytes
⟦₁ẉ⊥
Experimente online!
ẉ Print with a newline
⟦₁ the range from 1 to something,
⊥ then try again.
J , 13 bytes
$:@,~[echo@#\
Experimente online!
Saídas 1
, 1 2
, 1 2 3 4
, 1 2 3 4 5 6 7 8
, etc, com cada número em sua própria linha.
echo@#\
Produz os comprimentos de prefixo da lista atual, ou seja,1..n
onde n é o comprimento da lista atual. Isso é feito como um efeito colateral.$:@,~
Anexe a lista a si mesma,~
e chame a função recursivamente$:@
.
Ferrugem , 54 bytes
(2..).for_each(|x|(1..x).for_each(|y|print!("{} ",y)))
Experimente online
Ruby , 17 bytes
loop{p *1..$.+=1}
Experimente online!
Carvão , 8 bytes
W¹«I⊕ⅉD⸿
Experimente online! O link é para a versão detalhada do código. Funciona imprimindo repetidamente o próximo número na tela e, em seguida, despejando toda a tela.
2 bytes para uma versão que imprime o \$ n \$º termo de uma sequência:
IΣ
Experimente online! Explicação: Simplesmente imprime a soma digital da entrada. Dado qualquer número natural \$ n \$, todos os valores do formulário \$ \frac { 10 ^ n - 1 } 9 10 ^ m \$tem uma soma digital de \$ n \$para cada \$ m \$, assim, cada número natural aparece com frequência infinita.
C (gcc) , 43 bytes
i;main(j){for(;;)printf("%d ",j=--j?:++i);}
Experimente online!
JavaScript (V8) , 26 bytes
for(a=b='';;)write(a+=--b)
Experimente online!
Caractere -
usado como separador e a saída começa com ele, então não tenho certeza se isso é aceitável.
C (gcc) , 52 49 44 bytes
Economizei 5 bytes graças ao AZTECCO !!!
f(i,j){for(j=1;printf("%d ",j--);)j=j?:++i;}
Experimente online!
Java (JDK) , 61 bytes
v->{for(int i,j=2;;j++)for(i=0;++i<j;)System.out.println(i);}
Experimente online!
Edit: Obrigado @user por cortar alguns bytes e me ajudar a aprender algo hoje! Muito obrigado a @KevinCruijssen por -2 bytes.
Bash, 21 bytes
s(){ seq $[++n];s;};s
1
1
2
1
2
3
…
Execute a versão 21B no teste online
Isso define uma função s
que é executada seq NUMBER
onde NUMBER
começa 1
e incrementa a cada execução e, em seguida, é executada recursivamente. Após a definição, corremos s
.
Pelo custo de 5B para especificar -s\
(o separador é um caractere de espaço), ele pode ser adaptado para uma solução de uma resposta por linha em 26 bytes:
s(){ seq -s\ $[++n];s;};s
1
1 2
1 2 3
…
Execute a versão 26B no teste online
Zsh, 29 .. 19 bytes
Solução de @AdamKatz: Experimente online!
for ((;++i;))seq $i
19 bytes, porta do bash: s(){seq $[++n];s};s
25 bytes (por @AdamKatz): for ((;++i;))echo {1..$i}
25 bytes : for ((;;i++))shuf -i 1-$i
26 bytes (por @AdamKatz): for ((;;))echo {1..$[++i]}
29 bytes : for ((i=1;;))echo {1..$[i++]}
Tentei usar /dev/random
como alternativa, mas estava uma bagunça!
Perl 5 , 22 20 bytes
say while$_.=++$i.$"
Experimente online!
AWK , 34 bytes
{for(;;++i)for(j=0;j++<i;)print j}
Experimente online!
APL (Dyalog Unicode) , 12 11 bytes (SBCS)
Salvo 1 byte graças a @ovs
{∇1+⍴⎕←⍳⍵}1
Experimente online!
Este também usa a sequência da pergunta.