Viết một chương trình đếm mãi mãi, bắt đầu từ một.

Quy tắc:

• Chương trình của bạn phải đăng nhập STDOUThoặc thay thế chấp nhận được, nếu STDOUTkhông có sẵn.
• Chương trình của bạn phải là một chương trình đầy đủ, có thể chạy và không phải là một chức năng hoặc đoạn trích.
• Chương trình của bạn phải xuất ra mỗi số có một ký tự phân tách ở giữa (một dòng mới, dấu cách, tab hoặc dấu phẩy), nhưng điều này phải phù hợp với tất cả các số.
• Bạn có thể in các số ở dạng thập phân, đơn nhất hoặc ở cơ sở 256 trong đó mỗi chữ số được biểu thị bằng một giá trị byte .
• Chương trình của bạn phải tính ít nhất là 2 ¹²⁸ (bao gồm) mà không gặp sự cố và không hết bộ nhớ trên máy tính để bàn hợp lý. Cụ thể, điều này có nghĩa là nếu bạn đang sử dụng unary, bạn không thể lưu trữ một đại diện đơn nhất của số hiện tại trong bộ nhớ.

• Không giống như các quy tắc thông thường của chúng tôi, vui lòng sử dụng ngôn ngữ (hoặc phiên bản ngôn ngữ) ngay cả khi nó mới hơn thử thách này. Các ngôn ngữ được viết cụ thể để gửi câu trả lời 0 byte cho thử thách này là trò chơi công bằng nhưng không đặc biệt thú vị.

  Lưu ý rằng phải có một thông dịch viên để trình có thể được kiểm tra. Được phép (và thậm chí được khuyến khích) tự viết trình thông dịch này cho một ngôn ngữ chưa được thực hiện trước đó.

• Đây không phải là tìm ngôn ngữ với giải pháp ngắn nhất cho việc này (có một số nơi mà chương trình trống thực hiện thủ thuật) - đây là về việc tìm giải pháp ngắn nhất trong mọi ngôn ngữ. Do đó, không có câu trả lời sẽ được đánh dấu là chấp nhận.

Mục lục

Đoạn trích Stack ở cuối bài đăng này tạo ra danh mục từ các câu trả lời a) dưới dạng danh sách các giải pháp ngắn nhất cho mỗi ngôn ngữ và b) dưới dạng bảng xếp hạng tổng thể.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

## Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

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

Nếu bạn muốn bao gồm nhiều số trong tiêu đề của mình (ví dụ: vì điểm của bạn là tổng của hai tệp hoặc bạn muốn liệt kê riêng các hình phạt cờ của thông dịch viên), hãy đảm bảo rằng điểm thực tế là số cuối cùng trong tiêu đề:

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

Bạn cũng có thể đặt tên ngôn ngữ thành liên kết sau đó sẽ hiển thị trong đoạn trích:

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

Mê cung , 5 byte

):
\!

IP IP trong mã đi vòng tròn

Hướng dẫn liên quan:

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

> <> , 8 byte

01+:nao!

Các bước:

• Đẩy 0 trên ngăn xếp
• Thêm 1 vào phần tử ngăn xếp trên cùng
• Sao chép phần tử ngăn xếp trên cùng
• Xuất ra đỉnh của ngăn xếp dưới dạng số
• Xuất một dòng mới
• Chuyển đến bước 2 bằng cách quấn quanh và nhảy hướng dẫn tiếp theo (bước 11)

(Một chương trình ít hiệu quả bộ nhớ (do đó không hợp lệ) là llnao.)

Haskell, 21 byte

main=mapM_ print[1..]

Số nguyên chính xác tùy ý và danh sách vô hạn làm cho điều này trở nên dễ dàng :-)

May mắn mapM_là trong khúc dạo đầu. Nếu Data.Traversablecũng như vậy, chúng ta thậm chí có thể thu nhỏ nó thành 19 byte:

main=for_[1..]print

Gol> <> , 3 byte

P:N

Các bước:

• Thêm 1 vào phần tử ngăn xếp trên cùng (khi bắt đầu, nó là 0 ẩn)
• Sao chép phần tử ngăn xếp trên cùng
• Bật và xuất đỉnh của ngăn xếp dưới dạng số và một dòng mới
• Quấn qua bước 1 khi chúng tôi đến cuối dòng

Tuyệt vời , 11450 4632 byte

In số thập phân là một nỗi đau !!

Chắc chắn không chiến thắng với cái này, nhưng tôi nghĩ tôi sẽ cho nó một phát súng. Tôi hy vọng nó ổn khi nó đệm đầu ra tới 40 số không (để phù hợp với 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 (chỉ kiến ​​trúc 64 bit), 53 byte

Dựa vào các con trỏ là ít nhất 64 bit và in chúng thành hex bằng cách sử dụng bộ %pxác định. Chương trình sẽ trở lại ngay khi chạm 2 ^ 128.

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

Lục giác , 12 11 10 7 byte

Cảm ơn alephalpha đã gắn mã vào chiều dài 2.

10})!';

