Dada una cadena, inviértela entrelazada. A continuación, le indicamos cómo hacerlo abcdefghiy abcdefghijindexado en 0:

1. Separe los caracteres en los índices pares de los caracteres en los índices impares:

   acegi
    bdfh
   
   acegi
    bdfhj

2. Invierta los caracteres en índices impares:

   acegi
    hfdb
   
   acegi
    jhfdb

3. Intercalar en una cadena nuevamente:

   ahcfedgbi 
   
   ajchefgdib

Reglas

• Debe admitir cadenas de longitud par e impar.
• En cuanto al índice 0, debe invertir los caracteres en los índices impares, ni siquiera.
• 1-index-wise, por supuesto, debe revertir los caracteres en índices pares, no impares.
• La entrada consistirá en ASCII imprimible (puntos de código 32-126), sin líneas nuevas.
• Puede tomar la entrada como una cadena o como una lista de caracteres (NO cadenas de 1 carácter). Por ejemplo String/ char[]o char*mascotas, pero String[]/ char[][]o char**no lo son.

Casos de prueba

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 la cadena vacía, devuelva la cadena vacía en sí.

Jalea , 7 bytes

s2ZU2¦Z

Este es un programa completo.

Pruébalo en línea!

Cómo 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(

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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@/

Pruébalo en línea!

La mitad de los bytes de este programa se gastan en formatear correctamente la fuente, los comandos reales son justos IYRZO, porque Alice tiene las funciones correctas para esta tarea.

Explicación

Como dije, los espejos ( /\), la nueva línea y @están allí solo para hacer que la ip se mueva en la dirección correcta y finalice el programa al final. El código real, linealizado, es el siguiente:

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

Muy sencillo, diría.

Java (OpenJDK 8) , 108 96 94 93 bytes

Se guardó 1 byte usando el truco 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;}

Pruébalo en línea!

Python 2 , 52 bytes

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

Pruébalo en línea! o Pruebe todos los casos de prueba

Octava, 32 bytes

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

Pruébalo en línea!

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>

Jalea , 9 bytes

Ḋm2U
m2żÇ

Pruébalo en línea!

Ḋ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 gracias a Dennis}

retina ,17 13 bytes

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

Pruébalo en línea!

Se corrigió un error gracias a Neil.

Guardado 4 bytes gracias a Kobi.

Selecciona cada letra precedida por un número impar de caracteres y los invierte. Lo hace utilizando el \Gque coincide con el final del último partido.

PHP> = 7.1, 58 bytes

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

Versión en línea

APL (Dyalog) , 9 bytes

Requiere ⎕IO←0 (predeterminado en muchos sistemas) para la definición adecuada de pares e impares.

⌽@{2|⍳≢⍵}

Pruébalo en línea!

⌽ marcha atrás

@ en los elementos filtrados por el resultado de la máscara al aplicar el

{ función anónima

 2| el mod-2 de

 ⍳ los índices de

 ≢ la cuenta (longitud) de

 ⍵ el argumento

} en el argumento

Röda , 34 bytes

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

Pruébalo en línea!

Explicación

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

Aquí hay una solución alternativa en el mismo bytecount

36 34 bytes

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

Esta es una función anónima que toma la entrada como una cadena de la secuencia de entrada.

Python 2 , 67 bytes

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

Pruébalo en línea!

OCaml , 70 bytes

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

Pruébalo en línea!

Haskell , 63 bytes

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

Pruébalo en línea! Uso: f "some string".

Para cadenas impares como abcdefghi, la función fpasa la cadena y su inversión a la función !, que alterna tomando caracteres de ambas cadenas. Para cadenas pares, esto no funciona, y primero debemos agregar un carácter ficticio para obtener el desplazamiento correcto.

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

Bastante simple. Camina la cadena, imprimiendo el carácter actual o el opuesto.

Ungolfed y explicó:

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}]&

Japt , 14 13 bytes

12 bytes de código, +1 para la -Pbandera.

