Dada uma string, inverta-a intercaladamente. Veja como fazer isso abcdefghie abcdefghijindexado a 0:

1. Separe os caracteres nos índices pares dos caracteres nos índices ímpares:

   acegi
    bdfh
   
   acegi
    bdfhj

2. Inverta os caracteres em índices ímpares:

   acegi
    hfdb
   
   acegi
    jhfdb

3. Intercalar novamente em uma sequência:

   ahcfedgbi 
   
   ajchefgdib

Regras

• Você deve suportar as seqüências de comprimento par e de comprimento ímpar.
• No índice 0, você deve reverter os caracteres em índices ímpares, não pares.
• Com relação ao índice 1, é claro, você deve reverter os caracteres em índices pares, não ímpares.
• A entrada consistirá em ASCII imprimível (pontos de código 32-126), sem novas linhas.
• Você pode receber a entrada como uma string ou como uma lista de caracteres (NÃO strings de 1 caractere). Por exemplo, String/ char[]ou char*são permitidos, mas String[]/ char[][]ou char**não são.

Casos de teste

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

Para a cadeia vazia, retorne a própria cadeia vazia.

Geléia , 7 bytes

s2ZU2¦Z

Este é um programa completo.

Experimente online!

Como funciona

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 bytes

t2L)P5M(

Experimente online! Ou verifique todos os casos de teste .

Explicação

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 bytes

/ZY
\IOR@/

Experimente online!

Metade dos bytes deste programa são gastos na formatação correta da fonte, os comandos reais são justos IYRZO, porque Alice possui os recursos corretos para esta tarefa.

Explicação

Como eu disse, os espelhos ( /\), a nova linha e @existem apenas para fazer o ip se mover na direção certa e finalizar o programa no final. O código real, linearizado, é o seguinte:

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

Bem direto, eu diria.

Java (OpenJDK 8) , 108 96 94 93 bytes

Salvo 1 byte usando o truque de @ Neils[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;}

Experimente online!

Python 2 , 52 bytes

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

Experimente online! ou Experimente todos os casos de teste

Oitava, 32 bytes

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

Experimente online!

JavaScript (ES6), 48 bytes

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>

Geléia , 9 bytes

Ḋm2U
m2żÇ

Experimente online!

Ḋ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 graças a Dennis}

Retina ,17 13 bytes

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

Experimente online!

Corrigido um erro graças a Neil.

Guardado 4 bytes graças a Kobi.

Seleciona cada letra precedida por um número ímpar de caracteres e os reverte. Faz isso usando o \Gque corresponde ao final da última correspondência.

PHP> = 7.1, 58 bytes

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

Versão Online

APL (Dyalog) , 9 bytes

Requer ⎕IO←0(padrão em muitos sistemas) para definição adequada de ímpar e par.

⌽@{2|⍳≢⍵}

Experimente online!

⌽ marcha ré

@ nos elementos filtrados pela máscara resultam da aplicação do

{ função anônima

 2| o mod-2 de

 ⍳ os índices de

 ≢ a contagem (comprimento) de

 ⍵ o argumento

} no argumento

Röda , 34 bytes

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

Experimente online!

Explicação

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

Aqui está uma solução alternativa ao mesmo bytecount

36 34 bytes

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

Essa é uma função anônima que recebe a entrada como uma sequência do fluxo de entrada.

Python 2 , 67 bytes

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

Experimente online!

OCaml , 70 bytes

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

Experimente online!

Haskell , 63 bytes

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

Experimente online! Uso: f "some string".

Para strings ímpares abcdefghi, a função fpassa a string e sua reversão para a função !, que alterna o recebimento de caracteres de ambas as strings. Para seqüências pares, isso não funciona, e precisamos anexar um caractere fictício primeiro para obter o deslocamento correto.

C, 69 bytes

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

Bem simples. Anda na sequência, imprimindo o caractere atual ou o oposto.

Ungolfed e explicou:

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 bytes

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

Japonês , 14 13 bytes

