Ecrivez un programme qui compte pour toujours, à partir d'un.

Règles:

• Votre programme doit se connecter à STDOUTou à une alternative acceptable, si elle STDOUTn’est pas disponible.
• Votre programme doit être un programme complet exécutable et non une fonction ou un extrait de code.
• Votre programme doit sortir chaque nombre avec un caractère séparateur (une nouvelle ligne, un espace, une tabulation ou une virgule), mais cela doit être cohérent pour tous les nombres.
• Vous pouvez imprimer les nombres en décimal, en unaire ou en base 256, chaque chiffre étant représenté par une valeur d'octet .
• Votre programme doit compter au moins 2 ¹²⁸ (inclus) sans problèmes et sans manquer de mémoire sur un ordinateur de bureau raisonnable. En particulier, cela signifie que si vous utilisez unary, vous ne pouvez pas stocker en mémoire une représentation unaire du nombre actuel.

• Contrairement à nos règles habituelles, n'hésitez pas à utiliser une langue (ou une version linguistique) même si c'est plus récent que ce défi. Les langues spécifiquement écrites pour soumettre une réponse de 0 octet à ce défi sont un jeu juste mais pas particulièrement intéressant.

  Notez qu'il doit y avoir un interprète pour que la soumission puisse être testée. Il est permis (et même encouragé) d’écrire cet interprète vous-même pour une langue non encore implémentée.

• Il ne s'agit pas de trouver la langue avec la solution la plus courte pour cela (il y en a où le programme vide fait l'affaire) - il s'agit de trouver la solution la plus courte dans chaque langue. Par conséquent, aucune réponse ne sera marquée comme acceptée.

Catalogue

L'extrait de pile au bas de cet article génère le catalogue à partir des réponses a) sous forme de liste des solutions les plus courtes par langue et b) sous forme de classement global.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

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

Labyrinthe , 5 octets

):
\!

♫ L'IP dans le code tourne en rond ♫

Instructions pertinentes:

)       Increment top of stack (stack has infinite zeroes at bottom)
:       Duplicate top of stack
!       Output top of stack
\       Output newline

> <> , 8 octets

01+:nao!

Pas:

• Poussez 0 sur la pile
• Ajouter 1 à l'élément de pile supérieur
• Duplicate top stack element
• Affiche le haut de la pile sous forme de nombre
• Produire une nouvelle ligne
• Passez à l'étape 2 en faisant le tour et en sautant l'instruction suivante (étape 11)

(Un programme moins efficace en mémoire (donc invalide) est llnao.)

Haskell, 21 octets

main=mapM_ print[1..]

Les entiers à précision arbitraire et les listes infinies rendent cela facile :-)

Heureusement, mapM_c'est dans le prélude. Si Data.Traversablec'était aussi bien, nous pourrions même le réduire à 19 octets:

main=for_[1..]print

Gol> <> , 3 octets

P:N

Pas:

• Ajouter 1 à l'élément de pile supérieur (au début c'est un 0 implicite)
• Duplicate top stack element
• Pop et sortie le haut de la pile sous forme de nombre et une nouvelle ligne
• Passez à l'étape 1 lorsque nous avons atteint la fin de la ligne

Marbelous , 11450 4632 octets

Imprimer des nombres décimaux est une douleur !!

Certainement pas gagner avec celui-ci, mais je pensais que je pourrais tenter le coup. J'espère que ça va, ça compense la sortie à 40 zéros (pour 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 (architecture 64 bits uniquement), 53 octets

S'appuie sur des pointeurs d'au moins 64 bits et les affiche au format hexadécimal à l'aide du %pspécificateur. Le programme reviendrait juste quand il frappe 2 ^ 128.

char*a,*b;main(){for(;++b||++a;)printf("%p%p ",a,b);}

Hexagony , 12 11 10 7 octets

Merci à Alephalpha pour l’adaptation du code en side-length 2.

10})!';

Déplié:

 1 0
} ) !
 ' ;

