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 ¹²⁸ (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

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 63834; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 39069; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(42), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

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

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

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

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

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

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

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.

Pyth, 4 Bytes

.V1b

Erläuterung:

.V1    for b in range(1 to infinity):
   b      print b

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

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

Mathematica, 22 Bytes

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

Echo ist eine neue Funktion in Mathematica 10.3.

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 :)

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

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

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.

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.

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

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.

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

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.

MarioLANG , 11 Bytes

+<
:"
>!
=#

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

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.

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

Foo , 6 Bytes

(+1$i)

Erläuterung

(    )    Loop
 +1       Add one to current element
   $i     Output current element as a decimal integer

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.

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 ¹²⁸ 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.

Perl , 34 32 30 28 26 23 Bytes

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

Testen Sie mit

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

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

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

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.