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

Afficher l'extrait de code

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

Développer l'extrait

code-golf number counting vrwim
la source

29

Je ne suis pas sûr de savoir comment combiner obligatoirement la sortie de chaque nombre avec un [...] caractère de séparation entre ceux-ci et les chiffres de la base 256 .

Dennis

6

Pour les défis futurs, puis-je recommander le bac à sable de telle sorte que tous ces détails puissent être triés avant que les gens ne commencent à poster des réponses? :)

Martin Ender

3

@IlmariKaronen J'interprète cela comme une limite de mémoire, pas une limite de temps. éventuellement, une limite de temps par incrément. Il suffit de régler le compteur sur 2 ** 128-10 et de voir le temps nécessaire pour effectuer ces dix dernières étapes.

Sparr

5

Peut-on avoir des zéros non significatifs dans la sortie?

Paŭlo Ebermann

4

Pouah!!! J'ai une réponse pour la TI-89 (56b), mais je ne peux pas publier car je suis nouveau sur le site et je n'ai pas de représentant 10+!

gregsdennis

63

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

Sp3000
la source

77

Le programme est triste de ne pas s’arrêter ..

Optimiseur

7

@Optimizer def sad (en effet):

YoYoYonnY

1

Pourquoi n'est-ce pas 4 octets?

Aurel Bílý

2

@ Aurel300 Le cinquième octet est la nouvelle ligne entre :et\

Sp3000

@ Sp3000 Ah, oui. Que je suis bête. :)

Aurel Bílý

46

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

randomra
la source

66

+1 pour l'impatient exigeant, exigeant, implicite dans une ligne de code qui lit fondamentalement "plus un, maintenant!".

Janus Bahs Jacquet

24

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

Bergi
la source

N'y a-t-il pas un symbole qui généralise map / mapM, etc.?

JDługosz

@ JDługosz: pas que je sache

Bergi

Ah, car il faudrait toujours que sequencele résultat donne le résultat final.

JDługosz

n'est-il pas simplement [1..]autorisé, puisqu'il affiche tous les nombres avec une virgule entre? ou le premier [bousiller tout ça?

Baconaro

@ Baconaro: c'est une liste, ça n'imprime rien. GHCi imprime le résultat si vous entrez le terme dans la répl, mais ce n'est pas un programme exécutable. Et oui, le leader [n'est pas autorisé non plus.

Bergi

23

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

randomra
la source

21

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

Le docteur
la source

L'impression binaire serait-elle plus courte?

SuperJedi224

3

(ou que diriez-vous unaire?)

Bouton de porte

@Doorknob affichant la sortie n'est pas le problème. C'est quelque chose sur le Ehuntableau qui est supposé incrémenter le prochain chiffre, mais ne fonctionne pas correctement

TheDoctor

1

Saviez-vous que vous pouvez omettre les points à la fin de chaque ligne et les lignes vides entre les tableaux et utiliser des caractères uniques pour les noms de tableau? Il vous suffit de répéter à ce seul caractère le temps nécessaire pour l'appeler. Cela peut réduire votre réponse à environ 3000 octets.

Overactor

Finalement, je vais pousser un engagement à marbelous.py qui inclut tous include/par défaut

Sparr

18

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

feersum
la source

1

Donc, si ces pointeurs sont à chaque 64 bits, vous ne pouvez compter que jusqu'à 2 ^ 128-1, non?

flawr

6

Non valide car il ne peut pas compter jusqu'à 2 ^ 128

edc65

14

J'aime CodeGolf lorsqu'il s'agit d'exprimer et de récompenser la créativité. feersum n'est clairement pas en compétition pour la victoire ici. Voir de nombreux avis négatifs sur un détail technique et modifier le libellé de la question pour s'assurer que sa réponse est en violation me rend triste.

Flodel

3

Je pensais que les mots "au moins aussi loin que 2 ^ 128" étaient suffisamment clairs ...

vrwim

5

@vrwim Vous n'avez pas écrit ça. Vous avez écrit "jusqu’à 2 ^ 128". SuperJedi l'a édité il y a quelques minutes.

Feersum

17

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.

Martin Ender
la source

13

Pyth, 4 octets

.V1b

Explication:

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

Jakube
la source

f!\n( Lien TIO ) fonctionnera pendant 3 octets, pas sûr si cela utilise des fonctionnalités qui ont été ajoutées après votre réponse cependant.

Sok

@Sok Clever. Cependant, je ne changerai pas la réponse parce que je pense que fc'était une caractéristique de Pyth il y a 4 ans.

Jakube

Je le pensais aussi, c'est pourquoi je l'ai laissé comme commentaire - de nouvelles fonctionnalités linguistiques pour battre une réponse ancienne se sentent toujours bon marché IMO

Sok

13

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

Trauma numérique
la source

Où cela est-il imprimé?

Bálint

@ Bálint ++iest une expression, mais pas une affectation, et est donc explicitement sortie. Avez-vous essayé de l'exécuter? echo 'for(;;)++i' | bcdans votre terminal Linux le plus proche.

Digital Trauma

Je n'ai pas un seul terminal Linux chez moi. J'étais juste curieux.

Bálint

6

@ Bálint Chaque maison devrait avoir un terminal Linux.

Digital Trauma

1

@ Bálint Vous utilisez ce programme;)

