Compter pour toujours

71

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

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

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

Réponses:

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 128 ; changez simplement le 8en mov cx, 8pour 9afficher un nombre de 144 bits, ou même 80*25pour montrer des nombres allant jusqu’à 2 32000 .

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