Infinitamente molti ℕ

Question

Sfondo:

Una sequenza di infiniti naturali è una sequenza che contiene ogni numero naturale infinite volte.

Per chiarire, ogni numero deve essere stampato più volte!

La sfida:

Produce una sequenza di infiniti naturali con il codice più breve.

Regole:

1. Ogni numero deve essere separato da una quantità (finita) di caratteri visibili, spazi bianchi o nuove linee che non sono una cifra.
2. Il programma non può terminare (a meno che tu non abbia scritto in qualche modo tutti i numeri).
3. Qualsiasi modo di scrivere una sequenza del genere è accettabile.

Esempi:

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...

Si noti che scriviamo tutti i naturali da 1 a N per tutti N ∈ ℕ.

Commenti e modifiche alla domanda sono i benvenuti. Ispirato dal mio esame di calcolo.

Answer 1

Scratch 3.0 , 13 20 blocchi / 121 70 byte

Come sintassi SB:

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

Questo dice ogni termine nella sequenza. È possibile aggiungere un ritardo in modo che i numeri non si attivino rapidamente.

Non ho mai visto graffi così abusati. Si chiama la funzione nome vuoto con parametri vuoti . Mamma mia. Qualunque cosa salva i byte!

-51 grazie a @att

Provalo su Scratch

Spiegazione in arrivo.

Answer 2

Husk , 2 byte

ḣN

Provalo online!

Prima risposta di Husk! Utilizza anche la sequenza nella domanda

Come funziona

ḣN - Main program
 N - The infinite list [1, 2, 3, ...]
ḣ  - Prefixes; [[1], [1, 2], [1, 2, 3], ...]

Answer 3

05AB1E , 2 byte

∞L

Provalo online! Il piè di pagina formatta l'output come nell'esempio del post.

∞spinge un elenco di tutti i numeri naturali, Lprende l'intervallo [1 .. n]per ogni numero.

Answer 4

R , 26 25 24 byte

-1 byte grazie a Dominic van Essen

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

Provalo online!

Restituisce una sequenza infinita casuale di numeri interi, tratti dal \$Poisson(9)\$distribuzione (+1 per evitare di emettere 0). Vengono prodotti in lotti di 9 alla volta, per una maggiore "efficienza". Qualsiasi valore positivo della media funzionerebbe; usare una media di 9 massimizza la varianza per i numeri di 1 carattere.

Tutti i numeri appaiono infinitamente spesso nel senso che per qualsiasi numero intero \$k\$, il numero previsto di occorrenze di \$k\$nel primo \$n\$le realizzazioni vanno a \$\infty\$come \$n\to\infty\$:

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

Le chiamate a catindicare che ci sono numeri interi all'interno di un batch di 9 sono separati da spazi, ma non esiste un separatore tra i batch. La stragrande maggioranza dei numeri a 3 e 4 cifre nell'output è dovuta a questo artefatto, ma esiste una garanzia teorica che tali numeri (e numeri più grandi) verranno emessi alla fine, almeno se assumiamo che il generatore di numeri casuali sottostante è perfetto.

---

Per una maggiore varianza, possiamo seguire il suggerimento di Giuseppe per lo stesso numero di byte:

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

Provalo online!

