Zähle für immer

71

Schreiben Sie ein Programm, das von eins an für immer zählt.

Regeln:

  • Ihr Programm muss sich bei STDOUToder bei einer akzeptablen Alternative anmelden , falls diese STDOUTnicht verfügbar ist.
  • Ihr Programm muss ein vollständiges, lauffähiges Programm sein und darf keine Funktion oder ein Snippet sein.
  • Ihr Programm muss jede Zahl mit einem Trennzeichen (eine neue Zeile, ein Leerzeichen, ein Tabulator oder ein Komma) ausgeben, dies muss jedoch für alle Zahlen konsistent sein.
  • Sie können die Zahlen dezimal, unär oder zur Basis 256 ausgeben, wobei jede Ziffer durch einen Bytewert dargestellt wird .
  • Ihr Programm muss ohne Probleme und ohne Speichermangel auf einem vernünftigen Desktop-PC mindestens 2 128 (einschließlich) zählen. Dies bedeutet insbesondere, dass Sie bei Verwendung von unary keine unary-Darstellung der aktuellen Nummer im Speicher speichern können.

  • Im Gegensatz zu unseren üblichen Regeln können Sie auch dann eine Sprache (oder Sprachversion) verwenden, wenn diese neuer als diese Herausforderung ist. Sprachen, die speziell geschrieben wurden, um eine 0-Byte-Antwort auf diese Herausforderung zu senden, sind fair, aber nicht besonders interessant.

    Beachten Sie, dass ein Dolmetscher vorhanden sein muss, damit die Einreichung getestet werden kann. Es ist erlaubt (und sogar empfohlen), diesen Dolmetscher für eine zuvor nicht implementierte Sprache selbst zu schreiben.

  • Hier geht es nicht darum, die Sprache mit der kürzesten Lösung dafür zu finden (es gibt einige, bei denen das leere Programm den Trick macht) - hier geht es darum, die kürzeste Lösung in jeder Sprache zu finden. Daher wird keine Antwort als angenommen markiert.

Katalog

Das Stapel-Snippet am Ende dieses Beitrags generiert den Katalog aus den Antworten a) als Liste der kürzesten Lösungen pro Sprache und b) als Gesamt-Bestenliste.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

## Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

## Perl, 43 + 2 (-p flag) = 45 bytes

Sie können den Namen der Sprache auch als Link festlegen, der dann im Snippet angezeigt wird:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Code-Snippet anzeigen

code-golf  number  counting 
— vrwim
quelle
29
Ich bin nicht sicher, wie zu kombinieren ist , muss jede Zahl mit einem Trennzeichen dazwischen ausgeben, mit kann die Zahlen [...] in Basis 256 drucken .
— Dennis
6
Darf ich für zukünftige Herausforderungen die Sandbox empfehlen , damit alle diese Details aussortiert werden können, bevor Personen anfangen, Antworten zu veröffentlichen? :)
— Martin Ender
3
@IlmariKaronen Ich interpretiere das als Speicherbegrenzung, nicht als Zeitbegrenzung. Möglicherweise eine zeitliche Begrenzung des Inkrements. Stellen Sie einfach den Zähler auf 2 ** 128-10 und sehen Sie, wie lange es dauert, bis Sie die letzten zehn Schritte ausgeführt haben.
— Sparr
5
Können wir führende Nullen in der Ausgabe haben?
— Paŭlo Ebermann,
4
Pfui!!! Ich habe eine Antwort für TI-89 (56b), aber ich kann nicht b / c posten. Ich bin neu auf der Website und habe keinen Rep 10+!
— Gregsdennis

Antworten:

63

Labyrinth , 5 Bytes

):
\!

♫ Die IP im Code geht um und um ♫

Relevante Anweisungen:

)       Increment top of stack (stack has infinite zeroes at bottom)
:       Duplicate top of stack
!       Output top of stack
\       Output newline
— Sp3000
quelle
77
Das Programm ist traurig, dass es nicht aufhört.
— Optimizer
7
@Optimizer def traurig (in der Tat):
— YoYoYonnY
1
Warum sind das nicht 4 Bytes?
— Aurel Bílý
2
@ Aurel300 Das fünfte Byte ist der Zeilenumbruch zwischen :und\
— Sp3000 30.12.15
@ Sp3000 Ah ja. Wie dumm von mir. :)
— Aurel Bílý
46

> <> , 8 Bytes

01+:nao!

Schritte:

  • Drücken Sie 0 auf dem Stapel
  • Fügen Sie dem obersten Stapelelement 1 hinzu
  • Doppelte oberste Stapelelement
  • Geben Sie die Oberseite des Stapels als Zahl aus
  • Geben Sie eine neue Zeile aus
  • Fahren Sie mit Schritt 2 fort, indem Sie die nächste Anweisung umschließen und springen (Schritt 11).

