Infinitamente muitos ℕ

Nov 30 2020

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:

  1. 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.
  2. O programa não pode terminar (a menos que você de alguma forma tenha escrito todos os números).
  3. 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

23 Lyxal Nov 30 2020 at 21:03

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.

17 cairdcoinheringaahing Nov 30 2020 at 18:18

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], ...]
15 ovs Nov 30 2020 at 18:14

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, Lpega o intervalo [1 .. n]de cada número.

13 RobinRyder Nov 30 2020 at 18:59

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 catsignificam 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 1s e mais números grandes (incluindo alguns números muito grandes graças ao catartefato). 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

10 xnor Dec 01 2020 at 07:26

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 .

9 xnor Nov 30 2020 at 23:38

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.

7 DigitalTrauma Nov 30 2020 at 18:18

Bash + GNU Coreutils, 20

seq -fseq\ %g inf|sh

Experimente online! - Tempo limite após 60 segundos.

7 DigitalTrauma Nov 30 2020 at 18:29

sed 4.2.2 , 20

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

Experimente online!

A saída é unária, de acordo com este meta consenso .

7 Mukundan314 Dec 01 2020 at 04:51

Bash , 20 bytes

seq inf|xargs -l seq

Experimente online!

6 DominicvanEssen Dec 01 2020 at 08:36

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, 03para 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 ...

5 cairdcoinheringaahing Nov 30 2020 at 17:58

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.

5 LuisMendo Nov 30 2020 at 19:28

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)\$.

5 Giuseppe Nov 30 2020 at 23:06

R , 25 21 bytes

repeat T=print(T:0+1)

Experimente online!

Impressões 2..1, 3..1, 4..1e assim por diante.

Agradecimentos a Robin Ryder por -4 bytes.

Isso funciona porque printretorna invisivelmente seu primeiro argumento.

5 PizgenalFilegav Dec 02 2020 at 03:18

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 2ser 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 nem 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.
4 WheatWizard Dec 17 2020 at 23:21

transmitir , 27 bytes

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

Experimente online!

Esta contagem regressiva a partir de números sucessivos.

4 J42161217 Nov 30 2020 at 18:20

Linguagem Wolfram (Mathematica) , 25 bytes

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

Experimente online!

-1 byte @att

3 UnrelatedString Nov 30 2020 at 18:40

Brachylog , 4 bytes

⟦₁ẉ⊥

Experimente online!

  ẉ     Print with a newline
⟦₁      the range from 1 to something,
   ⊥    then try again.
3 Jonah Nov 30 2020 at 20:00

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..nonde n é o comprimento da lista atual. Isso é feito como um efeito colateral.
  • $:@,~Anexe a lista a si mesma ,~e chame a função recursivamente $:@.
3 Edgar Dec 01 2020 at 00:29

Ferrugem , 54 bytes

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

Experimente online

3 Sisyphus Dec 01 2020 at 00:59

Ruby , 17 bytes

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

Experimente online!

3 Neil Nov 30 2020 at 23:00

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.

3 Sisyphus Dec 01 2020 at 01:04

C (gcc) , 43 bytes

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

Experimente online!

3 NinaLisitsinskaya Dec 01 2020 at 05:42

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.

3 Noodle9 Nov 30 2020 at 18:26

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!

3 DMiddendorf Nov 30 2020 at 20:13

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.

3 AdamKatz Dec 03 2020 at 20:41

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 sque é executada seq NUMBERonde NUMBERcomeça 1e 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

3 roblogic Dec 01 2020 at 11:40

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/randomcomo alternativa, mas estava uma bagunça!

3 Xcali Nov 30 2020 at 19:51

Perl 5 , 22 20 bytes

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

Experimente online!

2 Noodle9 Nov 30 2020 at 21:38

AWK , 34 bytes

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

Experimente online!

2 user Nov 30 2020 at 18:18

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.