Celui-ci est assez simple. 10écrit un 10, c’est-à-dire un saut de ligne sur le bord initial de la mémoire. Puis })!';est exécuté à plusieurs reprises dans une boucle:

• } passer au bord de mémoire suivant.
• ) incrémente-le.
• ! Imprimez-le en tant qu'entier.
• ' revenir à la 10.
• ; Imprimez-le comme un personnage.

Je crois que c'est optimal (bien que de loin pas unique). Je l' ai laissé le script de la force brute , j'ai écrit pour cette réponse recherche de solutions 6 octets dans l'hypothèse où il devrait contenir au moins un chacun ;et !et soit (ou ), et ne contiendrait pas ?, ,ou @, et il n'a pas trouver des solutions.

Pyth, 4 octets

.V1b

Explication:

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

bc, 10

for(;;)++i

Insolite qui bcest plus court que dc.

De man bc:

LA DESCRIPTION

bc est un langage qui supporte les nombres de précision arbitraire

Java, 139 138 127 123 octets

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 octets

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

Echo est une nouvelle fonction de Mathematica 10.3.

Ruby, 15 12 octets

loop{p$.+=1}

• p, lorsqu'un nombre entier est donné, affiche le nombre entier tel quel (avec la permission de @philomory )
• $.est une variable magique contenant le nombre de lignes lues dans stdin. Il est évidemment initialisé à 0 et assignable :)

Python 3, 33 25 octets

Pour autant que je sache, les entiers Pythons ont une précision arbitraire et print()produisent automatiquement des nouvelles lignes.

Merci pour @Jakub et @ Sp3000 et @wnnmaw! Je ne sais vraiment pas beaucoup de python, la seule chose que je savais, c’est qu’il supporte des entiers de taille arbitraire =)

k=1
while 1:print(k);k+=1

Traitement , 95 85 71 octets

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

J'ai essayé quelque chose avec une boucle while, mais tout le traitement est en panne, je vais donc m'en tenir à cela pour le moment.

(Merci à @ SuperJedi224 et à @TWiStErRob pour leurs suggestions.)

Samau , 2 octets

N)

Explication:

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

Lorsque la sortie d'un programme est une liste, les crochets les plus à l'extérieur sont omis.

JavaScript (ES6), 99 94 67 octets

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

alertest l’ STDOUTéquivalent généralement accepté pour JavaScript, mais son utilisation signifie que des nombres consécutifs sont automatiquement séparés. J'ai supposé que la sortie d'un caractère après le nombre n'était pas nécessaire pour cette raison.

Matlab, 132 octets

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, je pense que ceci est la première réponse sérieuse qui accomplit cette tâche sans un nombre entier trivial intégré. Ce programme implémente un entier de taille arbitraire sous forme de tableau d’entiers. Chaque entier étant toujours compris entre 0 et 9, chaque élément du tableau représente un chiffre décimal. La taille du tableau sera augmentée de un dès que nous en serons par exemple 999. La taille de la mémoire n’est pas un problème ici, car elle 2^128nécessite seulement un tableau de longueur 39.

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 octets

Utiliser une bibliothèque standard Bigint est peut-être la façon la plus ennuyeuse de répondre à cette question, mais quelqu'un devait le faire.

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

La version golfée utilise stdio.het ne cstdiodoit pas utiliser l’ std::espace de noms.

C’est la première fois que je joue au golf en C ++. Dites-moi s’il existe des astuces pour le raccourcir davantage.

C # .NET 4.0, 111 103 102 97 octets

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

Je n’ai trouvé aucune réponse en C # ici, j’ai donc dû en écrire une.

.NET 4.0 est requis car c'est la première version qui inclut BigInteger . Vous devez cependant référencer System.Numerics.dll .

Avec indentation:

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

Merci à sweerpotato, Kvam et Berend d'avoir économisé quelques octets

Clojure, 17 octets

(map prn (range))