(Ein weniger speichereffizientes (daher ungültiges) Programm ist llnao.)

— randomra
quelle
66
+1 für das ungeduldige, nach Stimmengewinn verlangende Implizit in einer Codezeile, die im Grunde genommen "plus eins, jetzt!" Lautet.
— Janus Bahs Jacquet
24

Haskell, 21 Bytes

main=mapM_ print[1..]

Ganzzahlen mit beliebiger Genauigkeit und unendliche Listen machen dies einfach :-)

Zum Glück mapM_ist im Präludium. Wenn Data.Traversableja, könnten wir es sogar auf 19 Bytes verkleinern:

main=for_[1..]print
— Bergi
quelle
Gibt es nicht ein Symbol, das map / mapM usw. verallgemeinert?
— JDługosz
@ JDługosz: nicht dass ich es wüsste
— Bergi
Ah, denn es müsste immer noch sequencedas Ergebnis sein, damit die Ausgabe wirklich funktioniert.
— JDługosz,
ist nicht einfach [1..]erlaubt, da es alle Zahlen mit einem Komma dazwischen druckt? oder das erste [vermasseln alles?
— Baconaro
@ Baconaro: Das ist eine Liste, es wird nichts gedruckt. GHCi gibt das Ergebnis aus, wenn Sie den Begriff in die Replikation eingeben, dies ist jedoch kein ausführbares Programm. Und ja, das Führen [ist auch nicht erlaubt.
— Bergi
23

Gol> <> , 3 Bytes

P:N

Schritte:

  • Addiere 1 zum obersten Stapelelement (beim Start ist es eine implizite 0)
  • Doppelte oberste Stapelelement
  • Pop und Ausgabe der Oberseite des Stapels als Zahl und eine neue Zeile
  • Fahren Sie mit Schritt 1 fort, als wir das Ende der Linie erreicht haben
— randomra
quelle
21

Marbelous , 11450 4632 Bytes

Dezimalzahlen zu drucken ist ein Schmerz !!

Auf keinen Fall damit gewinnen, aber ich dachte, ich würde es versuchen. Ich hoffe, es ist in Ordnung, dass die Ausgabe auf 40 Nullen aufgefüllt wird (für 2 ^ 128).

00@0..@1..@2..@3..@4..@5..@6..@7..@8..@9..@A..@B..@C..@D..@E..@F..@G..@H..@I..@J
\\++..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00
..EhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhun
....AddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddt
..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7\/
../\&8..........................................................................
....@0..........................................................................
....../\&8......................................................................
....//..@1......................................................................
........../\&8..................................................................
......////..@2..................................................................
............../\&8..............................................................
........//////..@3..............................................................
................../\&8..........................................................
..........////////..@4..........................................................
....................../\&8......................................................
............//////////..@5......................................................
........................../\&8..................................................
..............////////////..@6..................................................
............................../\&8..............................................
................//////////////..@7..............................................
................................../\&8..........................................
..................////////////////..@8..........................................
....................................../\&8......................................
....................//////////////////..@9......................................
........................................../\&8..................................
......................////////////////////..@A..................................
............................................../\&8..............................
........................//////////////////////..@B..............................
................................................../\&8..........................
..........................////////////////////////..@C..........................
....................................................../\&8......................
............................//////////////////////////..@D......................
........................................................../\&8..................
..............................////////////////////////////..@E..................
............................................................../\&8..............
................................//////////////////////////////..@F..............
................................................................../\&8..........
..................................////////////////////////////////..@G..........
....................................................................../\&8......
....................................//////////////////////////////////..@H......
........................................................................../\&8..
......................................////////////////////////////////////..@I..
............................................................................../\&8
........................................//////////////////////////////////////..@J
&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9
Sixteenbytedecimalprintermodulewitharegi

:Sixteenbytedecimalprintermodulewitharegi
}J}J}I}I}H}H}G}G}F}F}E}E}D}D}C}C}B}B}A}A}9}9}8}8}7}7}6}6}5}5}4}4}3}3}2}2}1}1}0}00A
/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A
%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..
+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O..
+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O..