Insane

12

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

SuperJedi224
la source

2

Une boucle infinie plus petite en Java est for(;;)pour 3 octets faciles.

Ankh-Morpork

Vous pouvez également enregistrer un autre 2 avec BigInteger b=null;b=b.ZERO;, malheureusement, le =nullnécessaire, même s’il s’agit d’un accès statique.

TWiStErRob

Et puis un autre 9, parce que vous pouvez vous débarrasser de l'importation en faisant référence BigIntegerà FQCN une seule fois.

TWiStErRob

@TWiStErRob D'une manière ou d'une autre, je n'avais pas réalisé que ce serait plus court.

SuperJedi224

2

Pour Java 8 ou plus récent, vous pouvez remplacer la classe par interfaceet supprimer publicde la fonction. Vous ne voulez pas copier votre code et le poster comme une nouvelle réponse.

Luca H

10

Mathematica, 22 octets

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

Echo est une nouvelle fonction de Mathematica 10.3.

Alephalpha
la source

Echodonne quatre caractères de séparation: newline plus ">> ". Pas sûr que cela soit valide - peut-être utiliser à la Printplace? Enregistrez également un octet avec i=0;While[Echo@++i>0].

Roman

7

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

Daniero
la source

@philomory Il est généralement suggéré aux utilisateurs de laisser un commentaire suggérant leur solution d'économie d'octets. Aussi, j'aimerais voir une explication pour celui-ci. c:

Addison Crump

7

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

flawr
la source

1est une valeur de vérité en Python (et la plupart des autres langues). Alors while 1:c'est assez.

Jakube

Aussi, vous pouvez mettre le tout whilesur une seule ligne

Sp3000

Vous pouvez enregistrer un octet en utilisant repr(k)plutôt que print(k). Aussi, je compte votre taille d'octet de 25 (sans ma modification suggérée)

wnnmaw

1

Vous ne pouvez pas utiliser reprau lieu de print. reprne sort rien. @wnnmaw

Zach Gates

Que fait repralors?

flawr

6

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

geokavel
la source

C'est quoi les espaces? Je suis sûr que ça import java.math.*;BigInteger i=BigInteger.ZERO;void draw(){println(i=i.add(BigInteger.ONE));}marchera.

SuperJedi224

Oui, je viens de réparer ça.

geokavel

Le traitement permet-il BigInteger.ONEde le modifier i.ONE?

SuperJedi224

@ SuperJedi224 Oui, c'est le cas. Merci!

geokavel

Bon, ayez un vote positif.

SuperJedi224

6

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.

Alephalpha
la source

Une liste n'imprime-t-elle pas tout son contenu à la fois? Si cette liste est infinie , alors elle ne peut pas tenir dans la mémoire ou sur votre écran , et elle ne cessera jamais d'être générée, elle ne sera donc jamais imprimée.

Chat

1

@cat Samau est écrit en Haskell et il est paresseux . Il ne générera pas la liste complète avant de l’imprimer.

Alephalpha

Juste un heads-up. Sur la page GitHub de Samau, dans la description de @"push" est mal orthographié.

Carcigenicate

@Carcigenicate Merci.

Alephalpha

6

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.

utilisateur81655
la source

12

C'est pourquoi j'ai un bloqueur de fenêtres publicitaires intempestives.

Komintern

1

je viens de dire: pour (i = 0 ;;) alert (i ++), je ne pense pas que vous ayez besoin de tous ces contrôles

Towc

3

@towc Cela ne fonctionnera pas. Tous les nombres sont des nombres flottants 64 bits en JavaScript qui ont une valeur entière sécurisée maximale, 2^53mais la question oblige à aller jusqu'à 2^128.

user81655

1

oh, bon point ...

towc

5

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

flawr
la source

5

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.

Felixphew
la source

Peut-être que vous pourriez utiliser '\n'au lieu de std::endl, vous économiserait 8 octets. Il pourrait également y avoir un moyen d’utiliser CPP #define pour réduire certaines répétitions,

Kenney

@ Kenney Merci pour ça! (Cela ne sauve que 5 octets, pas 8). Je pense cependant avoir trouvé un moyen de modifier cette section encore plus courte.

