Yêu cầu:

• Lấy đầu vào trên stdin bao gồm các dòng mới / trả về vận chuyển có độ dài không giới hạn (chỉ giới hạn bởi bộ nhớ hệ thống; nghĩa là không có giới hạn vốn có trong chương trình.)
• Xuất ngược lại của đầu vào trên thiết bị xuất chuẩn.

Thí dụ:

Đầu vào:

Quick brown fox
He jumped over the lazy dog

Đầu ra:

god yzal eht revo depmuj eH
xof nworb kciuQ

Chiến thắng ngắn nhất.

Bảng xếp hạng:

var QUESTION_ID=242,OVERRIDE_USER=61563;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){return e.lang>s.lang?1:e.lang<s.lang?-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>

Golfscript - 3 ký tự

-1%

phiên bản obfuscated cũng là 3 ký tự

0(%

đây là một lời giải thích về cách % hoạt động

Bash - 7

tac|rev

tacđảo ngược thứ tự dòng, trong khi revđảo ngược thứ tự ký tự.

BrainFuck, 10 ký tự

,[>,]<[.<]

Đánh bại một lượng lớn câu trả lời cho một ngôn ngữ đơn giản như vậy.

C, 37 byte

main(_){write(read(0,&_,1)&&main());}

Haskell - 21

main=interact reverse

Python, 41 40 byte

import sys;print sys.stdin.read()[::-1]

41 -> 40 - dấu chấm phẩy bị loại bỏ vào cuối chương trình.

Có lẽ có thể được tối ưu hóa!

Pancake Stack , 342 316 byte

Put this nice pancake on top!
[]
Put this  pancake on top!
How about a hotcake?
If the pancake is tasty, go over to "".
Put this delightful pancake on top!
[#]
Eat the pancake on top!
Eat the pancake on top!
Show me a pancake!
Eat the pancake on top!
If the pancake is tasty, go over to "#".
Eat all of the pancakes!

Nó giả định rằng đầu vào được kết thúc bởi một ký tự null ( ^@trên dòng lệnh). Chạy ví dụ, sử dụng trình thông dịch :

Put this nice pancake on top!
[]
Put this  pancake on top!
How about a hotcake?
If the pancake is tasty, go over to "".
Put this delightful pancake on top!
[#]
Eat the pancake on top!
Eat the pancake on top!
Show me a pancake!
Eat the pancake on top!
If the pancake is tasty, go over to "#".
Eat all of the pancakes!
~~~~~~~~~~~~~~~~~~~~~~~~
Hello, World!^@
!dlroW ,olleH

APL, 2

⊖⍞

Hoặc CircleBar quoteQuad nếu các ký tự không đi qua, chỉ đơn giản là: nhập ngược ký tự bàn phím.

Perl - 23

print scalar reverse <>

Ruby - 19 ký tự

puts$<.read.reverse

C - 47 ký tự

main(c){if(c=getchar(),c>=0)main(),putchar(c);}

Lưu ý rằng điều này sử dụng không gian ngăn xếp O (n). Hãy thử trực tuyến!

Windows PowerShell, 53 54

-join($x=[char[]]($($input)-join'
'))[($x.count)..0]

2011-01-30 (54) - Nỗ lực đầu tiên

2011-01-30 (53) - Ngắt dòng nội tuyến rất thú vị.

2011-01-3- (52) - Bài tập biến nội tuyến quá.

Perl 5.1, 14

say~~reverse<>

Befunge-93 - 11x2 (22 ký tự)

>~:0`v >:v
^    _$^,_@

Đã thử nghiệm bằng cách sử dụng thông dịch viên này .

Tính toán Lambda nhị phân - 9 byte

16 46 80 17 3E F0 B7 B0 40

Nguồn: http://ioccc.org/2012/tromp/hint.html

Phân hạch , 16 14 12 byte

DY$\
?
[Z~K!

Giải trình

Kiểm soát dòng chảy bắt đầu Dvới một (1,0)nguyên tử đi xuống . Việc ?đọc từ STDIN, mỗi lần một ký tự, đặt khối lượng thành mã ký tự đọc và năng lượng thành 0. Khi chúng ta nhấn EOF, ?thay vào đó sẽ đặt năng lượng thành 1. Các [chuyển hướng nguyên tử vào một Zcông tắc. Miễn là chúng ta đọc các ký tự, năng lượng sẽ có 0, vì vậy nguyên tử bị lệch về phía trên bởi Z. Chúng tôi sao chép nguyên tử, lặp một bản sao lại ?để đọc đầu vào. Chúng tôi tăng năng lượng bản sao khác để 1có $và đẩy nó vào stack K. Vì vậy, vòng lặp đầu vào là:

DY$\
?
[Z K

Khi năng lượng là 1do EOF, Zthay vào đó , ý chí sẽ để nguyên tử đi thẳng qua và làm giảm năng lượng 0trở lại. ~giảm năng lượng hơn nữa -1. Các nguyên tử có năng lượng âm bật ra từ ngăn xếp, vì vậy chúng ta có thể truy xuất các ký tự theo thứ tự ngược lại và in chúng với !. Bây giờ lưu ý rằng lưới là hình xuyến, vì vậy nguyên tử xuất hiện lại ở cạnh trái của cùng một hàng. Hãy nhớ rằng chúng ta đã tăng năng lượng của các nguyên tử bị đẩy trước đó $, vì vậy các nguyên tử bây giờ có năng lượng 1giống như sản lượng cuối cùng từ ?và sẽ lại truyền thẳng qua Z. Do đó, đường dẫn sau EOF là

?
[Z~K!

Vòng lặp này ở hàng dưới cùng tiếp tục cho đến khi ngăn xếp trống. Khi điều đó xảy ra, nguyên tử được phản xạ trở lại Kvà năng lượng của nó trở nên dương ( +1). Sự suy ~giảm nó một lần nữa (di chuyển sang bên trái), để bây giờ chúng ta đạt được Znăng lượng không tích cực. Điều này làm chệch hướng nguyên tử đi xuống, sao cho nó kết thúc ở nêm Ynơi nó được lưu trữ và vì không còn các nguyên tử chuyển động nữa, chương trình chấm dứt.

> <>, ₁₆ 14 byte

-2 byte bởi @JoKing

hai năm sau (!), loại bỏ -1 thêm khỏi việc đọc đầu vào bằng cách chuyển xung quanh logic để tạm dừng.

i:0(7$.
0=?;ol

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

Tương tự như câu trả lời khác> <>, điều này không cần đảo ngược ngăn xếp vì cách đọc đầu vào trong dòng đầu tiên. Tôi thực sự không chắc chắn liệu điều này có nên là một gợi ý cho câu trả lời khác> <> hay không, vì nó khá khác nhau về ngoại hình nhưng tương tự về khái niệm.

Sự khác biệt chính là câu trả lời của tôi so sánh đầu vào là 0 và nếu ít hơn (nghĩa là không có đầu vào - itrả về -1 nếu không có đầu vào), nó sẽ nhảy tới (1,7), nếu không, (0, 7). Nếu nó nhảy về trước, nó sẽ bật giá trị trên cùng (-1) và bắt đầu một vòng lặp in. Nếu nó nhảy tới cái sau, nó tiếp tục vòng lặp đầu vào.

11 byte, thoát với một lỗi

Phép lịch sự của @JoKing

i:0(7$.
~o!

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

Tôi tin rằng điều này là hợp lệ thông qua sự đồng thuận meta.

Câu trả lời trước (14 byte)

i:0(7$.
~ol0=?;!

PHP - 38 17 ký tự

<?=strrev(`cat`);

Mèo xếp chồng , 7 byte

<!]T[!>

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

Có một loạt các lựa chọn thay thế cho cùng một số byte, hầu hết trong số đó về cơ bản là tương đương với cách chúng hoạt động:

Giải trình

Một mồi mèo Stack ngắn:

• Mọi chương trình đều phải có tính đối xứng gương và bằng cách phản chiếu bất kỳ đoạn mã nào, chúng ta sẽ có được mã mới để tính toán hàm nghịch đảo. Do đó, ba ký tự cuối cùng của chương trình ở trên hoàn tác ba ký tự đầu tiên, nếu không phải là lệnh ở trung tâm.
• Mô hình bộ nhớ là một cuộn băng vô hạn của các ngăn xếp, chứa một số lượng không giới hạn, vô tận ở phía dưới. Ngăn xếp ban đầu có một -1đỉnh ở trên các số 0 và sau đó là các byte đầu vào ở trên đó (với byte đầu tiên ở trên cùng và byte cuối cùng phía trên -1).
• Đối với đầu ra, chúng ta chỉ cần lấy ngăn xếp cuối cùng, loại bỏ a -1ở dưới cùng nếu có một, và sau đó in tất cả các giá trị dưới dạng byte sang STDOUT.

Bây giờ cho chương trình thực tế:

<    Move the tape head one stack left (onto an empty stack).
!    Bitwise NOT of the implicit zero on top, giving -1.
]    Move back to the original stack, taking the -1 with the tape head.
     We're now back to the original situation, except that we have a -1
     on top.
T    Reverse the stack down to the -1 at the bottom. One of the reasons
     we needed to move a -1 on top is that T only works when the top of
     the stack is nonzero. Since the first byte of the input could have
     been a null-byte we need the -1 to make sure this does anything at
     all.
[    Push the -1 to the stack on the left.
!    Bitwise NOT, turning it back into 0 (this is irrelevant).
>    Move the tape head back onto the original stack.

Sp3000 thiết lập tìm kiếm vũ lực của mình để tìm tất cả các giải pháp 7 byte khác, vì vậy đây là một số lựa chọn thay thế:

<]!T![>
>![T]!<
>[!T!]<

Ba biến thể này về cơ bản là giống nhau, ngoại trừ việc chúng khác nhau khi bit bit KHÔNG được tính toán và liệu chúng ta sử dụng ngăn xếp trống ở bên trái hay bên phải.

<]T!T[>
>[T!T]<

Như tôi đã nói trong phần giải thích ở trên, Tkhông làm gì cả khi đỉnh của ngăn xếp bằng không. Điều đó có nghĩa là chúng ta thực sự có thể đặt !ở giữa thay thế. Điều đó có nghĩa là cái đầu tiên Tlà no-op, sau đó chúng ta biến số 0 trên đỉnh thành a -1và sau đó thứ hai Tthực hiện đảo ngược. Tất nhiên, điều này có nghĩa là trạng thái bộ nhớ cuối cùng có một -1ngăn xếp bên cạnh trạng thái ban đầu, nhưng điều đó không quan trọng vì chỉ có ngăn xếp ở vị trí đầu băng hiện tại ảnh hưởng đến đầu ra.

<*ITI*>

Biến thể này sử dụng *(XOR 1) thay vì !, để biến số 0 thành +1và Ilà một cú đẩy có điều kiện đẩy các giá trị dương và phải, các giá trị âm sang trái và phủ nhận chúng trong cả hai trường hợp (như vậy chúng ta vẫn kết thúc bằng một -1trên cùng của ngăn xếp ban đầu khi chúng ta gặp phải T), vì vậy điều này cuối cùng hoạt động giống như <!]T[!>giải pháp ban đầu .

PHP, 82 29 24 29 28 ký tự

<?=strrev(fread(STDIN,2e9));

82 -> 29: Ký tự dòng mới được giữ nguyên khi đảo ngược với strrev.
29 -> 24: Sử dụng cú pháp phím tắt bây giờ
24 -> 29: Bây giờ đọc tất cả các dòng thay vì một dòng

Befunge-98 - 11 10

#v~
:<,_@#

(Đã thử nghiệm với cfunge)

Biến thể bên dưới phá vỡ yêu cầu một chút: nó thực hiện nhiệm vụ nhưng xuất ra một luồng vô hạn các byte rỗng sau đó (và không kết thúc).

~#,

Cách thức hoạt động của nó là nó liên tục đọc đầu vào cho stack ( ~) một ký tự một lần, nhảy qua ( #) dấu phẩy. Khi đạt được EOF, ~hoạt động như một gương phản xạ và PC lật lên, liên tục xuất hiện và xuất ra một ký tự ( ,) trong khi nhảy qua ( #) dấu ngã.

Pyth - 3 5 4 byte

Vì vậy, phiên bản 3-char ban đầu không đảo ngược thứ tự dòng, chỉ là các dòng. Sau đó tôi đã đưa ra phiên bản 5-char này:

_jb.z

Tôi đã lưu 1 byte nhờ @FryAmTheEggman để kết quả:

_j.z

Bản thử trực tiếp.

Giải trình:

  .w  read all the input into a list of strings
 j    join (j) by using a newline character
_     reverse the result
      Pyth implicitly prints the result on an expression

Giải pháp gốc (không chính xác):

Về mặt kỹ thuật này không được tính vì Pyth đã được tạo ra vào năm 2014, nhưng nó vẫn gọn gàng khi được gắn với GolfScript.

#_w

Giải trình:

#    loop while no errors
  w  read a line of input (throws an error on end-of-file or Control-C)
 _   reverse the input line
     Pyth implicitly prints the result on an expression

Hình khối , 9 8 byte

Rất cám ơn Martin Ender cho môn golf này:

w;o@i.?\

Xem nó hoạt động trực tuyến!

Điều này trở thành khối sau ( >chỉ ra con trỏ lệnh ban đầu):

      w ;
      o @
> i . ? \ . . . .
  . . . . . . . .
      . .
      . .

Bước đầu tiên của chương trình là lấy tất cả đầu vào. iđặt 1 byte đầu vào vào ngăn xếp. Trừ khi đầu vào kết thúc, ?làm cho IP rẽ phải, quấn quanh khối cho đến khi nó đạt được w, nó sẽ gửi lại i.

Khi đầu vào kết thúc, ?làm cho đầu IP ở phía bắc, đi vào vòng đầu ra:

• o: in ký tự ở đầu ngăn xếp
• w: 'sidestep' con trỏ bên phải
• ;: bật ký tự vừa được in
• \: phản ánh IP, gửi nó về hướng Đông
• ?: nếu có ký tự bên trái để in, rẽ phải, quay lại vòng lặp.

Lần cuối cùng được thực ?hiện, khi không còn gì trên ngăn xếp, IP sẽ tiếp tục chuyển tiếp:

• i: lấy một byte đầu vào. Điều này sẽ được -1như đầu vào đã kết thúc.
• \: phản ánh IP, gửi về phía Bắc, vào:
• @: chấm dứt chương trình.

Giải pháp 9 byte

..o;i?@!/

Xem nó hoạt động trực tuyến!

Ở dạng khối:

      . .
      o;
> tôi? @! /. . .
  . . . . . . . .
      . .
      . .

Ký tự đầu tiên được trang bị là i, trong đó có một mã số đầu vào. Nếu không có đầu vào còn lại, đây là -1.

Nhân vật tiếp theo là ?- một quyết định. Nếu đỉnh của ngăn xếp là dương, nó sẽ rẽ phải, quấn quanh khối cho đến khi nó chạm vào /đó sẽ gửi nó trở lại i, tạo ra một vòng lặp đầu vào. Tuy nhiên, nếu ĐKDV âm, đầu vào đã kết thúc và do đó, nó rẽ trái vào vòng lặp đầu ra.

Vòng lặp đầu ra rất đơn giản. o;đầu ra và bật ra ĐKDV. Lần đầu tiên này được chạy, -1là đỉnh của ngăn xếp, nhưng không ánh xạ tới một ký tự và do đó bị bỏ qua. /phản ánh IP để di chuyển sang trái, nơi nó gặp !@- kết thúc chương trình nếu ngăn xếp trống. Mặt khác, IP tiếp tục, nhấn ?lần nữa - vì ngăn xếp không trống, nên Tosh phải là một mã số, tất cả đều là số ¹ , do đó, điều này làm cho IP rẽ phải và tiếp tục vòng lặp đầu ra.

¹ Cả hai giải pháp đều cho rằng đầu vào sẽ không chứa byte rỗng.

05AB1E, 1 byte

R

R đảo ngược đầu vào.

Wumpus , 12 byte

i=)!4*0.l&o@

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

Câu trả lời của Martin cho thấy khả năng kiểm soát lưới tam giác của Wumpus rất tốt, nhưng tôi nghĩ tôi sẽ thử thách này với một lớp lót.

Phiên bản dễ hiểu hơn (dài hơn một byte) là:

i=)!8*0.;l&o@

hoạt động như vậy:

[Input loop]
i        Read a byte of input (gives -1 on EOF)
=)!      Duplicate, increment then logical not (i.e. push 1 if EOF, else 0)
8*       Multiply by 8 (= x)
0        Push 0 (= y)
.        Jump to (x, y), i.e. (8, 0) if EOF else (0, 0) to continue input loop 

[Output]
;        Pop the extraneous -1 at the top from EOF
l&o      Output <length of stack> times
@        Terminate the program

Bây giờ chúng ta hãy xem phiên bản golf, khác ở giữa:

i=)!4*0.l&o@

Phiên bản chơi gôn tiết kiệm một byte bằng cách không cần một lệnh rõ ràng ;để bật -1 bên ngoài. Trên EOF, chương trình này nhảy đến (4, 0)thay vì (8, 0)nơi nó thực thi 4*0.lại - ngoại trừ lần này -1 bên ngoài nằm trên cùng! Điều này khiến chúng tôi nhảy tới (-4, 0), do việc bọc cũng giống như (8, 0)đối với lưới này, đưa chúng tôi đến nơi chúng tôi muốn trong khi tiêu thụ giá trị ngoại lai cùng một lúc.

Wumpus , 13 11 byte

)?\;l&o@
=i

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

Giải trình

Vì Wumpus là ngôn ngữ dựa trên ngăn xếp, nên ý tưởng cơ bản là đọc tất cả STDIN vào ngăn xếp và sau đó chỉ cần in toàn bộ ngăn xếp từ trên xuống dưới. Phần thú vị ở đây là luồng điều khiển qua lưới.

Để hiểu được luồng điều khiển, chúng ta cần nhìn vào bố cục lưới tam giác thực tế:

IP bắt đầu ở góc trên bên trái đi về phía đông. Chúng ta có thể thấy rằng có một vòng lặp thông qua nhóm sáu ô bên trái và một nhánh bên ngoài \. Như bạn có thể mong đợi, vòng lặp đọc tất cả đầu vào và phần tuyến tính ở cuối ghi kết quả trở lại STDOUT.

Trước tiên hãy nhìn vào vòng lặp. Sẽ có ý nghĩa hơn khi nghĩ về cái đầu tiên )?\không phải là một phần của vòng lặp, với vòng lặp thực sự bắt đầu tại i. Vì vậy, đây là bit ban đầu:

)   Increment an implicit zero to get a 1.
?\  Pop the 1 (which is truthy) and execute the \, which reflects the IP
    to move southwest.

Sau đó, vòng lặp bắt đầu:

i   Read one byte from STDIN and push it to the stack (or -1 at EOF).
    Note that Wumpus's grid doesn't wrap around, instead the IP reflects
    off the bottom edge.
=   Duplicate the byte we've read, so that we can use it for the condition
    later without losing it.
)   Increment. EOF becomes zero (falsy) and everything else positive (truthy).
?\  If the incremented value is non-zero, execute the \ again, which 
    continues the loop. Otherwise (at EOF), the \ is skipped and the
    IP keeps moving east.

Rời khỏi phần tuyến tính ở cuối:

;   Get rid of the -1 we read at EOF.
l   Push the stack depth, i.e. the number of bytes we've read.
&o  Print that many bytes.

PHP - 44 ký tự

<?=strrev(file_get_contents('php://stdin'));

Perl

print scalar reverse for reverse(<STDIN>);

Phân hạch , 20 15 byte

KX$ \
!
SR?J%
~

Thuật toán này rất giống với Martin, nhưng việc thực hiện khác nhau đáng kể.

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

Mọi thứ bắt đầu từ Rđó giải phóng một nguyên tử hướng đông với khối lượng 1 và năng lượng 0.

Khi nhấn ?, một ký tự đầu vào được lưu dưới dạng khối lượng của nguyên tử và năng lượng được giữ ở mức 0 trừ khi stdin trả về EOF, trong trường hợp đó năng lượng trở thành 1.

Jlà lệnh nhảy của Fission và nhảy một nguyên tử về phía trước một số tế bào tương đương với năng lượng hiện tại của nó, khiến nguyên tử có 0 năng lượng. Hiện tại, nguyên tử của chúng ta có 0 năng lượng và bỏ qua lệnh này.

Chúng tôi sau đó đình công %, đó là một chuyển đổi. Với năng lượng lớn hơn 0, nguyên tử của chúng ta sẽ được hướng xuống (như thể được phản chiếu bởi \gương), nhưng vì chúng ta có chính xác 0 năng lượng, chúng ta được gửi lên bởi gương đối diện , /.

Nguyên tử của chúng tôi tiếp tục cho đến khi nó đập vào gương thứ hai, \lần này nó hướng nó rời đi.

Chúng tôi tăng năng lượng của nguyên tử lên 1 với $và sử dụng Xđể nhân đôi nguyên tử. Một bản sao sẽ phản ánh lại $lệnh (để lại bản sao đó với 2 năng lượng) và bản sao khác sẽ được đẩy vào ngăn xếp , K.

Bản sao được phản ánh của chúng tôi di chuyển ngược từ khi nó xuất hiện cho đến khi nó chạm vào %công tắc một lần nữa. Bây giờ chúng ta có một năng lượng tích cực, chúng ta phản xạ như thể chúng ta đã đánh vào một \tấm gương, quấn quanh tấm ván lên tấm tiếp theo Svà giảm năng lượng của chúng ta xuống 1.

Các Slệnh sẽ tiêu thụ 1 năng lượng để duy trì hướng của chúng tôi. Nếu chúng ta không có năng lượng, nguyên tử sẽ làm chệch hướng như thể bị \gương chiếu xuống. Thay vào đó, chúng tôi di chuyển sang bên phải một lần nữa và nhận thêm đầu vào ?và chu kỳ lặp lại.

Khi nguyên tử của chúng ta đạt EOF, ?lệnh sẽ lưu trữ 1 năng lượng trong nguyên tử. Do đó, khi chúng ta nhấn Jlệnh lần này, chúng ta hoàn toàn bỏ qua công %tắc và hạ cánh trên công Stắc với 0 năng lượng.

Bây giờ, vì năng lượng của chúng ta đã bị tiêu hao trong bước nhảy, hướng của chúng ta không được bảo vệ bởi công Stắc, nhưng chúng ta khá hướng xuống dưới. Sau đó, chúng tôi giảm năng lượng của chúng tôi xuống -1 với ~lệnh và quấn quanh bảng. Khi bị tấn công bằng năng lượng tiêu cực, Klệnh sẽ bật ra một nguyên tử thay vì đẩy một nguyên tử. Chúng tôi xuất ra nguyên tử mới xuất hiện của chúng tôi !và sử dụng năng lượng 1 của nguyên tử đó để bỏ qua công Stắc và chu trình hoàn tất.

Nếu ngăn xếp Ktrống, năng lượng nguyên tử của chúng ta bị phủ định (dẫn đến năng lượng +1) và nó được phản xạ trở lại ~lệnh, để lại năng lượng 0. Khi đánh Slại, chúng ta bị lệch về bên phải, cho đến khi ?bị tấn công. Vì EOF đã đạt được, ?phá hủy nguyên tử và chấm dứt chương trình.

Mê cung , 10 byte

,)";@
:".(

Thông thường, các chương trình Labyrinth được cho là giống với mê cung, nhưng tôi đã có thể nén các vòng lặp trong cái này rất chặt, mã đó kết thúc thành một khối duy nhất (phòng?). Đây là một phiên bản mở rộng một chút giúp việc theo dõi luồng điều khiển dễ dàng hơn:

,""")""""""";""@
"   "   "   "
:""""   ."""(

,đọc một byte mỗi lần từ STDIN cho đến khi nó chạm EOF và trả về -1. Gia )tăng giá trị này để chúng tôi nhận được giá trị dương cho từng byte đọc và 0 tại EOF. Các :bản sao mỗi byte đọc.

Khi chúng ta nhấn EOF, con trỏ lệnh tiến tới vòng lặp thứ hai, trong đó nó liên tục loại bỏ một giá trị với ;(ban đầu là EOF, sau đó là bản sao thứ hai của mỗi byte), sau đó giảm giá trị tiếp theo (và in ra .. Do bản sao thứ hai (luôn luôn tích cực), chúng tôi biết rằng IP sẽ rẽ phải ở trên cùng và tiếp tục trong vòng lặp này.

Sau khi tất cả các byte đã được in, đỉnh của ngăn xếp lại bằng 0 và IP tiếp tục đi thẳng tới @và chương trình kết thúc.

Sự trùng lặp dường như không cần thiết của mỗi byte là điều cho phép tôi đảm bảo rằng (ngay cả trong các vòng lặp chặt chẽ của phiên bản được đánh gôn), IP luôn thực hiện lần lượt chính xác và không bao giờ chuyển từ vòng này sang vòng khác.

Lời khuyên cho TheNumberOne và Sp3000, những nỗ lực của chính họ đã giúp ích rất nhiều cho việc tìm kiếm giải pháp nén cao này.