:/A
..}0..}0..
..>>}0....
..>>>>\\..
....//..//
../\>>\\..
....>>..//
....>>\\..
....>>....
\\>>//....
..>>......
..>>......
../\......
..../\<<..
......<<..
..\\<<//..
....~~....
....++....
....\\..//
\\....>9\/
..\\..?0..
......++..
....\\....
......{0..

:%A
@0..
}0..
<A-A
{0@0

:Eg
}0}0}0}0}0}0}0}0
^7^6^5^4^3^2^1^0
~~....~~~~..~~~~
^0^0^0^0^0^0^0^0
{0{0{0{0{0{0{0{0

:Ehun
}0..}0
Eg..&0
=8&0{0
&1\/00
0100&0
&1&1{1
{1{0

:Addt
}0}1
{1{1
— Der Arzt
quelle
Wäre das Drucken von Binärdateien kürzer?
— SuperJedi224
3
(oder was ist mit unary?)
— Türknauf
@Doorknob die Ausgabe anzuzeigen ist nicht das Problem. Es ist etwas auf dem EhunBoard, das die nächste Ziffer
— erhöhen
1
Wussten Sie, dass Sie die Punkte am Ende jeder Zeile und Leerzeilen zwischen den Tafeln weglassen und einzelne Zeichen für die Tafelnamen verwenden können? Sie müssen dieses einzelne Zeichen nur so lange wiederholen, bis Sie es aufgerufen haben. Dies kann Ihre Antwort auf ungefähr 3000 Bytes reduzieren.
— Overactor
Irgendwann werde ich ein Commit auf marbelous.py machen, das include/standardmäßig alles beinhaltet
— Sparr,
18

C (nur 64-Bit-Architektur), 53 Byte

Setzt voraus, dass Zeiger mindestens 64 Bit lang sind, und druckt sie unter Verwendung des Bezeichners in hexadezimaler Schreibweise %p. Das Programm würde direkt zurückkehren, wenn es 2 ^ 128 trifft.

char*a,*b;main(){for(;++b||++a;)printf("%p%p ",a,b);}
— Feersum
quelle
1
Wenn diese Zeiger also bei jeweils 64 Bit sind, können Sie nur bis 2 ^ 128-1 zählen, richtig?
— Fehler
6
Ungültig, da es nicht bis 2 ^ 128 zählen kann
— edc65
14
Ich mag CodeGolf, wenn es darum geht, Kreativität auszudrücken und zu belohnen. feersum kämpft hier eindeutig nicht um den Sieg. Es macht mich traurig, viele Abwertungen zu einer technischen Frage zu sehen und den Wortlaut der Frage zu ändern, um sicherzustellen, dass seine Antwort gegen die Regeln verstößt.
— Flodel
3
Ich dachte, die Wörter "mindestens so weit wie 2 ^ 128" waren klar genug ...
— vrwim
5
@vrwim Das hast du nicht geschrieben. Sie haben "bis 2 ^ 128" geschrieben. SuperJedi hat es vor ein paar Minuten bearbeitet.
— Feersum
17

Hexagony , 12 11 10 7 Bytes

Dank an alephalpha für das Einpassen des Codes in die Seitenlänge 2.

10})!';

Entfaltet:

 1 0
} ) !
 ' ;

Dieser ist ziemlich einfach. 10schreibt eine 10, dh einen Zeilenvorschub an die erste Speicherflanke. Dann })!';wird wiederholt in einer Schleife ausgeführt:

  • } zum nächsten Speicherrand gehen.
  • ) erhöhen Sie es.
  • ! Gib es als ganze Zahl aus.
  • ' gehe zurück zu den 10.
  • ; drucke es als Zeichen aus.

Ich glaube, dass dies optimal ist (obwohl bei weitem nicht einzigartig). Ich habe die Brute - Force - Skript lasse ich schrieb für diese Antwort für 6-Byte - Lösungen unter der Annahme , dass es suchen muss mindestens ein jeden von enthielte ;und !und entweder (oder ), und würde nicht enthalten ?, ,oder @, und es hat nicht finde irgendwelche Lösungen.

— Martin Ender
quelle
13

Pyth, 4 Bytes

.V1b

Erläuterung:

.V1    for b in range(1 to infinity):
   b      print b
— Jakube
quelle
f!\n( TIO-Link ) funktioniert für 3 Bytes, nicht sicher, ob diese Funktionen verwendet werden, die nach Ihrer Antwort hinzugefügt wurden.
— Sok
@Sok Clever. Ich werde die Antwort jedoch nicht ändern, da ich denke, dass dies fein Feature von Pyth vor 4 Jahren war.
— Jakube,
Das habe ich auch gedacht, weshalb ich es als Kommentar hinterlassen habe - neue
— Sok
13

bc, 10

for(;;)++i

Ungewöhnlich bcist das kürzer als dc.

Von man bc:

BESCHREIBUNG

bc ist eine Sprache, die Zahlen mit willkürlicher Genauigkeit unterstützt

— Digitales Trauma
quelle
Wo wird es ausgedruckt?
— Bálint
@ Bálint ++iist ein Ausdruck, aber keine Zuweisung und wird daher explizit ausgegeben. Hast du versucht, es laufen zu lassen? echo 'for(;;)++i' | bcin Ihrem nächsten Linux-Terminal.
— Digital Trauma
Ich habe kein einziges Linux-Terminal in meinem Haus. Ich war nur neugierig.
— Bálint
6
@ Bálint Jedes Haus sollte ein Linux-Terminal haben.
— Digital Trauma
1
@ Bálint Das Ausführen dieses Programms ist Ihre Aufgabe;)
— Insane
12

Java, 139 138 127 123 Bytes

class K{public static void main(String[]a){java.math.BigInteger b=null;for(b=b.ZERO;;)System.out.println(b=b.add(b.ONE));}}
— SuperJedi224
quelle
2
Eine kleinere Endlosschleife in Java ist for(;;)für einfache 3 Bytes.
— Ankh-Morpork
Sie können auch weitere 2 mit speichern BigInteger b=null;b=b.ZERO;, leider wird das =nullbenötigt, obwohl es sich um einen statischen Zugriff handelt.
— TWiStErRob,
Und dann noch 9, weil Sie den Import durch BigIntegereinmaliges Referenzieren von FQCN loswerden können .
— TWiStErRob,
@TWiStErRob Irgendwie war mir nicht klar, dass das kürzer sein würde.
— SuperJedi224
2
Ab Java 8 können Sie die Klasse durch die Funktion ersetzen interfaceund aus dieser entfernen public. Kopiere deinen Code nicht und poste ihn als neue Antwort.
— Luca H
10

Mathematica, 22 Bytes

i=0;While[Echo[++i]>0]

Echo ist eine neue Funktion in Mathematica 10.3.

— Alephalpha
quelle
Echoergibt vier Trennzeichen: newline plus ">> ". Nicht sicher, ob dies gültig ist - vielleicht Printstattdessen verwenden? Speichern Sie auch ein Byte mit i=0;While[Echo@++i>0].
— Roman
7

Rubin, 15 12 Bytes

loop{p$.+=1}
  • pGibt bei Angabe einer Ganzzahl die Ganzzahl wie sie ist aus (mit freundlicher Genehmigung von @philomory )
  • $.ist eine magische Variable, die die Anzahl der aus stdin gelesenen Zeilen enthält. Es ist offensichtlich auf 0 initialisiert und auch zuweisbar :)
