Scrivi un programma che conta per sempre, a partire da uno.

Regole:

• Il tuo programma deve accedere STDOUTo un'alternativa accettabile, se STDOUTnon è disponibile.
• Il tuo programma deve essere un programma completo, eseguibile e non una funzione o un frammento.
• Il programma deve generare ogni numero con un carattere di separazione tra (una nuova riga, spazio, tabulazione o virgola), ma questo deve essere coerente per tutti i numeri.
• È possibile stampare i numeri in decimale, in unario o in base 256 in cui ogni cifra è rappresentata da un valore in byte .
• Il tuo programma deve contare almeno fino a 2 ¹²⁸ (incluso) senza problemi e senza esaurire la memoria su un PC desktop ragionevole. In particolare, ciò significa che se si utilizza unario, non è possibile memorizzare una rappresentazione unaria del numero corrente in memoria.

• A differenza delle nostre solite regole, sentiti libero di usare una lingua (o versione linguistica) anche se è più recente di questa sfida. Le lingue specificamente scritte per inviare una risposta di 0 byte a questa sfida sono un gioco leale ma non particolarmente interessante.

  Si noti che deve essere presente un interprete per poter testare l'invio. È permesso (e persino incoraggiato) di scrivere questo interprete per una lingua precedentemente non implementata.

• Non si tratta di trovare la lingua con la soluzione più breve per questo (ci sono alcuni in cui il programma vuoto fa il trucco) - si tratta di trovare la soluzione più breve in ogni lingua. Pertanto, nessuna risposta verrà contrassegnata come accettata.

Catalogare

Lo snippet di stack nella parte inferiore di questo post genera il catalogo dalle risposte a) come elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello 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 byte

):
\!

♫ L'IP nel codice gira e rigira ♫

Istruzioni pertinenti:

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

> <> , 8 byte

01+:nao!

passi:

• Premi 0 sullo stack
• Aggiungi 1 all'elemento superiore dello stack
• Elemento stack superiore duplicato
• Stampa la parte superiore dello stack come numero
• Invia una nuova riga
• Vai al passaggio 2 avvolgendoti e saltando le istruzioni successive (passaggio 11)

(È un programma meno efficiente in termini di memoria (quindi non valido) llnao.)

Haskell, 21 byte

main=mapM_ print[1..]

Gli interi di precisione arbitraria e gli elenchi infiniti rendono questo facile :-)

Fortunatamente mapM_è nel preludio. Se Data.Traversablecosì fosse, potremmo addirittura ridurlo a 19 byte:

main=for_[1..]print

Gol> <> , 3 byte

P:N

passi:

• Aggiungi 1 all'elemento stack superiore (all'inizio è uno 0 implicito)
• Elemento stack superiore duplicato
• Pop e output la parte superiore dello stack come numero e una nuova riga
• Passa al punto 1 non appena abbiamo raggiunto la fine della linea

Marbelous , 11450 4632 byte

La stampa dei decimali è un dolore !!

Sicuramente non vincere con questo, ma ho pensato di provarlo. Spero sia ok che riduca l'output a 40 zeri (per adattarsi a 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 architettura a 64 bit), 53 byte

Si basa sul fatto che i puntatori sono almeno 64 bit e li stampa in esadecimale utilizzando l' %pidentificatore. Il programma ritornerebbe giusto quando colpisce 2 ^ 128.

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

Esagonia , 12 11 10 7 byte

Grazie ad alephalpha per aver inserito il codice nella lunghezza laterale 2.

10})!';

non piegato:

 1 0
} ) !
 ' ;

Questo è abbastanza semplice. 10scrive un 10, cioè un avanzamento di riga sul bordo di memoria iniziale. Quindi })!';viene ripetutamente eseguito in un ciclo:

• } passa al bordo di memoria successivo.
• ) incrementalo.
• ! stampalo come un numero intero.
• ' tornare al 10.
• ; stampalo come personaggio.

Credo che sia ottimale (anche se di gran lunga non unico). Ho lasciato il copione forza bruta che ho scritto per questa risposta ricerca di soluzioni 6 byte sotto l'ipotesi che avrebbe dovuto contenere almeno uno ciascuno dei ;e !eo (o ), e non conterrebbe ?, ,o @, e non l'ha fatto trova le soluzioni.

Pyth, 4 byte

.V1b

Spiegazione:

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

bc, 10

for(;;)++i

Insolito che bcè più breve di dc.

Da man bc:

DESCRIZIONE

bc è un linguaggio che supporta numeri di precisione arbitrari

Java, 139 138 127 123 byte

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 byte

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

Echo è una nuova funzione in Mathematica 10.3.

Rubino, 15 12 byte

loop{p$.+=1}

• p, quando viene dato un numero intero, stampa l'intero così com'è (per gentile concessione di @philomory )
• $.è una variabile magica che contiene il numero di righe lette da stdin. È ovviamente inizializzato su 0 e anche assegnabile :)

Python 3, 33 25 byte

Per quanto ho capito, gli interi di Pythons sono una precisione arbitraria e print()producono automaticamente nuove righe.

Grazie per @Jakub e @ Sp3000 e @wnnmaw! Davvero non conosco molto Python, l'unica cosa che sapevo era che supporta numeri interi di dimensioni arbitrarie =)

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

Elaborazione , 95 85 71 byte

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

Ho provato qualcosa con un ciclo while, ma causa l'arresto anomalo di tutta l'elaborazione, quindi per ora mi atterrò.

(Grazie a @ SuperJedi224 e @TWiStErRob per i suggerimenti.)

Samau , 2 byte

N)

Spiegazione:

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

Quando l'output di un programma è un elenco, le parentesi più esterne vengono omesse.

