Напишите программу, которая считает до бесконечности, начиная с одной.

Правила:

• Ваша программа должна войти в систему STDOUTили приемлемую альтернативу, если STDOUTона недоступна.
• Ваша программа должна быть полной, работающей программой, а не функцией или фрагментом кода.
• Ваша программа должна выводить каждое число с разделяющим символом между ними (перевод строки, пробел, табуляция или запятая), но это должно быть согласовано для всех чисел.
• Вы можете напечатать числа в десятичном, одинарном или базовом 256, где каждая цифра представлена ​​байтовым значением .
• Ваша программа должна считать как минимум до 2 ¹²⁸ (включительно) без проблем и без исчерпания памяти на приемлемом настольном ПК. В частности, это означает, что если вы используете унарный код, вы не можете хранить унарное представление текущего числа в памяти.

• В отличие от наших обычных правил, не стесняйтесь использовать язык (или языковую версию), даже если он новее этой задачи. Языки, специально написанные для предоставления 0-байтового ответа на этот вызов, являются честной игрой, но не особенно интересными.

  Обратите внимание, что должен быть переводчик, чтобы представление можно было проверить. Разрешается (и даже поощряется) самостоятельно писать этот переводчик для ранее не реализованного языка.

• Речь идет не о поиске языка с кратчайшим решением для этого (есть такие, где пустая программа делает свое дело) - речь идет о поиске кратчайшего решения в каждом языке. Поэтому ни один ответ не будет помечен как принятый.

Каталог

Фрагмент стека в нижней части этого поста создает каталог из ответов а) в виде списка кратчайшего решения для каждого языка и б) в качестве общей таблицы лидеров.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

## Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

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

Если вы хотите включить в заголовок несколько чисел (например, потому что ваш результат равен сумме двух файлов или вы хотите перечислить штрафы за флаг интерпретатора отдельно), убедитесь, что фактический результат является последним числом в заголовке:

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

Вы также можете сделать имя языка ссылкой, которая будет отображаться во фрагменте кода:

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

Лабиринт , 5 байт

):
\!

IP IP в коде ходит по кругу ♫

Соответствующие инструкции:

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

> <> , 8 байт

01+:nao!

шаги:

• Нажмите 0 в стеке
• Добавьте 1 к верхнему элементу стека
• Повторяющийся элемент верхнего стека
• Выведите вершину стека как число
• Вывести новую строку
• Перейдите к шагу 2, обернувшись и выполнив следующую инструкцию (шаг 11)

(Менее эффективная память (следовательно, недействительная) программа llnao.)

Haskell, 21 байт

main=mapM_ print[1..]

Произвольные целые числа и бесконечные списки делают это легко :-)

К счастью mapM_, в прелюдии. Если бы Data.Traversableбыло так же, мы бы даже могли уменьшить его до 19 байт:

main=for_[1..]print

Gol> <> , 3 байта

P:N

шаги:

• Добавьте 1 к верхнему элементу стека (при запуске это неявный 0)
• Повторяющийся элемент верхнего стека
• Выскочить и вывести верхнюю часть стека в виде числа и новой строки
• Обернитесь к шагу 1, когда мы достигли конца строки

Marbelous , 11450 4632 байта

Печать десятичных знаков - это боль!

Определенно не выиграл с этим, но я подумал, что смогу это сделать. Я надеюсь, что все в порядке, что это добавляет вывод к 40 нулям (чтобы соответствовать 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 (только 64-битная архитектура), 53 байта

Опирается на указатели размером не менее 64 бит и печатает их в шестнадцатеричном виде с использованием %pспецификатора. Программа вернется сразу, когда достигнет 2 ^ 128.

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

Гексагония , 12 11 10 7 байт

Спасибо alephalpha за встраивание кода в длину стороны 2.

10})!';

Развернутая:

 1 0
} ) !
 ' ;

Это довольно просто. 10записывает 10, т.е. перевод строки на начальный край памяти. Затем })!';многократно выполняется в цикле:

• } перейти к следующему краю памяти.
• ) увеличить его.
• ! выведите его как целое число
• ' вернитесь к 10.
• ; распечатать его как символ.

Я считаю, что это оптимально (хотя далеко не уникально). Я позволил сценарию грубой силы, который я написал для этого ответа, искать 6-байтовые решения в предположении, что он должен содержать хотя бы по одному на каждый из ;и !и либо (или ), или не будет содержать ?, ,или @, и он не найти любые решения.

Pyth, 4 байта

.V1b

Объяснение:

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

до н.э., 10

for(;;)++i

Необычно, что bcкороче dc.

От man bc:

ОПИСАНИЕ

bc - это язык, который поддерживает числа с произвольной точностью

Java 139 138 127 123 байта

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 байта

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

Echo это новая функция в Mathematica 10.3.

Рубин, 15 12 байт

loop{p$.+=1}

• pкогда задано целое число, печатает целое как есть (любезно предоставлено @philomory )
• $.магическая переменная, содержащая количество строк, считанных из стандартного ввода. Он явно инициализируется 0, а также присваивается :)

Python 3, 33 25 байт

Насколько я понимаю, целые числа Pythons имеют произвольную точность и print()автоматически создают переводы строк.

Спасибо за @Jakub и @ Sp3000 и @wnnmaw! Я действительно не знаю много Python, единственное, что я знал, было то, что он поддерживает произвольные целые числа размера =)

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

Обработка , 95 85 71 байт

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

Я пробовал что-то с циклом while, но это приводит к сбою всей обработки, так что я буду придерживаться этого пока.

