给定一个字符串，交错插入即可。这是针对abcdefghi和和abcdefghij0索引的方法：

1. 将偶数索引的字符与奇数索引的字符分开：

   acegi
    bdfh
   
   acegi
    bdfhj

2. 以奇数索引反转字符：

   acegi
    hfdb
   
   acegi
    jhfdb

3. 再次交织成一个字符串：

   ahcfedgbi 
   
   ajchefgdib

规则

• 您必须同时支持偶数长度和奇数长度的字符串。
• 从0索引角度来看，您必须以奇数索引而不是偶数反转字符。
• 当然，以1索引为单位，您必须以偶数索引而不是奇数反转字符。
• 输入将包含可打印的ASCII（代码点32-126），没有换行符。
• 您可以将输入作为字符串或字符列表（非1个字符的字符串）。例如String/ char[]或char*允许，但String[]/ char[][]或char**不允许。

测试用例

Input
Output

Hello, World!
HdlroW ,olle!

Hello World!
H!llooW rlde

ABCDEFGHIJKLMNOPQRSTUVWXYZ
AZCXEVGTIRKPMNOLQJSHUFWDYB

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
 }"{$y&w(u*s,q.o0m2k4i6g8e:c<a>_@]B[DYFWHUJSLQNOPMRKTIVGXEZC\A^?`=b;d9f7h5j3l1n/p-r+t)v'x%z#|!~

P
P

AB
AB

xyz
xyz

对于空字符串，返回空字符串本身。

果冻，7个字节

s2ZU2¦Z

这是一个完整程序。

在线尝试！

怎么运行的

s2ZU2¦Z  Main link. Argument: s (string)

s2       Split s into pairs.
  Z      Zip/tranpose, grouping characters by the parity of their indices.
     ¦   Sparse application:
   U         Upend; reverse both strings in the pair.
    2        Replace the second string with the reversed string.
      Z  Zip/transpose, interleaving the two strings.

MATL，8字节

t2L)P5M(

在线尝试！或验证所有测试用例。

说明

t     % Implicit input. Duplicate
      % STACK: 'abcdefghi', 'abcdefghi'
2L    % Push [2, 2, 1j]. This represents 2:2:end when used as an index
      % STACK: 'abcdefghi', 'abcdefghi', [2, 2, 1j]
)     % Get entries at those indices
      % STACK: 'abcdefghi', 'bdfh'
P     % Flip
      % STACK: 'abcdefghi', 'hfdb'
5M    % Push [2, 2, 1j] again
      % STACK: 'abcdefghi', 'hfdb', [2, 2, 1j]
