^{Kein Betrogene zu diesem . Diese Frage verlangt speziell, für immer hochzuzählen, während diese Frage viele andere Ansätze zulässt.}

Schreiben Sie ein Programm oder eine Funktion, die bei unendlicher Zeit und Speicher eine unendliche nichtperiodische Ausgabe drucken würde.

Klarstellungen

• 'Unendlich' bedeutet, dass die Lösung nach erfolgreichem Start des Programms oder der Funktion weiterhin etwas ohne weitere Eingaben oder Operationen ausgibt.
• 'Nicht periodisch' bedeutet, dass die Ausgabe keine Möglichkeit hat, denselben Abschnitt für immer zu wiederholen (unabhängig davon, wie lange dieser Zeitraum dauert). Ein Beispiel für eine gültige Lösung wäre das Drucken der Ziffern einer irrationalen Zahl.
• Zufällige Lösungen würden nicht zählen, wenn Sie nicht nachweisen können, dass sie den Anforderungen entsprechen. Datums- / Zeit-basierte Lösungen können auch ungültig sein, wenn sie nicht mit willkürlicher Genauigkeit gespeichert werden.

Gewinner

Der kürzeste Code (in Bytes) gewinnt.

Hexagonie , 2 Bytes

(!

Probieren Sie es online aus!

Der entfaltete Quellcode sieht folgendermaßen aus:

 ( !
. . .
 . .

Dies führt nur diese beiden Befehle in einer Schleife aus, die decrement ( () und print ( !) sind. Daher lautet die Ausgabe:

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

Wir müssen Dekrement anstelle von Inkrement verwenden, um sicherzustellen, dass das Programm zur ersten Zeile zurückkehrt (wenn der Speicherwert positiv wäre, würde Hexagony zwischen der zweiten und dritten Zeile eine Schleife ausführen und in einer Endlosschleife enden, ohne etwas zu tun).

Python 2 , 23 Bytes

while 1:print id;id=id,

Probieren Sie es online aus!

Druckt

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

und so weiter. Beginnt mit der integrierten Funktion id, dem kürzesten vorinitialisierten Variablennamen, und verwandelt ihn wiederholt in ein Tupel für sich.

In Python 3 ist diese Lösung aufgrund von ein Byte länger print(), aber das Byte kann aus der printAusgabe wiederhergestellt werden None:

while 1:id=print(id),id

oder

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

Labyrinth , 3 Bytes

#:!

Probieren Sie es online aus!

Druckt alle nicht negativen geraden Ganzzahlen ohne Trennzeichen:

024681012141618202224262830323436384042...

Die IP springt auf dem Code hin und her, so dass dies wirklich #:!:in einer Schleife ist:

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

Eine Reihe von Alternativen:

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

Brachylog , 2 Bytes

ẉ⊥

Probieren Sie es online aus!

Dies gibt alle nach Größe geordneten ganzen Zahlen aus. Dies wird niemals überlaufen und bereits gesehene Ganzzahlen drucken, da Brachylog standardmäßig unbegrenzte Ganzzahlen verwendet.

Erläuterung

ẉ      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

Gibt einen Zahlenstrom aus, der von 0 zählt.

Ich glaube, inkrementelle Zahlen laufen nicht ...

Erläuterung:

l schiebt die Stapellänge auf den Stapel

: dupliziert den obersten Stapelwert über dem Stapel

n gibt den Wert als Zahl aus

Wenn die Zeile fertig ist, geht sie zurück zum Anfang, also macht sie es wieder, aber jetzt ist der Stapel länger ...

online

PHP, 20 Bytes

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

Gibt dies aus:

101001000100001000001000000100000001000000001000000000...

Wenn Befehlszeilenargumente angegeben werden, ist die Ausgabe unterschiedlich, aber immer noch nicht periodisch.

Soweit ich die Dokumentation verstehe, beschränkt die Sprache selbst die Länge der Zeichenfolgen nicht.

JavaScript, 26 22 20 Bytes

for(;;)alert(Date())

(Warnung: es ist böse)

Haskell - 10 Bytes

print[1..] 

Obwohl Sie in ghci einfach [1 ..] eingeben könnten, würde der Druck automatisch gestartet.

Brainfuck, 13 Bytes, unter der Annahme, dass keine Obergrenze vorliegt, sondern Mod 256 ausgegeben wird

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

Ausgabezeichencode 2 2 4 6 2 4 6 8 10 12 14 16 18 ...

Entschuldigung, dass die alte Codedruckschleife 0 2 4 6 ... 254,

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

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

Ausgabe-Zeichencode 0 1 0 1 1 0 1 1 1 0 ...

Gelee , 3 Bytes

‘Ȯß

Probieren Sie es online aus!- schneidet die Ausgabe ab und löst einen Fehler aus, geht aber lokal viel länger (bis der Speicher knapp wird).

Bei einer impliziten Eingabe von Null besteht dieses Programm aus einer einzelnen Verknüpfung, die den neuen Wert inkrementiert ‘, druckt Ȯund sich dann selbst aufruft ß.

MATL, 4 Bytes

`@tD

Diese Lösung erstellt eine whileSchleife, die den Index der Schleife auf den Stapel schiebt, dupliziert, den Wert druckt und dann überprüft, ob der Schleifenindex ungleich Null ist, um ihn erneut zu wiederholen.

Probieren Sie es online aus!

RProgN 2 , 13 Bytes

2{22.`2=2p2}:

Es gibt viele Zweien in der Ausgabe, die durch zunehmend spärlichere Zeilenumbrüche getrennt sind.

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"

Was 2 ^ n 2s druckt, gefolgt von einer neuen Zeile für jede Iteration.

Probieren Sie es online aus!

Befunge , 4 Bytes

1+:.

Probieren Sie es online aus!

In Befunge ist der Stapel bodenlos und hat unendlich viele Nullen. Das gesagt:

1+ Fügt eins oben im Stapel hinzu

: dupliziert die Oberseite des Stapels

. Gibt den ASCII-Wert oben im Stapel als Zahl aus

Und es geht unendlich weiter, weil es keine Möglichkeit gibt, die @Ausführung zu stoppen. Dies ist tatsächlich eines dieser Probleme, die durch die Funktionsweise von befunge leichter zu lösen sind ... seltsam.

APL (Dyalog APL) , 8 Bytes

{∇⎕←0⍵}1

{emsp; eine anonyme Funktion ...

 ∇ Rekurs auf

 ⎕ ← Ausgabe an STDOUT

 0 ⍵ Die Liste mit zwei Elementen besteht aus einer Null und dem Argument

} angewendet auf die Nummer eins

Diese Ausgänge (auf separaten Leitungen) [0,1], [0,[0,1]], [0,[0,[0,1]]]usw.

Verarbeitung, 30 29 Bytes

1 Byte gespart dank QwerpDerp für die Verwendung millis()anstelle vonframeRate

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

Gibt kontinuierlich die Anzahl der Millisekunden seit dem Start des Programms aus.

Beispielausgabe:

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

Zuerst wird ein Zeiger auf dem Heap zugewiesen, dann zählt die Funktion bis zu einem Segfault von in den Speicheradressen vor *p++ , . Daher ist sie eher durch die Speichermenge im System als durch die verwendeten Datentypen begrenzt, die andernfalls eventuell überlaufen und die Serie wiederholen würden. Bei unendlichem Speicher mit unendlicher Adressierungsfähigkeit würde es für immer weitergehen.

Probieren Sie es online aus!

7 , 2 Bytes

Die Charaktere, aus denen dieses Programm besteht, sind:

240223

Wenn Sie die Datei in einem Editor anzeigen, wird wahrscheinlich versucht, sie als ASCII zu interpretieren. In diesem Fall sieht sie folgendermaßen aus:

P$

Probieren Sie es online aus!

Das Programm nimmt Eingaben entgegen. Ich habe hier angenommen, dass der Eingang bei EOF ist; Wenn Sie es eingeben, ist es möglich, dass es abstürzt.

Erläuterung

Zeroth-Iteration

240223
240223 Fügen Sie 240223 an das oberste Stapelelement an

Das gesamte Programm hier ist passiv, daher wird eine aktive Version von sich an das oberste Stapelelement angehängt (das anfangs leer ist). Das Programm befindet sich in einer impliziten Schleife, die das oberste Stapelelement bei jeder Iteration auswertet (während es auf dem Stapel belassen wird). Die aktive Version wird also ausgeführt. (So ​​ziemlich alle 7 Programme beginnen so.)

Erste Iteration

240223 
2        Kopieren des oberen
  Stapelelements 40 Verlassen Sie      das zweite Stapelelement und tauschen Sie es nach oben aus.
    2     Kopieren Sie das obere Stapelelement.
     23   Geben Sie das obere Stapelelement aus

Vor dem Ausgabebefehl enthält der Stapel zwei Kopien von 240223(dh passiv). Das oberste wird ausgegeben (ohne erkennbaren Effekt außer der Auswahl des Ausgabeformats 2, "Zahlen"), das folgende bleibt erhalten und wird zum Programm für die nächste Iteration.

Zweite Iteration

240223
240223 Fügen Sie 240223 an das oberste Stapelelement an

Das gleiche wie die nullte Iteration, richtig? Nicht ganz; Der Stapel hatte unterschiedliche Inhalte. Der Stapel ist jetzt 240223unten .240223240223

Dritte Iteration

240.223 240.223 
240.223         Append 240.223 auf das obere Stapelelement
       2        Kopieren des obere Stapelelement
       40      das zweite Stapelelementes Flucht, es nach oben Swapping
          2     Copy des oberen Stapelelement
           23   Output des oberen Stapelelement

Dies gibt ein Stapelelement aus, das drei weitere 6s und 0s als 7s und 1s hat. Das Ausgabeformat 2 interpretiert dies als eine Anforderung zur Eingabe einer Zahl. Wir lesen EOF, mit der Folge, dass das nächste Element auf dem Stapel auf eine Zeichenfolge mit der Länge Null reduziert wird. Aufgrund eines Fehlers (der leicht nützlich erscheint und möglicherweise zu einer Funktion heraufgestuft wird?) Tritt dies jedoch erst auf, nachdem die Ausführung gestartet wurde. Der Stapel enthält 240223unten erneut zwei Elemente, aber die maskierte Version dieses obersten Elements wird jetzt ausgeführt.24022324022324022372402236240223240223

Vierte Iteration

7 240223 6 240223240223
 7 240223 6 240223240223 Fügen Sie 240223 240223240223 an die Oberseite des Stapels an

Die Oberseite des Stapels war eine Zeichenfolge mit der Länge Null, sodass wir das Programm, das dort gelandet ist, im Grunde genommen nur entkoppeln.

Fünfte Iteration

240.223 240.223.240.223 
240.223               Append 240.223 auf das obere Stapelelement
       2              Kopieren des obere Stapelelement
       40            das zweite Stapelelementes Flucht, es nach oben Swapping
          2           Copy des oberen Stapelelement
           23         Output des oberen Stapelelement
       2        Kopieren des oberen Stapelelement
       40      Flucht der zweiten Stapeln des Elements nach oben
          2     Kopieren des oberen Stapelelements
           23   Geben Sie das obere Stapelelement aus

Dies ist der dritten Iteration sehr ähnlich. Es gibt jedoch zwei Änderungen. Erstens gibt es jetzt 4 mehr 0s und 6s als 1s und 7s, also werden wir versuchen, ein Zeichen von der Standardeingabe anstelle einer Zahl einzugeben. Wir erhalten jedoch immer noch EOF und reduzieren dadurch immer noch die Oberseite des Stapels auf eine Zeichenfolge mit der Länge Null. Als nächstes wird nach der Reduzierung Code ausgeführt , sodass die nächste Iteration nicht sofort beginnt. Vielmehr führen wir eine Reihe von Operationen an diesem Element mit der Länge Null durch, die am Ende drei Elemente mit der Länge Null ergeben. Wir geben eins aus, die anderen beiden verschwinden (weil es das Ende einer Iteration ist) und wir landen im Grunde dort, wo wir am Ende der dritten Iteration waren.

Sechste Iteration

Das Programm, das wir von oben kopieren, ist jetzt . Alles funktioniert wie in der vorherigen Iteration, bis wir die erste Ausgabeanweisung (die erste ) erreichen. Dies hat jetzt fünf mehr 0s und 6s als 1s und 7s, so dass ein Modus festgelegt wird, in dem der nächste Ausgabeanweis als Anforderung zum Ändern des Ausgabeformats interpretiert wird. Dies führt auch zu einer bemerkenswerten Verhaltensänderung; Da es keine Eingabeanforderung gab, haben wir EOF nicht gelesen und somit nicht die Konsequenz des Lesens von EOF (das neue oberste Stapelelement wird ausgeblendet) ausgelöst. Daher bleibt die maskierte Version des ursprünglichen Stapelelements erhalten und nicht entfernt. Dies bedeutet, dass die nächste240223240223240223240223232402ist kein No-Op mehr und erstellt zwei maskierte Kopien des maskierten Stapelelements (dh sie sind jetzt doppelt maskiert). Wir geben eins aus und setzen das Ausgabeformat auf 7 ("wie die Eingabe"); Dieses Ausgabeformat enthält keine E / A-Befehle und keine Befehle zum Ändern des Formats. Daher bleiben wir für den Rest des Programms darin. Wir geben auch 724022362402232402232402232402236(in der gleichen Codierung wie die Eingabe) an die Standardausgabe aus.

Wie auch immer, es ist ziemlich klar, was das Programm von diesem Punkt an tun wird: Es ist eine Kombination aus dem Anhängen verschiedener Anzahlen von Kopien von unterschiedlich entkommenen 240223 an den oberen Rand des Stapels maskiert wurden, dem Escaping des oberen Randes des Stapels und dem Ausgeben von Kopien des oberen Randes des Stapels der Stapel. Ab diesem Zeitpunkt wird das oberste Stapelelement nie gelöscht (weil wir nie EOF lesen), also wächst es einfach und wächst und wächst. Das periodische Escapezeichen stellt sicher, dass sich die Ausgabe nie wiederholt (da dies bedeutet, dass bei jeder Iteration die erste Ausgabe mit mindestens einer mehr beginnt 7als bei der vorherigen Iteration).

Ohm , 4 Bytes (CP437)

¼,¡∞

Druckt die Zählervariable, erhöht sie und geht in eine Endlosschleife! Einfach genug.

BEARBEITEN (1. März 17): Während ich einige andere Updates durchführte (nachdem ich diese Antwort gepostet hatte), habe ich das Verhalten von geändert ∞. Die aktualisierte Antwort wäre ∞^,.

"modernes" DC , 9 Bytes

Unendliche Erinnerung?
Dann ist ein kontinuierlich wachsender Stapel in Ordnung?
] :-)

