Data una stringa, invertirla in modo incrociato. Ecco come farlo per abcdefghie abcdefghij, indicizzato 0:

1. Separare i caratteri ad indici pari dai caratteri ad indici dispari:

   Acegi
    bdfh
   
   Acegi
    bdfhj

2. Invertire i caratteri negli indici dispari:

   Acegi
    hfdb
   
   Acegi
    jhfdb

3. Interlaccia di nuovo in una stringa:

   ahcfedgbi 
   
   ajchefgdib

Regole

• È necessario supportare stringhe sia di lunghezza pari che di lunghezza dispari.
• Per quanto riguarda l'indice 0, è necessario invertire i caratteri a indici dispari, nemmeno pari.
• Per quanto riguarda l'indice, ovviamente, devi invertire i caratteri con indici pari, non dispari.
• L'input consisterà in ASCII stampabile (punti di codice 32-126), senza nuove righe.
• È possibile accettare input come stringa o come elenco di caratteri (NON stringhe da 1 carattere). Ad esempio String/ char[]o char*sono consentiti, ma String[]/ char[][]o char**non lo sono.

Casi test

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

Per la stringa vuota, restituisce la stringa vuota stessa.

Gelatina , 7 byte

s2ZU2¦Z

Questo è un programma completo.

Provalo online!

Come funziona

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(

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

Provalo online!

La metà dei byte di questo programma viene spesa per formattare correttamente l'origine, i comandi effettivi sono giusti IYRZO , perché Alice ha i giusti comandi per questa attività.

Spiegazione

Come ho detto, i mirror ( /\), la newline e @sono lì solo per far muovere l'ip nella giusta direzione e terminare il programma alla fine. Il codice attuale, linearizzato, è il seguente:

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

Abbastanza semplice, direi.

Java (OpenJDK 8) , 108 96 94 93 byte

Salvato 1 byte utilizzando @ trucchetto di Neil di utilizzares[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;}

Provalo online!

Python 2 , 52 byte

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

Provalo online! oppure Prova tutti i casi di test

Ottava, 32 byte

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

Provalo online!

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>

Gelatina , 9 byte

Ḋm2U
m2żÇ

Provalo 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 grazie a Dennis}

Retina ,17 13 byte

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

Provalo online!

Risolto un errore grazie a Neil.

Risparmiato 4 byte grazie a Kobi.

Seleziona ogni lettera preceduta da un numero dispari di caratteri e li inverte. Fa questo usando \Gquale corrisponde alla fine dell'ultima partita.

PHP> = 7,1, 58 byte

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

Versione online

APL (Dyalog) , 9 byte

Richiede ⎕IO←0(impostazione predefinita su molti sistemi) per una corretta definizione di pari e dispari.

⌽@{2|⍳≢⍵}

Provalo online!

⌽ inverso

@ agli elementi filtrati dalla maschera risultano dall'applicazione del

{ funzione anonima

 2| il mod-2 di

 ⍳ gli indici di

 ≢ il conteggio (lunghezza) di

 ⍵ l'argomento

} sull'argomento

Röda , 34 byte

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

Provalo online!

Spiegazione

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

Ecco una soluzione alternativa allo stesso tempo

36 34 byte

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

Questa è una funzione anonima che accetta l'input come stringa dal flusso di input.

Python 2 , 67 byte

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

Provalo online!

OCaml , 70 byte

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

Provalo online!

Haskell , 63 byte

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

Provalo online! Uso:f "some string" .

Per stringhe dispari come abcdefghi, la funzione fpassa la stringa e la sua inversione alla funzione !, che si alterna prendendo i caratteri da entrambe le stringhe. Per le stringhe pari questo non funziona e dobbiamo prima aggiungere un carattere fittizio per ottenere l'offset corretto.

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

Abbastanza semplice. Cammina la corda, stampando il carattere corrente o quello opposto.

Ungolfed e spiegato:

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 byte

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

Japt , 14 13 byte

12 byte di codice, +1 per la -Pbandiera.