Mở ra:

 1 0
} ) !
 ' ;

Cái này khá đơn giản. 10ghi 10, tức là một dòng cấp vào cạnh bộ nhớ ban đầu. Sau đó })!';được lặp đi lặp lại trong một vòng lặp:

• } di chuyển đến cạnh bộ nhớ tiếp theo.
• ) tăng nó
• ! in nó dưới dạng một số nguyên.
• ' di chuyển trở lại số 10.
• ; in nó như một nhân vật.

Tôi tin rằng điều này là tối ưu (mặc dù cho đến nay không phải là duy nhất). Tôi đã để tập lệnh bạo lực mà tôi đã viết cho câu trả lời này tìm kiếm các giải pháp 6 byte theo giả định rằng nó sẽ phải chứa ít nhất một trong số đó ;và !, (hoặc ), và sẽ không chứa ?, ,hoặc @, và nó đã không chứa tìm bất kỳ giải pháp.

Bình thường, 4 byte

.V1b

Giải trình:

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

bc, 10

for(;;)++i

Không bình thường mà bcngắn hơn dc.

Từ man bc:

SỰ MIÊU TẢ

bc là ngôn ngữ hỗ trợ các số chính xác tùy ý

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

Toán học, 22 byte

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

Echo là một chức năng mới trong Mathicala 10.3.

Ruby, 15 12 byte

loop{p$.+=1}

• p, khi được cung cấp một số nguyên, in số nguyên như cũ (lịch sự của @philomory )
• $.là một biến số ma thuật giữ số lượng dòng đọc từ stdin. Nó rõ ràng được khởi tạo thành 0, và cũng có thể gán :)

Python 3, 33 25 byte

Theo tôi hiểu, số nguyên Pythons có độ chính xác tùy ý và print()tự động tạo ra các dòng mới.

Cảm ơn @Jakub và @ Sp3000 và @wnnmaw! Tôi thực sự không biết nhiều trăn, điều duy nhất tôi nghĩ là nó hỗ trợ các số nguyên kích thước tùy ý =)

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

Đang xử lý , 95 85 71 byte

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

Tôi đã thử một cái gì đó với một vòng lặp while nhưng nó khiến tất cả Quá trình xử lý bị sập, vì vậy tôi sẽ gắn bó với điều này ngay bây giờ.

(Cảm ơn @ SuperJedi224 và @TWiStErRob vì những gợi ý.)

Samau , 2 byte

N)

Giải trình:

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

Khi đầu ra của một chương trình là một danh sách, các dấu ngoặc ngoài cùng sẽ bị bỏ qua.

JavaScript (ES6), 99 94 67 byte

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

alertlà STDOUTtương đương được chấp nhận chung cho JavaScript nhưng sử dụng nó có nghĩa là các số liên tiếp được tự động tách ra. Tôi đã cho rằng việc xuất ra một ký tự sau số là không cần thiết vì điều này.

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, tôi nghĩ rằng đây là câu trả lời nghiêm túc đầu tiên hoàn thành nhiệm vụ này mà không cần một số nguyên kích thước abitrary dựng sẵn tầm thường. Chương trình này thực hiện một số nguyên kích thước tùy ý như một mảng các số nguyên. Mỗi số nguyên luôn nằm trong khoảng từ 0 đến 9, vì vậy mỗi phần tử mảng đại diện cho một chữ số thập phân. Kích thước mảng sẽ được tăng thêm một lần ngay khi chúng ta ở ví dụ 999. Kích thước bộ nhớ không có vấn đề ở đây, vì 2^128chỉ yêu cầu một mảng có chiều dài 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

Sử dụng thư viện bigint tiêu chuẩn có lẽ là hầu hết các cách nhàm chán của việc trả lời câu hỏi này, nhưng ai đó đã phải làm điều đó.

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

Ung dung:

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

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

Lý do phiên bản golf sử dụng stdio.hvà không phải cstdiolà để tránh phải sử dụng std::không gian tên.

Đây là lần đầu tiên tôi chơi golf trong C ++, hãy cho tôi biết nếu có bất kỳ thủ thuật nào để rút ngắn điều này hơn nữa.

C # .NET 4.0, 111 103 102 97 byte

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

Tôi không tìm thấy câu trả lời C # nào ở đây, vì vậy tôi chỉ phải viết một câu.

Cần có .NET 4.0, vì đây là phiên bản đầu tiên bao gồm BigInteger . Bạn phải tham khảo System.Numerics.dll mặc dù.

