Escriba un programa que cuente para siempre, comenzando desde uno.

Reglas:

• Su programa debe iniciar sesión STDOUTo una alternativa aceptable, si STDOUTno está disponible.
• Su programa debe ser un programa completo y ejecutable, y no una función o fragmento.
• Su programa debe generar cada número con un carácter separador (una nueva línea, espacio, tabulación o coma), pero esto debe ser coherente para todos los números.
• Puede imprimir los números en decimal, en unario o en base 256, donde cada dígito está representado por un valor de byte .
• Su programa debe contar al menos hasta 2 ¹²⁸ (inclusive) sin problemas y sin quedarse sin memoria en una PC de escritorio razonable. En particular, esto significa que si está usando unary, no puede almacenar una representación unaria del número actual en la memoria.

• A diferencia de nuestras reglas habituales, siéntase libre de usar un idioma (o versión de idioma) incluso si es más nuevo que este desafío. Los idiomas escritos específicamente para enviar una respuesta de 0 bytes a este desafío son juegos justos pero no particularmente interesantes.

  Tenga en cuenta que debe haber un intérprete para que se pueda probar el envío. Se permite (e incluso se recomienda) escribir este intérprete usted mismo para un idioma previamente no implementado.

• No se trata de encontrar el idioma con la solución más corta para esto (hay algunos en los que el programa vacío hace el truco), se trata de encontrar la solución más corta en cada idioma. Por lo tanto, ninguna respuesta se marcará como aceptada.

Catálogo

El Fragmento de pila al final de esta publicación genera el catálogo a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:

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

Laberinto , 5 bytes

):
\!

♫ La IP en el código da vueltas y vueltas ♫

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

Pasos:

• Empuja 0 en la pila
• Agregue 1 al elemento de la pila superior
• Elemento de pila superior duplicado
• Salida de la parte superior de la pila como número
• Salida de una nueva línea
• Vaya al paso 2 envolviéndose y saltando la siguiente instrucción (paso 11)

(Un programa menos eficiente en memoria (por lo tanto, no válido) es llnao).

Haskell, 21 bytes

main=mapM_ print[1..]

Los enteros de precisión arbitraria y las listas infinitas facilitan esto :-)

Por suerte mapM_está en el preludio. Si Data.Traversablefuera así, incluso podríamos reducirlo a 19 bytes:

main=for_[1..]print

Gol> <> , 3 bytes

P:N

Pasos:

• Agregue 1 al elemento de la pila superior (al inicio es un 0 implícito)
• Elemento de pila superior duplicado
• Pop y salida la parte superior de la pila como número y una nueva línea
• Pase al paso 1 cuando lleguemos al final de la línea

Maravillosa , 11450 4632 bytes

¡Imprimir decimales es un dolor!

Definitivamente no ganaré con este, pero pensé en intentarlo. Espero que esté bien que rellene la salida a 40 ceros (para ajustar 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 (solo arquitectura de 64 bits), 53 bytes

Se basa en punteros de al menos 64 bits y los imprime en hexadecimal utilizando el %pespecificador. El programa volvería justo cuando llegue a 2 ^ 128.

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

Hexagonía , 12 11 10 7 bytes

Gracias a alephalpha por ajustar el código en la longitud lateral 2.

10})!';

Desplegado:

 1 0
} ) !
 ' ;

Este es bastante simple. 10escribe un 10, es decir, un salto de línea al borde de memoria inicial. Luego })!';se ejecuta repetidamente en un bucle:

• } pasar al siguiente borde de memoria.
• ) incrementarlo
• ! imprímalo como un entero.
• ' volver a los 10.
• ; imprímalo como un personaje.

Creo que esto es óptimo (aunque de lejos no es único). Dejé que el script de fuerza bruta que escribí para esta respuesta buscara soluciones de 6 bytes bajo el supuesto de que tendría que contener al menos uno de cada uno de ;y !y o (o ), y no contendría ?, ,o @, y no lo hizo. Encuentra cualquier solución.

Pyth, 4 bytes

.V1b

Explicación:

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

a. C., 10

for(;;)++i

Inusual que bces más corto que dc.

De man bc:

DESCRIPCIÓN

bc es un lenguaje que admite números de precisión arbitrarios

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 es una nueva función en Mathematica 10.3.

Ruby, 15 12 bytes

loop{p$.+=1}

• p, cuando se le da un número entero, imprime el número entero tal como está (cortesía de @philomory )
• $.es una variable mágica que contiene el número de líneas leídas de stdin. Obviamente se inicializa a 0, y también se puede asignar :)

Python 3, 33 25 bytes

Por lo que yo entiendo, los enteros de Pythons son de precisión arbitraria y print()producen automáticamente nuevas líneas.

¡Gracias por @Jakub y @ Sp3000 y @wnnmaw! Realmente no sé mucho de Python, lo único que sabía era que admite enteros de tamaño arbitrario =)

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

Procesamiento , 95 85 71 bytes

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

Intenté algo con un ciclo while pero hace que todo el procesamiento se bloquee, por lo que me quedaré con esto por ahora.

(Gracias a @ SuperJedi224 y @TWiStErRob por sus sugerencias).

Samau , 2 bytes

N)

Explicación:

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

Cuando la salida de un programa es una lista, se omiten los corchetes externos.

JavaScript (ES6), 99 94 67 bytes

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

