^{Não é enganador para isso . Essa pergunta pede especificamente uma contagem para sempre, enquanto essa pergunta permite muitas outras abordagens.}

Escreva um programa ou função que, com tempo e memória infinitos, imprima uma saída não periódica infinita.

Esclarecimentos

• 'Infinito' significa que a solução continua produzindo algo sem outras entradas ou operações após o início do programa ou função com sucesso.
• 'Não periódico' significa que a saída não tem possibilidade de, eventualmente, repetir a mesma seção para sempre (independentemente da duração desse período). Um exemplo de uma solução válida seria imprimir os dígitos de um número irracional.
• As soluções aleatórias não contam, a menos que você possa provar que se encaixa nos requisitos. As soluções baseadas em data / hora também podem ser inválidas se não forem armazenadas com precisão arbitrária.

Vencedora

O código mais curto (em bytes) vence.

Hexagonia , 2 bytes

(!

Experimente online!

O código-fonte desdobrado se parece com:

 ( !
. . .
 . .

Isso apenas executa esses dois comandos em um loop, que são decrement ( () e print ( !). Portanto, a saída é:

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

Precisamos usar decremento em vez de incremento para garantir que o programa retorne à primeira linha (se o valor da memória for positivo, o Hexagony entrará em loop entre a segunda e a terceira linha e terminará em um loop infinito sem fazer nada).

Python 2 , 23 bytes

while 1:print id;id=id,

Experimente online!

Impressões

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

e assim por diante. Inicia com a função idinterna, o nome mais curto da variável pré-inicializada e a transforma repetidamente em uma tupla de si mesma.

No Python 3, essa solução tem um byte a mais print(), mas o byte pode ser recuperado da printsaída None:

while 1:id=print(id),id

ou

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

Labirinto , 3 bytes

#:!

Experimente online!

Imprime todos os números pares não negativos sem separador:

024681012141618202224262830323436384042...

O IP salta para frente e para trás no código, então isso é realmente #:!:um loop:

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

Um monte de alternativas:

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

Braquilog , 2 bytes

ẉ⊥

Experimente online!

Isso imprime todos os números inteiros ordenados por magnitude. Isso nunca excederá e imprimirá números inteiros já vistos, já que o Brachylog usa números inteiros ilimitados por padrão.

Explicação

ẉ      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

Gera um fluxo de números, contando de 0.

Eu acredito que incrementar números não circula ...

Explicação:

l empurra o comprimento da pilha para a pilha

: duplica o valor da pilha superior em cima da pilha

n gera valor como número

Quando a linha termina, ela volta ao início, e o faz novamente, mas agora a pilha é mais longa ...

conectados

PHP, 20 bytes

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

Emite isso:

101001000100001000001000000100000001000000001000000000...

Se argumentos de linha de comando forem fornecidos, a saída será diferente, mas ainda não periódica.

Tanto quanto eu entendo a documentação, o próprio idioma não restringe o comprimento das strings.

JavaScript, 26 22 20 bytes

for(;;)alert(Date())

(Aviso: é mau)

Haskell - 10 bytes

print[1..] 

Embora em ghci você possa digitar [1 ..] e isso iniciará automaticamente a impressão.

Brainfuck, 13 bytes, assumindo que não há modificação superior, mas saída 256

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

código de saída char 2 2 4 6 2 4 6 8 10 12 14 16 18 ...

desculpe o código antigo imprimir loop 0 2 4 6 ... 254,

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

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

código de saída de caracteres 0 1 0 1 1 0 1 1 1 0 ...

Gelatina , 3 bytes

‘Ȯß

Experimente online! - trunca a saída e gera um erro, mas vai demorar muito mais localmente (até a memória acabar).

Com uma entrada implícita de zero, este programa consiste em um único link que incrementa ‘, imprime Ȯe se autodenomina com o novo valor ß,.

MATL, 4 bytes

`@tD

Esta solução cria um whileloop que empurra o índice do loop para a pilha, duplica, imprime o valor e verifica se o índice do loop é diferente de zero para repetir novamente.

Experimente Online!

RProgN 2 , 13 bytes

2{22.`2=2p2}:

Há muitos dois na saída, separados por novas linhas progressivamente mais esparsas.

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 seguidos por uma nova linha para cada iteração.

Experimente online!

Befunge , 4 bytes

1+:.

Experimente online!

No Befunge, a pilha não tem fundo e possui zeros infinitos. Dito isto:

1+ adiciona um ao topo da pilha

: duplica a parte superior da pilha

. imprime o valor ascii da parte superior da pilha como um número

E continua infinitamente, porque não há @para parar a execução. Na verdade, esse é um daqueles problemas mais fáceis de resolver pela maneira como o befunge funciona ... estranho.

APL (Dyalog APL) , 8 bytes

{∇⎕←0⍵}1

{emsp; uma função anônima ...

 ∇ recursar em

 ⎕ ← saída para STDOUT

 0 ⍵ a lista de dois elementos que consiste em um zero e o argumento

} aplicado ao número um

A saídas (em linhas separadas) [0,1], [0,[0,1]], [0,[0,[0,1]]], etc.

Processando, 30 29 bytes

1 byte economizado graças ao QwerpDerp por usar em millis()vez deframeRate

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

Imprime continuamente o número de milissegundos desde o início do programa.

Saída de amostra:

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++);}

