Вимоги:

• Візьміть вклад на 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>

Гольфскрипт - 3 символи

-1%

затуманена версія також 3 символи

0(%

ось пояснення того, як працює %

Баш - 7

tac|rev

tacповертає порядок рядків, в той час як revсторнує порядок символів.

BrainFuck, 10 символів

,[>,]<[.<]

Отримує гарну кількість відповідей на таку просту мову.

C, 37 байт

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

Хаскелл - 21 рік

main=interact reverse

Пітон, 41 40 байт

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

41 -> 40 - видалено крапку з комою в кінці програми.

Напевно, можна було б оптимізувати!

Млинець стек , 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

APL, 2

⊖⍞

Або CircleBar QuoteQuad, якщо символи не проходять, просто означає: зворотне введення символів клавіатури.

Перл - 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

Fission , 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

• Кожна програма повинна мати дзеркальну симетрію, і дзеркальним відображенням будь-якого фрагмента коду ми отримуємо новий код, який обчислює зворотну функцію. Тому три останні символи програми відміняють перші три, якщо це не було для команди в центрі.
• Модель пам’яті - це нескінченна стрічка стеків, яка вміщує внизу неявну, нескінченну кількість нулів. Початковий стек має a -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!]<

Ці три варіанти по суті однакові, за винятком того, що вони відрізняються тим, коли обчислюється побітовий NOT і чи використовуємо ми порожній стек зліва чи справа.

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

Як я вже говорив у поясненні вище, Tнічого не робить, коли вершина стека дорівнює нулю. Це означає, що насправді можна поставити !середину замість цього. Це означає, що спочатку Tце не-оп, потім ми перетворюємо нуль зверху в a -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 досягнуто, він ~виступає в якості відбивача і ПК перевертається, багаторазово вискакуючи та видаючи символ ( ,), перестрибуючи ( #) тильду.

Піт - 3 5 4 байти

Отже, оригінальна 3-char версія не змінила порядок ліній, а лише рядки. Потім я придумав цю 5-char версію:

_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 байт

Велике спасибі Мартіну Ендеру за цей гольф:

w;o@i.?\

Побачте, це працює в Інтернеті!

Це стає наступним кубом ( >вказує на початковий вказівник інструкції):

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

Перший крок програми - це взяти весь внесок. iкладе 1 байт введення на стек. Якщо введення не закінчено, ?змушує IP повернути праворуч, обертаючись навколо куба, поки він не досягне w, що повертає його назад i.

Коли введення закінчується, ?IP робить голову на північ, входячи у вихідний цикл:

• o: надрукувати символ у верхній частині стека
• w: 'sidetep' вказівник праворуч
• ;: спливаючий символ, який щойно був надрукований
• \: відобразити 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'));

Perl

print scalar reverse for reverse(<STDIN>);

Розділення , 20 15 байт

KX$ \
!
SR?J%
~

Алгоритм дуже схожий з Мартіновим, але реалізація суттєво відрізняється.

Як це працює

Все починається з того R, що випускає атом на схід масою 1 та енергією 0.

При натисканні ?вхідний символ зберігається як маса атома, а енергія залишається при 0, якщо stdin не повертає EOF, і в цьому випадку енергія стає 1.

J- це команда стрибка Фіссіона і стрибає атом вперед декілька комірок, еквівалентних його поточній енергії, залишаючи атом 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, чиї власні спроби дуже допомогли знайти це сильно стиснене рішення.