alertes el STDOUTequivalente generalmente aceptado para JavaScript, pero usarlo significa que los números consecutivos se separan automáticamente. Supuse que no es necesario generar un carácter después del número debido a esto.

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, creo que esta es la primera respuesta seria que lleva a cabo esta tarea sin un entero trivial de tamaño abitano incorporado. Este programa implementa un número entero de tamaño arbitrario como una matriz de enteros. Cada entero siempre está entre 0 y 9, por lo que cada elemento de matriz representa un dígito decimal. El tamaño de la matriz se incrementará en uno tan pronto como estemos, por ejemplo 999. El tamaño de la memoria no es un problema aquí, ya que2^128 solo requiere una matriz de longitud 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

El uso de una biblioteca bigint estándar es quizás el más aburrida de responder esta pregunta, pero alguien tuvo que hacerlo.

#include<stdio.h>
#include<boost/multiprecision/cpp_int.hpp>
int main(){for(boost::multiprecision::uint512_t i=1;;){printf("%u\n",i++);}}

Sin golf:

#include<cstdio>
#include<boost/multiprecision/cpp_int.hpp>

int main()
{
    for(boost::multiprecision::uint512_t i=1;;)
    {
        std::printf("%u\n", i++);
    }
}

La razón por la cual la versión de golf usa stdio.h y no cstdioes para evitar tener que usar el std::espacio de nombres.

Esta es mi primera vez jugando al golf en C ++, avíseme si hay algún truco para acortar esto aún más.

C .NET 4.0, # 111 103 102 97 bytes

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

No encontré ninguna respuesta de C # aquí, así que solo tuve que escribir una.

Se requiere .NET 4.0, porque es la primera versión que incluye BigInteger . Sin embargo, debe hacer referencia a System.Numerics.dll .

Con sangría:

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

Gracias a sweerpotato, Kvam, Berend por guardar algunos bytes

Clojure, 17 bytes

(map prn (range))

Las secuencias perezosas y los enteros de precisión arbitraria facilitan esto (como para Haskell y CL). prnme ahorra algunos bytes ya que no necesito imprimir una cadena de formato. doseqprobablemente sería más idiomático ya que aquí solo tratamos con efectos secundarios; mapno tiene mucho sentido usarlo ya que creará una secuencia de nil(que es el valor de retorno de cadaprn llamada.

Suponiendo que cuento para siempre, la secuencia de puntero nulo que resulta de esta operación nunca se devuelve.

MarioLANG , 11 bytes

+<
:"
>!
=#

Inspirado por la respuesta de Martin Büttner en otra pregunta .

CJam, 7 bytes

0{)_p}h

Explicación:

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: Debe usar el intérprete de Java.

C, 89 bytes

Un nuevo enfoque (implementando un incrementador de bits) 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])));}

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

Terminar

Esta versión tiene un ligero defecto, que no termina (lo cual no es un requisito por el momento). Para hacer esto, deberías agregar 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)

Explicación

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

Minkolang , 4 bytes

1+dN

Pruébalo aquí (Bueno, en realidad, tenga cuidado. 3 segundos de tiempo de ejecución fueron suficientes para obtener hasta ~ 40,000).

1+agrega 1 a la parte superior de la pila, lo dduplica y Ngenera la parte superior de la pila como un entero con un espacio final. Esto se repite porque Minkolang es toroidal, por lo que cuando el contador del programa sale del borde derecho, vuelve a aparecer a la izquierda.

Conjunto Intel 8086+, 19 bytes

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

Aquí hay un desglose:

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

Emite el número de 128 bits en las 8 posiciones de la pantalla superior izquierda. Cada posición de la pantalla tiene un carácter ASCII de 8 bits y dos colores de 4 bits.

Nota: se ajusta a 2 ¹²⁸ ; simplemente cambie 8in mov cx, 8para 9mostrar un número de 144 bits, o incluso 80*25para mostrar números de hasta 2 ³²⁰⁰⁰ .

Corriendo

Imagen de disquete de arranque comprimida codificada en base64 de 1.44Mb bzip2

Genere la imagen del disquete copiando y pegando lo siguiente

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

en esta línea de comando:

base64 -d | bunzip2 > floppy.img

y correr con, por ejemplo, qemu -fda floppy.img -boot a

1.8Mb de arranque ISO

Esta es una imagen ISO comprimida bzip2 codificada en base64. Genera la iso pegando

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

dentro

base64 -d bunzip2 > cdrom.iso

y configurar una máquina virtual para arrancar desde ella.

DOS .COM

Este es un ejecutable DOS .COM codificado en base64 :

aAC4H7kIADH/+YMVAEdH4vnr8Q==

Genere un archivo .COM usando

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

y ejecutarlo en DOS (gratis).

Perl , 34 32 30 28 26 23 bytes

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

Prueba con

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

Maravilloso, 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 medios sumadores encadenados, el más a la derecha realiza N ++ cada ciclo y cada sumador alimenta su desbordamiento (00 o 01) al siguiente en la cadena. La salida está en hexadecimal.

El intérprete de Python tiene un error en el que se pierde la salida de las funciones memorizadas, por lo que debe ejecutar esto con "-m 0" para que funcione correctamente. Sin ese parámetro, puede ver qué tan rápido se ejecutará sin el error, pero la salida no funcionará correctamente.

Nota personal: corrija ese error en marbelous.py Este error se ha solucionado en la última versión de marbelous.py

R, 52 bytes

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

(Nota: gmpes una biblioteca externa, por lo que puede que tenga que descargarla para que esta solución funcione)

BotEngine, 128 120 112 8x13 = 104

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

La salida es en binario.