— daniero
quelle
@philomory Normalerweise wird Benutzern empfohlen, einen Kommentar zu hinterlassen, in dem ihre Lösung zum Speichern von Bytes vorgeschlagen wird. Außerdem würde ich gerne eine Erklärung für diese sehen. c:
— Addison Crump
7

Python 3, 33 25 Bytes

Nach print()meinem Verständnis sind Pythons-Ganzzahlen willkürlich genau und erzeugen automatisch Zeilenumbrüche.

Danke für @Jakub und @ Sp3000 und @wnnmaw! Ich kenne wirklich nicht viel Python, der einzige Gedanke, den ich kannte, war, dass es Ganzzahlen mit beliebiger Größe unterstützt =)

k=1
while 1:print(k);k+=1
— fehlerhaft
quelle
1ist ein wahrer Wert in Python (und den meisten anderen Sprachen). So while 1:genügt.
— Jakube
Sie können das Ganze auch whilein eine Zeile setzen
— Sp3000
Sie können ein Byte speichern, indem Sie repr(k)anstelle von verwenden print(k). Außerdem zähle ich Ihre Byte - Größe 25 (ohne meine vorgeschlagene Änderung)
— wnnmaw
1
Sie können nicht repranstelle von verwenden print. reprgibt nichts aus. @wnnmaw
— Zach Gates
Was macht reprman dann?
— Fehler
6

Verarbeitung , 95 85 71 Bytes

java.math.BigInteger i;{i=i.ZERO;}void draw(){println(i=i.add(i.ONE));}

Ich habe etwas mit einer while-Schleife ausprobiert, aber dadurch stürzt die gesamte Verarbeitung ab. Daher bleibe ich vorerst bei dieser.

(Vielen Dank an @ SuperJedi224 und @TWiStErRob für Vorschläge.)

— Geokavel
quelle
Was ist mit den Räumen? Ich bin mir ziemlich sicher, dass import java.math.*;BigInteger i=BigInteger.ZERO;void draw(){println(i=i.add(BigInteger.ONE));}es funktionieren wird.
— SuperJedi224,
Ja, habe das gerade behoben.
— Geokavel
Ermöglicht die Verarbeitung das BigInteger.ONEÄndern auf i.ONE?
— SuperJedi224
@ SuperJedi224 Ja, das tut es. Vielen Dank!
— Geokavel
Okay, hab eine Gegenstimme.
— SuperJedi224
6