Ciò induce più 1se numeri più grandi (inclusi alcuni numeri molto grandi grazie catall'artefatto). Di nuovo, il numero di occorrenze di qualsiasi numero intero va all'infinito quando la dimensione dell'output va all'infinito.

---

Altre due risposte R risultano più brevi, utilizzando metodi deterministici: quella di Giuseppe e quella di Dominic van Essen

Answer 5

Python 2 , 31 byte

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

Provalo online!

Grazie a @Danis per aver salvato un byte qui R+=R[-1]+1,. Questo

Stampe:

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

Accumula un elenco di numeri da 1 a n (tranne che 1 appare due volte) ogni volta aggiungendo l'ultimo elemento più uno.

32 byte

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

Provalo online!

---

Python 2 , 30 byte (congetturato)

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

Provalo online!

La sequenza di \$2^n \bmod n\$( A015910 ) si ipotizza che assuma tutti i valori \$k \geq 0\$tranne \$k=1\$. Non so se è anche ipotizzato che ogni valore appaia infinite volte, ma sembra coerente con soluzioni note per valori specifici .

Invece calcoliamo \$(2^n-1) \bmod n\$, che fa \$0\$piuttosto che \$1\$ essere l'unico valore mancante (se la congettura è valida).

Guardando l'output, potresti pensare che \$2\$non viene mai visualizzato, ma in effetti appare per primo per \$n=4700063497\$e per valori progressivamente superiori in A050259 .

---

Python 2 , 33 byte

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

Provalo online!

È più lungo, ma è piuttosto ingegnoso, stampare la sequenza ABACABA .

Answer 6

Haskell , 17 byte

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

Provalo online!

Poiché la sfida sembra consentire un output non piatto, possiamo semplicemente generare un elenco degli elenchi [1],[1,2],[1,2,3,],..., come suggerito da @AZTECCO.

Haskell , 19 byte

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

Provalo online!

Un elenco piatto infinito definito ricorsivamente con la sequenza ABACABA1,2,1,3,1,2,1,4,... ( A001511 ).

Una variante della stessa lunghezza:

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

Provalo online!

20 byte

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

Provalo online!

Conto alla rovescia 1,1,2,1,2,3,1,2,3,4,..., ma come una lista piatta.

Answer 7

Bash + GNU Coreutils, 20

seq -fseq\ %g inf|sh

Provalo online! - Timeout dopo 60 secondi.

Answer 8

sed 4.2.2 , 20

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

Provalo online!

L'output è unario, secondo questo meta consenso .

Answer 9

Bash , 20 byte

seq inf|xargs -l seq

Provalo online!

Answer 10

R , 21 byte

(anche quasi simultaneamente identificato da Robin Ryder)

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

Provalo online!

Simile alla sequenza di esempio, ma ogni sottoserie è invertita e il valore iniziale in ogni sottoserie è rappresentato con uno zero iniziale (quindi, 03per 3, per esempio).

Se non ti piacciono gli zeri iniziali, guarda la versione precedente usando show(sotto) o la risposta di Giuseppe .

---

R , 23 22 byte

Modifica: -1 byte grazie a Robin Ryder

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

Provalo online!

Emette la sequenza utilizzata nell'esempio, più un numero infinito aggiuntivo di copie del numero 1.
Ogni numero è separato da uno spazio " ", una nuova riga più parentesi, " \n[" o una parentesi più spazio " [ ".

2 byte più golfisti (al momento del post, almeno ...) rispetto alle altre due risposte R ...

Answer 11

Gelatina , 4 byte

‘RṄß

Provalo online!

Penso che questo restituisca tutti i numeri un numero infinito di volte, ma poiché si tratta di un formato di output diverso, non ne sono sicuro al 100%

Come funziona

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

Per n = 0, ‘RṄuscite [1]. Quindi ricorriamo, usando n = [1]. ‘RṄquindi le uscite [[1, 2]], e ricorriamo di nuovo, usando n = [[1, 2]], quali uscite [[[1, 2], [1, 2, 3]]]ecc.

Answer 12

Ottava , 29 28 byte

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

Provalo online!

Questo produce una sequenza \$(x_k)\$di numeri naturali casuali indipendenti e identicamente distribuiti. Ogni valore \$x_k\$si ottiene come \$1/r\$arrotondato verso zero, dove \$r\$ha una distribuzione uniforme sull'intervallo \$(0,1)\$.

Per un dato indice \$k\$e per qualsiasi \$n \in \mathbb N\$, esiste una probabilità diversa da zero che \$x_k=n\$(ignorando le imprecisioni in virgola mobile). Pertanto, con probabilità \$1\$ogni \$n\$appare infinitamente spesso nella sequenza \$(x_k)\$.

Answer 13

R , 25 21 byte

repeat T=print(T:0+1)

Provalo online!

Stampe 2..1, 3..1, 4..1e così via.

Grazie a Robin Ryder per -4 byte.

Funziona perché printrestituisce invisibilmente il suo primo argomento.

Answer 14

Befunge , 5 byte

>1+?.

Provalo online!

Ad ogni uscita, c'è una probabilità del 50% che il numero corrente venga stampato e reimpostato a 1, e una probabilità del 50% che 2verrà stampato e il numero corrente aumenterà di un numero dispari casuale (seguendo una distribuzione esponenziale). Questo può accadere più volte, quindi anche i numeri dispari possono essere emessi.

Ogni numero naturale ha una probabilità diversa da zero di verificarsi, quindi verrà stampato infinite volte.

Spiegazione

>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 byte

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

Provalo online!

Una soluzione deterministica, stampando ogni intervallo da 1 a nin ordine decrescente.

Spiegazione

]           # 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.