Primeiro, alocando um ponteiro no heap, a função é contabilizada nos endereços de memória adiante até que um segfault seja *p++, portanto, é limitada pela quantidade de memória no sistema, e não pelos tipos de dados usados ​​que, eventualmente, estourariam e repetiriam a série. Dada a memória infinita com capacidade de endereçamento infinito, ela continuaria para sempre.

Experimente online!

7 , 2 bytes

Os caracteres que compõem este programa são:

240223

Ao visualizar o arquivo em um editor, ele provavelmente tentará interpretá-lo como ASCII; nesse caso, ele será assim:

P$

Experimente online!

O programa recebe entrada. Eu assumi aqui que a entrada está no EOF; se você fornecer uma entrada, é possível que ela trava.

Explicação

Iteração Zeroth

240223
240223 Anexe 240223 ao elemento de pilha superior

O programa inteiro aqui é passivo, portanto, ele anexará uma versão ativa de si mesmo ao elemento da pilha superior (que está inicialmente vazio). O programa está em um loop implícito, que avalia o elemento da pilha superior (enquanto o deixa na pilha) a cada iteração. Portanto, a versão ativa será executada. (Praticamente todos os 7 programas começam assim.)

Primeira iteração

240223 
2        Copie o elemento da pilha superior
  40      Escape do segundo elemento da pilha, trocando-o pelo topo
    2     Copie o elemento da pilha superior
     23   Crie o elemento da pilha superior

Antes do comando de saída, a pilha contém duas cópias de 240223(ou seja, passivo). O primeiro obtém saída (com nenhum efeito observável além de selecionar o formato de saída 2, "números"), o abaixo fica e se torna o programa para a próxima iteração.

Segunda iteração

240223
240223 Anexe 240223 ao elemento de pilha superior

O mesmo que a iteração zero, certo? Não é bem assim; a pilha tinha conteúdos diferentes. A pilha está agora 240223abaixo .240223240223

Terceira iteração

240223 240223 
240223         Anexe 240223 ao elemento superior da pilha
       2        Copie o elemento superior da pilha
       40      Escape do segundo elemento da pilha, troque-o pelo topo
          2     Copie o elemento superior da pilha
           23   Crie o elemento superior da pilha

Isso gera um elemento de pilha que possui mais três 6s e 0s do que 7s e 1s. O formato de saída 2 interpreta isso como uma solicitação para inserir um número. Lemos EOF, com a conseqüência de que o próximo elemento da pilha é reduzido a uma cadeia de comprimento zero. No entanto, devido a um bug (que parece levemente útil e pode ser promovido a um recurso?), Isso só acontece após o início da execução. A pilha mais uma vez possui dois elementos, 240223abaixo , mas a versão escapada desse elemento superior está em execução.24022324022324022372402236240223240223

Quarta iteração

7 240223 6 240223240223
 7 240223 6 240223240223 Anexe 240223 240223240223 ao topo da pilha

O topo da pilha era uma string de comprimento zero, então basicamente estamos apenas escapando do programa que acabou lá.

Quinta iteração

240223 240223240223 
240223               Anexar 240223 ao elemento de pilha superior
       2              Copie o elemento de pilha superior
       40            Escape do segundo elemento de pilha, alterne-o para o topo
          2           Copie o elemento de pilha superior
           23         Crie o elemento de pilha superior
       2        Copie o elemento de pilha superior
       40      Escape o segundo elemento da pilha, trocando-o pelo topo
          2     Copie o elemento da pilha superior
           23   Crie o elemento da pilha superior

Isso é muito semelhante à terceira iteração. Existem duas mudanças, no entanto. Primeiro, agora existem 4 mais 0s e 6s do que 1s e 7s; portanto, tentaremos inserir um caractere da entrada padrão em vez de um número. Porém, ainda temos EOF e, no final, acabamos reduzindo o topo da pilha a uma string de comprimento zero. Em seguida, há código em execução após a redução, para que a próxima iteração não inicie imediatamente. Em vez disso, fazemos várias operações nesse elemento de comprimento zero, terminando com três elementos de comprimento zero. Nós produzimos um, os outros dois desaparecem (porque é o fim de uma iteração) e terminamos basicamente onde estávamos no final da terceira iteração.