Samau , 2 Bytes

N)

Erläuterung:

N     push the infinite list [0 1 2 ...] onto the stack
 )    increase by 1

Wenn die Ausgabe eines Programms eine Liste ist, werden die äußersten Klammern weggelassen.

— Alephalpha
quelle
Druckt eine Liste nicht alle Inhalte auf einmal? Wenn diese Liste unendlich ist , kann sie möglicherweise nicht in den Speicher oder auf Ihren Bildschirm passen , und sie wird niemals aufhören, generiert zu werden, sodass sie niemals gedruckt wird.
— Katze
1
@cat Samau ist in Haskell geschrieben und es ist faul . Vor dem Drucken wird nicht die gesamte Liste erstellt.
— alephalpha
Nur ein Kopf hoch. Auf der GitHub-Seite für Samau wird in der Beschreibung von @"push" falsch geschrieben.
— Carcigenicate
@Carcigenicate Danke.
— Alephalpha
6

JavaScript (ES6), 99 94 67 Bytes

for(n=[i=0];;)(n[i]=-~n[i++]%10)&&alert([...n].reverse(i=0).join``)

alertist die allgemein akzeptierte STDOUTEntsprechung für JavaScript, aber die Verwendung von JavaScript bedeutet, dass fortlaufende Nummern automatisch getrennt werden. Ich bin davon ausgegangen, dass die Ausgabe eines Zeichens nach der Zahl aus diesem Grund nicht erforderlich ist.

— user81655
quelle
12
Deshalb habe ich einen Popup-Blocker.
— Comintern
1
nur sagen: für (i = 0 ;;) alert (i ++) Ich glaube nicht, dass Sie alle diese Kontrollen brauchen
— Towc
3
@towc Das geht nicht. Bei allen Zahlen handelt es sich um 64-Bit-Floats in JavaScript, die einen maximalen sicheren Ganzzahlwert von haben, 2^53aber die Frage erfordert, dass dieser Wert erreicht wird 2^128.
— user81655
1
oh, fair point ...
— Schlepptau
5

Matlab, 132 Bytes

a=0;while 1;b=a==9;n=find(cumsum(b)-(1:numel(b)),1);a(n)=a(n)+1;a(1:n-1)=0;if ~numel(n);a=[0*a,1];end;disp([a(end:-1:1)+'0','']);end

Ok, ich denke, dies ist die erste ernsthafte Antwort, die diese Aufgabe ohne eine trivial eingebaute Ganzzahl mit beliebiger Größe erfüllt. Dieses Programm implementiert eine Ganzzahl beliebiger Größe als Array von Ganzzahlen. Jede Ganzzahl liegt immer zwischen 0 und 9, sodass jedes Array-Element eine Dezimalstelle darstellt. Die Array-Größe wird um eins erhöht, sobald wir z 999. Die Speichergröße ist hier kein Problem, da 2^128nur ein Array mit der Länge 39 erforderlich ist.

a=0;
while 1
    b=a==9;
    %first number that is not maxed out
    n=find(cumsum(b)-(1:numel(b)),1);
    %increase that number, and sett all maxed out numbers to zero
    a(n)=a(n)+1; 
    a(1:n-1)=0;
    if ~numel(n) %if we maxed out all entries, add another digit
        a=[0*a,1];
    end    
    disp([a(end:-1:1)+'0',''])%print all digits
end
— fehlerhaft
quelle
5

C ++, 146 141 138 Bytes

Eine Standard - Bigint Bibliothek ist vielleicht die meisten langweilig Weg , um diese Frage zu beantworten, aber jemand musste es tun.

#include<stdio.h>
#include<boost/multiprecision/cpp_int.hpp>
int main(){for(boost::multiprecision::uint512_t i=1;;){printf("%u\n",i++);}}

Ungolfed:

#include<cstdio>
#include<boost/multiprecision/cpp_int.hpp>

int main()
{
    for(boost::multiprecision::uint512_t i=1;;)
    {
        std::printf("%u\n", i++);
    }
}

Der Grund, warum die Golf-Version verwendet stdio.hund nicht, cstdioist zu vermeiden, dass der std::Namespace verwendet werden muss.

Dies ist mein erstes Mal in C ++, lass es mich wissen, wenn es irgendwelche Tricks gibt, um dies weiter zu verkürzen.