[zprdx]dx

Kommentiert:

[         # 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

Aufgrund der Verwendung des rBefehls wird dies auf einigen alten Domänencontrollern nicht ausgeführt.

Ruby, 21 12 Bytes

loop{p$.+=1}

Drucken Sie alle natürlichen Zahlen. Soweit ich die Problembeschreibung verstehe, sollte dies in Ordnung sein.

PHP, 21 Bytes

for(;;)echo uniqid();

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

Gibt eindeutige IDs basierend auf der aktuellen Zeit in Mikrosekunden aus: 58b3e065e4b4c58b3e065e4b6358b3e065e4b7b58b3e065e4b9458b3e065e4bac58b3e065e4bc458b3e065e4bdc58b3e065e4bf558b3e065e4c0e58b3e065e4c2658b3e065e4c3e58b3e065e4c5658b3e065e4c6f58b3e065e4c8758b3e065e4c9f...

als kontinuierliche Folge von: 58b3e09390617 58b3e09390651 58b3e0939068a 58b3e093906c3 58b3e093906fc ...

Perl 6 , 11 Bytes

say($++)xx*

Druckt die natürlichen Zahlen.

Probieren Sie es online aus!

Python 2, 24 Bytes

Druckt 9 mal jede Potenz von 2.

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

Probieren Sie es online aus

Stapel, 7 Bytes

time|%0

Oder:

%random%|%0

Powershell, 19 Bytes

Langweilige Antwort hochzählen.

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

Verbesserte Version der Antwort von Count Up Forever

gestapelt , 9 Bytes

$out0 ani

Probieren Sie es online aus! Ähnlich wie bei meiner Antwort "Für immer zählen" werden hier natürliche Zahlen vom 0Zähler ausgegeben.

Bourne Shell, 11 Bytes

yes date|sh

TI-Basic, 11 Bytes

While 1
Ans+1
Disp Ans
End

GNU sed , 13 Bytes

Dies ist ein beliebiger Präzisionszähler in unär. Das ist eine ausgefallene Art zu sagen, dass ich eine 0an den Musterraum anhänge und sie bei jeder Iteration drucke (Endlosschleife).

:
s:0*:&0:p
b

Nach einiger Zeit würde dies normalerweise zu einem Speicherzuordnungsfehler führen und den Druckvorgang beenden, da der ständig wachsende Musterspeicher nicht mehr gespeichert werden kann. Das ist kein Problem für diese Herausforderung, da angenommen wird, dass der Speicher unendlich ist.

Probieren Sie es online aus!(Dieser Interpreter schränkt die verfügbaren Ressourcen durch das Design weiter ein.)

Ausgabevorschau: nur die ersten 5 Zeilen

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

Druckt alle nicht negativen Ganzzahlen der Reihe nach.

Probieren Sie es online aus!