JavaScript (ES6), 99 94 67 byte

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

alertè l' STDOUTequivalente generalmente accettato per JavaScript ma utilizzarlo significa che i numeri consecutivi vengono automaticamente separati. Ho assunto che l'output di un personaggio dopo il numero non è necessario per questo motivo.

Matlab, 132 byte

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, penso che questa sia la prima risposta seria che compie questo compito senza un banale numero intero di dimensioni abitative. Questo programma implementa un numero intero di dimensioni arbitrarie come un array di numeri interi. Ogni numero intero è sempre compreso tra 0 e 9, quindi ogni elemento dell'array rappresenta una cifra decimale. La dimensione dell'array verrà aumentata di uno non appena saremo ad es 999. La dimensione della memoria non è un problema qui, poiché 2^128richiede solo un array di lunghezza 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 byte

L'uso di una libreria bigint standard è forse il modo più noioso di rispondere a questa domanda, ma qualcuno ha dovuto farlo.

#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 ragione per cui la versione golfizzata utilizza stdio.he non cstdioè quella di evitare di usare lo std::spazio dei nomi.

Questa è la prima volta che gioco a golf in C ++, fammi sapere se ci sono trucchi per accorciarlo ulteriormente.

C # .NET 4.0, 111 103 102 97 byte

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

Non ho trovato nessuna risposta C # qui, quindi ho dovuto solo scriverne una.

È richiesto .NET 4.0, poiché è la prima versione che include BigInteger . Devi fare riferimento a System.Numerics.dll però.

Con rientro:

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

Grazie a sweerpotato, Kvam, Berend per aver salvato alcuni byte

Clojure, 17 byte

(map prn (range))

Le sequenze pigre e gli interi di precisione arbitraria lo rendono facile (come per Haskell e CL). prnmi fa risparmiare qualche byte poiché non ho bisogno di stampare una stringa di formato. doseqsarebbe probabilmente più idiomatico poiché qui abbiamo a che fare solo con effetti collaterali; mapnon ha molto senso usare poiché creerà una sequenza di nil(che è il valore di ritorno di ogni prnchiamata.

Supponendo che io conti per sempre, la sequenza di puntatori null risultante da questa operazione non viene mai restituita.

MarioLANG , 11 byte

+<
:"
>!
=#

Ispirato dalla risposta di Martin Büttner in un'altra domanda .

CJam, 7 byte

0{)_p}h

Spiegazione:

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: è necessario utilizzare l'interprete Java.

C, 89 byte

Un nuovo approccio (implementando un incrementatore bit a bit) in 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])));}

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

Terminare

Questa versione ha il leggero difetto, che non termina (che non è un requisito al momento). Per fare ciò dovresti aggiungere 3 caratteri:

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 byte

(+1$i)

Spiegazione

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

Minkolang , 4 byte

1+dN

Provalo qui. (Beh, in realtà, fai attenzione. 3 secondi di autonomia sono stati sufficienti per arrivare a ~ 40.000.)

1+aggiunge 1 nella parte superiore dello stack, lo dduplica e Ngenera la parte superiore dello stack come numero intero con uno spazio finale. Ciò si verifica perché Minkolang è toroidale, quindi quando il contatore del programma si spegne sul bordo destro, riappare a sinistra.

Intel 8086+ Assembly, 19 byte

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

Ecco una ripartizione:

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

Emette il numero di 128 bit nelle 8 posizioni dello schermo in alto a sinistra. Ogni posizione dello schermo contiene un carattere ASCII a 8 bit e due colori a 4 bit.

Nota: si avvolge a 2 ¹²⁸ ; è sufficiente cambiare 8in mov cx, 8in 9per mostrare un numero a 144 bit o anche 80*25per mostrare numeri fino a 2 ³²⁰⁰⁰ .

In esecuzione

Immagine floppy di avvio compressa da 1,44 Mb bzip2 codificata base64

Genera l'immagine floppy copiando e incollando quanto segue

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

in questa riga di comando:

base64 -d | bunzip2 > floppy.img

ed eseguire con, ad esempio, qemu -fda floppy.img -boot a

ISO di avvio da 1,8 Mb

Questa è un'immagine ISO compressa con codifica base64 bzip2. Genera l'iso incollando

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, come moto a luogo, andare da dentro a fuori: I put my hand inTO my pocket = metto la mano in tasca

base64 -d bunzip2 > cdrom.iso

e configurare una macchina virtuale per l'avvio da essa.

DOS .COM

Questo è un eseguibile DOS .COM codificato in base64 :

aAC4H7kIADH/+YMVAEdH4vnr8Q==

Genera un file .COM usando

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

ed eseguirlo in DOS (gratuito).

Perl , 34 32 30 28 26 23 byte

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

Prova con

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

Marbelous, 358 byte

..@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 mezze aggiunte sono incatenate insieme, la più a destra esegue N ++ per ogni ciclo e ogni sommatore alimenta il suo overflow (00 o 01) al successivo nella catena. L'output è in esadecimale.

L'interprete python ha un bug in cui l'output delle funzioni memorizzate viene perso, quindi è necessario eseguirlo con "-m 0" per farlo funzionare correttamente. Senza quel parametro puoi vedere quanto velocemente verrà eseguito senza il bug, ma l'output non funzionerà correttamente.

Nota per sé: correggi quel bug in marbelous.py Questo bug è stato corretto nell'ultima versione di marbelous.py

R, 52 byte

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

(Nota: gmpè una libreria esterna, quindi potrebbe essere necessario scaricarla per far funzionare questa soluzione)

BotEngine, 128 120 112 8x13 = 104

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

L'output è in binario.