Escreva um programa que conta para sempre, começando em um.

Regras:

• Seu programa deve efetuar logon STDOUTou uma alternativa aceitável, se STDOUTnão estiver disponível.
• Seu programa deve ser um programa completo e executável, e não uma função ou trecho.
• Seu programa deve gerar cada número com um caractere separador no meio (uma nova linha, espaço, tabulação ou vírgula), mas isso deve ser consistente para todos os números.
• Você pode imprimir os números em decimal, em unário ou na base 256, onde cada dígito é representado por um valor de byte .
• Seu programa deve contar pelo menos até 2 ¹²⁸ (inclusive) sem problemas e sem ficar sem memória em um PC de mesa razoável. Em particular, isso significa que, se você estiver usando unário, não poderá armazenar uma representação unária do número atual na memória.

• Diferentemente de nossas regras usuais, fique à vontade para usar um idioma (ou versão do idioma), mesmo que seja mais novo que esse desafio. Os idiomas escritos especificamente para enviar uma resposta de 0 byte a esse desafio são um jogo justo, mas não particularmente interessante.

  Observe que deve haver um intérprete para que o envio possa ser testado. É permitido (e até encorajado) escrever esse intérprete para um idioma anteriormente não implementado.

• Não se trata de encontrar o idioma com a solução mais curta para isso (existem algumas onde o programa vazio faz o truque) - trata-se de encontrar a solução mais curta em todos os idiomas. Portanto, nenhuma resposta será marcada como aceita.

Catálogo

O snippet de pilha na parte inferior desta postagem gera o catálogo a partir das respostas a) como uma lista da solução mais curta por idioma eb) como uma tabela geral de líderes.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

## Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet:

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

Labirinto , 5 bytes

):
\!

♫ O IP no código dá voltas e voltas ♫

Instruções relevantes:

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

> <> , 8 bytes

01+:nao!

Passos:

• Empurre 0 na pilha
• Adicione 1 ao elemento da pilha superior
• Elemento duplicado da pilha superior
• Saída da parte superior da pilha como número
• Saída de uma nova linha
• Vá para o passo 2, contornando e pulando a próxima instrução (passo 11)

(Um programa menos eficiente em termos de memória (portanto inválido) é llnao.)

Haskell, 21 bytes

main=mapM_ print[1..]

Inteiros de precisão arbitrária e listas infinitas facilitam isso :-)

Felizmente mapM_está no Prelúdio. Se Data.Traversablefosse assim, poderíamos reduzi-lo para 19 bytes:

main=for_[1..]print

Gol> <> , 3 bytes

P:N

Passos:

• Adicione 1 ao elemento da pilha superior (no início, é um 0 implícito)
• Elemento duplicado da pilha superior
• Pop e produza a parte superior da pilha como número e uma nova linha
• Enrole para a etapa 1 quando chegamos ao final da linha

Marbelous , 11450 4632 bytes

Imprimir decimais é uma dor !!

Definitivamente não ganhei com este, mas pensei em tentar. Espero que seja bom que a saída seja de 40 zeros (para caber 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 (somente arquitetura de 64 bits), 53 bytes

Confia que os ponteiros têm pelo menos 64 bits e os imprime em hexadecimal usando o %pespecificador. O programa retornaria exatamente quando atingir 2 ^ 128.

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

Hexagonia , 12 11 10 7 bytes

Agradecimentos a alephalpha por ajustar o código no comprimento lateral 2.

10})!';

Desdobrado:

 1 0
} ) !
 ' ;

Este é bastante simples. 10grava um 10, ou seja, um avanço de linha na borda da memória inicial. Então })!';é executado repetidamente em um loop:

• } vá para a próxima borda da memória.
• ) incrementá-lo.
• ! imprima-o como um número inteiro.
• ' volte para o 10.
• ; imprima-o como um personagem.

Eu acredito que isso é ótimo (embora de longe não seja único). Eu deixei o script força bruta que eu escrevi para esta resposta busca de soluções 6 bytes sob a suposição de que ele teria que conter pelo menos um cada um ;e !e quer (ou ), e não deverá conter ?, ,ou @, e isso não aconteceu encontre soluções.

Pitão, 4 bytes

.V1b

Explicação:

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

bc, 10

for(;;)++i

Incomum que bcé mais curto que dc.

De man bc:

DESCRIÇÃO

bc é uma linguagem que suporta números de precisão arbitrários

Java, 139 138 127 123 bytes

class K{public static void main(String[]a){java.math.BigInteger b=null;for(b=b.ZERO;;)System.out.println(b=b.add(b.ONE));}}

Mathematica, 22 bytes

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

Echo é uma nova função no Mathematica 10.3.

Ruby, 15 12 bytes

loop{p$.+=1}

• p, quando determinado um número inteiro, imprime o número inteiro como está (cortesia de @philomory )
• $.é uma variável mágica que contém o número de linhas lidas em stdin. Obviamente, é inicializado como 0 e também pode ser atribuído :)

Python 3, 33 25 bytes

Tanto quanto eu entendo, inteiros Pythons são precisão arbitrária e print()produz automaticamente novas linhas.

Obrigado por @Jakub e @ Sp3000 e @wnnmaw! Eu realmente não sei muito python, a única coisa que eu sabia era que ele suporta números inteiros de tamanho arbitrário =)

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

Processando , 95 85 71 bytes

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

Tentei algo com um loop while, mas ele causou uma falha em todo o Processing, por isso vou continuar com isso por enquanto.

(Obrigado a @ SuperJedi224 e @TWiStErRob por sugestões.)