— felixphew
quelle
Vielleicht könntest du '\n'stattdessen std::endl8 Bytes sparen. Es kann auch eine Möglichkeit geben, CPP #define zu verwenden, um Wiederholungen zu komprimieren.
— Kenney,
@Kenney Danke dafür! (Es werden nur 5 Bytes gespart, nicht 8.) Ich glaube, ich habe mir einen Weg ausgedacht, um diesen Abschnitt noch kürzer zu machen.
— Felixphew
Ich weiß nicht, was Boost ist (und ich würde auch nicht sagen, dass es Standard ist), aber ist es nicht istandardmäßig mit dem Wert 0 konstruiert? Sie könnten dann die Definition entfernen und das Post-Inkrement auf Preincremet umstellen, wodurch 2b
— Zereges
Wie wäre es mit den veralteten #import?
— connectyourcharger
5

C # .NET 4.0, 111 103 102 97 Bytes

class C{static void Main(){System.Numerics.BigInteger b=1;for(;;)System.Console.WriteLine(b++);}}

Ich habe hier keine C # Antwort gefunden, also musste ich nur eine schreiben.

.NET 4.0 ist erforderlich, da es die erste Version ist, die BigInteger enthält . Sie müssen jedoch auf System.Numerics.dll verweisen .

Mit Einrückung:

class C
{
    static void Main()
    {   
        System.Numerics.BigInteger b = 1;
        for (;;)
            System.Console.WriteLine(b++);
    }
}

Dank Sweerpotato, Kvam, Berend für das Speichern einiger Bytes

— Kazarp
quelle
Sie können 8 Bytes sparen mit class C{static void Main(){var b=System.Numerics.BigInteger.One;for(;;)System.Console.WriteLine(b++);}}: ~)!
— Sweerpotato
1
Verschieben Sie die Deklaration von b und Console.WriteLinein die Schleifenstruktur:class C{static void Main(){for(var b=System.Numerics.BigInteger.One;;Console.WriteLine(b++));}}
— Kvam
Du brauchst noch System. Das spart aber ein Byte!
— Sweerpotato
Ja, du hast recht.
— Kvam
Wenn Sie using System;(13 Bytes) hinzufügen , können Sie die System.(7 Bytes) zweimal entfernen und 1 Byte sparen.
— Kenney
5

Clojure, 17 Bytes

(map prn (range))

Lazy Sequences und Integer mit beliebiger Genauigkeit machen dies einfach (wie bei Haskell und CL). prnspart mir ein paar Bytes, da ich keinen Formatstring drucken muss. doseqwäre wahrscheinlich idiomatischer, da wir hier nur mit Nebenwirkungen zu tun haben; mapDie Verwendung ist wenig sinnvoll, da dadurch eine Sequenz von nil(erstellt wird, die den Rückgabewert jedes prnAufrufs darstellt.

Angenommen, ich zähle für immer, wird die Nullzeigerfolge, die sich aus dieser Operation ergibt, nie zurückgegeben.

— MONODA43
quelle
4

MarioLANG , 11 Bytes

+<
:"
>!
=#

Inspiriert von Martin Büttners Antwort auf eine andere Frage .

— Alephalpha
quelle
Sind Sie sicher, dass dies ohne Probleme zu 2 ^ 128 funktioniert?
— Fehler
1
— Martin Ender
@flawr MarioLANG hat einen Ruby-Interpreter, und der Integer-Typ von Ruby ist willkürlich genau.
— Martin Ender
@flawr Kommt auf den Interpreter an. Der von mir verwendete Interpreter ist in Ruby geschrieben und unterstützt willkürliche Genauigkeit.
— alephalpha
4

CJam, 7 Bytes

0{)_p}h

Erläuterung:

0         e# Push a zero to the stack
 {        e# Start a block
  )         e# Increment top of stack
   _        e# Duplicate top of stack
    p       e# Print top of stack
     }    e# End block
      h   e# Do-while loop that leaves the condition on the stack

Hinweis: Muss Java-Interpreter verwenden.

— GamrCorps
quelle
4

C 89 Bytes

Ein neuer Ansatz (Implementierung eines bitweisen Inkrementierers) in C:

b[999],c,i;main(){for(;;)for(i=c=0,puts(b);i++<998;)putchar(48+(c?b[i]:(b[i]=c=!b[i])));}

Weniger golfen

int b[999], c, i;
main() {
  for(;;)
    for(i=c=0, puts(b); i++ < 998;)
      putchar(48 + (c ? b[i] : (b[i] = c = !b[i])));
}

Kündigen

Diese Version hat den kleinen Fehler, dass sie nicht terminiert (was im Moment keine Voraussetzung ist). Dazu müssten Sie 3 Zeichen hinzufügen:

b[129],c=1,i;main(){for(;c;)for(i=c=0,puts(b);i++<128;)putchar(48+(c?b[i]:(b[i]=c=!b[i])));}
— Helco
quelle
4
Tatsächlich sollte es nicht enden. Das ist die Bedeutung vonforever
— edc65
4

Foo , 6 Bytes

(+1$i)

Erläuterung

(    )    Loop
 +1       Add one to current element
   $i     Output current element as a decimal integer
— Zach Gates
quelle
4

Minkolang , 4 Bytes

1+dN

Probieren Sie es hier aus.(Nun, eigentlich ist Vorsicht geboten. 3 Sekunden Laufzeit reichten aus, um auf ~ 40.000 zu kommen.)

1+Fügt 1 zum Anfang des Stapels hinzu, ddupliziert ihn und Ngibt den Anfang des Stapels als Ganzzahl mit einem nachgestellten Leerzeichen aus. Dies führt zu einer Schleife, da Minkolang toroidal ist. Wenn der Programmzähler von der rechten Kante abweicht, wird er auf der linken Seite erneut angezeigt.

— El'endia Starman
quelle
4

Intel 8086+ Assembly, 19 Byte

68 00 b8 1f b9 08 00 31 ff f9 83 15 00 47 47 e2 f9 eb f1

Hier ist eine Aufschlüsselung:

68 00 b8                push   0xb800             # CGA video memory
1f                      pop    ds                 # data segment
b9 08 00           L1:  mov    cx, 8              # loop count
31 ff                   xor    di, di             # ds:di = address of number
f9                      stc                       # set carry
83 15 00           L2:  adc    word ptr [di], 0   # add with carry
47                      inc    di
47                      inc    di
e2 f9                   loop   L2
eb f1                   jmp    L1

Es gibt die 128-Bit-Nummer in den oberen linken 8 Bildschirmpositionen aus. Jede Bildschirmposition enthält ein 8-Bit-ASCII-Zeichen und zwei 4-Bit-Farben.

Hinweis: Es wird um 2 128 gewickelt. Ändern Sie einfach den Wert 8in mov cx, 8, 9um eine 144-Bit-Zahl anzuzeigen , oder sogar 80*25, um Zahlen bis zu 2 32000 anzuzeigen .

Laufen

1,44 MB bzip2 komprimiertes, base64-codiertes bootfähiges Disketten-Image

Generieren Sie das Disketten-Image, indem Sie Folgendes kopieren und einfügen

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

in diese Kommandozeile:

base64 -d | bunzip2 > floppy.img

und laufen zum Beispiel mit qemu -fda floppy.img -boot a

1,8 MB bootfähiges ISO

Dies ist ein Base64-kodiertes bzip2-komprimiertes ISO-Image. Erzeugen Sie die ISO durch Einfügen

QlpoOTFBWSZTWZxLYpUAAMN/2//fp/3WY/+oP//f4LvnjARo5AAQAGkAEBBKoijAApcDbNgWGgqa
mmyQPU0HqGCZDQB6mQ0wTQ0ZADQaAMmTaQBqekyEEwQaFA0AA0AxBoAAA9Q0GgNAGg40NDQ0A0Bi
BoDIAANNAA0AyAAABhFJNIJiPSmnpMQDJpp6nqeo0ZDQaAANB6IA0NAGj1EfIBbtMewRV0acjr8u
b8yz7cCM6gUUEbDKcCdYh4IIu9C6EIBehb8FVUgEtMIAuvACCiO7l2C0KFaFVABcpglEDCLmQqCA
LTCAQ5EgnwJLyfntUzNzcooggr6EnTje1SsFYLFNW/k+2BFABdH4c4vMy1et4ZjYii1FbDgpCcGl
mhZtl6zX+ky2GDOu3anJB0YtOv04YISUQ0JshGzAZ/3kORdb6BkTDZiYdBAoztZA1N3W0LJhITAI
2kSalUBQh60i3flrmBh7xv4TCMEHTIOM8lIurifMNJ2aXr0QUuLDvv6b9HkTQbKYVSohRPsTOGHi
isDdB+cODOsdh31Vy4bZL6mnTAVvQyMO08VoYYcRDC4nUaGGT7rpZy+J6ZxRb1b4lfdhtDmNwuzl
E3bZGU3JTdLNz1uEiRjud6oZ5kAwqwhYDok9xaVgf0m5jV4mmGcEagviVntDZOKGJeLjyY4ounyN
CWXXWpBPcwSfNOKm8yid4CuocONE1mNqbd1NtFQ9z9YLg2cSsGQV5G3EhhMXKLVC2c9qlqwLRlw4
8pp2QkMAMIhSZaSMS4hGb8Bgyrf4LMM5Su9ZnKoqELyQTaMAlqyQ3lzY7i6kjaGsHyAndc4iKVym
SEMxZGG8xOOOBmtNNiLOFECKHzEU2hJF7GERK8QuCekBUBdCCVx4SDO0x/vxSNk8gKrZg/o7UQ33
Fg0ad37mh/buZAbhiCIAeeDwUYjrZGV0GECBAr4QVYaP0PxP1TQZJjwT/EynlkfyKI6MWK/Gxf3H
V2MdlUQAWgx9z/i7kinChITiWxSo

