Trong thử thách này, bạn nên viết một chương trình hoặc hàm không có đầu vào và in hoặc trả về một chuỗi có cùng số byte như chính chương trình đó. Có một vài quy tắc:

• Bạn chỉ có thể xuất byte trong phạm vi ASCII có thể in (0x20 đến 0x7E, đã bao gồm) hoặc dòng mới (0x0A hoặc 0x0D).
• Mã của bạn không được là một quine, vì vậy mã và đầu ra phải khác nhau ít nhất một byte.
• Mã của bạn phải dài ít nhất một byte.
• Nếu đầu ra của bạn chứa các dòng mới, thì đó là một phần của số byte.
• Nếu mã của bạn yêu cầu các cờ dòng lệnh không chuẩn, hãy tính chúng như bình thường (nghĩa là bằng cách thêm sự khác biệt vào lời gọi chuẩn của ngôn ngữ của bạn vào số byte) và độ dài của đầu ra phải khớp với điểm của giải pháp của bạn. Ví dụ: nếu chương trình của bạn là abvà yêu cầu cờ không chuẩn -n(chúng tôi sẽ cho rằng nó không thể được kết hợp với cờ tiêu chuẩn, vì vậy đó là 3 byte), bạn nên xuất tổng cộng 5 byte.
• Đầu ra không phải luôn luôn giống nhau, miễn là bạn có thể chỉ ra rằng mọi đầu ra có thể đáp ứng các yêu cầu trên.
• Quy tắc quine thông thường không áp dụng. Bạn có thể đọc mã nguồn hoặc kích thước của nó, nhưng tôi nghi ngờ điều này sẽ ngắn hơn mã hóa mã hóa trong hầu hết các ngôn ngữ.

Bạn có thể viết một chương trình hoặc một chức năng và sử dụng bất kỳ phương pháp cung cấp đầu ra tiêu chuẩn nào . Lưu ý rằng nếu bạn in kết quả, bạn có thể chọn in nó ra đầu ra tiêu chuẩn hoặc luồng lỗi tiêu chuẩn, nhưng chỉ một trong số chúng được tính.

Bạn có thể sử dụng bất kỳ ngôn ngữ lập trình nào , nhưng lưu ý rằng các lỗ hổng này bị cấm theo mặc định.

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất - được đo bằng byte - thắng.

Bảng xếp hạng