(     % Write entries at those indices. Implicit display
      % STACK: 'ahcfedgbi'

爱丽丝，10字节

/ZY
\IOR@/

在线尝试！

该程序的一半字节用于正确格式化源，实际的命令只是IYRZO，因为Alice恰好适合此任务。

说明

正如我所说的，镜像（/\），换行符和@在那里只是为了使ip向正确的方向移动并最终终止程序。线性化的实际代码如下：

IYRZO
I      Input a line
 Y     Unzip it into its even positions and its odd ones
  R    Reverse the odd positions
   Z   Zip it back again
    O  Output

我会说很简单。

Java（OpenJDK 8），108 96 94 93字节

使用@Neil巧妙的使用技巧节省了1个字节s[s.length+~i|1]

String f(char[]s){int a=s.length,b=0;String c="";for(;b<a;b++)c+=s[b%2<1?b:a+~b|1];return c;}

在线尝试！

Python 2，52字节

s=list(input())
s[1::2]=s[1::2][::-1]
print`s`[2::5]

在线尝试！或尝试所有测试用例

八度，32字节

@(a,b=a(x)=a(flip(x=2:2:end)))a;

在线尝试！

JavaScript（ES6），48个字节

f=
s=>s.replace(/./g,(c,i)=>i%2?s[s.length+~i|1]:c)

<input oninput=o.textContent=f(this.value)><pre id=o>

果冻，9个字节

Ḋm2U
m2żÇ

在线尝试！

Ḋm2U Helper Link -> Dequeue (return last len-1 elements), take every second element, reverse
m2żÇ Main Link -> Take every second element, then interleave with the result of the helper link

^{-1字节感谢丹尼斯}

视网膜，17 13字节

O^$`(?<=\G.).

在线尝试！

修正了尼尔的错误。

感谢Kobi，节省了4个字节。

选择每个字母后跟奇数个字符并反转它们。通过使用\G哪个匹配最后一个匹配的结尾来做到这一点。

PHP> = 7.1，58字节

for(;$i<$l=strlen($a=$argn);$i++)echo$a[$i&1?-$i-$l%2:$i];

在线版本

APL（Dyalog），9字节

需要⎕IO←0（许多系统默认）正确定义奇数和偶数。

⌽@{2|⍳≢⍵}

在线尝试！

⌽ 相反

@ 在蒙版过滤的元素上应用

{ 匿名功能

 2| 的mod-2

 ⍳ 的指数

 ≢ 的理货（长度）

 ⍵ 论点

} 论据

罗达（Röda），34个字节

f a{a/=""a[::2]<>reverse(a[1::2])}

在线尝试！

说明

a/=""                    Convert the argument a into an array of length-1 strings
      <>                 Interleave
a[::2]                   Every even element of a with
        reverse(a[1::2]) Every odd element of a reversed

这是相同字节数的替代解决方案

36 34字节

{[_/""]|_[::2]<>reverse(_1[1::2])}

这是一个匿名函数，它将输入作为来自输入流的字符串。

Python 2，67字节

lambda s,j=''.join:j(map(j,zip(s[::2]+' ',s[1::2][::-1]+' ')))[:-1]

在线尝试！

OCaml，70个字节

let f s=String.(mapi(fun i c->s.[(length s land-2-i-i)*(i mod 2)+i])s)

在线尝试！

Haskell，63个字节

(_:r)!(a:s)=a:s!r
_!_=[]
f s=([' '|even$length s]++reverse s)!s

在线尝试！用法：f "some string"。

对于像这样的奇数字符串abcdefghi，该函数f将字符串及其反转传递给函数!，该函数交替从两个字符串中获取字符。对于偶数字符串，这是行不通的，我们需要先附加一个虚拟字符才能正确获得偏移量。

C，69字节

c,l;f(char*s){l=strlen(s);for(c=0;c<l;++c)putchar(s[c&1?l-l%2-c:c]);}

很简单 遍历字符串，打印当前字符或相反的字符。

脱节并解释：

f(char *str) {
    int len = strlen(str);      // Get the total length
    for(int c = 0; c<len; ++c)  // Loop over the string
        putchar(s[              // Print the char that is,
            c & 1               // if c is odd,
                ? l - l % 2 - c // c chars from the end (adjusting odd lengths),
                : c             // and at index c otherwise
        ]);
}

Mathematica，82个字节

""<>(f=Flatten)[{#&@@#,Reverse@Last@#}&@f[Characters@#~Partition~UpTo@2,{2}],{2}]&

Japt，14 13字节

12个字节的代码，-P标志+1 。

@Shaggy节省了1个字节

¬ë íU¬Åë w)c

说明：

¬ë íU¬Åë w)c
¬                   Split the input into an array of chars
 ë                  Get every other char, starting at index 0
   í                Pair with:
    U¬                Input, split into a char array
      Å               .slice(1)
       ë              Get every other char
         w            Reverse
           c       Flatten
-P                 Join into a string

在线尝试！

Japt，8字节

ó
v íUÌw

测试一下

K（oK），18个字节

解：

{x[w:&2!!#x]:x@|w}

在线尝试！

例子：

> {x[w:&2!!#x]:x@|w}"Hello, World!"
"HdlroW ,olle!"
> {x[w:&2!!#x]:x@|w}"Hello World!"
"H!llooW rlde"

说明：

大多从右到左解释，找到奇数索引字符，将它们反转并将其放回字符串中

{x[w:&2!!#x]:x@|w} / solution
{                } / lambda function with implicit parameter x
         #x        / count x,    #"Hello, World!" -> 13
        !          / til,        !13 -> 0 1 2 3 4 5 6 7 8 9 10 11 12
      2!           / 2 modulo,   2!0 1 2 3 4 5 6 7 8 9 10 11 12 -> 0 1 0 1 0 1 0 1 0 1 0 1 0
     &             / where true, @0 1 0 1 0 1 0 1 0 1 0 1 0 -> 1 3 5 7 9 11
   w:              / store in variable w
               |w  / reverse w,  |1 3 5 7 9 11 -> 11 9 7 5 3 1
             x@    / index into x at these indices
 x[        ]:      / assign right to x at these indices

J，26个字节

[:,@,./(0 1$~#)]`(|.@])/.]

不打高尔夫球

