Napisz program, który liczy się na zawsze, zaczynając od jednego.

Zasady:

• Twój program musi się zalogować na STDOUTakceptowalną alternatywę, jeśli STDOUTnie jest dostępna.
• Twój program musi być pełnym programem, który można uruchomić, a nie funkcją lub fragmentem kodu.
• Twój program musi wypisać każdą liczbę ze znakiem oddzielającym pomiędzy nimi (nowy wiersz, spacja, tabulator lub przecinek), ale musi to być spójne dla wszystkich liczb.
• Można drukować numery w systemie dziesiętnym, w jednoskładnikowa lub w bazie 256, gdzie każda cyfra jest reprezentowana przez wartość bajtów .
• Twój program musi liczyć co najmniej do 2 ¹²⁸ (włącznie) bez problemów i bez braku pamięci na rozsądnym komputerze stacjonarnym. W szczególności oznacza to, że jeśli używasz jednoargumentowej, nie możesz przechowywać w pamięci jednoznacznej reprezentacji bieżącego numeru.

• W przeciwieństwie do naszych zwykłych zasad, możesz swobodnie używać języka (lub wersji językowej), nawet jeśli jest on nowszy niż to wyzwanie. Języki napisane specjalnie w celu przesłania 0-bajtowej odpowiedzi na to wyzwanie są uczciwą grą, ale nie są szczególnie interesujące.

  Pamiętaj, że musi być tłumacz, aby można było przetestować zgłoszenie. Zezwala się (a nawet zachęca) do samodzielnego napisania tego tłumacza dla wcześniej niewdrożonego języka.

• Nie chodzi o znalezienie języka z najkrótszym rozwiązaniem tego problemu (są takie, w których pusty program rozwiązuje problem) - chodzi o znalezienie najkrótszego rozwiązania w każdym języku. Dlatego żadna odpowiedź nie zostanie oznaczona jako zaakceptowana.

Katalog

Fragment kodu na dole tego postu generuje katalog na podstawie odpowiedzi a) jako listy najkrótszych rozwiązań dla każdego języka oraz b) jako ogólnej tabeli wyników.

Aby upewnić się, że Twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

## Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie:

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

Labirynt , 5 bajtów

):
\!

IP Adres IP w kodzie się kręci round

Odpowiednie instrukcje:

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

> <> , 8 bajtów

01+:nao!

Kroki:

• Naciśnij 0 na stosie
• Dodaj 1 do górnego elementu stosu
• Zduplikowany element górnego stosu
• Wyprowadzaj górę stosu jako liczbę
• Wyjście nowego wiersza
• Przejdź do kroku 2, owijając się i przeskakując następną instrukcję (krok 11)

(Program mniej wydajny (a więc nieprawidłowy)) llnao.

Haskell, 21 bajtów

main=mapM_ print[1..]

Liczby całkowite o dowolnej dokładności i nieskończone listy ułatwiają to :-)

Na szczęście mapM_jest w Preludium. Gdyby Data.Traversabletak było, moglibyśmy nawet zmniejszyć go do 19 bajtów:

main=for_[1..]print

Gol> <> , 3 bajty

P:N

Kroki:

• Dodaj 1 do górnego elementu stosu (na początku jest to domyślnie 0)
• Zduplikowany element górnego stosu
• Pop i wypisz górę stosu jako liczbę i nowy wiersz
• Przejdź do kroku 1, gdy dotarliśmy do końca linii

Marbelous , 11450 4632 bajtów

Drukowanie miejsc po przecinku to ból !!

Zdecydowanie nie wygrywam z tym, ale pomyślałem, że dam temu szansę. Mam nadzieję, że to w porządku, że uzupełnia wyjście do 40 zer (aby zmieścić 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 (tylko architektura 64-bitowa), 53 bajty

Opiera się na wskaźnikach o długości co najmniej 64 bitów i drukuje je w formacie szesnastkowym przy użyciu %pspecyfikatora. Program powróci zaraz, gdy osiągnie 2 ^ 128.

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

Sześciokąt , 12 11 10 7 bajtów

Dzięki alephalpha za dopasowanie kodu do boku 2.

10})!';

Rozłożony:

 1 0
} ) !
 ' ;

Ten jest dość prosty. 10zapisuje 10, tzn. wysuwa wiersz do początkowej krawędzi pamięci. Następnie })!';jest wielokrotnie wykonywany w pętli:

• } przejdź do następnej krawędzi pamięci.
• ) zwiększ to.
• ! wydrukuj jako liczbę całkowitą.
• ' wróć do 10.
• ; wydrukuj jako postać.

Uważam, że jest to optymalne (choć zdecydowanie nie unikalne). Mam niech brute force napisałem skrypt do tej odpowiedzi poszukiwaniu rozwiązań 6-bajtowych przy założeniu, że będzie musiał zawierać co najmniej po jednym z ;i !i albo (albo )i nie zawierają ?, ,albo @i nie zrobił znajdź jakieś rozwiązania.

Pyth, 4 bajty

.V1b

Wyjaśnienie:

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

pne, 10

for(;;)++i

Niezwykłe to bc to jest krótsze niż dc.

Od man bc :

OPIS

bc jest językiem obsługującym dowolne precyzyjne liczby

Java, 139 138 127 123 bajtów

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 bajty

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

Echo jest nową funkcją w Mathematica 10.3.

Rubin, 15 12 bajtów

loop{p$.+=1}

• p, gdy podano liczbę całkowitą, drukuje liczbę całkowitą taką, jaka jest (dzięki uprzejmości @philomory )
• $.to magiczna zmienna przechowująca liczbę linii odczytanych ze standardowego wejścia. Jest oczywiście inicjowany na 0, a także przypisywany :)

Python 3, 33 25 bajtów

O ile rozumiem, liczby całkowite w Pythonie są dowolne i print()automatycznie tworzą nowe linie.

Dzięki za @Jakub i @ Sp3000 i @wnnmaw! Naprawdę nie znam dużo Pythona, jedyne, co wiedziałem, to to, że obsługuje liczby całkowite o dowolnym rozmiarze =)

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

Przetwarzanie , 95 85 71 bajtów

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

Próbowałem czegoś z pętlą while, ale powoduje to awarię całego Przetwarzania, więc na razie pozostanę przy tym.

(Dzięki @ SuperJedi224 i @TWiStErRob za sugestie.)

Samau , 2 bajty

N)

Wyjaśnienie:

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

Gdy wyjściem programu jest lista, skrajne nawiasy kwadratowe są pomijane.

JavaScript (ES6), 99 94 67 bajtów

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

alertjest ogólnie przyjętym STDOUTodpowiednikiem JavaScript, ale użycie go oznacza, że ​​kolejne liczby są automatycznie rozdzielane. Założyłem, że z tego powodu wypisywanie znaku po liczbie nie jest konieczne.

Matlab, 132 bajty

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, myślę, że jest to pierwsza poważna odpowiedź, która wykonuje to zadanie bez trywialnej liczby całkowitej wielkości arytmetycznej. Ten program implementuje liczbę całkowitą o dowolnym rozmiarze jako tablicę liczb całkowitych. Każda liczba całkowita ma zawsze wartość od 0 do 9, więc każdy element tablicy reprezentuje jedną cyfrę dziesiętną. Rozmiar tablicy zostanie zwiększony o jeden, gdy tylko będziemy na np 999. Rozmiar pamięci nie stanowi tutaj problemu, ponieważ 2^128wymaga tylko tablicy o długości 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 bajtów

Korzystanie z biblioteki standardowej bigint jest chyba najbardziej nudny sposób odpowiedzieć na to pytanie, ale ktoś musiał to zrobić.

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

Nie golfowany:

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

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

Powodem, dla którego gra w golfa jest używana, stdio.ha nie, cstdiojest unikanie konieczności używaniastd:: nazw.

To jest moja pierwsza gra w golfa w C ++, daj mi znać, jeśli są jakieś sztuczki, aby to jeszcze skrócić.

C # .NET 4.0, 111 103 102 97 bajtów

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

Nie znalazłem tutaj żadnej odpowiedzi w języku C #, więc musiałem tylko napisać jedną.

.NET 4.0 jest wymagany, ponieważ jest to pierwsza wersja, która zawiera BigInteger . Musisz jednak odwołać się do System.Numerics.dll .

Z wcięciem:

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

Dzięki sweerpotato, Kvam, Berend za uratowanie niektórych bajtów

Clojure, 17 bajtów

(map prn (range))

