^{No es un engaño a esto . Esa pregunta pide específicamente contar para siempre, mientras que esta pregunta permite muchos otros enfoques.}

Escriba un programa o función que, dado el tiempo y la memoria infinitos, imprima una salida no periódica infinita.

Aclaraciones

• 'Infinito' significa que la solución sigue generando algo sin más entradas u operaciones después de iniciar con éxito el programa o la función.
• 'No periódico' significa que la salida no tiene posibilidad de repetir eventualmente la misma sección para siempre (independientemente de la duración de ese período). Un ejemplo de una solución válida sería imprimir los dígitos de un número irracional.
• Las soluciones aleatorias no contarían a menos que pueda probar que cumple con los requisitos. Las soluciones basadas en fecha / hora también pueden no ser válidas si no se almacenan con precisión arbitraria.

Ganador

El código más corto (en bytes) gana.

Hexagonía , 2 bytes.

(!

Pruébalo en línea!

El código fuente desplegado se ve así:

 ( !
. . .
 . .

Esto solo ejecuta estos dos comandos en un bucle, que son decrement ( () e print ( !). Por lo tanto, la salida es:

-1-2-3-4-5-6-7-8-9-10-11-12...

Necesitamos usar decremento en lugar de incremento para asegurarnos de que el programa regrese a la primera línea (si el valor de la memoria fue positivo, Hexagony realizaría un bucle entre la segunda y la tercera línea y terminaría en un bucle infinito sin hacer nada).

Python 2 , 23 bytes

while 1:print id;id=id,

Pruébalo en línea!

Huellas dactilares

<built-in function id>
(<built-in function id>,)
((<built-in function id>,),)
(((<built-in function id>,),),)
((((<built-in function id>,),),),)

y así. Comienza con la función incorporada id, el nombre de variable preinicializado más corto, y lo convierte repetidamente en una tupla de sí mismo.

En Python 3, esta solución tarda un byte más print(), pero el byte se puede recuperar de la printsalida None:

while 1:id=print(id),id

o

while[print(id)]:id=id,

Laberinto , 3 bytes

#:!

Pruébalo en línea!

Imprime todos los enteros pares no negativos sin separador:

024681012141618202224262830323436384042...

La IP rebota de un lado a otro en el código, por lo que esto realmente está #:!:en un bucle:

#  Push stack depth.
:  Duplicate.
!  Print.
:  Duplicate.

Un montón de alternativas:

:#!     Prints all positive odd integers.
:)!     Prints all positive integers.
):!     Prints all positive integers.
:(!     Prints all negative integers.
(:!     Prints all negative integers.

Brachylog , 2 bytes

ẉ⊥

Pruébalo en línea!

Esto imprime todos los enteros ordenados por magnitud. Esto nunca se desbordará e imprimirá enteros ya vistos ya que Brachylog usa enteros ilimitados de forma predeterminada.

Explicación

ẉ      Writeln: the Input is anything, so we label it implicitely to an integer and write it
 ⊥     False: backtrack and try another integer value for the Input

> <>, 3 bytes

l:n

Emite una secuencia de números, contando desde 0.

Creo que los números incrementales no circulan ...

Explicación:

l empuja la longitud de la pila sobre la pila

: duplica el valor de la pila superior sobre la pila

n da salida al valor como número

Cuando la línea termina, vuelve al principio, por lo que lo vuelve a hacer, pero ahora la pila es más larga ...

en línea

PHP, 20 bytes

for(;;)echo$argc.=0;

Salidas esto:

101001000100001000001000000100000001000000001000000000...

Si se proporcionan argumentos de línea de comando, la salida será diferente, pero aún no periódica.

Hasta donde entiendo la documentación, el lenguaje en sí no restringe la longitud de las cadenas.

JavaScript, 26 22 20 bytes

for(;;)alert(Date())

(Advertencia: es malvado)

Haskell - 10 bytes

print[1..] 

Aunque en ghci podría escribir [1 ..] y eso comenzaría a imprimir automáticamente.

Brainfuck, 13 Bytes, asumiendo que no hay modulación superior pero salida 256

+[[->+++.<]>]

código de salida 2 2 4 6 2 4 6 8 10 12 14 16 18 ...

lo siento, el antiguo bucle de impresión de código 0 2 4 6 ... 254,

Brainfuck, 13 12 Bytes (-1 de Jo King)

+[[>.]<[<]+]

código char de salida 0 1 0 1 1 0 1 1 1 0 ...

Jalea , 3 bytes

‘Ȯß

Pruébalo en línea! - trunca la salida y genera un error, pero durará mucho más localmente (hasta que se agote la memoria).

Con una entrada implícita de cero, este programa consiste en un único enlace que incrementa ‘, imprime Ȯy luego se llama a sí mismo con el nuevo valor ß,.

MATL, 4 bytes

`@tD

Esta solución crea un whilebucle que empuja el índice del bucle a la pila, lo duplica, imprime el valor y luego comprueba que el índice del bucle no sea cero para repetirlo nuevamente.

Pruébalo en línea!

RProgN 2 , 13 bytes

2{22.`2=2p2}:

Hay muchos dos en la salida, separados por nuevas líneas progresivamente más espaciadas.

2{22.`2=2p2}:
2               # Push a two to the stack
 {         }:   # While the top of the stack is truthy
  22.           # Push the value of "2" twice, and concatenate them together.
     `2=        # Set the value of "2" to this.
        2p      # Print the value of "2"
          2     # And push the value of "2"

Que imprime 2 ^ n 2s seguido de una nueva línea para cada iteración.

Pruébalo en línea!

Befunge , 4 bytes

1+:.

Pruébalo en línea!

En Befunge, la pila no tiene fondo y tiene ceros infinitos. Eso dijo:

1+ agrega uno a la parte superior de la pila

: duplica la parte superior de la pila

. imprime el valor ASCII de la parte superior de la pila como un número

Y continúa infinitamente, porque no hay forma @de detener la ejecución. Este es en realidad uno de esos problemas más fáciles de resolver por la forma en que funciona befunge ... raro.

APL (Dyalog APL) , 8 bytes

{∇⎕←0⍵}1

{emsp; una función anónima ...

 ∇ recurse en

 ⎕ ← salida a STDOUT

 0 ⍵ la lista de dos elementos que consiste en un cero y el argumento

} aplicado al número uno

Este salidas (en líneas separadas) [0,1], [0,[0,1]], [0,[0,[0,1]]], etc.

Procesamiento, 30 29 bytes

1 byte guardado gracias a QwerpDerp por usar en millis()lugar deframeRate

void draw(){print(millis());}

Imprime continuamente el número de milisegundos desde el inicio del programa.

Salida de muestra:

3573743914054244404574734925085205375585755916...

C (gcc) , 83 81 bytes

*p,*t,*g;f(){for(t=p=malloc(1),g=--t;t<p?putchar(55):(t=g,*p++,putchar(9));t++);}

Primero asignando un puntero en el montón, la función luego cuenta hacia atrás en las direcciones de memoria hasta que se produzca una falla predeterminada *p++, por lo tanto, está limitada por la cantidad de memoria en el sistema en lugar de los tipos de datos utilizados que de otro modo eventualmente se desbordarían y repetirían la serie. Dada una memoria infinita con capacidad de direccionamiento infinito, continuaría para siempre.

Pruébalo en línea!

7 , 2 bytes

Los personajes que componen este programa son:

240223

Al ver el archivo en un editor, es probable que intente interpretarlo como ASCII, en cuyo caso se ve así:

P$

Pruébalo en línea!

El programa toma entrada. He asumido aquí que la entrada está en EOF; si le proporciona información, es posible que se bloquee.

Explicación

Iteración cero

240223
240223 Agrega 240223 al elemento de la pila superior

Todo el programa aquí es pasivo, por lo que agregará una versión activa de sí mismo al elemento de la pila superior (que inicialmente está vacío). El programa está en un bucle implícito, que evalúa el elemento de la pila superior (mientras lo deja en la pila) cada iteración. Entonces se ejecutará la versión activa. (Casi todos los 7 programas comienzan así).

Primera iteración

240223 
2        Copie el elemento de la pila superior
  40      Escape del segundo elemento de la pila, intercambiándolo a la parte superior
    2     Copie el elemento de   la pila superior 23 Imprima el elemento
     de la pila superior

Antes del comando de salida, la pila contiene dos copias de 240223(es decir, pasivo). El primero obtiene salida (sin ningún efecto observable que no sea seleccionar el formato de salida 2, "números"), el siguiente permanece y se convierte en el programa para la próxima iteración.

Segunda iteración

240223
240223 Agrega 240223 al elemento de la pila superior

Lo mismo que la iteración cero, ¿verdad? No exactamente; la pila tenía diferentes contenidos. La pila está ahora 240223debajo .240223240223

Tercera iteración

240 223 240 223 
240 223         Anexar 240223 al elemento de pila superior
       2        Copia la pila superior elemento
       40      Escape del segundo elemento de la pila, el intercambio a la parte superior
          2     Copiar el elemento de la pila superior
           23   de salida del elemento de pila superior

Esto genera un elemento de pila que tiene tres 6s-y-0 más que 7s-y-1s. El formato de salida 2 interpreta esto como una solicitud para ingresar un número. Leemos EOF, con la consecuencia de que el siguiente elemento en la pila se reduce a una cadena de longitud cero. Sin embargo, debido a un error (que parece ligeramente útil y puede ser promovido a una función), esto solo ocurre después de que comienza a ejecutarse. La pila una vez más tiene dos elementos, a 240223continuación , pero la versión escapada de este elemento superior , ahora se está ejecutando.24022324022324022372402236240223240223

Cuarta iteración

7 240223 6 240223240223
 7 240223 6 240223240223 Agregar 240223 240223240223 a la parte superior de la pila

La parte superior de la pila era una cadena de longitud cero, por lo que básicamente estamos eliminando el programa que terminó allí.

Quinta iteración

240223 240223240223 
240223               Anexar 240223 al elemento de pila superior
       2              Copiar el elemento de pila superior
       40            Escapar del segundo elemento de pila, intercambiarlo a la parte superior
          2           Copiar el elemento de pila superior
           23         Producir el elemento de pila superior
       2        Copiar el elemento de pila superior
       40      Escapar el segundo elemento de pila, intercambiándolo a la parte superior
          2     Copie el elemento de pila superior
           23   Imprima el elemento de pila superior

Esto es muy similar a la tercera iteración. Sin embargo, hay dos cambios. Primero, ahora hay 4 0 y 6 más que los 1 y 7, por lo que intentaremos ingresar un carácter desde la entrada estándar en lugar de un número. Sin embargo, todavía obtenemos EOF y, como resultado, seguimos reduciendo la parte superior de la pila a una cadena de longitud cero. A continuación, se ejecuta código después de la reducción, por lo que la siguiente iteración no comienza de inmediato. Más bien, hacemos un montón de operaciones en ese elemento de longitud cero, terminando con tres elementos de longitud cero. Producimos uno, los otros dos desaparecen (porque es el final de una iteración), y terminamos básicamente donde estábamos al final de la tercera iteración.

Sexta iteración

El programa que copiamos desde la parte superior de la pila es ahora . Todo funciona como en la iteración anterior hasta llegar a la primera instrucción de salida (la primera ). Esto ahora tiene cinco 0 y 6 más que los 1 y 7, por lo que establece un modo en el que la siguiente instrucción de salida se interpretará como una solicitud para cambiar el formato de salida. Esto también conduce a un cambio notable en el comportamiento; como no hubo solicitud de entrada, no leímos EOF y, por lo tanto, no desencadenamos la consecuencia de leer EOF (el nuevo elemento de pila superior está en blanco) y, como tal, la versión escapada del elemento de pila original permanece en lugar de ser remoto. Esto significa que el próximo240223240223240223240223232402ya no es un no-op, creando dos copias con escape del elemento de pila con escape (es decir, ahora tienen doble escape). Generamos uno, configurando el formato de salida a 7 ("igual que la entrada"); este formato de salida no tiene comandos de E / S ni comandos para cambiar el formato, por lo que permaneceremos en él durante el resto del programa. También enviamos 724022362402232402232402232402236(en la misma codificación que la entrada) a la salida estándar.

De todos modos, está bastante claro lo que el programa va a hacer a partir de este momento: es una combinación de agregar varios números de copias que se escapan de varias maneras 240223a la parte superior de la pila, escapar de la parte superior de la pila y generar copias de la parte superior de la pila. A partir de este punto, el elemento de la pila superior nunca se borra (porque nunca leemos EOF), por lo que solo crece y crece y crece. El escape periódico garantiza que la salida nunca se repita (porque significa que en cada iteración, la primera salida comienza con al menos una más 7que en la iteración anterior).

Ohm , 4 bytes (CP437)

¼,¡∞

Imprime la variable del contador, la incrementa y entra en un bucle infinito. Suficientemente simple.

EDITAR (1 de marzo de 2017): mientras estaba en el proceso de hacer otras actualizaciones (después de publicar esta respuesta), cambié el comportamiento de ∞. La respuesta actualizada sería ∞^,.

DC "moderno" , 9 bytes

Memoria infinita?
Entonces, ¿una pila en continuo crecimiento está bien?
] :-)

[zprdx]dx

Comentado:

[         # start string constant
 z        #   push current stack depth
  p       #   print TOS without removing
   r      #   swap TOS and NOS
    d     #   duplicate TOS
     x    #   pop TOS and interprete it
      ]   # end string constant, push it
       d  # duplicate TOS
        x # pop TOS and interprete it

Debido al uso del rcomando, esto no se ejecutará en algunos DC antiguos.

Ruby, 21 12 bytes

loop{p$.+=1}

Imprime todos los números naturales. Hasta donde entiendo la descripción del problema, esto debería estar bien.

PHP, 21 bytes

for(;;)echo uniqid();

Uso: php -r "for(;;)echo uniqid();"

Produce ID únicos basados ​​en la hora actual en microsegundos: 58b3e065e4b4c58b3e065e4b6358b3e065e4b7b58b3e065e4b9458b3e065e4bac58b3e065e4bc458b3e065e4bdc58b3e065e4bf558b3e065e4c0e58b3e065e4c2658b3e065e4c3e58b3e065e4c5658b3e065e4c6f58b3e065e4c8758b3e065e4c9f...

como una secuencia continua de: 58b3e09390617 58b3e09390651 58b3e0939068a 58b3e093906c3 58b3e093906fc ...

Perl 6 , 11 bytes

say($++)xx*

Imprime los números naturales.

Pruébalo en línea!

Python 2, 24 bytes

Imprime 9 veces cada potencia de 2.

n=9
while 1:print n;n+=n

Pruébalo en línea

Lote de 7 bytes

time|%0

O:

%random%|%0

Powershell, 19 bytes

Aburrido contando la respuesta.

for(){[bigint]$i++}

Versión mejorada de la respuesta de Count Up Forever

apilado , 9 bytes

$out0 ani

Pruébalo en línea! Similar a mi respuesta Count up forever , esto genera números naturales desde 0el contador.

Bourne Shell, 11 bytes

yes date|sh

TI-Basic, 11 bytes

While 1
Ans+1
Disp Ans
End

GNU sed , 13 bytes

Este es un contador de precisión arbitrario en unario. Esa es una forma elegante de decir que agrego uno 0al espacio del patrón e imprimo en cada iteración (bucle infinito).

:
s:0*:&0:p
b

Después de algún tiempo, esto normalmente se encontraría con un error de asignación de memoria y dejaría de imprimir, porque ya no puede almacenar el espacio de patrón cada vez mayor. Eso no es un problema para este desafío, ya que se supone que la memoria es infinita.

Pruébalo en línea! (este intérprete limita aún más los recursos disponibles por diseño)

Vista previa de salida: solo las primeras 5 líneas

me@LCARS:/PPCG$ echo | sed -f infinite_non_periodic.sed | head -5
0
00
000
0000
00000

Sesos , 2 bytes

SASM

set numout
jmp, put, add 1

SBIN

00000000: c40a                                              ..

Imprime todos los enteros no negativos en orden.

Pruébalo en línea!