Answer 15

trasmettere , 27 byte

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

Provalo online!

Conta alla rovescia dai numeri successivi.

Answer 16

Wolfram Language (Mathematica) , 25 byte

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

Provalo online!

-1 byte @att

Answer 17

Brachylog , 4 byte

⟦₁ẉ⊥

Provalo online!

  ẉ     Print with a newline
⟦₁      the range from 1 to something,
   ⊥    then try again.

Answer 18

J , 13 byte

$:@,~[echo@#\

Provalo online!

Uscite 1, 1 2, 1 2 3 4, 1 2 3 4 5 6 7 8, ecc, con ogni numero sulla propria riga.

• echo@#\Emette le lunghezze del prefisso dell'elenco corrente, cioè, 1..ndove n è la lunghezza dell'elenco corrente. Questo viene fatto come effetto collaterale.
• $:@,~Aggiungi l'elenco a se stesso ,~e chiama la funzione in modo ricorsivo $:@.

Answer 19

Ruggine , 54 byte

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

Provalo online

Answer 20

Ruby , 17 byte

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

Provalo online!

Answer 21

Carboncino , 8 byte

Ｗ¹«Ｉ⊕ⅉＤ⸿

Provalo online! Il collegamento è alla versione dettagliata del codice. Funziona stampando ripetutamente il numero successivo sulla tela e quindi scaricando l'intera tela.

2 byte per una versione che stampa il \$ n \$esimo termine di una sequenza:

ＩΣ

Provalo online! Spiegazione: Stampa semplicemente la somma digitale dell'ingresso. Dato qualsiasi numero naturale \$ n \$, tutti i valori del modulo \$ \frac { 10 ^ n - 1 } 9 10 ^ m \$avere una somma digitale di \$ n \$per ogni \$ m \$, così ogni numero naturale appare infinitamente spesso.

Answer 22

C (gcc) , 43 byte

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

Provalo online!

Answer 23

JavaScript (V8) , 26 byte

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

Provalo online!

Carattere -utilizzato come separatore e l'output inizia con esso, quindi non sono sicuro che sia accettabile.

Answer 24

C (gcc) , ^{52 49} 44 byte

Salvati 5 byte grazie ad AZTECCO !!!

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

Provalo online!

Answer 25

Java (JDK) , 61 byte

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

Provalo online!

Modifica: grazie @user per aver ridotto alcuni byte e avermi aiutato a imparare qualcosa oggi! Grazie mille a @KevinCruijssen per -2 byte.

Answer 26

Bash, 21 byte

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

1
1
2
1
2
3
…

Esegui la versione 21B su Provalo online

Definisce una funzione sche viene eseguita da seq NUMBERdove NUMBERinizia 1e aumenta con ogni esecuzione, quindi viene eseguita in modo ricorsivo. Dopo la definizione, corriamo s.

Per il costo di 5B da specificare -s\ (il separatore è un carattere spazio), può essere adattato a una soluzione di una risposta per riga a 26 byte:

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

1
1 2
1 2 3
…

Esegui la versione 26B su Provalo online

Answer 27

Zsh, 29 .. 19 byte

Soluzione di @AdamKatz: provalo online!

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

_{19 byte, porta da bash: s(){seq $[++n];s};s
25 byte (per @AdamKatz): for ((;++i;))echo {1..$i}
25 byte : for ((;;i++))shuf -i 1-$i
26 byte (per @AdamKatz): for ((;;))echo {1..$[++i]}
29 byte : for ((i=1;;))echo {1..$[i++]}
ho provato a usare /dev/randomun'alternativa ma è stato un casino!}

Answer 28

Perl 5 , 22 20 byte

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

Provalo online!

Answer 29

AWK , 34 byte

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

Provalo online!

Answer 30

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

Salvato 1 byte grazie a @ovs

{∇1+⍴⎕←⍳⍵}1

Provalo online!

Anche questo usa la sequenza della domanda.