Với vết lõm:

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

Cảm ơn sweerpotato, Kvam, Berend vì đã lưu một số byte

Clojure, 17 byte

(map prn (range))

Trình tự lười biếng và số nguyên chính xác tùy ý làm cho điều này trở nên dễ dàng (như đối với Haskell và CL). prntiết kiệm cho tôi một vài byte vì tôi không cần phải in một chuỗi định dạng. doseqcó lẽ sẽ thành ngữ hơn vì ở đây chúng ta chỉ xử lý các tác dụng phụ; mapkhông có nhiều ý nghĩa để sử dụng vì nó sẽ tạo ra một chuỗi nil(là giá trị trả về của mỗi prncuộc gọi.

Giả sử tôi đếm mãi, chuỗi con trỏ null kết quả từ thao tác này không bao giờ được trả về.

MarioLANG , 11 byte

+<
:"
>!
=#

Lấy cảm hứng từ câu trả lời của Martin Büttner trong một câu hỏi khác .

CJam, 7 byte

0{)_p}h

Giải trình:

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

Lưu ý: Phải sử dụng trình thông dịch Java.

C, 89 byte

Một cách tiếp cận mới (triển khai bộ tăng bit) trong 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])));}

Ít chơi gôn

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

Chấm dứt

Phiên bản này có một lỗi nhỏ, rằng nó không chấm dứt (hiện tại không phải là một yêu cầu). Để làm điều này, bạn sẽ phải thêm 3 ký tự:

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)

Giải trình

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

Chồn , 4 byte

1+dN

Hãy thử nó ở đây. (Chà, thực sự, hãy cẩn thận. 3 giây thời gian chạy là đủ để lên tới ~ 40.000.)

1+thêm 1 vào đầu ngăn xếp, dsao chép nó và Nxuất ra đỉnh của ngăn xếp dưới dạng một số nguyên có dấu cách. Vòng lặp này vì Minkolang có hình xuyến, vì vậy khi bộ đếm chương trình đi ra khỏi cạnh phải, nó sẽ xuất hiện lại ở bên trái.

Intel 8086+ hội, 19 byte

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

Đây là một sự cố:

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

Nó xuất ra số 128 bit ở 8 vị trí trên cùng bên trái. Mỗi vị trí màn hình chứa một ký tự ASCII 8 bit và hai màu 4 bit.

Lưu ý: nó kết thúc ở mức 2 ¹²⁸ ; chỉ cần thay đổi 8in mov cx, 8để 9hiển thị số 144 bit hoặc thậm chí 80*25để hiển thị số lên tới 2 ³²⁰⁰⁰ .

Đang chạy

1.44Mb bzip2 được nén, đĩa mềm có thể khởi động được mã hóa Base64

Tạo hình ảnh đĩa mềm bằng cách sao chép sau đây

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

vào dòng lệnh này:

base64 -d | bunzip2 > floppy.img

và chạy với, ví dụ, qemu -fda floppy.img -boot a

ISO khởi động 1,8Mb

Đây là hình ảnh ISO được nén bzip2 được mã hóa base64. Tạo iso bằng cách dán

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

vào

base64 -d bunzip2 > cdrom.iso

và cấu hình một máy ảo để khởi động từ nó.

DOS .COM

Đây là một tệp DOS .COM được mã hóa thực thi: 64 :

aAC4H7kIADH/+YMVAEdH4vnr8Q==

Tạo tệp .COM bằng cách sử dụng

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

và chạy nó trong (Miễn phí) DOS.

Perl , 34 32 30 28 26 23 byte

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

Kiểm tra với

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

Tuyệt vời, 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 nửa cộng được nối với nhau, một nửa bên phải thực hiện N ++ mỗi chu kỳ và mỗi bộ cộng cho phép tràn (00 hoặc 01) sang chuỗi tiếp theo trong chuỗi. Đầu ra là hex.

Trình thông dịch python có một lỗi trong đó đầu ra từ các chức năng ghi nhớ bị mất, vì vậy bạn phải chạy nó với "-m 0" để làm cho nó hoạt động tốt. Nếu không có tham số đó, bạn có thể thấy nó sẽ chạy nhanh như thế nào mà không có lỗi, nhưng đầu ra sẽ không hoạt động đúng.

Lưu ý đến bản thân: sửa lỗi đó trong marbelous.py Lỗi này đã được sửa trong phiên bản mới nhất của marbelous.py

R, 52 byte

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

(Lưu ý: gmplà một thư viện bên ngoài, vì vậy bạn có thể phải tải xuống để giải pháp này hoạt động)

BotEngine, 128 120 112 8x13 = 104

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

Đầu ra là nhị phân.