Требования:

• Возьмите ввод в stdin, включая новые строки / возврат каретки неограниченной длины (ограничен только системной памятью; т. Е. В программе нет внутреннего ограничения).
• Вывести обратный ввод на стандартный вывод.

Пример:

Входные данные:

Quick brown fox
He jumped over the lazy dog

Выход:

god yzal eht revo depmuj eH
xof nworb kciuQ

Кратчайшие победы.

Leaderboard:

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

Стек блин , 342 316 байт

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

Python, 41 40 байт

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

41 -> 40 - удалена точка с запятой в конце программы.

Вероятно, может быть оптимизировано!

APL, 2

⊖⍞

Или CircleBar QuoteQuad, если символы не вводятся, просто означая: обратный ввод с клавиатуры.

Perl - 23

print scalar reverse <>

Рубин - 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
^    _$^,_@

Протестировано с использованием этого интерпретатора .

Двоичное лямбда-исчисление - 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)атома. ?Читает из STDIN, одного символа в то время, устанавливая массу на считанный код символа и энергию 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где он хранится, и поскольку больше нет движущихся атомов, программа завершается.

> <>, ₁₆ 14 байт

-2 байта @JoKing

два года спустя (!) удаляет лишние -1 из чтения ввода, переключаясь вокруг логики остановки.

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

Попробуйте онлайн!

Как и в случае с другим ответом> <>, здесь не нужно переворачивать стек из-за способа чтения ввода в первой строке. Я на самом деле не слишком уверен, должно ли это быть предложением для другого ответа> <>, так как оно совершенно другое по внешнему виду, но схожее по концепции.

Основное отличие состоит в том, что мой ответ сравнивает вход с 0, и если он меньше (т.е. нет ввода - iвозвращает -1, если нет ввода), он переходит к (1,7), если нет, (0, 7). Если он переходит к первому, он высвечивает верхнее значение (-1) и запускает цикл печати. Если он переходит к последнему, он продолжает цикл ввода.

11 байт, выходит с ошибкой

Предоставлено @JoKing

i:0(7$.
~o!

Попробуйте онлайн!

Я полагаю, что это действительно сейчас через мета-консенсус.

Предыдущий ответ (14 байт)

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

PHP - 38 17 символов

<?=strrev(`cat`);

Стека кошек , 7 байт

<!]T[!>

Попробуйте онлайн!

Существует несколько альтернатив для одного и того же числа байтов, большинство из которых по сути эквивалентны в своей работе:

объяснение

Краткий учебник по Stack Cats:

• Каждая программа должна иметь зеркальную симметрию, и, отражая любой фрагмент кода, мы получаем новый код, который вычисляет обратную функцию. Поэтому последние три символа программы выше отменяют первые три, если не для команды в центре.
• Модель памяти представляет собой бесконечную ленту стеков, которые содержат неявное, бесконечное количество нулей внизу. Начальный стек имеет -1сверху этих нулей, а затем входные байты поверх него (с первым байтом в самом верху и последним байтом над -1).
• Для вывода мы просто берем последний стек, отбрасываем a -1внизу, если он есть, и затем печатаем все значения в байтах в 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!]<

Эти три варианта по сути одинаковы, за исключением того, что они отличаются тем, когда вычисляется побитовое НЕ, и используем ли мы пустой стек слева или справа.