var QUESTION_ID=121056,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){var F=function(a){return a.lang.replace(/<\/?a.*?>/g,"").toLowerCase()},el=F(e),sl=F(s);return el>sl?1:el<sl?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<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="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><div id="language-list"> <h2>Winners 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><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>

C (Linux hiện đại), 19 byte

main(){puts('s');}

Khi được biên dịch và chạy, bản in này:

Segmentation fault

Excel, 11 byte

Phiên bản tiếng Na Uy:

=SMÅ(13^9)

Phiên bản tiếng Anh (12 byte):

=LOWER(17^9)

Tạo số n chữ số và chuyển đổi thành văn bản bằng cách chuyển đổi thành chữ thường.

Mê cung , 4 byte

!!>@

Hãy thử trực tuyến!

Bản in 0000

Giải trình

!   Print an implicit 0 from the stack.
!   Print an implicit 0 from the stack.
>   Rotate the source code right by one cell, so the code now becomes

    @!!>

    The IP is moved along, so it's now at the end of the line, which is 
    a dead end. So the IP turns around and starts moving left.
!   Print an implicit 0 from the stack.
!   Print an implicit 0 from the stack.
@   Terminate the program.

Bash (chỉ có nội dung), 8 byte

{e,,}cho

In cho chovà một dòng mới.

Võng mạc , 2 byte

no

Hãy thử trực tuyến!

In 0và một linefeed.

Có rất nhiều giải pháp 2 byte, nhưng tôi tin rằng điều này là tối ưu. Retina theo mặc định luôn in một dòng mới và việc loại bỏ nó mất quá nhiều byte. Vì vậy, chúng ta phải tìm một chương trình 1 byte để đầu vào trống không thay đổi. Tôi tin rằng chương trình duy nhất thực hiện điều này là chương trình chứa một dòng cấp dữ liệu duy nhất, do đó bằng với đầu ra và do đó không được phép thử thách cho phép.

Điều đơn giản tiếp theo cần làm là sống với Retina xuất ra một chữ số (số lượng khớp của một số biểu thức so với đầu vào trống) và chúng ta có thể làm điều đó với rất nhiều mẫu 2 byte thất bại (hoặc khớp).

Toán học, 2 byte

4!

yếu tố

24

C, 20 byte

f(){printf("%20d");}

Xuất ra một số số, được đệm với khoảng trắng đến độ dài 20. (Số nào? Bất cứ điều gì xảy ra tiếp theo trong bộ nhớ.)

Một số mẫu chạy trên hệ thống của tôi:

llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           -666605944
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
          -1391039592
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           1727404696
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
             10717352
llama@llama:...code/c/ppcg121056samelen$ ./a.out 
           1485936232

Thật đáng tiếc khi đầu ra không thể là byte tùy ý, vì điều đó sẽ cho phép giải pháp 19 byte này:

f(){write(1,f,19);}

mà kết quả đầu ra 19 byte của rác, bắt đầu từ f'địa chỉ s.

Bash trên Linux, 6

uname

(tiếp theo là một dòng mới)

Đầu ra Linuxtheo sau là một dòng mới.

Javascript ES6, 9 byte

Sử dụng chuỗi mẫu

_=>`${_}`

f=

_=>`${_}`

console.log(f());
console.log(typeof f());

Sơ đồ kim tự tháp , 74 43 42 byte

Đã lưu 31 byte nhờ Khuldraeseth na'Barya! Đã lưu 1 byte nhờ giải pháp được thiết kế lại của JoKing!

  ^
 /^\
^---^
-^ ^-
 -^-
 /2\
/ 8 \
-----

Hãy thử trực tuyến! Xuất ra số có 41 chữ số 28^28 = 33145523113253374862572728253364605812736, theo sau là một dòng mới.

Phiên bản cũ

  ^
 / \
/out\
-----^
    /^\
   ^---^
  /1\ /9\
 /606\---
/51015\
-------

Hãy thử trực tuyến!

Đầu ra 71277303925397560663333806233294794013421332605135474842607729452115234375= 160651015 ** 9, hoặc khoảng 10 ⁷⁴ .

Python 2 , 9 byte

print{+1}

Điều này in set([1])và một linefeed.

Hãy thử trực tuyến!

Python 2 , 9 byte

print 1e5

Đầu ra được hiển thị chứa một dòng mới.

Hãy thử trực tuyến!

Brainfuck , 25 byte

--[-->+<]+++++[->-.....<]

Hãy thử trực tuyến! Lưu ý: Yêu cầu triển khai với các ô không dấu 8 bit

Đầu ra:

~~~~~}}}}}|||||{{{{{zzzzz

Giải trình

--[         254
 -->+<]      /2 = 127 into the second cell
+++++[      Five times
 ->-.....<]  Print the second cell - 1 five times

C (Ideone), 14 byte

f(){warn(0);}

Trên Ideone , cái tên được thực thi của nó prog, cái này xuất ra dòng sau với một dòng mới.

prog: Success

C (GCC), 15 byte

f(){warn(00);}

Bởi vì GCC viết một tệp thực thi được đặt tên a.outtheo mặc định (trong trường hợp không có các cờ bổ sung sẽ có giá byte), điều này sẽ xuất ra dòng sau với một dòng mới.

a.out: Success

C (gcc) , 18 17 byte

f(){puts('@C');}

Lưu ý rằng có một byte STX ( 0x02 ) giữa @và C.

Hãy thử trực tuyến!

Tính di động

Điều này đã được thử nghiệm với gcc 6.3.1 và clang 3.9.1 trên Fedora 25, gcc 4.8.4 trên Ubuntu 14.04.4 và gcc 4.8.3 trên openSUSE 13.2, trong đó nó in ra đầu ra sau.

inux-x86-64.so.2

Tôi hy vọng điều này sẽ tạo ra cùng một đầu ra với tất cả các phiên bản của gcc, miễn là nó biên dịch thành một loại thực thi sau đây.

ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2

Các nền tảng khác nhau sẽ yêu cầu một địa chỉ bộ nhớ khác nhau và có thể là một thứ tự khác nhau cho các byte trong hằng ký tự nhiều ký tự.

Ví dụ: thay thế @\2Cbằng @\2\4các bản in exec/ld-elf.so.1và một dòng mới trên FreeBSD 11 bằng clang 3.8.0.

Xác minh ngoại tuyến

$ printf "%b\n" "f(){puts('@\2C');}main(){f();}" > quine.c
$ gcc -w -o quine quine.c
$ ./quine
inux-x86-64.so.2
$ ./quine | wc -c
17

Làm thế nào nó hoạt động

Theo mặc định, ld sử dụng 0x400000 làm địa chỉ cơ sở của đoạn văn bản, nghĩa là chúng ta có thể tìm thấy nội dung của ELF bắt đầu từ địa chỉ bộ nhớ 0x400000 .

640 byte đầu tiên của ELF phần lớn độc lập với mã nguồn thực tế. Ví dụ, nếu khai báo f được theo sau main(){f();}và không có gì khác, chúng trông như sau.

00000000: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00  .ELF............
00000010: 02 00 3e 00 01 00 00 00 00 04 40 00 00 00 00 00  ..>.......@.....
00000020: 40 00 00 00 00 00 00 00 e8 19 00 00 00 00 00 00  @...............
00000030: 00 00 00 00 40 00 38 00 09 00 40 00 1e 00 1b 00  ....@.8...@.....
00000040: 06 00 00 00 05 00 00 00 40 00 00 00 00 00 00 00  ........@.......
00000050: 40 00 40 00 00 00 00 00 40 00 40 00 00 00 00 00  @.@.....@.@.....
00000060: f8 01 00 00 00 00 00 00 f8 01 00 00 00 00 00 00  ................
00000070: 08 00 00 00 00 00 00 00 03 00 00 00 04 00 00 00  ................
00000080: 38 02 00 00 00 00 00 00 38 02 40 00 00 00 00 00  8.......8.@.....
00000090: 38 02 40 00 00 00 00 00 1c 00 00 00 00 00 00 00  8.@.............
000000a0: 1c 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00  ................
000000b0: 01 00 00 00 05 00 00 00 00 00 00 00 00 00 00 00  ................
000000c0: 00 00 40 00 00 00 00 00 00 00 40 00 00 00 00 00  ..@.......@.....
000000d0: 04 07 00 00 00 00 00 00 04 07 00 00 00 00 00 00  ................
000000e0: 00 00 20 00 00 00 00 00 01 00 00 00 06 00 00 00  .. .............
000000f0: 08 0e 00 00 00 00 00 00 08 0e 60 00 00 00 00 00  ..........`.....
00000100: 08 0e 60 00 00 00 00 00 1c 02 00 00 00 00 00 00  ..`.............
00000110: 20 02 00 00 00 00 00 00 00 00 20 00 00 00 00 00   ......... .....
00000120: 02 00 00 00 06 00 00 00 20 0e 00 00 00 00 00 00  ........ .......
00000130: 20 0e 60 00 00 00 00 00 20 0e 60 00 00 00 00 00   .`..... .`.....
00000140: d0 01 00 00 00 00 00 00 d0 01 00 00 00 00 00 00  ................
00000150: 08 00 00 00 00 00 00 00 04 00 00 00 04 00 00 00  ................
00000160: 54 02 00 00 00 00 00 00 54 02 40 00 00 00 00 00  T.......T.@.....
00000170: 54 02 40 00 00 00 00 00 44 00 00 00 00 00 00 00  T.@.....D.......
00000180: 44 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00  D...............
00000190: 50 e5 74 64 04 00 00 00 b0 05 00 00 00 00 00 00  P.td............
000001a0: b0 05 40 00 00 00 00 00 b0 05 40 00 00 00 00 00  ..@.......@.....
000001b0: 3c 00 00 00 00 00 00 00 3c 00 00 00 00 00 00 00  <.......<.......
000001c0: 04 00 00 00 00 00 00 00 51 e5 74 64 06 00 00 00  ........Q.td....
000001d0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
000001e0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
000001f0: 00 00 00 00 00 00 00 00 10 00 00 00 00 00 00 00  ................
00000200: 52 e5 74 64 04 00 00 00 08 0e 00 00 00 00 00 00  R.td............
00000210: 08 0e 60 00 00 00 00 00 08 0e 60 00 00 00 00 00  ..`.......`.....
00000220: f8 01 00 00 00 00 00 00 f8 01 00 00 00 00 00 00  ................
00000230: 01 00 00 00 00 00 00 00 2f 6c 69 62 36 34 2f 6c  ......../lib64/l
00000240: 64 2d 6c 69 6e 75 78 2d 78 38 36 2d 36 34 2e 73  d-linux-x86-64.s
00000250: 6f 2e 32 00 04 00 00 00 10 00 00 00 01 00 00 00  o.2.............
00000260: 47 4e 55 00 00 00 00 00 02 00 00 00 06 00 00 00  GNU.............
00000270: 20 00 00 00 04 00 00 00 14 00 00 00 03 00 00 00   ...............

Việc sử dụng, ví dụ, main(int c, char**v){f();}thay vào đó thay đổi một số byte, nhưng không phải là phần bù của chuỗi /lib64/ld-linux-x86-64.so.2, chúng ta sẽ sử dụng để tạo đầu ra.

Độ lệch của chuỗi đã nói là 0x238 và dài 27 byte. Chúng tôi chỉ muốn in 17 byte (và cái cuối cùng sẽ là một dòng mới nếu chúng tôi sử dụng puts), vì vậy chúng tôi thêm 11 vào phần bù để lấy 0x243 , phần bù của inux-x86-64.so.2. Thêm 0x400000 và 0x243 sẽ cho 0x400243 , vị trí bộ nhớ của inux-x86-64.so.2.

Để có được địa chỉ bộ nhớ này, chúng ta có thể sử dụng các hằng ký tự nhiều ký tự, thể hiện hành vi được xác định theo thực hiện. 0x400243 là (64) (2) (67) trong các hằng ký tự đa ký tự cơ sở 256 và gcc sử dụng thứ tự byte cuối lớn, do đó '@\2C'mang lại địa chỉ bộ nhớ của chuỗi mong muốn.

Cuối cùng, putsin sting (kết thúc null) tại vị trí bộ nhớ đó và một dòng mới, tạo ra 17 byte đầu ra.

Brainfuck tự sửa đổi , 5 byte

<[.<]

Hãy thử trực tuyến!

Đầu ra:

]<.[<

Giải trình:

Thực sự đơn giản, in nguồn ngược lại. Trong SMBF, nội dung của chương trình được lưu trên băng, ở bên trái vị trí ban đầu của con trỏ. Lướt sang trái và in sẽ xuất mã nguồn ngược.

Vì nguồn đọc được cho phép trong thử thách này, điều này chắc chắn phải nằm trong quy tắc.

Máy tính số học cơ bản , 2 byte

1=

in 1., hoặc:

    |
    |
    |  .

trên những màn hình bảy đoạn ngớ ngẩn đó.

Để sao chép, chọn bất kỳ máy tính ngẫu nhiên; tất cả đều có ngôn ngữ lập trình này được cài đặt bằng cách nào đó.

Fourier, 26 22 20 byte

5^(`na`&i)` Batman!`

Hãy thử nó trên FourIDE!

Đầu ra:

nananananana Batman!

Để viết hoa đúng, đó là 4 byte thêm:

`N`7^(`an`i^~i)`a Batman!`

Hãy thử nó trên FourIDE!

Nanananananananana Batman!

_{RIP Adam West}

Brachylog , 1 byte

w

Hãy thử trực tuyến!

Giải trình

wlà "ghi" tích hợp. Ở đây, nó sẽ viết Input. Vì Đầu vào là một biến miễn phí, wsẽ gắn nhãn đó là số nguyên trước khi in. Số nguyên đầu tiên nó thử là 0.

Java (OpenJDK 8) , 11 byte

o->1e8-1+""

Hãy thử trực tuyến!

Đầu ra:

9.9999999E7

Chỉ là một chút công phu hơn câu trả lời rõ ràng ()->"".format("%23s",0),.

Tiết kiệm

• 18 -> 16 byte: Sự kết hợp thuận lợi hơn giữa làm tròn và sức mạnh của 10, nhờ vào PunPun1000
• 16 -> 13 byte: công thức tốt hơn, nhờ JollyJoker
• 13 -> 11 byte: công thức được cải thiện, nhờ Kevin Cruijssen

05AB1E , 1 byte

õ

Xuất ra một dòng mới. õđẩy một chuỗi rỗng và nó được xuất ra hoàn toàn với một dòng mới.

Hãy thử trực tuyến!

Một số giải pháp 2 byte khác, cho niềm vui xem của bạn (đầu ra nằm trong ngoặc và tất cả đầu ra có một dòng mới):

X, (1)
Y, (2)
¾, (0)
¼, (1)
¶, (newline)
ð, (space)
Î, (0)

Có nhiều cách hơn 2 giải pháp mặc dù.

V / vim, 1 byte

o

Điều này in một dòng mới.

Hãy thử trực tuyến!

Có một loạt các biến thể về điều này cũng sẽ làm việc. Ví dụ,

O

trong vim, và

Ä
ä
ï
Ï

trong V.

Ngoài ra còn có rất nhiều nhiều giải pháp ba byte. Ví dụ:

3ii
i³i
¬ac

Đây là tất cả cụ thể cho V.

Mẻ, 12 byte

@echo %OS%

Số lượng byte bao gồm dòng mới theo dõi cho cả tập lệnh và đầu ra, đó là

Windows_NT

Lục giác , 3 byte

o!@

Hãy thử trực tuyến!

In 111.

Mở ra:

 o !
@ . .
 . .

Nhưng mã thực sự chỉ chạy theo thứ tự o!@.

o   Set the memory edge to 111, the code point of 'o'.
!   Print this value as a decimal integer.
@   Terminate the program.

/// , 12 byte

/a/bcd/aaaa/

Hãy thử trực tuyến!

Bản in này bcdbcdbcdbcdvà vì đây là 12 byte, tôi đã thêm một đoạn mã vô hại / vào cuối đoạn mã để xóa nó.

R, 7 byte

mode(T)

In "logic"

MATL , 2 byte

H

Có một dòng mới.

Hãy thử trực tuyến!

Giải trình

Clipboard H chứa số 2theo mặc định. Hđẩy nội dung đó lên ngăn xếp, được hiển thị ngầm với một dòng mới.

Than , 2 byte

→¹

Hãy thử trực tuyến!

In một hàng ngang dài 1 -bên phải và một dòng mới.

Thạch , 1 byte

V

Khá nhiều biến đổi Jelly one - đây là một - nó đánh giá đối số bên trái, khi không có gì được cung cấp làm đầu vào, mặc định là 0, từ đó ước tính thành 0 và kết quả được in ngầm, a 0.

Hãy thử trực tuyến!

Trong thực tế, trong số 256 byte trong trang mã, chỉ có 95 byte hiện không tạo ra một đầu ra một byte khác trong phạm vi được chỉ định khi chạy dưới dạng một chương trình đầy đủ; đây là (dưới dạng các ký tự trang mã theo thứ tự byte):

¡¢£¦©½¿€ÇÑÞßçıȷñ÷þ"#&',-./0123456789:;?@IMRTVZ\`dmpstxyz{}~°³⁴⁵⁹ƓƈɠḶỌṬḊĖİĿṄȮṖṘẆẊṃọṣṭḃḟḣŀṁṗṡẋż’“

Ghi chú:

• Hầu hết các chương trình 1 byte đều in một 0(không có op / mang lại một danh sách có một số 0 duy nhất, in ra một 0), hầu hết các chương trình khác in một 1( 0=0và tương tự)

• Ọlà một chương trình mà không mang lại một byte khác nhau, nhưng một trong đó là ra khỏi phạm vi theo đặc điểm kỹ thuật - nó tạo ra null byte (phôi các 0nhân vật)

• ⁶ tạo ra một không gian (một nghĩa đen)

• ⁷ tạo ra một nguồn cấp dữ liệu (một nghĩa đen)

• Một số byte hoạt động ngay bây giờ có thể không làm như vậy trong tương lai - có một vài byte được bảo lưu (tôi tin) cho các giá trị niladic, khi được gán, gần như chắc chắn sẽ không tạo ra đầu ra một byte.

Befunge , 2 byte

.@

Hãy thử trực tuyến!

In 0với một không gian dấu. Cũng hoạt động trong Befunge 98.