这对您来说是一个相对简单的挑战。

给定长度为N的字符串，向前输出该字符串，然后向后输出，然后向前，然后向后输出……等等。N次。例如，如果您输入的是

Hello!

您应该输出：

Hello!!olleHHello!!olleHHello!!olleH

您也可以选择输出一个尾随换行符。

您的提交可以是完整程序，也可以是函数，并且您可以采用任何合理的格式进行输入和输出。例如，您可以从STDIN / STDOUT中获取IO，从函数中获取参数，并从文件中获取返回值，等等。您可以放心地假设输入字符串将不会为空，并且仅包含可打印的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答案不太可能会击败perl或某些打高尔夫球语言的答案，但拥有最短的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>

VIM，39，34次的击键

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

@Lynn节省了5个字节！

这是现场直播的gif图像：（请注意，此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抓住一条额外的换行符，通常这是一个令人讨厌的功能。这实际上可能是有史以来第一次，它实际上节省了几个字节！

Python，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[()])

然后，我们循环播放直到该数字达到零为止，并使用跟踪循环()。

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

每次循环时，我们都会拾取顶部的项目并将其下方的项目移至另一个堆栈。这将数字放在其顶部。

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

我们现在要做的就是把我们移回的数字。我们切换到非堆栈，并推动循环的运行次数。

(...<>)

我们循环递减新推入的数字，直到达到零为止。每次我们向后移动一个数字。

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

相反

接下来，我修改了卷以使整个堆栈反向：

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

n再次代表反向的深度。那就是堆栈中的前n个项目将被颠倒。这个怎么运作：

相反的只是一个幻想包装的滚筒。我们简单地滚动堆栈顶部n次，每次将滚动深度减一。

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

重复

就地复制很难。真的很难。在我弄清楚如何反转堆栈之后，仍然花费了大量的精力来提出复制算法。

这里是：

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

它有点大，但是它是这样工作的：

从按n开始。n是重复项的深度。我们还打开两个括号。这些使我们能够将n的值存储在范围中，直到再次需要它为止。

(((n)<

接下来，每次将堆栈的最高值两次推入非堆栈时，我们循环n次。这使堆栈上每个数字的初始重复项。

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

现在，堆外每个数字都有两个副本。我们需要将它们分为两组。

因此，我们切换到堆栈外并回想起初保存的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编码。在线尝试！

Ruby，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!是伟大，是因为每次它被评为字符串获取真实翻转。因此，它将替换字符串。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|
+------+------+

外两个动词构成了其余部分。#在这种情况下，是参数的大小，即长度。链接这些的动词是;@$或ravelover 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字节感谢Hedi和Huntro。

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

递归函数。

反转字符串几乎需要一半的大小（25 22字节！）...
为什么没有一种本机的方式？

Minkolang，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

独立的PC 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"

甚至更短（归功于Damien）：

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

s >> [s，reverse s]循环[“ abc”，“ cba”，...]，将其压缩为正确的大小并使用fst进行concatMap

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个字节。

感谢Destructible Watermelon的建议，削减了一个字节。

库比克斯，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
• ?如果top为零，请直接转到@并终止
• 其他
  • psq:uq ：将底部移动到顶部，交换顶部，然后将顶部移动到底部dup，然后将顶部移动到底部 3 2 A B C 3
  • $u ：跳过 u
  • < 让我们回到循环中。

口译员

C（gcc），88 87 85 83 68 66 83 82 78字节

-1感谢ceilingcat

旧版本

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

在线尝试！

较短的版本（略有损坏）

在注释中使用仅ASCII字符对76字节方法进行整理，并从他的调整中减去-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]})

没有真正干净的方法来获取字符串长度或反转'em，因此这很长。

接受input $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个字节+ LINQ导入为18个字节。

这个怎么运作：

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循环的方式，其中用花括号and 代替了doand done关键字。第一个括号后的空格是必需的，结尾处的分号也是必需的。{}
• 事实证明，在“ C样式” for循环中，您可以i;使用进行初始化，而不是使用i=0;。
• ${#1}条件的一部分是i < ${#1}指我们输入的长度（第一个参数$1）。通常，您可以使用${#foo}来检索string的大小$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