Requisitos:

• Faça uma entrada no stdin, incluindo novas linhas / retornos de carro de comprimento ilimitado (limitado apenas pela memória do sistema; ou seja, não há limite inerente no programa).
• Saída o inverso da entrada em stdout.

Exemplo:

Entrada:

Quick brown fox
He jumped over the lazy dog

Resultado:

god yzal eht revo depmuj eH
xof nworb kciuQ

Vitórias mais curtas.

Entre os melhores:

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 caracteres

-1%

versão ofuscada também é de 3 caracteres

0(%

aqui está uma explicação de como % funciona

Bash - 7

tac|rev

tacinverte a ordem das linhas, enquanto revinverte a ordem dos caracteres.

BrainFuck, 10 caracteres

,[>,]<[.<]

Bate uma boa quantidade de respostas para um idioma tão simples.

C, 37 bytes

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

Haskell - 21

main=interact reverse

Pilha de panquecas , 342 316 bytes

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!

Ele pressupõe que a entrada seja finalizada por um caractere nulo ( ^@na linha de comando). Exemplo de execução, usando o intérprete :

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

Python, 41 40 bytes

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

41 -> 40 - ponto e vírgula removido no final do programa.

Provavelmente poderia ser otimizado!

APL, 2

⊖⍞

Ou CircleBar QuoteQuad se os caracteres não aparecerem, simplesmente significando: entrada reversa de caracteres do teclado.

Perl - 23

print scalar reverse <>

Ruby - 19 caracteres

puts$<.read.reverse

C - 47 caracteres

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

Observe que isso usa espaço de pilha O (n). Experimente online!

Windows PowerShell, 53 54

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

2011-01-30 (54) - Primeira tentativa

30/01/2011 (53) - Quebras de linha em linha são divertidas.

2011-01-3- (52) - atribuições de variáveis ​​embutidas também.

Perl 5.1, 14

say~~reverse<>

Befunge-93 - 11x2 (22 caracteres)

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

Testado usando este intérprete .

Cálculo binário lambda - 9 bytes

16 46 80 17 3E F0 B7 B0 40

Fonte: http://ioccc.org/2012/tromp/hint.html

Fissão , 16 14 12 bytes

DY$\
?
[Z~K!

Explicação

O fluxo de controle começa Dcom um (1,0)átomo descendente . As ?leituras de STDIN, um caractere de cada vez, definem a massa para o código do caractere lido e a energia para 0. Quando atingirmos o EOF, ?definiremos a energia para 1. O [redireciona o átomo para um Zswitch. Enquanto estivermos lendo caracteres, a energia será 0, então o átomo é desviado para cima pelo Z. Clonamos o átomo, colocando uma cópia de volta no ?arquivo para continuar lendo a entrada. Nós incremento de energia da outra cópia para 1com $e empurrá-lo para a pilha K. Portanto, o loop de entrada é este:

DY$\
?
[Z K

Quando a energia é 1devida a EOF, a Zvontade deixa o átomo passar direto e diminui a energia 0novamente. ~diminui ainda mais a energia -1. Átomos com energia negativa saem da pilha, para que possamos recuperar os caracteres na ordem oposta e imprimi-los com !. Agora observe que a grade é toroidal; portanto, o átomo reaparece na borda esquerda da mesma linha. Lembre-se de que aumentamos a energia dos átomos pressionados anteriormente $, para que os átomos agora tenham energia 1exatamente como a última saída ?e passem novamente através do Z. O caminho após o EOF é, portanto,

?
[Z~K!

Esse loop na linha inferior continua até que a pilha esteja vazia. Quando isso acontece, o átomo é refletido de volta Ke sua energia se torna positiva ( +1). A ~diminui mais uma vez (movendo-se para a esquerda), de modo que agora atingimos a Zenergia não positiva. Isso desvia o átomo para baixo, de forma que ele acaba na cunha de Yonde está armazenado e, como não há mais átomos em movimento, o programa termina.

> <>, ₁₆ 14 bytes

-2 bytes por @JoKing

dois anos (!) depois, remove o -1 extra da entrada de leitura, alternando a lógica da interrupção.

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

Experimente online!

Semelhante à outra resposta> <>, isso não precisa inverter a pilha devido à maneira como a entrada é lida na primeira linha. Na verdade, não tenho certeza se isso deve ou não ser uma sugestão para a outra resposta, pois é bastante diferente na aparência, mas similar no conceito.

A principal diferença é que minha resposta compara a entrada com 0 e, se for menor (ou seja, não há entrada - iretorna -1 se não houver entrada), ela salta para (1,7), se não, (0, 7) Se pular para o primeiro, ele exibirá o valor superior (-1) e iniciará um loop de impressão. Se pular para o último, continuará o loop de entrada.

11 bytes, sai com um erro

Cortesia de @JoKing

i:0(7$.
~o!

Experimente online!

Acredito que isso seja válido agora via meta consenso.

Resposta anterior (14 bytes)

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

PHP - 38 17 caracteres

<?=strrev(`cat`);

Stack Cats , 7 bytes

<!]T[!>

Experimente online!

Existem várias alternativas para a mesma contagem de bytes, a maioria das quais é essencialmente equivalente na forma como elas funcionam:

Explicação

Uma pequena cartilha Stack Cats:

• Todo programa precisa ter simetria espelhada e, espelhando qualquer parte do código, obtemos um novo código que calcula a função inversa. Portanto, os três últimos caracteres do programa acima desfazem os três primeiros, se não fosse o comando no centro.
• O modelo de memória é uma fita infinita de pilhas, que contém uma quantidade implícita e infinita de zeros na parte inferior. A pilha inicial tem um -1em cima desses zeros e, em seguida, os bytes de entrada em cima disso (com o primeiro byte no topo e o último byte acima do -1).
• Para saída, simplesmente pegamos a pilha final, descartamos um -1na parte inferior, se houver, e depois imprimimos todos os valores como bytes em STDOUT.

Agora, para o programa atual:

<    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.

O Sp3000 definiu sua pesquisa de força bruta para encontrar todas as outras soluções de 7 bytes, então, aqui estão algumas alternativas:

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

Essas três variantes são essencialmente as mesmas, exceto que diferem quando o NOT bit a bit é calculado e se usamos a pilha vazia à esquerda ou à direita.

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

Como eu disse na explicação acima, Tnão faz nada quando o topo da pilha é zero. Isso significa que podemos colocar !o meio no lugar. Isso significa que o primeiro Té um no-op, depois transformamos o zero no topo em um -1e , em seguida, o segundo Trealiza a reversão. Obviamente, isso significa que o estado final da memória tem um -1na pilha ao lado do original, mas isso não importa, pois apenas a pilha na posição atual do cabeçote de fita afeta a saída.

<*ITI*>

Essa variante usa *(XOR 1) em vez de !, para transformar o zero em +1, e Ié um impulso condicional que empurra valores positivos e direitos, valores negativos deixados e os nega em ambos os casos (de modo que ainda terminamos com um -1no topo da pilha original quando nos encontramos T), então isso funciona da mesma forma que a <!]T[!>solução original .

PHP, 82 29 24 29 28 caracteres

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

82 -> 29: O novo caractere de linha é preservado quando invertido com strrev.
29 -> 24: agora usa a sintaxe de atalho
24 -> 29: agora lê todas as linhas em vez de uma única linha

Befunge-98 - 11 10

#v~
:<,_@#

(Testado com cfunge)

A variante abaixo quebra um pouco o requisito: ele executa a tarefa, mas gera um fluxo infinito de bytes nulos posteriormente (e não termina).

~#,

O modo como funciona é que ele lê repetidamente a entrada na pilha ( ~) um caractere de cada vez, pulando ( #) a vírgula. Quando o EOF é atingido, ele ~atua como um refletor e o PC vira, repetidamente exibindo e exibindo um caractere ( ,) enquanto pula ( #) sobre o til.

Pitão - 3 5 4 bytes

Portanto, a versão original de 3 caracteres não reverteu a ordem das linhas, apenas as linhas. Eu então vim com esta versão de 5 caracteres:

_jb.z

Eu salvei 1 byte graças a @FryAmTheEggman como resultado:

_j.z

Demonstração ao vivo.

Explicação:

  .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

Solução original (incorreta):

Tecnicamente, isso não conta porque o Pyth foi criado em 2014, mas ainda é interessante que esteja vinculado ao GolfScript.

#_w

Explicação:

#    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 bytes

Muito obrigado a Martin Ender por este golfe:

w;o@i.?\

Veja como funciona online!

Este se torna o seguinte cubo ( >indica o ponteiro inicial da instrução):

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

O primeiro passo do programa é receber todas as informações. icoloca 1 byte de entrada na pilha. A menos que a entrada seja concluída, ?o IP vira à direita, envolvendo o cubo até que ele chegue w, o que o envia de volta i.

Quando a entrada termina, o ?IP é direcionado para o norte, entrando no loop de saída:

• o: imprime o caractere na parte superior da pilha
• w: 'desviar' o ponteiro para a direita
• ;: pop o caractere que acabou de ser impresso
• \: reflete o IP, enviando-o para o leste
• ?: se houver caracteres restantes para imprimir, vire à direita e volte ao loop.

O tempo final ?é atingido, quando nada resta na pilha, o IP continua em frente:

• i: pegue um byte de entrada. Será assim -1que a entrada terminar.
• \: reflete o IP, enviando-o para o norte, em:
• @: encerra o programa.

Solução de 9 bytes

..o;i?@!/

Veja como funciona online!

Em forma de cubo:

      . .
      o;
> eu? @! /. . .
  . . . . . . . .
      . .
      . .

O primeiro caractere encontrado é i, que recebe um código de entrada. Se não houver nenhuma entrada, é isso -1.

O próximo personagem é ?- uma decisão. Se a parte superior da pilha for positiva, ela vira à direita, envolvendo o cubo até atingir o /que o envia de volta ao i, criando um loop de entrada. No entanto, se o TOS for negativo, a entrada foi concluída e, portanto, vira à esquerda no loop de saída.

O loop de saída é simples. o;produz e exibe os TOS. A primeira vez que isso é executado, -1é o topo da pilha, mas não é mapeado para um personagem e, portanto, é ignorado. /reflete o IP para mover para a esquerda, onde encontra !@- o que encerra o programa se a pilha estiver vazia. Caso contrário, o IP continuará, pressionando ?novamente - porque a pilha não está vazia, os TOS devem ser um código, todos positivos ¹ , o que faz com que o IP vire à direita e continue o loop de saída.

¹ Ambas as soluções assumem que a entrada não conterá bytes nulos.

05AB1E, 1 byte

R

R inverte a entrada.

Wumpus , 12 bytes

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

Experimente online!

A resposta de Martin mostra bem o fluxo de controle de grade triangular de Wumpus, mas pensei em tentar esse desafio com uma única linha.

A versão mais fácil de entender (um byte a mais) é:

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

que funciona assim:

[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

Agora vamos dar uma olhada na versão golfed, que difere no meio:

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

A versão golfed salva um byte por não precisar de um comando explícito ;para exibir o -1 externo. No EOF, este programa salta para em (4, 0)vez de (8, 0)onde é executado 4*0.novamente - exceto que desta vez o -1 externo está no topo! Isso nos leva a pular para (-4, 0), que devido ao empacotamento é o mesmo que (8, 0)para esta grade, nos leva aonde queremos enquanto consumimos o valor estranho ao mesmo tempo.

Wumpus , 13 11 bytes

)?\;l&o@
=i

Experimente online!

Explicação

Como o Wumpus é uma linguagem baseada em pilha, a idéia básica é ler todos os STDIN na pilha e imprimir a pilha inteira de cima para baixo. A parte interessante aqui é o fluxo de controle através da grade.

Para entender o fluxo de controle, precisamos observar o layout da grade triangular real:

O IP começa no canto superior esquerdo, indo para leste. Podemos ver que há um loop no grupo de seis células à esquerda e um ramo fora da \. Como seria de esperar, o loop lê todas as entradas e a seção linear no final grava o resultado novamente em STDOUT.

Vamos dar uma olhada no loop primeiro. Faz mais sentido pensar no primeiro )?\como não fazendo parte do loop, com o loop real começando no i. Então aqui está o bit inicial:

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

Então o loop começa:

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.

Isso deixa a seção linear no final:

;   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 caracteres

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

Perl

print scalar reverse for reverse(<STDIN>);

Fissão , 20 15 bytes

KX$ \
!
SR?J%
~

O algoritmo é muito semelhante ao de Martin, mas a implementação difere significativamente.

Como funciona

Tudo começa em R, que libera um átomo para o leste com massa 1 e energia 0.

Ao bater ?, um caractere de entrada é salvo como a massa do átomo e a energia é deixada em 0, a menos que stdin retorne EOF; nesse caso, a energia se torna 1.

Jé o comando de salto da Fissão e pula um átomo para frente um número de células equivalente à sua energia atual, deixando o átomo com 0 de energia. Por enquanto, nosso átomo tem 0 de energia e ignora esse comando.

Em seguida %, atacamos , que é um interruptor. Com energia maior que 0, nosso átomo seria direcionado para baixo (como se refletido por um \espelho), mas como temos exatamente 0 de energia, somos enviados para cima pelo espelho oposto /.

Nosso átomo continua até atingir um segundo espelho, \desta vez direcionando-o para a esquerda.

Nós incrementamos a energia do átomo para 1 com $e usamos Xpara duplicar o átomo. Uma cópia será refletida novamente no $comando (deixando a cópia com 2 energia) e a outra cópia será empurrada para a pilha K,.

Nossa cópia refletida viaja para trás, de onde veio até que %pressione o botão novamente. Agora que temos uma energia positiva, refletimos como se tivéssemos atingido um \espelho, envolvendo o quadro para o próximo Se diminuindo nossa energia para 1.

O Scomando consumirá 1 energia para preservar nossa direção. Se não tivéssemos energia, o átomo teria desviado como se fosse atingido por um \espelho, para baixo. Em vez disso, movemos para a direita novamente e captamos mais informações com ?e o ciclo se repete.

Quando nosso átomo atingir EOF, o ?comando armazenará 1 energia no átomo. Assim, quando pressionamos o Jcomando dessa vez, pulamos completamente o %comutador e pousamos no Scomutador com 0 de energia.

Agora, como nossa energia foi consumida no salto, nossa direção não é preservada pelo Sinterruptor, mas somos direcionados para baixo. Em seguida, diminuímos nossa energia para -1 com o ~comando e contornamos o quadro. Quando atingido com uma energia negativa, o Kcomando lança um átomo em vez de empurrá-lo. Produzimos nosso átomo recém-liberado !e usamos a energia 1 desse átomo para ignorar a Schave, e o ciclo é concluído.

Se a pilha estiver Kvazia, a energia do nosso átomo é negada (resultando em energia +1) e é refletida de volta no ~comando, deixando-a com energia 0. Ao bater Snovamente, somos desviados para a direita, até que ?seja atingida. Desde que o EOF foi alcançado, o ?destrói o átomo e finaliza o programa.

Labirinto , 10 bytes

,)";@
:".(

Normalmente, os programas de labirinto devem se parecer com labirintos, mas eu pude comprimir os loops com tanta força que esse código acabou como um único bloco (sala?). Aqui está uma versão ligeiramente expandida que facilita o acompanhamento do fluxo de controle:

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

,lê um byte de cada vez de STDIN até atingir EOF e retornar -1. Os )incrementos este valor para que possamos obter algo de positivo para cada byte de leitura e zero no EOF. Os :duplicados cada byte de leitura.

Quando pressionamos o EOF, o ponteiro da instrução prossegue para o segundo loop, onde descarta repetidamente um valor com ;(inicialmente o EOF, depois a segunda cópia de cada byte), depois decrementa o próximo valor com (e o imprime com .. Devido a essa segunda cópia (que é sempre positiva), sabemos que o IP fará uma curva à direita no topo e continuará nesse loop.

Após a impressão de todos os bytes, a parte superior da pilha é zero novamente e o IP continua em frente até o @final do programa.

A duplicação aparentemente desnecessária de cada byte é o que me permite garantir que (mesmo nos loops apertados da versão golfed) o IP sempre faça a curva correta e nunca passe de um loop para o outro.

Uma dica do TheNumberOne e Sp3000, cujas próprias tentativas ajudaram muito a encontrar essa solução altamente compactada.