Infinitamente muchos ℕ
Antecedentes:
Una secuencia de infinitos naturales es una secuencia que contiene cada número natural infinitamente muchas veces.
Para aclarar, ¡ cada número debe imprimirse varias veces!
El reto:
Genere una secuencia de infinitos naturales con el código más corto.
Reglas:
- Cada número debe estar separado por una cantidad (finita) de caracteres visibles, espacios en blanco o de nueva línea que no sean dígitos.
- El programa no puede terminar (a menos que de alguna manera haya escrito todos los números).
- Cualquier forma de escribir tal secuencia es aceptable.
Ejemplos:
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 escribimos todos los naturales de 1 a N para todos los N ∈ ℕ.
Se agradecen los comentarios y las modificaciones a la pregunta. Inspirado por mi examen de cálculo.
Respuestas
Scratch 3.0 , 13 20 bloques / 121 70 bytes
Como SB Syntax:
define(n)(i
say(i
((n)+<(i)=(n)>)((1)+((i)*<(i)<(n
Esto dice cada término de la secuencia. Se puede agregar un retraso para que los números no se disparen rápidamente.
Nunca había visto a scratch tan maltratado. Llamas a la función de nombre vacía con parámetros vacíos . Dios mío. ¡Lo que sea que ahorre bytes!
-51 gracias a @att
Pruébalo en Scratch
Explicación próximamente.
Cáscara , 2 bytes
ḣN
¡Pruébelo en línea!
¡Primera respuesta de Husk! También usa la secuencia en la pregunta
Cómo funciona
ḣN - Main program
N - The infinite list [1, 2, 3, ...]
ḣ - Prefixes; [[1], [1, 2], [1, 2, 3], ...]
05AB1E , 2 bytes
∞L
¡Pruébelo en línea! El pie de página formatea la salida como el ejemplo de la publicación.
∞empuja una lista de todos los números naturales, Ltoma el rango [1 .. n]para cada número.
R , 26 25 24 bytes
-1 byte gracias a Dominic van Essen
repeat cat(rpois(9,9)+1)
¡Pruébelo en línea!
Produce una secuencia infinita aleatoria de números enteros, extraída de \$Poisson(9)\$distribución (+1 para evitar generar ceros). Se producen en lotes de 9 a la vez, para una mayor "eficiencia". Cualquier valor positivo de la media funcionaría; el uso de una media de 9 maximiza la varianza para números de 1 carácter.
Todos los números aparecen infinitamente a menudo en el sentido de que para cualquier entero \$k\$, el número esperado de apariciones de \$k\$en el primer \$n\$las realizaciones van a \$\infty\$como \$n\to\infty\$:
$$E\left[\sum_{i=1}^n\mathbb{I}_{X_i=k}\right]\xrightarrow[n\to\infty]{}\infty.$$
Las llamadas catsignifican que hay números enteros dentro de un lote de 9 separados por espacios, pero no hay un separador entre lotes. La gran mayoría de los números de 3 y 4 dígitos en la salida se deben a este artefacto, pero existe una garantía teórica de que dichos números (y números más grandes) se generarán eventualmente, al menos si asumimos que el generador de números aleatorios subyacente es perfecto.
Para una variación mayor, podemos seguir la sugerencia de Giuseppe para el mismo recuento de bytes:
repeat cat(1%/%runif(9))
¡Pruébelo en línea!
Esto induce más 1sy más números grandes (incluidos algunos números muy grandes gracias al catartefacto). Nuevamente, el número de apariciones de cualquier número entero llega al infinito cuando el tamaño de la salida llega al infinito.
Otras dos respuestas R resultan más breves, utilizando métodos deterministas: Giuseppe y Dominic van Essen
Python 2 , 31 bytes
R=1,
while 1:print R;R+=len(R),
¡Pruébelo en línea!
Gracias a @Danis por guardar un byte aquí R+=R[-1]+1,. Esta
Huellas dactilares:
(1,)
(1, 1)
(1, 1, 2)
(1, 1, 2, 3)
(1, 1, 2, 3, 4)
(1, 1, 2, 3, 4, 5)
...
Acumula una lista de números del 1 al n (excepto que 1 aparece dos veces) cada vez que agrega el último elemento más uno.
32 bytes
R=[1]
for x in R:print R;R+=x+1,
¡Pruébelo en línea!
Python 2 , 30 bytes (conjeturado)
n=2
while 1:print~-2**n%n;n+=1
¡Pruébelo en línea!
La secuencia de \$2^n \bmod n\$( A015910 ) se conjetura que toma todos los valores \$k \geq 0\$excepto \$k=1\$. No sé si también se conjetura que cada valor aparece infinitamente muchas veces, pero parece consistente con soluciones conocidas para valores específicos .
En su lugar, calculamos \$(2^n-1) \bmod n\$, lo que hace \$0\$en lugar de \$1\$ ser el único valor que falta (si la conjetura es válida).
Mirando la salida, podría pensar que \$2\$nunca sale, pero de hecho aparece primero para \$n=4700063497\$y para valores progresivamente más altos en A050259 .
Python 2 , 33 bytes
R=[1]
for x in R:print x;R+=x+1,1
¡Pruébelo en línea!
Esto es más largo, pero es bastante ingenioso, imprimiendo la secuencia ABACABA .
Haskell , 17 bytes
[[1..x]|x<-[1..]]
¡Pruébelo en línea!
Dado que el desafío parece permitir una salida no plana, simplemente podemos generar una lista de las listas [1],[1,2],[1,2,3,],..., como lo sugiere @AZTECCO.
Haskell , 19 bytes
l=1:do x<-l;[x+1,1]
¡Pruébelo en línea!
Una lista plana infinita definida de forma recursiva con la secuencia ABACABA 1,2,1,3,1,2,1,4,... ( A001511 ).
Una variante de la misma longitud:
l=(:[1]).succ=<<0:l
¡Pruébelo en línea!
20 bytes
l=do x<-[1..];[1..x]
¡Pruébelo en línea!
Contando 1,1,2,1,2,3,1,2,3,4,..., pero como una lista plana.
Bash + GNU Coreutils, 20
seq -fseq\ %g inf|sh
¡Pruébelo en línea! - Se agota después de 60 segundos.
sed 4.2.2 , 20
:;s/(1*).*/1\1 &/p;b
¡Pruébelo en línea!
La salida está en unario, según este meta consenso .
Bash , 20 bytes
seq inf|xargs -l seq
¡Pruébelo en línea!
R , 21 bytes
(también identificado casi simultáneamente por Robin Ryder)
while(T<-T+1)cat(T:0)
¡Pruébelo en línea!
Similar a la secuencia del ejemplo, pero cada subserie se invierte y el valor inicial en cada subserie se representa con un cero inicial ( 03por ejemplo , para 3).
Si no le gustan los ceros iniciales, mire la versión anterior usando show(abajo), o la respuesta de Giuseppe .
R , 23 22 bytes
Editar: -1 byte gracias a Robin Ryder
while(T<-T+1)show(1:T)
¡Pruébelo en línea!
Muestra la secuencia utilizada en el ejemplo, más un número infinito adicional de copias del número 1.
Cada número está separado por un espacio " ", una nueva línea más un corchete, " \n[" o un corchete más un espacio " [ ".
2 bytes más golfista (en el momento de la publicación, al menos ...) que las otras dos respuestas R ...
Gelatina , 4 bytes
‘RṄß
¡Pruébelo en línea!
Creo que esto genera todos los números una cantidad infinita de veces, pero debido a que es un formato de salida diferente, no estoy 100% seguro
Cómo funciona
‘RṄß - Main link. Left argument is initially n = 0
‘ - Increment
R - Range
Ṅ - Print
ß - Recursively run the main link
Para n = 0, ‘RṄsalidas [1]. Luego recurrimos, usando n = [1]. ‘RṄluego salidas [[1, 2]], y recurrimos de nuevo, usando n = [[1, 2]], qué salidas, [[[1, 2], [1, 2, 3]]]etc.
Octava , 29 28 bytes
do disp(fix(1/rand)) until 0
¡Pruébelo en línea!
Esto genera una secuencia \$(x_k)\$de números naturales aleatorios independientes distribuidos de forma idéntica. Cada valor \$x_k\$se obtiene como \$1/r\$redondeado hacia cero, donde \$r\$tiene una distribución uniforme en el intervalo \$(0,1)\$.
Para un índice dado \$k\$y para cualquier \$n \in \mathbb N\$, hay una probabilidad distinta de cero de que \$x_k=n\$(ignorando las inexactitudes del punto flotante). Por tanto, con probabilidad \$1\$cada \$n\$aparece infinitamente a menudo en la secuencia \$(x_k)\$.
R , 25 21 bytes
repeat T=print(T:0+1)
¡Pruébelo en línea!
Impresiones, 2..1, 3..1, 4..1etc.
Gracias a Robin Ryder por -4 bytes.
Esto funciona porque printdevuelve de forma invisible su primer argumento.
Befunge , 5 bytes
>1+?.
¡Pruébelo en línea!
En cada salida, hay un 50% de probabilidad de que el número actual se imprima y se restablezca a 1, y un 50% de probabilidad de que 2se imprima y el número actual aumente en algún número impar aleatorio (siguiendo una distribución exponencial). Esto puede suceder varias veces, por lo que también se pueden generar números impares.
Cada número natural tiene una probabilidad de ocurrir distinta de cero, por lo que eventualmente se imprimirá infinitas veces.
Explicación
>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
]:+!
¡Pruébelo en línea!
Una solución determinística, imprimiendo cada rango de 1 a nen orden descendente.
Explicación
] # 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+<<<
¡Pruébelo en línea!
Esta cuenta regresiva de números sucesivos.
Wolfram Language (Mathematica) , 25 bytes
Do[Print@n,{m,∞},{n,m}]
¡Pruébelo en línea!
-1 byte @att
Brachylog , 4 bytes
⟦₁ẉ⊥
¡Pruébelo en línea!
ẉ Print with a newline
⟦₁ the range from 1 to something,
⊥ then try again.
J , 13 bytes
$:@,~[echo@#\
¡Pruébelo en línea!
Salidas 1, 1 2, 1 2 3 4, 1 2 3 4 5 6 7 8, etc, con cada número en su propia línea.
echo@#\Muestra las longitudes de prefijo de la lista actual, es decir,1..ndonde n es la longitud de la lista actual. Esto se hace como efecto secundario.$:@,~Anexa la lista a sí misma,~y llama a la función de forma recursiva$:@.
Óxido , 54 bytes
(2..).for_each(|x|(1..x).for_each(|y|print!("{} ",y)))
Pruébelo en línea
Rubí , 17 bytes
loop{p *1..$.+=1}
¡Pruébelo en línea!
Carbón , 8 bytes
Ｗ¹«Ｉ⊕ⅉＤ⸿
¡Pruébelo en línea! El enlace corresponde a la versión detallada del código. Funciona imprimiendo repetidamente el siguiente número en el lienzo y luego volcando todo el lienzo.
2 bytes para una versión que imprime el \$ n \$el término de una secuencia:
ＩΣ
¡Pruébelo en línea! Explicación: Simplemente imprime la suma digital de la entrada. Dado cualquier número natural \$ n \$, todos los valores de la forma \$ \frac { 10 ^ n - 1 } 9 10 ^ m \$tener una suma digital de \$ n \$por cada \$ m \$, así cada número natural aparece infinitamente a menudo.
C (gcc) , 43 bytes
i;main(j){for(;;)printf("%d ",j=--j?:++i);}
¡Pruébelo en línea!
JavaScript (V8) , 26 bytes
for(a=b='';;)write(a+=--b)
¡Pruébelo en línea!
El carácter se -usa como separador y la salida comienza con él, por lo que no estoy realmente seguro de si esto es aceptable.
C (gcc) , 52 49 44 bytes
5 bytes guardados gracias a AZTECCO !!!
f(i,j){for(j=1;printf("%d ",j--);)j=j?:++i;}
¡Pruébelo en línea!
Java (JDK) , 61 bytes
v->{for(int i,j=2;;j++)for(i=0;++i<j;)System.out.println(i);}
¡Pruébelo en línea!
Editar: ¡Gracias @usuario por recortar algunos bytes y ayudarme a aprender algo hoy! Muchas gracias a @KevinCruijssen por -2 bytes.
Bash, 21 bytes
s(){ seq $[++n];s;};s
1
1
2
1
2
3
…
Ejecute la versión 21B en Try It Online
Esto define una función sque se ejecuta seq NUMBERdonde NUMBERcomienza 1y se incrementa con cada ejecución, luego se ejecuta de forma recursiva. Después de la definición, corremos s.
Para especificar el costo de 5B -s\ (el separador es un carácter de espacio), se puede adaptar a una solución de una respuesta por línea a 26 bytes:
s(){ seq -s\ $[++n];s;};s
1
1 2
1 2 3
…
Ejecute la versión 26B en Try It Online
Zsh, 29 .. 19 bytes
Solución de @AdamKatz: ¡ Pruébelo en línea!
for ((;++i;))seq $i
19 bytes, puerto de 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++]}
Traté de usar /dev/randomuna alternativa, ¡pero fue un desastre!
Perl 5 , 22 20 bytes
say while$_.=++$i.$"
¡Pruébelo en línea!
AWK , 34 bytes
{for(;;++i)for(j=0;j++<i;)print j}
¡Pruébelo en línea!
APL (Dyalog Unicode) , 12 11 bytes (SBCS)
1 byte guardado gracias a @ovs
{∇1+⍴⎕←⍳⍵}1
¡Pruébelo en línea!
Este también usa la secuencia de la pregunta.