文字列が与えられたら、インターリーブで逆にします。abcdefghiおよびabcdefghijにインデックスを付ける方法を次に示します。

1. 偶数インデックスの文字を奇数インデックスの文字から分離します。

   acegi
    bdfh
   
   acegi
    bdfhj

2. 奇数インデックスで文字を反転します：

   acegi
    hfdb
   
   acegi
    jhfdb

3. 再び1つの文字列にインターリーブします。

   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、アリスがこのタスクにぴったりのビルトインを持っているためです。

説明

先ほど言ったように、ミラー（/\）、改行、および@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.).

オンラインでお試しください！

Neilのおかげでエラーを修正しました。

Kobiのおかげで4バイト節約されました。

奇数の文字が先頭にある各文字を選択し、それらを逆にします。これ\Gは、最後の一致の最後に一致するwhich を使用して行います。

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

 ⍳ のインデックス

 ≢ 集計（長さ）

 ⍵ 引数

} 引数について

ローダ、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 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（オーケー）、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を入力の長さまで周期的に繰り返すことにより、グループ定義を作成します。主動詞]`(|.@])にgerundial形式のKeyを使用します。これは、最初のグループにIDを適用し、2番目のグループを逆にします。(|.@])。
• 奇妙なグループが逆になった2つのグループができたので、それらを一緒に圧縮して平らにします。 ,@,./

オンラインでお試しください！

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停止入力リストの1が排出されるとすぐに。

Mathematica, 62 bytes

takes as input a string

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

Try it online!

APL (Dyalog), 24 bytes

Bytes golfed thanks to @Adám

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

Try it online!

GNU APL 1.2, 24 bytes

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

APL works from right to left. ⍴R←⍞ assigns user input to R and then evaluates its length. Halve this by multiplying by .5 and apply ⌊ floor function. ⍳ returns all numbers from 1 to the argument.

APL operates on arrays, so 2× the array we just got from ⍳ doubles each element, giving us just the even indices (1-indexed, so relies on ⎕IO being 1).

When accessing multiple indices of a vector, APL gives the elements at those indices in a vector. R[X←2×⍳⌊.5×⍴R←⍞] gives just the even-indexed elements. ⌽ reverses the elements. Then, assign the reversed values back to the even indices (assigning these indices to X saves 6 bytes).

◊ is the statement separator. After the reversing is done, evaluate R to print the result.

Perl 5, 46 + 3 for -F flag = 49 bytes

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

Uses the -F flag to auto split the input into an array of characters, @F. Loops through the array and outputs that element for an even index or that index (plus one for an odd length string) from the end for an odd input.

Takes input with a trailing newline. Without the trailing newline, can just change the pre-increment on $x to a post-increment.

A little more readable:

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 bytes

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

Try it online!

I'm guessing the reason this wasn't done in 05AB1E yet is because it's gross...

Yet another time the zip function's auto-drop-last-element hurts instead of helps.

P.S. If you have improvement suggestions on my answer, post your own; it's likely enough of an improvement to warrant you getting the points. I am pretty ashamed of this answer.

q/kdb+, 70 56 47 38 35 29 27 bytes

Solution:

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

Example:

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"

Explanation:

Find the odd indices of the string, reverse this list, pull out elements at these points and then reassign them in-place to the original string.

{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

Edits:

• -9 bytes; switching out count for (#:), til for (!), where for (&:) and reverse for (|:).

• -3 bytes; switching out (#:) for (#), (&:) for (&) and (|:) for (|)

• -6 bytes; complete re-write

• -2 bytes; using assignment rather than apply

05AB1E, 12 bytes

RDgÈúøvyNÉè?

Try it online!

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