Cho một chuỗi, đảo ngược nó xen kẽ. Đây là cách thực hiện abcdefghivà abcdefghij0 được lập chỉ mục:

1. Tách các ký tự tại các chỉ số chẵn từ các ký tự tại các chỉ số lẻ:

   acegi
    bdfh
   
   acegi
    bdfhj

2. Đảo ngược ký tự tại các chỉ số lẻ:

   acegi
    hfdb
   
   acegi
    jhfdb

3. Xen kẽ vào một chuỗi một lần nữa:

   ahcfedgbi 
   
   ajchefgdib

Quy tắc

• Bạn phải hỗ trợ cả chuỗi có độ dài chẵn và độ dài lẻ.
• 0-index-khôn ngoan, bạn phải đảo ngược các ký tự ở các chỉ số lẻ, không chẵn.
• Tất nhiên, chỉ số 1 chỉ số, bạn phải đảo ngược các ký tự ở các chỉ số chẵn, không lẻ.
• Đầu vào sẽ bao gồm ASCII có thể in (mã điểm 32-126), không có dòng mới.
• Bạn có thể lấy đầu vào dưới dạng chuỗi hoặc dưới dạng danh sách ký tự (KHÔNG phải chuỗi 1 ký tự). Ví dụ String/ char[]hoặc char*được cho phép, nhưng String[]/ char[][]hoặc char**không.

Các trường hợp thử nghiệm

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

Đối với chuỗi trống, trả lại chuỗi trống.

Thạch , 7 byte

s2ZU2¦Z

Đây là một chương trình đầy đủ.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

t2L)P5M(

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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'

Alice , 10 byte

/ZY
\IOR@/

Hãy thử trực tuyến!

Một nửa số byte của chương trình này được dành cho việc định dạng chính xác nguồn, các lệnh thực tế là chính xác IYRZO, bởi vì Alice chỉ có các phần bổ trợ phù hợp cho tác vụ này.

Giải trình

Như tôi đã nói, các gương ( /\), dòng mới và @ở đó chỉ để làm cho ip di chuyển đúng hướng và chấm dứt chương trình ở cuối. Mã thực tế, được tuyến tính hóa, như sau:

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

Khá đơn giản, tôi nói.

Java (OpenJDK 8) , 108 96 94 93 byte

Lưu 1 byte bằng cách sử dụng @ lừa gọn gàng của Neil của việc sử dụngs[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;}

Hãy thử trực tuyến!

Python 2 , 52 byte

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

Hãy thử trực tuyến! hoặc Thử tất cả các trường hợp thử nghiệm

Octave, 32 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 48 byte

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>

Thạch , 9 byte

Ḋm2U
m2żÇ

Hãy thử trực tuyến!

Ḋ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 byte nhờ Dennis}

Võng mạc ,17 13 byte

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

Hãy thử trực tuyến!

Đã sửa lỗi nhờ Neil.

Đã lưu 4 byte nhờ Kobi.

Chọn mỗi chữ cái đứng trước một số ký tự lẻ và đảo ngược chúng. Liệu điều này bằng cách sử dụng \Gphù hợp với kết thúc của trận đấu cuối cùng.

PHP> = 7.1, 58 byte

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

Phiên bản trực tuyến

APL (Dyalog) , 9 byte

Yêu cầu ⎕IO←0(mặc định trên nhiều hệ thống) để định nghĩa đúng về lẻ và chẵn.

⌽@{2|⍳≢⍵}

Hãy thử trực tuyến!

⌽ đảo ngược

@ tại các yếu tố được lọc bởi kết quả mặt nạ từ việc áp dụng

{ chức năng anonyomous

 2| mod-2 của

 ⍳ các chỉ số của

 ≢ kiểm đếm (chiều dài) của

 ⍵ tranh luận

} về lập luận

Röda , 34 byte

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

Hãy thử trực tuyến!

Giải trình

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

Đây là một giải pháp thay thế tại cùng một bytecount

36 34 byte

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

Đây là một hàm ẩn danh lấy đầu vào là một chuỗi từ luồng đầu vào.

Con trăn 2 , 67 byte

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

Hãy thử trực tuyến!

OCaml , 70 byte

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

Hãy thử trực tuyến!

Haskell , 63 byte

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

Hãy thử trực tuyến!Cách sử dụng : f "some string".

Đối với các chuỗi lẻ như abcdefghi, hàm fchuyển chuỗi và đảo ngược của nó sang hàm !, xen kẽ lấy ký tự từ cả hai chuỗi. Đối với các chuỗi chẵn, điều này không hoạt động và trước tiên chúng ta cần phải thêm một ký tự giả để có được phần bù đúng.

C, 69 byte

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

Khá đơn giản. Đi theo chuỗi, in ký tự hiện tại hoặc ký tự ngược lại.

Ungolfed và giải thích:

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

Toán học, 82 byte

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

Japt , 14 13 byte

12 byte mã, +1 cho -Pcờ.