<]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 ~действует как отражатель, и компьютер переворачивается, многократно нажимая и выводя символ ( ,), перепрыгивая через ( #) тильду.

Pyth - 3 5 4 байта

Итак, оригинальная версия с тремя символами не изменила порядок строк, только линии. Затем я придумал эту 5-символьную версию:

_jb.z

Я спас 1 байт благодаря @FryAmTheEggman, чтобы привести его:

_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: указатель вправо
• ;: поп символ, который был только что напечатан
• \: отразить IP, отправив его на восток
• ?: если для печати остались символы, поверните направо и вернитесь в цикл.

Последнее время ?достигнуто, когда в стеке ничего не осталось, вместо этого IP-адрес продолжает:

• i: взять байт ввода. Это будет после -1ввода.
• \: отразить IP, отправив его на север, в:
• @: завершить программу.

9-байтовое решение

..o;i?@!/

Посмотрите, как это работает онлайн!

В форме куба:

      , ,
      о;
> я? @! /. , ,
  , , , , , , , ,
      , ,
      , ,

Первый 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'));

Perl

print scalar reverse for reverse(<STDIN>);

Деление , 20 15 байт

KX$ \
!
SR?J%
~

Алгоритм очень похож на алгоритм Мартина, но реализация существенно отличается.

Как это устроено

Все начинается с того R, что высвобождает восточный атом с массой 1 и энергией 0.

После нажатия ?входной символ сохраняется как масса атома, а энергия остается равной 0, если stdin не возвращает EOF, и в этом случае энергия становится равной 1.

Jэто команда прыжка деления, и она прыгает на атом на количество клеток, эквивалентное его текущей энергии, оставляя атом с нулевой энергией. На данный момент наш атом имеет нулевую энергию и игнорирует эту команду.

Затем мы наносим удар %, который является переключателем. С энергией, превышающей 0, наш атом будет направлен вниз (как если бы он отражался \зеркалом), но, поскольку у нас ровно 0 энергий, противоположное зеркало направляет нас вверх /.

Наш атом продолжается до тех пор, пока не ударит второе зеркало, на \этот раз направив его влево.

Мы увеличиваем энергию атома до 1 с $, и используем Xдля дублирования атома. Одна копия будет отражена обратно в $команду (оставив эту копию с энергией 2), а другая копия будет помещена в стек K.

Наша отраженная копия движется в обратном направлении, откуда она пришла, пока не нажмет %снова на выключатель. Теперь, когда у нас есть положительная энергия, мы размышляем, как если бы мы попали в \зеркало, оборачивая доску на следующую Sи уменьшая нашу энергию до 1.

Команда Sбудет потреблять 1 энергию, чтобы сохранить наше направление. Если бы у нас не было энергии, атом отклонился бы так, как если бы его ударило \зеркало вниз. Вместо этого мы снова двигаемся вправо и выбираем больше ввода, ?и цикл повторяется.

Как только наш атом достигнет EOF, ?команда сохранит в нем 1 энергию. Таким образом, когда мы нажимаем Jкоманду в этот раз, мы полностью пропускаем %переключатель и приземляемся на Sпереключатель с нулевой энергией.

Теперь, так как наша энергия была потреблена в прыжке, наше направление не сохраняется Sпереключателем, но мы скорее направлены вниз. Затем мы уменьшаем нашу энергию до -1 с помощью ~команды и оборачиваемся вокруг доски. При попадании с отрицательной энергией, Kкоманда выбрасывает атом вместо того, чтобы нажать на него. Мы выводим наш недавно выдвинутый атом с помощью !и используем энергию 1 этого атома для обхода Sпереключателя, и цикл завершается.

Если стек Kбыл пустым, энергия нашего атома сводится на нет (в результате чего +1 энергия), и она отражается обратно в ~команду, оставляя ее с энергией 0. При Sповторном ударе мы отклоняемся вправо, пока не ?будет нанесен удар. Поскольку EOF был достигнут, ?уничтожает атом и завершает программу.

Лабиринт , 10 байт

,)";@
:".(

Обычно лабиринтные программы должны напоминать лабиринты, но я смог сжать циклы в этом настолько плотно, что код оказался единым блоком (комната?). Вот немного расширенная версия, которая облегчает отслеживание потока управления:

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

,читает один байт за раз из STDIN, пока он не достигнет EOF и не вернется -1. В )приращения это значение так , что мы получаем что - то положительное для каждого байта чтения и нулем в EOF. :Дублирует каждый байт для чтения.

Как только мы нажимаем EOF, указатель инструкции переходит ко второму циклу, где он многократно сбрасывает одно значение с ;(вначале EOF, затем вторая копия каждого байта), затем уменьшает следующее значение с (и печатает его с .. Из-за этой второй копии (которая всегда положительна) мы знаем, что IP будет поворачивать вправо вверх и продолжать в этом цикле.

После того, как все байты были напечатаны, вершина стека снова становится равной нулю, а IP продолжается прямо до @и программа заканчивается.

Казалось бы, ненужное дублирование каждого байта - это то, что позволяет мне гарантировать, что (даже в крутых петлях версии с гольфом) IP всегда делает правильный поворот и никогда не переходит от одной петли к другой.

Наконечник шляпы к TheNumberOne и Sp3000, чьи собственные попытки очень помогли найти это сильно сжатое решение.