要求：

• 在stdin上进行输入，包括无限制长度的新行/回车符（仅受系统内存限制；也就是说，程序中没有固有的限制。）
• 在stdout上输出与输入相反的值。

例：

输入：

Quick brown fox
He jumped over the lazy dog

输出：

god yzal eht revo depmuj eH
xof nworb kciuQ

最短的胜利。

排行榜：

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个字符

-1%

混淆版本也是3个字符

0(%

这是％工作原理的解释

重击-7

tac|rev

tac反转行顺序，而rev反转字符顺序。

BrainFuck，10个字符

,[>,]<[.<]

如此简单的语言带来了很多答案。

C，37个字节

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

哈斯克尔-21

main=interact reverse

Python，41 40字节

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

41-> 40-在程序结束时删除了分号。

可能可以优化！

煎饼堆，342316字节

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!

假定输入以空字符终止（^@在命令行上）。使用解释器运行示例：

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

⊖⍞

或CircleBar QuoteQuad（如果字符不通过），仅表示：反转键盘字符输入。

Perl-23

print scalar reverse <>

Ruby-19个字符

puts$<.read.reverse

C-47个字符

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

请注意，这使用了O（n）堆栈空间。在线尝试！

Windows PowerShell，53 54

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

2011-01-30（54）–第一次尝试

2011-01-30（53）–内联换行很有趣。

2011-01-3-（52）–内联变量分配。

Perl 5.1、14

say~~reverse<>

Befunge-93-11x2（22个字符）

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

使用此解释器进行了测试。

二进制Lambda演算-9字节

16 46 80 17 3E F0 B7 B0 40

资料来源：http：//ioccc.org/2012/tromp/hint.html

裂变，16 14 12字节

DY$\
?
[Z~K!

说明

控制流从D一个向下的(1,0)原子开始。在?从标准输入，每次一个字符读取，大容量设置为读取字符代码和能量0。一旦我们达到EOF，?就会将能量设置为1。该[重定向原子到Z开关。只要我们正在阅读字符，能量就将保持0不变，因此原子将通过向上偏转Z。我们克隆原子，将一个副本循环回到，?以继续读取输入。我们将另一个副本的能量增加到1，$然后将其推入堆栈K。所以输入循环是这样的：

DY$\
?
[Z K

当能量1归因于EOF时，Z将改为让原子直接通过并使能量递减0。~进一步减少能量-1。具有负能量的原子从堆栈中弹出，因此我们可以按相反的顺序检索字符并使用进行打印!。现在请注意，网格是环形的，因此原子重新出现在同一行的左边缘。记住，我们早先增加了被推动的原子的能量$，因此原子现在的能量1就像上一个输出的能量一样，?并且将再次直接通过Z。因此，EOF之后的路径为

?
[Z~K!

最下面一行的循环继续进行，直到堆栈为空。发生这种情况时，原子从反射回来K，其能量变为正（+1）。在~一次以上（向左移动），所以我们现在打的递减Z与非正能量。这会使原子向下偏转，从而使其最终在Y存储原子的楔形中结束，并且由于没有更多的移动原子，该程序终止。

> <>，_16个 14字节

@JoKing -2字节

两年后（！），通过在逻辑上移动来暂停，从而从读取输入中删除多余的-1。

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

在线尝试！

与其他> <>答案类似，由于第一行中读取输入的方式，因此不需要反转堆栈。我实际上不太确定这是否应该作为其他> <>答案的建议，因为它的外观差异很大但概念相似。

主要区别在于我的答案将输入与0进行比较，如果输入比较少（即没有输入- i如果没有输入则返回-1），则跳至（1,7），否则跳至（0， 7）。如果跳到前者，它将弹出最高值（-1）并开始打印循环。如果跳到后者，它将继续输入循环。

11个字节，错误退出

由@JoKing提供

i:0(7$.
~o!

在线尝试！

我相信通过meta共识现在是有效的。

上一个答案（14个字节）

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

PHP- 38个 17个字符

<?=strrev(`cat`);

叠猫，7字节

<!]T[!>

在线尝试！

对于相同的字节数，有很多替代方法，其中大多数在工作方式上基本上是等效的：

说明

简短的Stack Cats底漆：

• 每个程序都必须具有镜像对称性，并且通过镜像任何一段代码，我们可以获得计算逆函数的新代码。因此，如果不是中央命令，上面程序的最后三个字符将撤消前三个字符。
• 内存模型是一个无限的堆栈带，在堆栈的底部具有一个隐含的，无限量的零。初始堆栈-1在这些零的顶部有一个，然后在该零的顶部有输入字节（第一个字节在最顶部，最后一个字节在上方-1）。
• 对于输出，我们只需要获取最终的堆栈，-1如果有一个，则在底部丢弃a ，然后将所有值作为字节打印到STDOUT。

现在，对于实际程序：

<    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设置了蛮力搜索以查找所有其他7字节解决方案，因此，这里有一些替代方案：

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

这三个变体在本质上是相同的，除了它们在计算按位NOT时以及在左侧还是右侧使用空堆栈方面有所不同。

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

就像我在上面的解释中说的那样，T当栈顶为零时，不执行任何操作。这意味着我们实际上可以将其!放在中间。这意味着该第一T是一个空操作，那么我们把零顶部成-1和然后接着第二T执行逆转。当然，这意味着最终的内存状态-1在堆栈上的原始状态旁边是一个，但这没关系，因为只有当前磁带头位置的堆栈会影响输出。

<*ITI*>

此变体使用*（XOR 1）代替!，从而将零变为+1，并且I是有条件推送，将正值和右，负值向左推送，并且在两种情况下都将它们取反（因此我们最终得到一个-1当遇到T）时，它会位于原始堆栈的顶部，因此最终效果与原始<!]T[!>解决方案相同。

PHP，82 29 24 29 28个字符

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

82-> 29：换行时保留换行符 strrev。
29-> 24：现在使用快捷方式语法
24-> 29：现在读取所有行，而不是一行

Befunge-98 - 11 10

#v~
:<,_@#

（使用cfunge测试）

下面的变体稍微破坏了要求：它执行任务，但之后输出无限的空字节流（并且不会终止）。

~#,

它的工作方式是一次一次地重复输入到堆栈（~）的一个字符，跳过（#）逗号。到达EOF时，~充当反射器，PC翻转过来，反复弹出并输出一个字符（,），同时跳过（#）波浪号。

Pyth- 3 5 4字节

因此，原始的3字符版本不会颠倒行顺序，而只是颠倒行。然后，我想到了这个5个字符的版本：

_jb.z

感谢@FryAmTheEggman，我节省了1个字节来生成它：

_j.z

现场演示。

说明：

  .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

原始（不正确）解决方案：

从技术上讲这并不重要，因为Pyth成立于2014年，但与GolfScript捆绑在一起仍然很整洁。

#_w

说明：

#    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

Cubix，9 8字节

非常感谢Martin Ender参加这次高尔夫比赛：

w;o@i.?\

看到它在线上工作！

这将成为以下多维数据集（>指示初始指令指针）：

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

该程序的第一步是获取所有输入。i将1个字节的输入放入堆栈。除非输入完成，否则请?使IP右转，环绕立方体直至到达w，然后将其发送回i。

输入完成后，?使IP朝北，进入输出循环：

• o：在堆栈顶部打印字符
• w：'sidestep'指向右边的指针
• ;：弹出刚打印的字符
• \：反映IP，向东发送
• ?：如果还有字符要打印，请向右转，返回循环。

?到达最后时间了，当堆栈上没有剩余任何内容时，IP继续前进：

• i：输入一个字节。这将在-1输入完成后进行。
• \：反映IP，将其向北发送到：
• @：终止程序。

9字节解决方案

..o;i?@!/

看到它在线上工作！

以立方体形式：

      。。
      o;
>我？@！/。。。
  。。。。。。。。
      。。
      。。

加密的第一个字符是i，它接受输入字符。如果没有输入，则为-1。

下一个角色是?-一个决定。如果堆栈的顶部为正，它将向右转，环绕立方体，直到撞到为止，/然后将其发送回i，从而创建输入循环。但是，如果TOS为负，则输入已完成，因此它将变成输出循环。

输出循环很简单。o;输出并弹出TOS。第一次运行时，它-1是堆栈的顶部，但没有映射到字符，因此被忽略。/反映遇到的IP向左移动!@-如果堆栈为空，则终止程序。否则，IP将继续，?然后再次命中-因为堆栈不是空的，所以TOS必须是一个字符代码，所有字符均为正¹，因此这会使IP右转并继续输出循环。

¹两种解决方案都假定输入将不包含空字节。

05AB1E，1个字节

R

R反转输入。

Wumpus，12个字节

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

在线尝试！

马丁的答案很好地展示了Wumpus的三角网格控制流程，但我想我可以单线尝试一下这一挑战。

更容易理解的版本（长一个字节）是：

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

像这样工作：

[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

现在让我们看一下高尔夫版本，中间版本有所不同：

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

高尔夫球版本不需要显式命令;来弹出多余的-1，从而节省了一个字节。在EOF上，此程序跳至(4, 0)而不是(8, 0)在其处4*0.再次执行-除非这次无关的-1在最上面！这导致我们跳转到(-4, 0)，这归因于与(8, 0)该网格的包装相同，从而使我们到达所需的位置，同时消耗了无关的值。

Wumpus，13 11字节

)?\;l&o@
=i

在线尝试！

说明

由于Wumpus是基于堆栈的语言，因此基本思想是将所有STDIN读取到堆栈中，然后仅从上至下打印整个堆栈。这里有趣的部分是通过网格的控制流。

要了解控制流程，我们需要查看实际的三角形网格布局：

IP从左上角开始向东。我们可以看到，在左侧的六个单元格中有一个循环，在的旁边有一个分支\。如您所料，循环读取所有输入，最后的线性部分将结果写回到STDOUT。

让我们先来看一下循环。将第一个)?\视为不属于循环的一部分更为有意义，实际的循环始于i。所以这是初始位：

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

然后循环开始：

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.

线性部分留在最后：

;   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个字符

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

佩尔

print scalar reverse for reverse(<STDIN>);

裂变，20 15字节

KX$ \
!
SR?J%
~

该算法与Martin的算法非常相似，但是实现方式有很大的不同。

这个怎么运作

一切始于R，释放出质量为1且能量为0的向东原子。

击中时?，输入字符将保存为原子的质量，并且能量保留为0，除非stdin返回EOF，在这种情况下，能量变为1。

J是Fission的jump命令，将一个原子向前跳跃相当于其当前能量的多个单元格，使该原子具有0能量。现在，我们的原子具有0的能量，并忽略此命令。

然后我们点击%，这是一个开关。能量大于0时，原子将被向下定向（就像被\镜子反射一样），但是由于我们的能量恰好为0，因此我们由相反的镜子向上发送/。

我们的原子继续前进，直到它撞击到第二面镜子为止，\这一次将其引导离开。

我们使用将原子的能量增加到1 $，并使用X来复制原子。一个副本将反射回该$命令（该副本保留2能量），而另一个副本将被压入堆栈K。

我们反射的副本从它到达的地方开始向后移动，直到%再次碰到开关。既然我们拥有正能量，我们就好像\反射镜一样，将板子缠绕到另一块板子上，然后将S能量递减到1。

该S命令将消耗1能量来保持我们的方向。如果我们没有能量，原子就会像被\镜子撞击一样向下偏转。取而代之的是，我们再次向右移动并使用来获取更多输入，?然后循环重复。

一旦我们的原子到达EOF，该?命令将在原子中存储1个能量。因此，当我们J这次点击命令时，我们将完全跳过%开关并S以0的能量降落在开关上。

现在，由于跳跃中消耗了我们的能量，因此开关不会保留我们的方向S，而是将其指向下方。然后，使用该~命令将能量减小到-1 并环绕在板上。当被负能量击中时，该K命令将弹出一个原子而不是推动一个原子。我们使用输出新弹出的原子!，并使用该原子的1能量绕过S开关，然后循环完成。

如果堆栈K是空的，则我们的原子的能量被否定（产生+1能量），并被反射回~命令，使其能量为0。S再次命中时，我们将向右偏转，直到?被击中。由于已经达到EOF，?销毁原子并终止程序。

迷宫，10字节

,)";@
:".(

通常，迷宫程序应该像迷宫一样，但是我能够紧紧地压缩其中的循环，以至于代码最终以一个块的形式出现（房间？）。这是一个稍微扩展的版本，使您可以更轻松地遵循控制流程：

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

,一次从STDIN读取一个字节，直到达到EOF并返回-1。该)增量这个值，使我们得到一些积极的事情在每个EOF读字节和为零。该:副本每次读字节。

一旦我们到达EOF，指令指针将进入第二个循环，在该循环中，它反复丢弃带有的值;（最初是EOF，随后是每个字节的第二个副本），然后使用递减下一个值(并使用进行打印.。由于有了第二个副本（始终为正），我们知道IP将在顶部进行右转并继续该循环。

在打印完所有字节之后，堆栈的顶部再次为零，并且IP继续直接前进到@，程序结束。

每个字节看似不必要的重复使我能够确保（即使在高尔夫球版本的紧凑循环中）IP始终正确转弯，并且永远不会从一个循环过渡到另一个循环。

TheNumberOne和Sp3000的一针见血，他们自己的尝试对找到这种高度压缩的解决方案很有帮助。