12 bytes de código, +1 para o -Psinalizador.

Guardado 1 byte graças a @Shaggy

¬ë íU¬Åë w)c

Explicação:

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

Experimente online!

Japonês , 8 bytes

ó
v íUÌw

Teste-o

K (oK) , 18 bytes

Solução:

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

Experimente online!

Exemplos:

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

Explicação:

Interpretada principalmente da direita para a esquerda, encontre os caracteres dos índices ímpares, inverta-os e coloque-os de volta na string

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

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

destroçado

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

explicação

• (0 1$~#)]`(|.@])/.]Use Key /.para dividir a entrada nos grupos pares / ímpares: (0 1$~#)cria a definição do grupo, repetindo 0 e 1 ciclicamente no comprimento da entrada. Nós usamos a forma gerundial de Key por seu verbo principal ]`(|.@]), que se aplica a identidade para o primeiro grupo e inverte o segundo grupo: (|.@]).
• Agora que temos os dois grupos, o estranho invertido, apenas os juntamos e achatamos: ,@,./

Experimente online!

Python 3, 93 87 bytes

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 bytes

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

Teste-o

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

Teste-o

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

Teste-o

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


    ]
}

Eu tive que usar, em roundrobinvez de zip, porque zippára assim que uma das listas de entrada é esgotada.

Mathematica, 62 bytes

toma como entrada uma string

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

Experimente online!

APL (Dyalog) , 24 bytes

Bytes jogados graças a @ Adám

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

Experimente online!

GNU APL 1.2, 24 bytes

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

O APL funciona da direita para a esquerda. ⍴R←⍞atribui entrada do usuário Re avalia seu comprimento. Divida pela metade, multiplicando .5e aplicando a ⌊função de piso. ⍳retorna todos os números de 1 ao argumento.

O APL opera em matrizes; portanto, 2×a matriz que obtivemos ⍳dobra cada elemento, fornecendo apenas os índices pares (indexado a 1, portanto, depende de ⎕IOser 1).

Ao acessar vários índices de um vetor, o APL fornece os elementos nesses índices em um vetor. R[X←2×⍳⌊.5×⍴R←⍞]fornece apenas os elementos indexados pares. ⌽inverte os elementos. Em seguida, atribua os valores revertidos de volta aos índices pares (atribuindo esses índices aX economia de 6 bytes).

◊é o separador de instruções. Após a reversão, avalie Rpara imprimir o resultado.

Perl 5, 46 + 3 para sinalizador -F = 49 bytes

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

Usa o -Fsinalizador para dividir automaticamente a entrada em uma matriz de caracteres @F,. Faz um loop na matriz e gera esse elemento para um índice par ou esse índice (mais um para uma sequência de comprimento ímpar) do final para uma entrada ímpar.

Recebe entrada com uma nova linha à direita. Sem a nova linha à direita, basta alterar o pré-incremento em$x para um pós-incremento.

Um pouco mais legível:

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

Experimente online!

Eu estou supondo que a razão pela qual isso não foi feito no 05AB1E ainda é porque é nojento ...

Mais uma vez, o zipelemento soltar automaticamente o último elemento da função dói em vez de ajudar.

PS Se você tiver sugestões de melhoria na minha resposta, publique a sua; é provável que haja uma melhoria suficiente para garantir que você obtenha os pontos. Tenho muita vergonha dessa resposta.

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

Solução:

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

Exemplo:

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"

Explicação:

Encontre os índices ímpares da sequência, inverta esta lista, retire os elementos nesses pontos e, em seguida, reatribua-os no lugar à sequência original.

{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

Edições:

• -9 bytes; mudar countpara (#:), tilpara (!), wherepara (&:)e reversepara (|:).

• -3 bytes; mudar (#:)para (#), (&:)para (&)e (|:)para(|)

• -6 bytes; reescrita completa

• -2 bytes; usando atribuição em vez de aplicar

05AB1E , 12 bytes

RDgÈúøvyNÉè?

Experimente 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