Guardado 1 byte gracias a @Shaggy

¬ë íU¬Åë w)c

Explicación:

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

Pruébalo en línea!

Japt , 8 bytes

ó
v íUÌw

Pruébalo

K (oK) , 18 bytes

Solución:

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

Pruébalo en línea!

Ejemplos:

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

Explicación:

Interpretado principalmente de derecha a izquierda, encuentre los caracteres de índices impares, inviértalos y vuelva a colocarlos en la cadena

{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$~#)]`(|.@])/.]

sin golf

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

explicación

• (0 1$~#)]`(|.@])/.]Use la tecla /.para dividir la entrada en los grupos pares / impares: (0 1$~#)crea la definición del grupo, repitiendo 0 y 1 cíclicamente a la longitud de la entrada. Nosotros usamos la forma de gerundio de Key por su verbo principal ]`(|.@]), que se aplica a la identidad del primer grupo y el segundo grupo se invierte: (|.@]).
• Ahora que tenemos los dos grupos, el extraño invertido, simplemente los unimos y aplanamos: ,@,./

Pruébalo en línea!

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...^*>=$_}]}

Pruébalo

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

Pruébalo

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

Pruébalo

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


    ]
}

Tuve que usar en roundrobinlugar de zip, porque se zipdetiene tan pronto como una de las listas de entrada se agota.

Mathematica, 62 bytes

toma como entrada una cadena

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

Pruébalo en línea!

APL (Dyalog) , 24 bytes

Bytes golfed gracias a @ Adám

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

Pruébalo en línea!

GNU APL 1.2, 24 bytes

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

APL funciona de derecha a izquierda. ⍴R←⍞asigna la entrada del usuario Ry luego evalúa su longitud. Reduce a la mitad esto multiplicando por .5y aplica la ⌊función de piso.⍳devuelve todos los números del 1 al argumento.

APL opera en matrices, por lo que 2×la matriz que acabamos de obtener ⍳duplica cada elemento, dándonos solo los índices pares (1 indexado, por lo que se basa en ⎕IOser 1).

Al acceder a múltiples índices de un vector, APL proporciona los elementos en esos índices en un vector. R[X←2×⍳⌊.5×⍴R←⍞]da solo los elementos indexados pares. ⌽invierte los elementos. Luego, asigne los valores invertidos nuevamente a los índices pares (asignando estos índices aX guardar 6 bytes).

◊es el separador de enunciados. Una vez realizada la inversión, evalúe Rpara imprimir el resultado.

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

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

Utiliza la -Fbandera para dividir automáticamente la entrada en una matriz de caracteres,@F . Recorre la matriz y genera ese elemento para un índice par o ese índice (más uno para una cadena de longitud impar) desde el final para una entrada impar.

Toma entrada con una nueva línea final. Sin la nueva línea final, solo puede cambiar el pre-incremento en$x a un incremento posterior.

Un poco más legible:

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

Pruébalo en línea!

Supongo que la razón por la que esto no se hizo en 05AB1E todavía es porque es asqueroso ...

Otra vez, el elemento zipauto-drop-last-last de la función duele en lugar de ayudar.

PD: si tiene sugerencias de mejora en mi respuesta, publique la suya; Es probable que sea una mejora suficiente para garantizar que obtenga los puntos. Estoy bastante avergonzado de esta respuesta.

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

Solución:

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

Ejemplo:

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"

Explicación:

Encuentre los índices impares de la cadena, invierta esta lista, extraiga elementos en estos puntos y luego reasigne en su lugar a la cadena 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

Ediciones:

• -9 bytes; cambiar countpor (#:), tilpara (!), wherepara (&:)y reversepara (|:).

• -3 bytes; cambiar (#:)por (#), (&:)por (&)y (|:)para(|)

• -6 bytes; reescritura completa

• -2 bytes; usando la asignación en lugar de aplicar

05AB1E , 12 bytes

RDgÈúøvyNÉè?

Pruébalo en línea!

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