Leniwe sekwencje i dowolne liczby całkowite precyzji ułatwiają to (tak jak w przypadku Haskell i CL). prnoszczędza mi kilka bajtów, ponieważ nie muszę drukować ciągu formatu. doseqprawdopodobnie byłby bardziej idiomatyczny, ponieważ tutaj mamy do czynienia tylko z efektami ubocznymi; mapnie ma większego sensu w użyciu, ponieważ utworzy sekwencję nil(która jest wartością zwracaną dla każdego z nichprn wywołania.

Zakładając, że liczę na zawsze, sekwencja wskaźnika zerowego wynikająca z tej operacji nigdy nie zostanie zwrócona.

MarioLANG , 11 bajtów

+<
:"
>!
=#

Zainspirowany odpowiedzią Martina Büttnera na inne pytanie .

CJam, 7 bajtów

0{)_p}h

Wyjaśnienie:

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

Uwaga: Należy użyć interpretera Java.

C, 89 bajtów

Nowe podejście (implementujące moduł przyrostowy bitowy) w 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])));}

Mniej golfa

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

Zakończyć

Ta wersja ma niewielką wadę, polegającą na tym, że się nie kończy (co obecnie nie jest wymagane). Aby to zrobić, musisz dodać 3 znaki:

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 bajtów

(+1$i)

Wyjaśnienie

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

Minkolang , 4 bajty

1+dN

Wypróbuj tutaj. (Właściwie uważaj. 3 sekundy czasu wystarczyły, aby dostać się do ~ 40 000).

1+dodaje 1 na górze stosu, dduplikuje go i Nwysyła górę stosu jako liczbę całkowitą z końcową spacją. Zapętla się, ponieważ Minkolang jest toroidalny, więc gdy licznik programu zejdzie z prawej krawędzi, ponownie pojawi się po lewej.

Zestaw Intel 8086+, 19 bajtów

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

Oto podział:

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

Wysyła 128 bitową liczbę w 8 górnych lewych pozycjach ekranu. Każda pozycja ekranu zawiera 8-bitowy znak ASCII i dwa 4-bitowe kolory.

Uwaga: otacza 2 ¹²⁸ ; wystarczy zmienić 8in, mov cx, 8aby 9wyświetlić liczbę 144 bitów, a nawet 80*25pokazać liczby do 2 ³²⁰⁰⁰ .

Bieganie

Skompresowana bzip2 1.44Mb, dyskietka startowa zakodowana w standardzie base64 Obraz

Wygeneruj obraz dyskietki, kopiując i wklejając następujące elementy

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

w tym wierszu poleceń:

base64 -d | bunzip2 > floppy.img

i biegać na przykład z qemu -fda floppy.img -boot a

Rozruchowy ISO 1,8 Mb

Jest to obraz ISO zakodowany w formacie bzip2 w formacie base64. Wygeneruj ISO, wklejając

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

w

base64 -d bunzip2 > cdrom.iso

i skonfiguruj maszynę wirtualną do uruchamiania z niej.

DOS .COM

Jest to plik wykonywalny DOS .COM zakodowany w standardzie base64 :

aAC4H7kIADH/+YMVAEdH4vnr8Q==

Wygeneruj plik .COM za pomocą

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

i uruchom go w (darmowym) systemie DOS.

Perl , 34 32 30 28 26 23 bajtów

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

Przetestuj za pomocą

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

Cudowny, 358 bajtów

..@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 pół sumatorów połączonych razem, skrajnie prawy, wykonujący N ++ w każdym cyklu, a każdy sumator podaje swój przelew (00 lub 01) do następnego w łańcuchu. Dane wyjściowe są w formacie szesnastkowym.

Interpretator python ma błąd polegający na tym, że dane wyjściowe z zapamiętanych funkcji są tracone, więc musisz uruchomić to z „-m 0”, aby działało poprawnie. Bez tego parametru można zobaczyć, jak szybko będzie działać bez błędu, ale dane wyjściowe nie będą działać poprawnie.

Uwaga do siebie: napraw ten błąd w marbelous.py Ten błąd został naprawiony w najnowszej wersji marbelous.py

R, 52 bajty

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

(Uwaga: gmpjest biblioteką zewnętrzną, więc może być konieczne pobranie jej, aby to rozwiązanie działało)

BotEngine, 128 120 112 8x13 = 104

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

Dane wyjściowe są binarne.