in

base64 -d bunzip2 > cdrom.iso

und konfigurieren Sie eine virtuelle Maschine zum Booten.

DOS .COM

Dies ist eine Base64-kodierte DOS .COM- Programmdatei:

aAC4H7kIADH/+YMVAEdH4vnr8Q==

Generieren Sie eine .COM-Datei mit 

/bin/echo -n aAC4H7kIADH/+YMVAEdH4vnr8Q== | base64 -d > COUNTUP.COM

und starte es unter (Free) DOS.

— Kenney
quelle
4

Perl , 34 32 30 28 26 23 Bytes

-Mbigint -E '{say$_+=1;redo}'

Testen Sie mit

perl -Mbigint -E '{say$_+=1;redo}'
— Kenney
quelle
Sie können ersetzen for(,,){...}mit {...;redo}zwei.
— Primo
Ja, ich habe gesehen (Perl 5.18+), aber ich dachte, es könnte schummeln; dann wären die Antworten die gleichen. Ich bin neu hier, also ;-)
— Kenney
1
Skalare Referenzen werden automatisch als belebt. SV UNDEFWenn sie inkrementiert werden, wird die BigIntÜberladung nicht ausgelöst, da dies nicht der Fall ist BigInt. Ganzzahlige Literale werden jedoch als BigInts erstellt. Nicht so seltsam;)
— Primo
1
Könnten Sie verwenden $-, um es als Ganzzahl zu behalten und zur Verwendung zurückzukehren ++$-?
— Dom Hastings
1
@DomHastings, mit dem ich getestet habe, perl -Mbigint -E '{say++$-;$-+=$-;redo}' | moreund es geht auf 1 zurück. Es bleibt ein int, aber bigint greift leider nicht ein.
— Kenney
4

Marbelous, 358 Bytes

..@F..@E..@D..@C..@B..@A..@9..@8..@7..@6..@5..@4..@3..@2..@1..@001@Z01
..AddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddo/\&I
00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I....@Z
@FHd@EHd@DHd@CHd@BHd@AHd@9Hd@8Hd@7Hd@6Hd@5Hd@4Hd@3Hd@2Hd@1Hd@0Hd
0A@N
..&I
@N/\..
:Hd
}0
Hp
}0
..
{<
#include hex_out.mbl
#include arithmetic.mbl

16 Halbaddierer verkettet, wobei der am weitesten rechts stehende Addierer in jedem Zyklus N ++ ausführt und jeder Addierer seinen Überlauf (00 oder 01) dem nächsten in der Kette zuführt. Die Ausgabe erfolgt in hex.

Der Python-Interpreter weist einen Fehler auf, bei dem die Ausgabe von gespeicherten Funktionen verloren geht. Sie müssen dies also mit "-m 0" ausführen, damit es richtig funktioniert. Ohne diesen Parameter können Sie sehen, wie schnell es ohne den Fehler ausgeführt wird, aber die Ausgabe funktioniert nicht richtig.

Hinweis zur Selbsthilfe: Beheben Sie diesen Fehler in marbelous.py. Dieser Fehler wurde in der neuesten Version von marbelous.py behoben

— Sparr
quelle
4

R, 52 Bytes

a=gmp::as.bigz(1);repeat{cat(paste(a,""));a=a+1}

(Hinweis: Es gmphandelt sich um eine externe Bibliothek, daher müssen Sie sie möglicherweise herunterladen, damit diese Lösung funktioniert.)

— Schnarchfrosch
quelle
1
+1 ... Entschuldigung für alle Extras. Um dir ein paar zurückzuholen, könntest du es versuchen a=gmp::as.bigz(0);repeat{cat(paste(a<-a+1,''))}. Möglicherweise möchten Sie eine Notiz erstellen, bei der gmpes sich um eine externe Bibliothek handelt, die möglicherweise heruntergeladen werden muss.
— MickyT
— Giuseppe
4

BotEngine, 128 120 112 8 x 13 = 104

v2 2 01
>e>S SS
   e1e1
   e2 e0 12
   > > S SS P
  ^   <e0e1 R
     ^ < <lC^
^         <

Die Ausgabe erfolgt binär.

— SuperJedi224
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.