felixphew

Je ne sais pas boost (et je ne dirais pas que c'est standard non plus) mais n'est pas iconstruit par défaut avec la valeur 0? Vous pouvez ensuite supprimer la définition et passer de post-incrémentation à pré-incrémentation, ce qui vous évitera 2b

Zereges

Que diriez-vous du obsolète #import?

connectyourcharger

5

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

Kazarp
la source

Vous pouvez économiser 8 octets avec class C{static void Main(){var b=System.Numerics.BigInteger.One;for(;;)System.Console.WriteLine(b++);}}: ~)!

sweerpotato

1

Déplacer la déclaration de b et Console.WriteLinedans la structure de la boucle:class C{static void Main(){for(var b=System.Numerics.BigInteger.One;;Console.WriteLine(b++));}}

Kvam

Tu as encore besoin System. Cela sauve un octet cependant!

sweerpotato

Oui vous avez raison.

Kvam

Si vous ajoutez using System;(13 octets), vous pouvez supprimer System.deux fois (7 octets), en enregistrant 1 octet.

Kenney

5

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.

MONODA43
la source

4

MarioLANG , 11 octets

+<
:"
>!
=#

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

Alephalpha
la source

Etes-vous sûr que cela fonctionne sans problèmes à 2 ^ 128?

flawr

1

Cela semble familier. :)

Martin Ender

@flawr MarioLANG a un interpréteur Ruby et le type entier de Ruby a une précision arbitraire.

Martin Ender

@flawr Cela dépend de l'interprète. L'interprète que j'utilise est écrit en Ruby et supporte une précision arbitraire.

Alephalpha

4

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.

GamrCorps
la source

4

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

Helco
la source

4

En fait, cela ne devrait pas prendre fin. C'est le sens deforever

edc65

4

Foo , 6 octets

(+1$i)

Explication

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

Zach Gates
la source

4

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.

El'endia Starman
la source

4

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.

Kenney
la source

4

Perl , 34 32 30 28 26 23 octets

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

Test avec

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

Kenney
la source

Vous pouvez remplacer for(,,){...}par {...;redo}pour deux.

Primo

Oui j'ai vu (perl 5.18+), mais j'ai pensé que c'était peut-être de la triche; alors les réponses seraient les mêmes. Je suis nouveau ici, alors ;-)

Kenney

1

Les références scalaires seront auto-vivifiées comme SV UNDEF, ce qui, une fois incrémentées, ne déclenchera pas la BigIntsurcharge, car ce n'est pas un fichier BigInt. Les littéraux entiers, cependant, sont créés en tant que BigInts. Pas si étrange que ça en soit;)

primo

1

Pourriez-vous l'utiliser $-pour le conserver en tant qu'entier et revenir à l'utilisation ++$-?

Dom Hastings

1

J'ai testé avec @DomHastings perl -Mbigint -E '{say++$-;$-+=$-;redo}' | moreet ça tourne autour de 1. Ça reste un int, mais bigint n'intervient pas, malheureusement.

Kenney

4

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

Sparr
la source

4

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)

SnoringFrog
la source

1

+1 ... désolé pour tous les extras. Pour vous récupérer un couple, vous pouvez essayer a=gmp::as.bigz(0);repeat{cat(paste(a<-a+1,''))}. Vous voudrez peut-être noter qu’il gmps’agit d’une bibliothèque externe qui peut nécessiter un téléchargement.

MickyT

44 octets :)

Giuseppe

4

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.

SuperJedi224
la source

Compter pour toujours

Catalogue

Réponses:

Labyrinthe , 5 octets

> <> , 8 octets

Haskell, 21 octets

Gol> <> , 3 octets

Marbelous , 11450 4632 octets

C (architecture 64 bits uniquement), 53 octets

Hexagony , 12 11 10 7 octets

Pyth, 4 octets

Explication:

bc, 10

Java, 139 138 127 123 octets

Mathematica, 22 octets

Ruby, 15 12 octets

Python 3, 33 25 octets

Traitement , 95 85 71 octets

Samau , 2 octets

JavaScript (ES6), 99 94 67 octets

Matlab, 132 octets

C ++, 146 141 138 octets

C # .NET 4.0, 111 103 102 97 octets

Clojure, 17 octets

MarioLANG , 11 octets

CJam, 7 octets

C, 89 octets

Foo , 6 octets

Explication

Minkolang , 4 octets

Intel 8086+ Assembly, 19 octets

Fonctionnement

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

1,8 Mo ISO amorçable

DOS .COM

Perl , 34 32 30 28 26 23 octets

Marbelous, 358 octets

R, 52 octets

BotEngine, 128 120 112 8x13 = 104