Ось для вас порівняно простий виклик.

Давши рядок довжиною N , виведіть рядок вперед, потім назад, потім вперед, потім назад ... і т.д. N разів. Наприклад, якщо ваш вхід був

Hello!

Вам слід вивести:

Hello!!olleHHello!!olleHHello!!olleH

Ви також можете вивести один зворотний рядок.

Ваше повідомлення може бути або повною програмою, або функцією, і ви можете брати введення та вихід у будь-якому розумному форматі . Наприклад, ви можете взяти IO з STDIN / STDOUT, аргументи функцій та повернути значення, з файлу тощо. Ви можете сміливо припускати, що рядок введення не буде порожньою і міститиме лише ASCII для друку. Ви повинні вивести новий рядок в одному рядку. Так, наприклад, якщо був вихід на останній приклад

Hello!
!olleH
Hello!
!olleH
Hello!
!olleH

Це не було б правильним рішенням!

Ось ще кілька тестових випадків:

Input:
a
Output:
a

Input:
abcd
Output:
abcddcbaabcddcba

Input:
OK!
Output:
OK!!KOOK!

Input:
4815162342
Output:
4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

Input:
PPCG
Output:
PPCGGCPPPPCGGCPP

Input:
42
Output:
4224

Табло лідерів

Оскільки це проблема з кодовим гольфом , стандартні лазівки заборонені, а найкоротша відповідь у байтах виграє! Однак це також змагання за найкоротший відповідь у будь-якому конкретному мові. Хоча навряд чи відповідь на Java переможе відповідь на перлі або на якійсь мові для гольфу, все ще дуже вражає найкоротший відповідь на Java. Отже, ви можете використовувати цей таблицю лідерів, щоб побачити обидва

1. Найкоротша відповідь з усіх мов, і

2. Найкоротша відповідь у кожній окремій мові.

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

# Language Name, N bytes

де Nрозмір вашого подання. Якщо ви покращите свій рахунок, ви можете зберегти старі бали у заголовку, прокресливши їх. Наприклад:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Якщо ви хочете включити у свій заголовок декілька чисел (наприклад, тому що ваш результат становить суму двох файлів або ви хочете окремо вказати штрафні санкції для перекладача), переконайтесь, що фактичний результат - це останнє число у заголовку:

# Perl, 43 + 2 (-p flag) = 45 bytes

Ви також можете зробити ім'я мови посиланням, яке потім з’явиться у фрагменті таблиць лідерів:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=93261,OVERRIDE_USER=31716;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>

Вім, 39 , 34 натискання клавіш

:se ri
Y:s/./<C-r>"/g
<C-o>qqgJC<C-r>"<esc>gJ@qq@q

5 байт збережено завдяки @Lynn!

Ось подарунок, який відбувається в прямому ефірі: (Зауважте, що цей gif є попередньою версією, оскільки я ще не встиг його повторно записати).

Ось пояснення, як це працює:

:se ri                  "Turn 'reverse indent' on.
Y                       "Yank this line
:s/./<C-r>"/g           "Replace every character on this line with the register
                        "We just yanked followed by a newline
<C-o>                   "Jump to our previous location
     qq                 "Start recording in register 'q'
       gJ               "Join these two lines
         C              "Delete this line, and enter insert mode
          <C-r>"<esc>   "Paste the line we just deleted backwards 
gJ                      "Join these two lines
  @q                    "Call macro 'q'. This will run until we hit the bottom of the buffer.
    q                   "Stop recording.
     @q                 "Start our recursive macro

Зі сторони Yзаписує додатковий новий рядок, який зазвичай є неприємною особливістю. Це, мабуть, перший раз, коли він фактично врятував кілька байтів!

Пітон, 40 байт

f=lambda s,i=0:s[i:]and s+f(s[::-1],i+1)

Рекурсивна функція. Попереджує введення рядка sдо функції реверсу, поки лічильник не iперевищить довжину s.

Мозг-Флак , 418 378 228 байт