Les séquences paresseuses et les entiers de précision arbitraire facilitent cette opération (comme pour Haskell et CL). prnme sauve quelques octets car je n’ai pas besoin d’imprimer une chaîne de format. doseqserait probablement plus idiomatique puisque nous ne traitons ici que des effets secondaires; mapn’a pas beaucoup de sens à utiliser car cela créera une séquence de nil(qui est la valeur de retour de chaque prnappel).

En supposant que je compte pour toujours, la séquence de pointeur null résultant de cette opération n'est jamais renvoyée.

MarioLANG , 11 octets

+<
:"
>!
=#

Inspiré par la réponse de Martin Büttner à une autre question .

CJam, 7 octets

0{)_p}h

Explication:

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

Remarque: Vous devez utiliser un interpréteur Java.

C, 89 octets

Une nouvelle approche (implémentation d’un incrémenteur au niveau du bit) en 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])));}

Moins golfé

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

Mettre fin

Cette version a le léger défaut de ne pas se terminer (ce qui n’est pas une obligation pour le moment). Pour ce faire, vous devez ajouter 3 caractères:

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 octets

(+1$i)

Explication

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

Minkolang , 4 octets

1+dN

Essayez ici. (Eh bien, en fait, soyez prudent. 3 secondes de temps d'exécution suffisaient pour atteindre environ 40 000 $.)

1+ajoute 1 au sommet de la pile, le dduplique et Ngénère le haut de la pile sous la forme d'un entier avec un espace de fin. Cela boucle parce que Minkolang est toroïdal, donc lorsque le compteur de programme sort du bord droit, il réapparaît à gauche.

Intel 8086+ Assembly, 19 octets

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

Voici une ventilation:

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

Il émet le numéro 128 bits sur les 8 positions d'écran en haut à gauche. Chaque position d’écran contient un caractère ASCII 8 bits et deux couleurs 4 bits.

Remarque: il se termine à 2 ¹²⁸ ; changez simplement le 8en mov cx, 8pour 9afficher un nombre de 144 bits, ou même 80*25pour montrer des nombres allant jusqu’à 2 ³²⁰⁰⁰ .

Fonctionnement

Disquette amorçable compressée bzip2 de 1,44 Mo, codée en Base64 Image

Générez l'image de la disquette en copiant-collant ce qui suit

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

dans cette ligne de commande:

base64 -d | bunzip2 > floppy.img

et courir avec, par exemple, qemu -fda floppy.img -boot a

1,8 Mo ISO amorçable

Ceci est une image ISO compressée bzip2 codée en base64. Générer l'iso en collant

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

dans

base64 -d bunzip2 > cdrom.iso

et configurer une machine virtuelle pour démarrer à partir de celle-ci.

DOS .COM

Il s’agit d’un exécutable DOS .COM codé en base64 :

aAC4H7kIADH/+YMVAEdH4vnr8Q==

Générez un fichier .COM en utilisant

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

et lancez-le sous (Free) DOS.

Perl , 34 32 30 28 26 23 octets

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

Test avec

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

Marbelous, 358 octets

..@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 demi-additionneurs enchaînés, le plus à droite effectuant N ++ à chaque cycle et chaque additionneur alimentant son trop-plein (00 ou 01) au suivant dans la chaîne. La sortie est en hexadécimal.

L'interpréteur python a un bogue dans lequel la sortie des fonctions mémoisées est perdue. Vous devez donc l'exécuter avec "-m 0" pour que tout fonctionne correctement. Sans ce paramètre, vous pouvez voir à quelle vitesse il fonctionnera sans le bogue, mais la sortie ne fonctionnera pas correctement.

Note to self: corrigeons ce bogue dans marbelous.py Ce bogue a été corrigé dans la dernière version de marbelous.py

R, 52 octets

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

(Remarque: gmpest une bibliothèque externe, vous devrez peut-être la télécharger pour que cette solution fonctionne)

BotEngine, 128 120 112 8x13 = 104

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

La sortie est en binaire.