Sexta iteração

O programa que copiamos do topo da pilha é agora . Tudo funciona como na iteração anterior até chegarmos à primeira instrução de saída (a primeira ). Agora, ele tem mais cinco 0s e 6s do que 1s e 7s; portanto, define um modo no qual a próxima instrução de saída será interpretada como uma solicitação para alterar o formato de saída. Isso também leva a uma notável mudança de comportamento; como não havia solicitação de entrada, não lemos o EOF e, portanto, não acionamos a conseqüência da leitura do EOF (o novo elemento da pilha superior sendo apagado) e, como tal, a versão escapada do elemento da pilha original permanece em vez de ser removido. Isso significa que o próximo240223240223240223240223232402não é mais um no-op, criando duas cópias com escape do elemento de pilha com escape (ou seja, agora elas têm escape duplo). Nós produzimos um, configurando o formato de saída para 7 ("igual à entrada"); esse formato de saída não possui comandos de E / S e nenhum comando para alterar o formato; portanto, permaneceremos nele pelo resto do programa. Também produzimos 724022362402232402232402232402236(na mesma codificação que a entrada) para a saída padrão.

De qualquer forma, é bastante claro o que o programa fará a partir deste momento: é uma combinação de anexar vários números de cópias de várias formas escapadas 240223para o topo da pilha, escapando do topo da pilha e emitindo cópias da parte superior da a pilha. A partir deste momento, o elemento da pilha superior nunca é limpo (porque nunca lemos EOF), portanto, apenas cresce, cresce e cresce. O escape periódico garante que a saída nunca se repita (porque significa que a cada iteração, a primeira saída começa com pelo menos um a mais 7do que na iteração anterior).

Ohm , 4 bytes (CP437)

¼,¡∞

Imprime a variável do contador, a incrementa e entra em um loop infinito! Simples o suficiente.

EDIT (1 / mar / 17): Enquanto eu estava no processo de fazer outras atualizações (depois de postar esta resposta), alterei o comportamento de ∞. A resposta atualizada seria ∞^,.

"modernos" DC , 9 bytes

Memória infinita?
Então uma pilha em crescimento contínuo está ok?
] :-)

[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

Por causa do uso do rcomando, isso não será executado em alguns controladores de domínio antigos.

Ruby, 21 12 bytes

loop{p$.+=1}

Imprima todos os números naturais. Tanto quanto eu entendo a descrição do problema, isso deve estar ok.

PHP, 21 bytes

for(;;)echo uniqid();

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

Produz IDs exclusivos com base no horário atual em microssegundos: 58b3e065e4b4c58b3e065e4b6358b3e065e4b7b58b3e065e4b9458b3e065e4bac58b3e065e4bc458b3e065e4bdc58b3e065e4bf558b3e065e4c0e58b3e065e4c2658b3e065e4c3e58b3e065e4c5658b3e065e4c6f58b3e065e4c8758b3e065e4c9f...

como uma sequência contínua de: 58b3e09390617 58b3e09390651 58b3e0939068a 58b3e093906c3 58b3e093906fc ...

Perl 6 , 11 bytes

say($++)xx*

Imprime os números naturais.

Experimente online!

Python 2, 24 bytes

Imprime 9 vezes cada potência de 2.

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

Experimente online

Lote, 7 bytes

time|%0

Ou:

%random%|%0

Powershell, 19 bytes

Chato contando resposta.

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

Versão aprimorada da resposta do Count Up Forever

empilhados , 9 bytes

$out0 ani

Experimente online! Semelhante à minha resposta Contar para sempre , isso gera números naturais 0do contador.

Bourne Shell, 11 bytes

yes date|sh

TI-Basic, 11 bytes

While 1
Ans+1
Disp Ans
End

GNU sed , 13 bytes

Este é um contador de precisão arbitrário em unário. É uma maneira elegante de dizer que eu anexo um 0ao espaço do padrão e o imprimo em todas as iterações (loop infinito).

:
s:0*:&0:p
b

Depois de algum tempo, isso normalmente ocorre com um erro de alocação de memória e para de imprimir, porque não pode mais armazenar o espaço padrão cada vez maior. Isso não é um problema para esse desafio, pois a memória é assumida como infinita.

Experimente online! (esse intérprete limita ainda mais os recursos disponíveis por design)

Visualização de saída: apenas as 5 primeiras linhas

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 os números inteiros não negativos em ordem.

Experimente online!