[: ,@,./ (0 1 $~ #) ]`(|.@])/. ]

说明

• (0 1$~#)]`(|.@])/.]使用“键” /.将输入分成偶数/奇数组：(0 1$~#)通过循环重复输入的长度的0和1来创建组定义。我们将Key的成语形式用作其主要动词]`(|.@])，该动词将标识应用于第一组并反转第二组：(|.@])。
• 现在我们有两个组，奇数一组反转了，我们将它们拉在一起并展平： ,@,./

在线尝试！

Python 3，93 87字节

lambda s:"".join("".join(t)for t in zip(s[::2],reversed(s[1::2])))+("",s[-1])[len(s)%2]

Perl 6的， 63个58  55字节

{[~] .comb[{flat roundrobin (0,2...^*>=$_),[R,] 1,3...^*>=$_}]}

测试一下

{[~] flat roundrobin .comb[{0,2...*},{$_-1-$_%2,*-2...*}]}

测试一下

{[~] flat roundrobin .comb[{0,2...*},{[R,] 1,3...^$_}]}

测试一下

{  # bare block lambda with implicit parameter ｢$_｣

  [~]                 # reduce using string concatenation operator

    flat              # make the following a flat list

    roundrobin        # grab one from each of the following 2 lists,
                      # repeat until both are empty

    .comb\            # split the input into graphemes (implicit method call)

    [                 # index into that sequence



      { 0, 2 ... * }, # code block producing every non-negative even number


      {               # code block producing reversed odd numbers
                      # (｢$_｣ here contains the number of available elements)

        [R,]          # reduce with reversed comma operator
                      # (shorter than ｢reverse｣)

        1, 3 ...^ $_  # odd numbers stopping before it gets
                      # to the number of input elements
      }


    ]
}

我必须使用roundrobin而不是zip，因为zip输入列表之一用完后立即停止。

Mathematica，62个字节

以字符串作为输入

(s=Characters@#;Row@Riffle[s[[;; ;;2]],Reverse@s[[2;; ;;2]]])&

在线尝试！

APL（Dyalog），24字节

@Adám为字节打高尔夫球

A⊣A[i]←⌽A[i←2×⍳⌊2÷⍨⍴A←⎕]

在线尝试！

GNU APL 1.2，24个字节

R[X]←⌽R[X←2×⍳⌊.5×⍴R←⍞]◊R

APL从右到左起作用。 ⍴R←⍞将用户输入分配给用户R，然后评估其长度。通过乘以.5并应用⌊下限函数将其减半。⍳返回从1到参数的所有数字。

APL在阵列上运行，因此 2×，我们从数组中获得的数组将⍳每个元素加倍，从而仅给我们偶数索引（1索引，因此依赖于⎕IO1）。

访问向量的多个索引时，APL会在向量中给出这些索引处的元素。 R[X←2×⍳⌊.5×⍴R←⍞]仅给出偶数索引元素。⌽反转元素。然后，将反转的值分配回偶数索引（将这些索引分配为X节省6个字节）。

◊是语句分隔符。反转完成后，评估R以打印结果。

Perl 5，46 + 3 -F标志= 49字节

while(++$x<@F){print$F[$x%2?$x-1:@F-$x-$#F%2]}

使用 -F标志将输入自动拆分为一个字符数组，@F。循环遍历数组，并从末尾输出该元素以获取偶数索引，或从索引的末尾输出该索引（为奇数长度字符串添加一个索引）以获取奇数输入。

使用尾随换行符输入。没有尾随的换行符，只需更改$x为后增量即可。

更具可读性：

while(++$x<@F) { #While the index is less than the number of elements in the array. $x is 1-indexing the array despite the fact that perl is 0-indexed because it keeps us from having to use a proper for loop or a do-while loop
    if($x%2) { #If $x is odd
        print $F[$x-1] #Print the element
    } else {
        print $F[@F-$x-$#F%2] #Print from the end. $#F%2 fixes it for odd length strings    
    }
}

05AB1E，21字节

DgÉi¶«}2ô.BøRćR‚˜øJ¶K

在线尝试！

我猜这是在05AB1E中尚未完成的原因，是因为它太贵了...

再有一次，zip函数的自动拖放最后一个元素会伤害而不是帮助。

附言：如果您对我的回答有改进建议，请发表您自己的建议；可能有足够的改进可以保证您获得积分。我很this愧这个答案。

q / kdb +，70 56 47 38 35 29 27字节

解：

{x[w]:x(|)w:(&)#:[x]#0 1;x}

例：

q){x[w]:x(|)w:(&)#:[x]#0 1;x}"Hello, World!"
"HdlroW ,olle!"
q){x[w]:x(|)w:(&)#:[x]#0 1;x}"Hello World!"
"H!llooW rlde"

说明：

找到字符串的奇数索引，反转此列表，在这些点处提取元素，然后将它们就地重新分配给原始字符串。

{x[w]:x reverse w:where count[x]#0 1;x} / ungolfed
{                                   ; } / lambda function with two lines
                                 0 1    / the list (0;1)
                                #       / take
                        count[x]        / length of input
                  where                 / indices where this is > 0
                w:                      / save in variable w
        reverse                         / reverse this list
      x                                 / index into x at these points
     :                                  / assignment             
 x[w]                                   / assign x at indices with new values
                                     x  / return x

编辑：

• -9个字节；转换出来count的(#:)，til对(!)，where对(&:)，并reverse为(|:)。

• -3个字节；切换出(#:)为(#)，(&:)对于(&)和(|:)用于(|)

• -6个字节；完成重写

• -2个字节；使用分配而不是应用

05AB1E，12个字节

RDgÈúøvyNÉè?

在线尝试！

RDgÈúøvyNÉè?   Implicit input: "abcdefghij"
R              Reverse the string: "jihgfedcba"
 DgÈú          Put (length is even?1:0) spaces in front of it " jihgfedcba"
     ø         Zip (reinjects the input implicitly): ["a ", "bj", "ci", ...]
      vy       For each element of the list
        NÉè    Extract&push element[iteration is odd?1:0] 
           ?   Print without newline