문자열이 주어지면 인터리빙 방식으로 뒤집습니다. 0 인덱스로 abcdefghi및 abcdefghij에 대해 수행하는 방법은 다음과 같습니다 .

1. 짝수 인덱스의 문자를 홀수 인덱스의 문자와 분리하십시오.

   아 세기
    bdfh
   
   아 세기
    bdfhj

2. 홀수 인덱스에서 문자를 뒤집습니다.

   아 세기
    hfdb
   
   아 세기
    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'

Alice , 10 바이트

/ZY
\IOR@/

온라인으로 사용해보십시오!

이 프로그램의 바이트 중 절반은 소스를 올바르게 포맷하는 데 사용되며 실제 명령은 IYRZOAlice가이 작업에 적합한 내장을 가지고 있기 때문에이 입니다.

설명

내가 말했듯이, 거울 ( /\), 줄 바꿈 및 @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

아주 간단합니다.

자바 (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;}

온라인으로 사용해보십시오!

파이썬 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;

온라인으로 사용해보십시오!

자바 스크립트 (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

^{Dennis 덕분에 -1 바이트}

망막 ,17 13 바이트

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

온라인으로 사용해보십시오!

Neil 덕분에 오류가 수정되었습니다.

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| 의 모드 -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])}

이것은 입력 스트림에서 문자열로 입력을받는 익명 함수입니다.

파이썬 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)

온라인으로 사용해보십시오!

하스켈 , 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
        ]);
}

수학, 82 바이트

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

apt , 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을 반복하여 그룹 정의를 작성하십시오. 우리는 주요 동사에 건의 한 형태의 키를 사용하는데 ]`(|.@]), 이는 첫 번째 그룹에 신원을 적용하고 두 번째 그룹을 뒤집습니다 (|.@]).
• 이제 우리는 홀수 그룹을 뒤집은 두 그룹을 가지게되었습니다. ,@,./

온라인으로 사용해보십시오!

파이썬 3, 93 87 바이트

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

펄 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대신 에 사용해야했습니다 .zipzip

수학, 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 인덱스)를 제공합니다.⎕IO )를 제공합니다 .1에 .

벡터의 여러 인덱스에 액세스 할 때 APL은 벡터의 해당 인덱스에있는 요소를 제공합니다. R[X←2×⍳⌊.5×⍴R←⍞]짝수 색인 요소 만 제공합니다. ⌽요소를 반대로합니다. 그런 다음 반전 된 값을 짝수 인덱스에 다시 지정하십시오 (이 인덱스를 지정하여 X6 바이트 를 절약 함).

◊문 구분 기호입니다. 반전이 완료된 후 평가 R하여 결과를 인쇄하십시오.

-F 플래그 = 49 바이트의 경우 Perl 5, 46 + 3

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기능 대신 자동 드롭-마지막 요소가 아프게됩니다.

추신 : 당신이 내 대답에 개선 제안이 있다면, 당신의 자신을 게시; 당신이 요점을 얻도록 보증하기에 충분할 것입니다. 나는이 대답이 매우 부끄럽다.

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