Samau , 2 bytes

N)

Explicação:

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

Quando a saída de um programa é uma lista, os colchetes extremos são omitidos.

JavaScript (ES6), 99 94 67 bytes

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

alerté o STDOUTequivalente geralmente aceito para JavaScript, mas usá-lo significa que números consecutivos são separados automaticamente. Eu assumi que a saída de um caractere após o número não é necessária por causa disso.

Matlab, 132 bytes

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

Ok, acho que esta é a primeira resposta séria que realiza essa tarefa sem um número inteiro de tamanho abitrário interno trivial. Este programa implementa um número inteiro de tamanho arbitrário como uma matriz de números inteiros. Cada número inteiro está sempre entre 0 e 9, portanto, cada elemento da matriz representa um dígito decimal. O tamanho da matriz será aumentado em um assim que estivermos, por exemplo 999. O tamanho da memória não é um problema aqui, pois 2^128requer apenas uma matriz de comprimento 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 bytes

Usar uma biblioteca bigint padrão talvez seja a maneira mais chata de responder a essa pergunta, mas alguém precisava fazer isso.

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

O motivo pelo qual a versão golfada usa stdio.he não cstdioé evitar o uso do std::espaço para nome.

Esta é minha primeira vez jogando golfe em C ++, deixe-me saber se há algum truque para diminuir ainda mais isso.

C # .NET 4.0, 111 103 102 97 bytes

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

Não encontrei nenhuma resposta em C # aqui, então apenas tive que escrever uma.

O .NET 4.0 é necessário, porque é a primeira versão que inclui o BigInteger . Você precisa fazer referência ao System.Numerics.dll .

Com recuo:

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

Obrigado a sweerpotato, Kvam, Berend por salvar alguns bytes

Clojure, 17 bytes

(map prn (range))

Sequências preguiçosas e números inteiros de precisão arbitrários facilitam isso (como Haskell e CL). prneconomiza alguns bytes, pois não preciso imprimir uma string de formato. doseqprovavelmente seria mais idiomático, já que aqui estamos lidando apenas com efeitos colaterais; mapnão faz muito sentido usar, pois criará uma sequência de nil(que é o valor de retorno de cada prnchamada.

Supondo que eu conte para sempre, a sequência de ponteiros nulos resultante dessa operação nunca será retornada.

MarioLANG , 11 bytes

+<
:"
>!
=#

Inspirado pela resposta de Martin Büttner em outra pergunta .

CJam, 7 bytes

0{)_p}h

Explicação:

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

Nota: É necessário usar o interpretador Java.

C, 89 bytes

Uma nova abordagem (implementando um incrementador bit a bit) em 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])));}

Menos golfe

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

Terminar

Esta versão tem uma pequena falha, que não termina (o que não é um requisito no momento). Para fazer isso, você teria que adicionar 3 caracteres:

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

Foo , 6 bytes

(+1$i)

Explicação

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

Minkolang , 4 bytes

1+dN

Experimente aqui. (Bem, na verdade, tenha cuidado. 3 segundos de tempo de execução foram suficientes para chegar a ~ 40.000.)

1+adiciona 1 ao topo da pilha, dduplica-o e Ngera o topo da pilha como um número inteiro com um espaço à direita. Isso faz um loop porque Minkolang é toroidal; portanto, quando o contador de programa sai pela borda direita, ele reaparece à esquerda.

Conjunto Intel 8086+, 19 bytes

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

Aqui está um detalhamento:

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

Ele gera o número de 128 bits nas 8 posições da tela superior esquerda. Cada posição da tela contém um caractere ASCII de 8 bits e duas cores de 4 bits.

Nota: gira em torno de 2 ¹²⁸ ; simplesmente mudar o 8em mov cx, 8para 9mostrar um número 144 bit, ou mesmo 80*25para mostrar números até 2 ³²⁰⁰⁰ .

Corrida

1.44Mb bzip2 comprimido, disquete inicializável codificado em base64

Gere a imagem de disquete copiando e colando o seguinte

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

nesta linha de comando:

base64 -d | bunzip2 > floppy.img

e corra com, por exemplo, qemu -fda floppy.img -boot a

ISO inicializável de 1,8 Mb

Esta é uma imagem ISO compactada bzip2 codificada em base64. Gere o iso colando

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

para dentro

base64 -d bunzip2 > cdrom.iso

e configure uma máquina virtual para inicializá-la.

DOS .COM

Este é um executável .COM do DOS codificado em base64 :

aAC4H7kIADH/+YMVAEdH4vnr8Q==

Gere um arquivo .COM usando

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

e execute-o no DOS (gratuito).

Perl , 34 32 30 28 26 23 bytes

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

Teste com

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

Marbelous, 358 bytes

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

16 semi-adutores encadeados, o mais à direita executando N ++ a cada ciclo e cada adicionador alimentando seu excesso (00 ou 01) para o próximo na cadeia. A saída está em hexadecimal.

O interpretador python possui um erro no qual a saída das funções memorizadas é perdida; portanto, você deve executá-lo com "-m 0" para que funcione corretamente. Sem esse parâmetro, você pode ver o quão rápido ele será executado sem o bug, mas a saída não funcionará corretamente.

Nota para self: corrija esse bug no marbelous.py Este bug foi corrigido na versão mais recente do marbelous.py

R, 52 bytes

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

(Nota: gmpé uma biblioteca externa, pode ser necessário fazer o download para que esta solução funcione)

BotEngine, 128 120 112 8x13 = 104

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

A saída está em binário.