Вот сравнительно простой вызов для вас.

Если задана строка длины 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

Leaderboards

Так как это вызов кода для гольфа , стандартные лазейки запрещены, и выигрывает самый короткий ответ в байтах! Тем не менее , это также соревнование, чтобы иметь самый короткий ответ в любом конкретном языке. Хотя маловероятно, что ответ на Java превзойдет ответ на Perl или на некотором языке игры в гольф, все равно очень впечатляет кратчайший ответ на Java. Таким образом, вы можете использовать этот список лидеров, чтобы увидеть оба

1. Самый короткий ответ из всех языков и

2. Самый короткий ответ на каждом отдельном языке.

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

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

Vim, 39 , 34 нажатия клавиш

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

5 байтов сохранено благодаря @Lynn!

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

И вот объяснение того, как это работает:

: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берет дополнительную новую строку, которая является обычно неприятной особенностью. Это, вероятно, первый раз, когда он действительно сохранил несколько байтов!

Python, 40 байт

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

Рекурсивная функция. Добавляет входную строку sк функции реверса, пока счетчик не iпревысит длину s.

Brain-Flak , 418 378 228 байт

Это мой шедевр Brain-Flak. Возможно, он не очень удачный, но это самая сложная задача, с которой я когда-либо сталкивался.

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

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

объяснение

Это объяснение в настоящее время немного устарело, но оно все еще довольно хорошо объясняет программу.

Это объяснение будет немного отличаться от моего обычного процесса объяснения. Я собираюсь объяснить, как я пришел к этому результату, а не объяснять результат по порядку. Здесь это идет:

роликовый

Поработав над проблемой, я немного придумал этот код:

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

Этот код (где n является литералом для некоторого числа, например ()()) возьмет элемент на вершину стека и переместит его вниз на n шагов. При n в качестве высоты стека это будет выполнять "крен" стека. т.е. переместить верхний элемент в нижнюю часть стопки. Вот как это работает:

Мы помещаем место, куда хотим переместить элемент, в минус один в стеке. Почему минус один? Я не знаю, это просто так работает.

(n[()])

Затем мы выполняем цикл, пока это число не достигнет нуля, отслеживая цикл с помощью ().

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

Каждый раз, когда мы выполняем цикл, мы выбираем верхний элемент и перемещаем элемент под ним в другой стек. Это ставит номер сверху на свое место.

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

Все, что нам нужно сделать сейчас, это положить числа, которые мы переместили назад. Мы переключаемся на выключенный стек и увеличиваем количество выполненных циклов.

(...<>)

Мы циклически уменьшаем число только что отправленного, пока оно не достигнет нуля. Каждый раз мы перемещаем один номер назад.

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

Обратный

Затем я изменил бросок, чтобы сделать обратный полный стек:

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

Еще раз n представляет глубину обратного. То есть верхние n элементов в стеке будут перевернуты. Как это работает:

Реверс - это просто красиво завернутый ролик. Мы просто катим вершину стека n раз, уменьшая глубину рулона на единицу каждый раз.

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

Дублированный

На месте дублирование сложно. Очень трудно. После того, как я понял, как перевернуть стек, все еще потребовалось немало усилий, чтобы придумать алгоритм дублирования.

Вот:

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

Это немного большой, но вот как это работает:

Начните с нажатия n. n - глубина дубликата. Мы также открываем две скобки. Это позволяет нам хранить значение n в области видимости, пока оно не понадобится снова.

(((n)<

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

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

Теперь у нас есть две копии каждого номера в оффшеке. Нам нужно разделить их на две группы.

Таким образом, мы переключаемся на offstack и вспоминаем одно из ns, которое мы сохранили в начале.

<>>)

Мы зациклились 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);

2sable , 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!}}

Я сосу на Руби. Помощь в гольф приветствуется.

Ruby действительно хороший язык для этого из-за .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!то, что при каждой оценке строка get переворачивается. Так как он заменяет строку. 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 Assembly, 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, reverse 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]);}

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

Укороченная версия (слегка сломанная)

Riffing на 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;};

Тестовая программа Ungolfed

    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));}}

}

Ungolfed:

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сохранить один байт (работает, потому что все элементы 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циклах "C-style" вы можете просто инициализировать с помощью 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