Це мій шедевр Brain-Flak. Це може бути не так добре гольф, але виклик - це найскладніше, з чим я коли-небудь стикався.

Спробуйте в Інтернеті!

(([])[()]){({}[()]<(({}(<()>))<{({}[()]<(({}()<(({}<>))>)<({()<({}[()]<({}<({}<>)<>>)>)>}{}<>){({}[()]<({}<>)<>>)}{}>)>)}{}{}<>([]){{}({}<>)<>([])}{}<>>)>)}{}([(({}))]{({})({}[()])}{}){(({}[({}<>)<>])<<>({}<><{(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}>)>)}

Пояснення

Це пояснення зараз трохи застаріло, але воно все ще робить досить непогану роботу з пояснення програми.

Це пояснення буде трохи відрізнятися від мого звичайного процесу пояснення. Я збираюся пояснити, як я прийшов до цього результату, а не пояснював його по порядку. Ось це іде:

Ролик

Після роботи над проблемою я трохи придумав цей код:

(n[()])({()<({}[()]<({}<({}<>)<>>)>)>}{}<>){({}[()]<({}<>)<>>)}{}<>

Цей код (де n є буквальним для деякого числа. Наприклад ()()) візьме елемент у верхній частині стека і перемістить його по n кроків. З n як висота стека, це виконає "рулон" стека. тобто перемістіть верхній елемент у нижній частині стека. Ось як це працює:

Поміщаємо місце, яке ми хочемо перемістити, на мінус одне на стек. Чому мінус один? Я не знаю, що це працює саме так.

(n[()])

Потім ми петлюємо, поки це число не досягне нуля, відслідковуючи цикл з a ().

{()<({}[()]<...>)>)>}{}

Кожен раз, коли ми робимо цикл, ми підбираємо верхній елемент і переміщуємо предмет під ним до іншого стека. Це ставить цифру зверху на своє місце.

({}<({}<>)<>>)

Все, що нам потрібно зробити зараз, - це поставити номери, які ми перенесли назад. Переходимо на вимикається стек і проштовхуємо кількість виконаних циклів.

(...<>)

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

{({}[()]<({}<>)<>>)}{}<>

Зворотний

Наступним чином я змінив рулон, щоб зробити повний зворотний стек:

(n){(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}

Ще раз n позначає глибину реверсу. Тобто перші n елементів у стеці будуть перетворені. Як це працює:

Реверс - це просто химерно загорнутий валик. Ми просто згортаємо верхню частину стека n разів, зменшуючи глибину рулону по одному на кожен раз.

(n){(({}[()])<ROLLER>)}{}

Дублікат

На місці дублювання важко. Дійсно важко. Після того, як я зрозумів, як повернути стек, для створення алгоритму дублювання потрібно було докласти багато зусиль.

Ось:

(((n)<{({}[()]<(({}<>))<>>)}{}<>>)<{({}[()]<({}<>)<>([][()])({()<({}[()]<({}<({}<>)<>>)>)>}{}<>){({}[()]<({}<>)<>>)}{}<>>)}{}<>([]){{}({}<>)<>([])}{}<>([]){(({}[()])<{({}[()]<({}<({}<>)<>>)>)}{}<>([]){{}({}<>)<>([])}{}<>>)}{}>)

Це трохи великий, але ось як це працює:

Почніть з натискання n. n - глибина дубліката. Також ми відкриваємо дві дужки. Вони дозволяють нам зберігати значення n в області, поки воно знову не буде потрібно.

(((n)<

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

{({}[()]<(({}<>))<>>)}{}

Тепер ми маємо дві копії кожного номера на офшпаку. Нам потрібно розділити їх на дві групи.

Тож ми переходимо на офсет і згадуємо одну з нс, яку ми зберегли на початку.

<>>)

Обв'язуємо n разів.

{({}[()]<...>)}{}

Кожен раз, коли ми переміщуємо одну копію на основний стек.

({}<>)<>

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

([][()])ROLLER

Після цього ми розділили оригінал на дві групи "оригінал" і копію на офсетному стеці (копія насправді зворотна). Таким чином, ми просто переміщуємо копію до основного стеку і ми можемо зробити це з нею.

([]){{}({}<>)<>([])}{}<>

Програма скелету

Тепер, коли я зробив усі фрагменти програми, мені просто потрібно вставити їх у кадр.

Кадр подвоює текст на один менше, ніж висота стека, використовуючи дублікат.

(([])[()])
{
 ({}[()]<
  DUPLICATE 
 >)
>)}{}

А потім повертає стек із зменшенням кроку початкової висоти стека від n ^ 2-n до 0.

(({}))
{
 (({}[()])<
  ({}<>)<>(({}))({<({}[()])><>({})<>}{})<>{}<>
  ({}<({}<>)<>>)<>({}<>)
  ({}<
   REVERSE
  >)
 >)
}{}{}

Желе , 4 3 байти

,Ṛṁ

Спробуйте в Інтернеті! або Перевірте всі тестові випадки.

Збережено байт завдяки @ Maltysen .

Пояснення

,Ṛṁ  Input: string S
 Ṛ    Reverse S
,     Join S with reverse of S. Makes a list [S, rev(S)]
  ṁ   Mold [S, rev(S)] to len(S) by repeating elements cyclically
      Return and print implicitly as a string

PHP, 54 52 байти

(49 байт, але не працює, якщо рядок містить '0')

for(;($a=$argv[1])[$i++];)echo$i%2?$a:strrev($a);

(52 байти)

<?=str_pad('',strlen($a=$argv[1])**2,$a.strrev($a));

(54 байти)

for(;$i++<strlen($a=$argv[1]);)echo$i%2?$a:strrev($a);

2 придатних , 3 байти

Код:

gGÂ

Пояснення:

g   # Get the length of the input
 G  # Do the following n - 1 times:
  Â # Bifurcate, which duplicates a and reverses the duplicate

Використовує кодування CP-1252 . Спробуйте в Інтернеті!

Рубін, 39 байт

->(s){s.reverse!.gsub(/./){s.reverse!}}

Я смоктав Рубі. Допомога в гольфі вдячна.

Рубі - це справді приємна мова для цього через .reverse!

Пояснення

Я сподівався, що це буде щось на зразок простого:

s.gsub(/./){s.reverse!}

але через обмеження котла / виклику це довше.

Що s.reverse!дуже корисно. s.reverse!в основному s = s.reverse!, тобто він також мутує s.

Що робиться в кожному розділі програми, описано нижче:

->(s){             # Lambda with argument s
      s.reverse!   # Reverse `s` see above for details
      .gsub(/./)   # Replace every character with...
      {s.reverse!} # the input reversed!

Справа в тому, s.reverse!що це чудово - це те, що кожного разу, коли він оцінюється, гортання рядка перевертається. Так як він замінює рядок. sзмінено!

Perl, 24 байти

Включає +2 для -lp

Введіть дані про STDIN:

rev.pl <<< Hello!

rev.pl:

#!/usr/bin/perl -lp
s%.%s/.?/chop/eg;$`%eg

Дивно, але для цього не використовується вбудований reverseоператор. Ця назва просто така довга, всі рішення, про які я міг би придумати reverse, принаймні на 1 байт довше.

J, 13 8 байт

Збережено 5 байт за милі!

#;@$];|.

Це 5-поїзд із наступними дієсловами:

# ;@$ ] ; |.

Внутрішня вилка складається з ](тотожність), ;(посилання) та |.(зворотний). Дотримуйтесь:

   (| ; |.) 'Hello!'
+------+------+
|Hello!|!olleH|
+------+------+

Зовнішні два дієслова складають решту поїзда. #це в цьому випадку розмір аргументу, тобто довжина. Дієслово, яке пов'язує ці, є ;@$або ravelзакінчилось reshape. Дотримуйтесь:

   # 'Hello!'
6
   6 $ (] ; |.) 'Hello!'
+------+------+------+------+------+------+
|Hello!|!olleH|Hello!|!olleH|Hello!|!olleH|
+------+------+------+------+------+------+
   ; 6 $ (] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   6 ;@$ (] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (# ;@$ (] ; |.)) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (# ;@$ ] ; |.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH
   (#;@$];|.) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH

Старе рішення.

[:,|.^:(i.@#)

Досить просто. |.є зворотним, і ^:це силова сполука, яка повторює це ліве дієслово (права рука) # разів. Коли правильний аргумент є дієсловом, це дієслово викликається аргументом. Правослово в цьому випадку діапазон від нуля ( i.) до довжини ( #). При підвищенні до масиву проміжні результати зберігаються. Все, що потрібно зробити, це згладити масив ,.

Проміжні результати

   (i.@#) 'Hello!'
0 1 2 3 4 5
   |.^:0 1 2 3 4 5 'Hello!'
Hello!
!olleH
Hello!
!olleH
Hello!
!olleH
   |.^:(i.@#) 'Hello!'
Hello!
!olleH
Hello!
!olleH
Hello!
!olleH
   ([:,|.^:(i.@#)) 'Hello!'
Hello!!olleHHello!!olleHHello!!olleH

JavaScript (ES 6), 59 50 байт

9 байт завдяки Хеди та Хантро.

f=(s,n=1)=>s[n]?s+f([...s].reverse().join``,n+1):s

рекурсивна функція.

Обернення рядка займає майже половину розміру ( 25 22 байти!) ...
Чому для цього не існує рідного способу?

Міколанг , 17 байт:

$oId$z$Dz[rz[O]].

Спробуйте тут!

Пояснення

$o                   Read in whole input as characters
  Id                 Push the length of stack and duplicate
    $z               Pop top of stack and store in register (z)
      $D             Pop top of stack (n) and duplicate whole stack n-1 times
        z[     ]     z times, do the following:
          r          Reverse the stack
           z[O]      z times, pop the top of stack and output as character
                .    Stop.

8088 Асамблея, IBM PC DOS, 29 28 байт

Зібраний, xxdзвалище:

00000000: d1ee ac48 938a cbfc 518a cbf7 da78 01fd  ...H....Q....x..
00000010: acac b40e cd10 e2f9 59e2 ecc3            ........Y...

Нерозбірний список:

D1 EE       SHR  SI, 1          ; point SI to DOS PSP (080H) 
AC          LODSB               ; load input string length into AL 
48          DEC  AX             ; remove leading space from length counter 
93          XCHG BX, AX         ; save input length to BL 
8A FB       MOV  BH, BL         ; string output counter in BH 
        S_LOOP: 
FC          CLD                 ; set direction forward 
8A CB       MOV  CL, BL         ; reset char counter in CL 
F7 DA       NEG  DX             ; flip DX to toggle fwd/back output 
78 01       JS   C_START        ; if positive, go forward 
FD          STD                 ; otherwise go backwards 
        C_START: 
AC          LODSB               ; adjust SI to first/last char
        C_LOOP: 
AC          LODSB               ; load next char into AL
B4 0E       MOV  AH, 0EH        ; PC BIOS tty output function
CD 10       INT  10H            ; write char to console
E2 F9       LOOP C_LOOP         ; continue looping through chars
FE CF       DEC  BH             ; decrement string count loop
75 EC       JNZ  S_LOOP         ; if not zero, continue loop
C3          RET                 ; exit to DOS

Автономна виконувана програма ПК DOS. Рядок введення через командний рядок, вихід - консольний.

Піп , 11 10 байт

L#aORVRV:a

Спробуйте в Інтернеті!

Пояснення:

            a is first cmdline argument (implicit)
L#a         Loop len(a) times:
      RV:a   Reverse a and assign back to a
   ORV       Output the reverse of a (since it needs to go forward first then backward)

Haskell, 40 36 32 байт

m s=take(length s^2)$cycle$s++reverse s

Приклад:

*Main> m "Hello!"
"Hello!!olleHHello!!olleHHello!!olleH"

Ще коротше (кредит Деміену):

q s=zip(s>>[s,reverse s])s>>=fst

s >> [s, зворотний s] циклів ["abc", "cba", ...], які блискавки до правильного розміру та concatMap'ped з fst

Perl 6 ,  31  30 байт

{[~] (|($_,.flip)xx*)[^.chars]}

Збережіть один байт шляхом неправильного використання .ords, який повертає список порядків, а потім неявно перетворите його на число, для якого створіть діапазон.

{[~] (|($_,.flip)xx*)[^.ords]}

Пояснення:

# bare block lambda with implicit parameter ｢$_｣
{
  # reduce using string concatenation operator ｢~｣
  [~]

  (
    # create a Slip
    |(
      # of the input, and its string reverse
      $_, .flip

    # list repeated infinitely
    ) xx *

  # get the values in the range from 0 up-to and excluding
  # the number of characters ｢0 ..^ +$_.ords｣
  )[ ^.ords ]
}

Використання:

my &code = {[~] (|($_,.flip)xx*)[^.ords]}

say code 'a'; # a
say code 'abcd'; # abcddcbaabcddcba
say code 'OK!'; # OK!!KOOK!
say code 4815162342; # 4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

Vim + coreutils, 32 натискання клавіш

Ніколи не можеш мати занадто багато відповідей на Vim.

qqYv:!rev
Pjq@=len(@")
@q2dkv{gJ

Пояснення

qq               " Start recording macro
Y                " Yank (copy) line
v:!rev<CR>       " Reverse line with coreutils rev command
Pj               " Paste yanked line above this line
q                " Stop recording
@=len(@")<CR>@q  " Playback macro once for each character
2dk              " Delete last 3 lines
v{gJ             " Join lines

MATL, 13 12 8 байт

Проштовхує всі елементи, поєднується в кінці.

td"tP]&h

td"  ]     %For loop over string length - 1 due to diff
   tP      %Push copy of string, reverse
      &h   %Concatenate entire stack horizontally

Спробуйте в Інтернеті!

Старі версії:

Зовсім інший підхід, заснований на fprintf:

t"t1$0#YDP]x

t"        ]   % For loop over string
  t           % Duplicate string for printing:
   1$0#YD     % `fprintf` with 1 input, 0 output (i.e., to screen).
         P    % Reverse
           x  % Empty stack to prevent implicit output

Версія, заснована на оберненні рядка шаблону

ttd"wPtbYc]Dx

t                 %Duplicate input, to create 'accumulator' string 
                  % (alongside the input string which will serve as 'template'
 td               %Duplicate input, diff to get an stringof size input-1
   "       ]      %For loop over size n-1 string (consumes diff'd string)
     wP           %Get 'template' string on top of stack, and reverse
       tb         %Duplicate template string, and switch with 'accumulator' string
         Yc       %Concatenate template string with accumulator. 
            Dx   %Display top element, delete template string to prevent implicit disp

Scala, 73 72 71 байт

def f(s:String)=for(i<-1 to s.length){print(if(i%2>0)s else s.reverse)}

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

Оновлення:

Зібравши дужки на 1 байт, знявши дужки.

Завдяки зруйнованому кавуну за пропозицію, поголений байт.

Cubix , 52 байти

Ap\:\;.#u/\:qqsoq(?;u.q..$u<../pB@u:\.....\(?q..s..p

На кубі:

      A p \
      : \ ;
      . # u
/ \ : q q s o q ( ? ; u
. q . . $ u < . . / p B
@ u : \ . . . . . \ ( ?
      q . .
      s . .
      p . .

Цей був веселим; Є ще байти, які з цього ще потрібно буде гольфувати, але це обов'язково спрацює.

Спробуйте в Інтернеті!

пояснення:

Введення ABC

• /A: піти на північ і прочитати у всіх введеннях як символи; -1буде внизу
• p\;.: видаліть -1зі стека
• u# : натисніть на довжину рядка (кількість елементів у стеку)
• \:\:qq : двічі скопіюйте довжину рядка, натисніть дві копії до нижньої частини стека

• петля:

  • soq(?/<u : поміняйте верхню частину стека, опутуйте верхню частину стека як ASCII, натисніть на верхню частину (літеру) донизу, верхню частину стека, поверніть праворуч, якщо не зроблено, а потім перемістіть IP в потрібне місце.
  • в кінці циклу буде виглядати стека C B A 3 3 0

• ;u : поп-вершина стека C B A 3 3

• B : зворотний стек 3 3 A B C
• p( : переміщення знизу вгору та зменшення 3 A B C 2
• ?якщо вершина дорівнює нулю, перейдіть до @і закінчіть
• ще
  • psq:uq : перемістити знизу вгору, поміняти верхню частину і перемістити верхню частину вниз, а також перемістити зверху вниз 3 2 A B C 3
  • $u : пропустити u
  • < повертає нас назад у цикл.

Перекладач

C (gcc) , 88 87 85 83 68 66 83 82 78 байт

-1 завдяки стельовій кішці

Стара версія

p,q;f(char*s){p=q=1;for(char*m=s--;*m;s[p+=q]*p?:(m++,p+=q=-q))putchar(s[p]);}

Спробуйте в Інтернеті!

Коротша версія (трохи зламана)

Визначаючи 76-байтний підхід, виконаний лише ASCII в коментарях, і -1 байт від його налаштування.

Редагувати: Ця версія трохи зламана тим, що передбачає, що перед кожним рядком передує байт NULL, що не завжди відповідає дійсності. (Див. Останній тестовий випадок за посиланням). Повернення до 83-байтної версії наразі.

f(char*s){for(char*n=s-1,k=1;*s++;k=-k)for(;*(n+=k);)putchar(*n);}

Спробуйте в Інтернеті!

Java, 127 111 88 байт

(s,r)->{for(int i=0;i++<s.length();)r+=i%2<1?new StringBuffer(s).reverse():s;return r;};

Програма тестування без вогків

    public static void main(String[] args) {
    BiFunction<String, String, String> func = (s, r) -> {
        for (int i = 0; i++ < s.length();) {
            r += i % 2 < 1 ? new StringBuffer(s).reverse() : s;
        }
        return r;
    };
    System.out.println(func.apply("Hello!", ""));
}

R, 53 байти

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

cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")

Деякі тестові випадки:

> cat(rep(c(i<-scan(,""),rev(i)),len=length(i)^2),sep="")
1: h e l l o !
7: 
Read 6 items
hello!!ollehhello!!ollehhello!!olleh

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: a
2: 
Read 1 item
a

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: a b c d
5: 
Read 4 items
abcddcbaabcddcba

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: O K !
4: 
Read 3 items
OK!!KOOK!

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: 4 8 1 5 1 6 2 3 4 2
11: 
Read 10 items
4815162342243261518448151623422432615184481516234224326151844815162342243261518448151623422432615184

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: P P C G
5:    
Read 4 items
PPCGGCPPPPCGGCPP

> cat(rep(c(i<-scan(,""),rev(i)),l=length(i)^2),sep="")
1: 4 2
3: 
Read 2 items
4224

PowerShell v2 +, 57 байт

param($a)-join(1..($x=$a.length)|%{($a[$x..0],$a)[$_%2]})

Немає справжнього чистого способу отримати довжину рядків або повернути їх назад, тому це досить довго.

Бере введення $a, цикли від 1до $a.length(зберігається $xдля використання пізніше). Кожну ітерацію ми використовуємо псевдотерміналом для індексації до масиву $aабо $a[$x..0](тобто зворотного), виходячи з того, чи є наш вхідний номер непарним / парним [$_%2]. Усі вони інкапсульовані в паренах і -joinразом з єдиним рядком. Це залишилося на конвеєрі, і вихід неявний.

PS C:\Tools\Scripts\golfing> .\stringgnirts.ps1 'TimmyD'
TimmyDDymmiTTimmyDDymmiTTimmyDDymmiT

Java, 151 байт

public static void r(String s){String t = new StringBuffer(s).reverse().toString();for(int i=0;i<s.length();i++){System.out.print(((i%2==1)?t:s));}}

}

Безголівки:

public static void r(String s) {
    String t = new StringBuffer(s).reverse().toString();
    for(int i = 0; i < s.length();i++) {
        System.out.print(((i % 2 == 1) ? t : s));
    }
}

C #, 94 байти

using System.Linq;string R(string n)=>string.Concat(n.SelectMany((c,i)=>1>i%2?n:n.Reverse()));

76 байт для методу + 18 байт для імпорту LINQ.

Як це працює:

using System.Linq; // Required for LINQ extension methods.

string R(string n) => 
    string.Concat( // Concatenate the following chars into a single string
        n.SelectMany( // Enumerate each char in n, flattening the returned IEnumerable<char>'s into a single IEnumerable<char>
            /*IEnumerable<char> Lambda*/(/*char*/ c, /*int*/ i) => // i = index in n
                1 > i % 2 // Check if i is even or odd
                    ? n // if i is even, add n to the concat
                    : n.Reverse() // else reverse n and concat that
        )
    )
;

CJam , 10 байт

l_,({_W%}*

Спробуйте в Інтернеті!

Пояснення

l            e# Read line
 _           e# Duplicate
  ,(         e# Length minus 1
    {   }*   e# Run code block that many times
     _       e# Duplicate
      W%     e# Reverse
             e# Implicitly display

Октава, 39 35 байт

@(x)[x'+~x;flip(x'+~x),''](1:end/2)

f('Hello!')
ans = Hello!!olleHHello!!olleHHello!!olleH

Пояснення:

@(x)            % Take x as input, inside apostrophes 'Hello!'
x'+~x           % Create a mesh of the ASCII-code of the input letters
                % For input `bcd` this will be:
                %    98    98    98
                %    99    99    99
                %   100   100   100
;flip(x'+~x)   % Concatenate vertically to create:
                %    98    98    98
                %    99    99    99
                %   100   100   100
                %   100   100   100
                %    99    99    99
                %    98    98    98
___,'']         % Short cut to convert ASCII-code to characters
(1:end/2)       % Display the first half of this array of letters, as a
                % horizontal string

Збережено 4 байти завдяки Луїсу. ~xзамість 0*xзбереженого одного байта (працює тому, що всі елементи х є нульовими. flipзамість flipudзбережених ще два байти (я не знав, що flipіснують).

bash + util-linux, 68 58 53 байт

y=$1;for((i;i<${#1};i++)){ echo -n $y;y=`rev<<<$y`;}

Пояснення

Дві речі з forциклом:

• Існує, очевидно, незадокументований спосіб написання forциклів, коли один замінює doі doneключові слова фігурними дужками {та }. Пробіл після першого дужки необхідний, і крапка з комою в кінці також необхідна.
• Виявляється, в forциклі "С-стиль" ви можете просто ініціалізувати, i;а не використовувати i=0;.
• ${#1}Частина умови i < ${#1}відноситься до довжини нашого входу (перший параметр $1). Загалом, ви можете використовувати ${#foo}для отримання розміру рядка $foo.

Додатково:

• rev - це інструмент util-linux, який обертає рядок.
• Нам потрібно передати -nпрапор, щоб echoпозбутися нових рядків.
• Вираз rev<<<$yназивається тут-рядком (див. Цю відповідну сторінку tldp.org ), який передає змінну $yстандартному вводу rev.

Japt , 11 байт

ê1 pUÊ ¯Uʲ
ê1          // Append the reverse of the input to the input,
   pUÊ      // then repeat it input length times
       ¯Uʲ // and finally trim to length input length squared.

Спробуйте в Інтернеті!

05AB1E , 7 байт

vDR}v}J

Спробуйте в Інтернеті!

Буде продовжувати працювати над цим. Мені не дуже подобається "v}" її частина, можливо, там можна зберегти байт.

Пояснення

vDR}v}J

v         ; Iterates through each character
 D        ; Duplicate top of stack
  R       ; Push top of stack reversed
   }      ; end for loop
   v}     ; same as other v, effectively pops top of stack off
     J    ; Join everything together