Đã lưu 1 byte nhờ @Shaggy

¬ë íU¬Åë w)c

Giải trình:

¬ë í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

Hãy thử trực tuyến!

Japt , 8 byte

ó
v íUÌw

Kiểm tra nó

K (oK) , 18 byte

Dung dịch:

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

Hãy thử trực tuyến!

Ví dụ:

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

Giải trình:

Giải thích chủ yếu từ phải sang trái, tìm các ký tự chỉ số lẻ, đảo ngược chúng và đặt chúng trở lại chuỗi

{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 byte

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

vô dụng

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

giải trình

• (0 1$~#)]`(|.@])/.]Sử dụng Khóa /.để phân chia đầu vào thành các nhóm chẵn / lẻ: (0 1$~#)tạo định nghĩa nhóm, bằng cách lặp lại 0 và 1 theo chu kỳ theo chiều dài của đầu vào. Chúng tôi sử dụng hình thức chính của khóa cho động từ chính của nó ]`(|.@]), áp dụng danh tính cho nhóm thứ nhất và đảo ngược nhóm thứ hai : (|.@]).
• Bây giờ chúng tôi có hai nhóm, nhóm lẻ đảo ngược, chúng tôi chỉ cần nén chúng lại với nhau và làm phẳng: ,@,./

Hãy thử trực tuyến!

Python 3, 93 87 byte

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 byte

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

Kiểm tra nó

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

Kiểm tra nó

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

Kiểm tra nó

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


    ]
}

Tôi đã phải sử dụng roundrobinchứ không phải zip, bởi vì zipdừng ngay khi một trong các danh sách đầu vào đã hết.

Toán học, 62 byte

lấy đầu vào là một chuỗi

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

Hãy thử trực tuyến!

APL (Dyalog) , 24 byte

Byte chơi golf nhờ @ Adám

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

Hãy thử trực tuyến!

GNU APL 1.2, 24 byte

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

APL hoạt động từ phải sang trái. ⍴R←⍞gán đầu vào của người dùng Rvà sau đó đánh giá chiều dài của nó. Giảm một nửa điều này bằng cách nhân với .5và áp dụng ⌊chức năng sàn.⍳trả về tất cả các số từ 1 cho đối số.

APL hoạt động trên các mảng, vì vậy 2×mảng chúng ta vừa nhận được từ nhân ⍳đôi mỗi phần tử, chỉ cung cấp cho chúng ta các chỉ số chẵn (1 chỉ mục, do đó phụ thuộc vào ⎕IO1).

Khi truy cập nhiều chỉ số của một vectơ, APL cung cấp cho các phần tử tại các chỉ mục đó trong một vectơ. R[X←2×⍳⌊.5×⍴R←⍞]chỉ đưa ra các yếu tố được lập chỉ mục chẵn. ⌽đảo ngược các yếu tố. Sau đó, gán các giá trị đảo ngược trở lại các chỉ số chẵn (gán các chỉ số này để Xlưu 6 byte).

◊là dấu phân cách câu lệnh. Sau khi hoàn thành việc đảo ngược, đánh giá Rđể in kết quả.

Perl 5, 46 + 3 cho cờ -F = 49 byte

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

Sử dụng -Fcờ để tự động phân chia đầu vào thành một mảng các ký tự,@F . Vòng lặp qua mảng và xuất ra phần tử đó cho một chỉ mục chẵn hoặc chỉ mục đó (cộng với một chuỗi cho một chuỗi có độ dài lẻ) từ cuối cho một đầu vào lẻ.

Đưa đầu vào với một dòng mới. Nếu không có dòng mới, chỉ có thể thay đổi mức tăng trước$x sau.

Một chút dễ đọc hơn:

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 byte

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

Hãy thử trực tuyến!

Tôi đoán lý do điều này chưa được thực hiện trong 05AB1E là vì nó quá ...

Tuy nhiên, một lần khác zip, phần tử tự động thả xuống cuối cùng của hàm bị tổn thương thay vì trợ giúp.

PS Nếu bạn có đề xuất cải tiến về câu trả lời của tôi, hãy đăng bài của riêng bạn; nó có thể đủ để cải thiện để đảm bảo bạn nhận được điểm. Tôi khá xấu hổ về câu trả lời này.

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

Dung dịch:

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

Thí dụ:

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"

Giải trình:

Tìm các chỉ số lẻ của chuỗi, đảo ngược danh sách này, kéo các phần tử tại các điểm này và sau đó gán lại chúng tại chỗ cho chuỗi ban đầu.

{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

Chỉnh sửa:

• -9 byte; chuyển ra countcho (#:), tilcho (!), wherecho (&:)và reversecho (|:).

• -3 byte; chuyển đổi (#:)cho (#), (&:)cho (&)và (|:)cho(|)

• -6 byte; hoàn thành viết lại

• -2 byte; sử dụng bài tập thay vì áp dụng

05AB1E , 12 byte

RDgÈúøvyNÉè?

Hãy thử trực tuyến!

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