Salvato 1 byte grazie a @Shaggy

¬ë íU¬Åë w)c

Spiegazione:

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

Provalo online!

Japt , 8 byte

ó
v íUÌw

Provalo

K (oK) , 18 byte

Soluzione:

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

Provalo online!

Esempi:

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

Spiegazione:

Interpretati principalmente da destra a sinistra, trova i caratteri degli indici dispari, invertili e rimettili nella stringa

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

ungolfed

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

spiegazione

• (0 1$~#)]`(|.@])/.]Utilizzare il tasto /.per dividere l'input nei gruppi pari / dispari: (0 1$~#)crea la definizione del gruppo, ripetendo ciclicamente 0 e 1 per la lunghezza dell'input. Usiamo la forma gerundica di Chiave per il suo verbo principale]`(|.@]) , che applica l'identità al primo gruppo e inverte il secondo gruppo:(|.@]) .
• Ora che abbiamo i due gruppi, quello dispari invertito, li comprimiamo e li appiattiamo: ,@,./

Provalo online!

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

Provalo

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

Provalo

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

Provalo

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


    ]
}

Ho dovuto usare roundrobinpiuttosto che zip, perché si zipferma non appena una delle liste di input è esaurita.

Mathematica, 62 byte

accetta come input una stringa

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

Provalo online!

APL (Dyalog) , 24 byte

Byte giocati a golf grazie a @ Adám

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

Provalo online!

GNU APL 1.2, 24 byte

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

APL funziona da destra a sinistra. ⍴R←⍞assegna l'input dell'utente a Re quindi ne valuta la lunghezza. Dimezzalo moltiplicando per .5e applica la ⌊funzione piano. ⍳restituisce tutti i numeri da 1 all'argomento.

APL funziona su array, quindi 2×l'array da cui siamo appena arrivati⍳ raddoppia ogni elemento, dandoci solo gli indici pari (1-indicizzato, quindi si basa su⎕IO sull'essere 1).

Quando si accede a più indici di un vettore, APL fornisce gli elementi di quegli indici in un vettore. R[X←2×⍳⌊.5×⍴R←⍞]fornisce solo gli elementi con indice pari. ⌽inverte gli elementi. Quindi, riassegnare i valori invertiti agli indici pari (assegnando questi indici per Xsalvare 6 byte).

◊è il separatore di istruzioni. Al termine dell'inversione, valutare Rper stampare il risultato.

Perl 5, 46 + 3 per -F flag = 49 byte

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

Utilizza il -Fflag per dividere automaticamente l'input in una matrice di caratteri,@F . Passa attraverso l'array e genera quell'elemento per un indice pari o quell'indice (più uno per una stringa di lunghezza dispari) dall'estremità per un input dispari.

Riceve input con una nuova riga finale. Senza la nuova riga finale, puoi semplicemente modificare il pre-incremento in $xun post-incremento.

Un po 'più leggibile:

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

Provalo online!

Sto indovinando il motivo per cui questo non è stato fatto in 05AB1E è perché è disgustoso ...

Ancora un'altra volta zipfa male la funzione auto-drop-last-element anziché aiuta.

PS Se hai suggerimenti di miglioramento sulla mia risposta, pubblica la tua; è probabilmente abbastanza un miglioramento per giustificare il raggiungimento dei punti. Mi vergogno abbastanza di questa risposta.

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

Soluzione:

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

Esempio:

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"

Spiegazione:

Trova gli indici dispari della stringa, inverti questo elenco, estrai gli elementi in questi punti e quindi riassegnali sul posto alla stringa originale.

{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

modifiche:

• -9 byte; passare countper (#:), tilper (!), whereper (&:)e reverseper (|:).

• -3 byte; passare (#:)per (#), (&:)per (&)e (|:)per(|)

• -6 byte; riscrittura completa

• -2 byte; usando il compito piuttosto che applicare

05AB1E , 12 byte

RDgÈúøvyNÉè?

Provalo 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