(Спасибо @ SuperJedi224 и @TWiStErRob за предложения.)

Самау , 2 байта

N)

Объяснение:

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

Когда вывод программы представляет собой список, крайние скобки опускаются.

JavaScript (ES6), 99 94 67 байт

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

alertявляется общепринятым STDOUTэквивалентом для JavaScript, но его использование означает, что последовательные числа автоматически разделяются. Я предположил, что вывод символа после числа не является необходимым из-за этого.

Matlab, 132 байта

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

Хорошо, я думаю, что это первый серьезный ответ, который выполняет эту задачу без тривиального встроенного целочисленного размера abitrary. Эта программа реализует целое число произвольного размера в виде массива целых чисел. Каждое целое число всегда находится в диапазоне от 0 до 9, поэтому каждый элемент массива представляет одну десятичную цифру. Размер массива будет увеличен на единицу, как только мы находимся, например 999. Размер памяти здесь не проблема, так как 2^128требуется только массив длиной 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 байт

Использование стандартной библиотеки bigint, пожалуй, самый скучный способ ответить на этот вопрос, но кто-то должен был это сделать.

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

Причина, по которой используется stdio.hи не используется версия для гольфа, cstdioсостоит в том, чтобы не использовать std::пространство имен.

Это мой первый опыт игры в гольф на C ++, дайте мне знать, если есть какие-то хитрости, чтобы сократить это дальше.

C # .NET 4.0, 111 103 102 97 байт

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

Я не нашел никакого ответа C # здесь, поэтому мне просто нужно было написать один.

Требуется .NET 4.0, потому что это первая версия, включающая BigInteger . Вы должны ссылаться на System.Numerics.dll, хотя.

С отступом:

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

Спасибо Sweerpotato, Kvam, Berend за сохранение некоторых байтов

Clojure, 17 байт

(map prn (range))

Ленивые последовательности и произвольные целые числа точности делают это легким (как для Haskell и CL). prnэкономит мне несколько байтов, так как мне не нужно печатать строку формата. doseqвероятно, будет более идиоматичным, поскольку здесь мы имеем дело только с побочными эффектами; mapне имеет большого смысла использовать, так как он создаст последовательность nil(которая является возвращаемым значением каждого prnвызова.

Предполагая, что я считаю всегда, последовательность нулевых указателей, которая возникает в результате этой операции, никогда не возвращается.

MarioLANG , 11 байт

+<
:"
>!
=#

Вдохновленный ответом Мартина Бюттнера на другой вопрос .

CJam, 7 байтов

0{)_p}h

Объяснение:

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

Примечание. Необходимо использовать интерпретатор Java.

C 89 байтов

Новый подход (реализация побитового инкремента) в 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])));}

Меньше гольфа

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

прекратить

Эта версия имеет небольшой недостаток, заключающийся в том, что она не заканчивается (что на данный момент не является обязательным). Для этого вам нужно добавить 3 символа:

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 байт

(+1$i)

объяснение

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

Минколанг , 4 байта

1+dN

Попробуй это здесь. (Ну, на самом деле, будьте осторожны. 3 секунд времени выполнения было достаточно, чтобы набрать ~ 40000.)

1+добавляет 1 к вершине стека, dдублирует его и Nвыводит вершину стека в виде целого числа с завершающим пробелом. Это происходит из-за того, что Минколанг тороидален, поэтому, когда счетчик программ выходит за пределы правого края, он снова появляется слева.

Сборка Intel 8086+, 19 байт

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

Вот разбивка:

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

Он выводит 128-битное число на верхних левых 8 позициях экрана. Каждая позиция экрана содержит 8-битный символ ASCII и два 4-битных цвета.

Примечание: оно оборачивается на 2 ¹²⁸ ; просто изменить 8в систему, mov cx, 8чтобы 9показать 144 битное число, или даже 80*25показать номера до 2 ³²⁰⁰⁰ .

Бег

1.44Mb сжатая bzip2, загрузочная дискета в кодировке base64

Создайте образ дискеты, вставив следующую копию

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

в эту командную строку:

base64 -d | bunzip2 > floppy.img

и работать, например, с qemu -fda floppy.img -boot a

1.8Mb загрузочный ISO

Это сжатый ISO-образ bzip2 в кодировке Base64. Генерация ISO путем вставки

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

в

base64 -d bunzip2 > cdrom.iso

и настроить виртуальную машину для загрузки с нее.

DOS .COM

Это исполняемый файл DOS .COM в кодировке base64 :

aAC4H7kIADH/+YMVAEdH4vnr8Q==

Создайте файл .COM, используя

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

и запустить его в (Free) DOS.

Perl , 34 32 30 28 26 23 байта

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

Тест с

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

Marbelous, 358 байт

..@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 половинных сумматоров соединены вместе, причем самый правый из них выполняет N ++ каждый цикл, а каждый сумматор передает свой переполнение (00 или 01) следующему в цепочке. Вывод в шестнадцатеричном виде.

В интерпретаторе python есть ошибка, из-за которой теряется вывод из запомненных функций, поэтому вам нужно запустить его с «-m 0», чтобы он работал правильно. Без этого параметра вы можете видеть, как быстро он будет работать без ошибки, но вывод не будет работать правильно.

Примечание для себя: исправьте эту ошибку в marbelous.py Эта ошибка была исправлена ​​в последней версии marbelous.py

R, 52 байта

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

(Примечание: gmpэто внешняя библиотека, поэтому вам может потребоваться загрузить ее, чтобы это решение работало)

BotEngine, 128 120 112 8x13 = 104

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

Вывод в двоичном виде.