Étant donné une chaîne, inversez-la de manière entrelacée. Voici comment procéder pour abcdefghiet abcdefghijindexé 0:

1. Séparez les caractères aux indices pairs des caractères aux indices impairs:

   acegi
    bdfh
   
   acegi
    bdfhj

2. Inversez les caractères aux indices impairs:

   acegi
    hfdb
   
   acegi
    jhfdb

3. Entrelacer à nouveau dans une chaîne:

   ahcfedgbi 
   
   ajchefgdib

Règles

• Vous devez prendre en charge les chaînes de longueur paire et de longueur impaire.
• 0 par index, vous devez inverser les caractères aux indices impairs, pas même.
• Bien entendu, vous devez inverser les caractères à des indices pairs, pas impairs.
• L'entrée consistera en ASCII imprimable (points de code 32-126), sans nouvelle ligne.
• Vous pouvez prendre les entrées sous forme de chaîne ou de liste de caractères (PAS de chaînes de 1 caractère). Par exemple String/ char[]ou char*sont autorisés, mais String[]/ char[][]ou char**ne le sont pas.

Cas de 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

Pour la chaîne vide, renvoyez la chaîne vide elle-même.

Gelée , 7 octets

s2ZU2¦Z

Ceci est un programme complet.

Essayez-le en ligne!

Comment ça fonctionne

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 octets

t2L)P5M(

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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 octets

/ZY
\IOR@/

Essayez-le en ligne!

La moitié des octets de ce programme sont consacrés au formatage correct de la source, les commandes réelles sont justes IYRZO, car Alice a juste les bonnes fonctionnalités pour cette tâche.

Explication

Comme je l'ai dit, les miroirs ( /\), la nouvelle ligne et @sont là juste pour faire bouger l'ip dans la bonne direction et terminer le programme à la fin. Le code réel, linéarisé, est le suivant:

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

Je dirais assez simple.

Java (OpenJDK 8) , 108 96 94 93 octets

Enregistré 1 octet en utilisant @ astuce de Neil d'utilisers[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;}

Essayez-le en ligne!

Python 2 , 52 octets

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

Essayez-le en ligne! ou Essayez tous les cas de test

Octave, 32 octets

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

Essayez-le en ligne!

JavaScript (ES6), 48 octets

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ée , 9 octets

Ḋm2U
m2żÇ

Essayez-le en ligne!

Ḋ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 octet grâce à Dennis}

Retina ,17 13 octets

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

Essayez-le en ligne!

Correction d'une erreur grâce à Neil.

4 octets enregistrés grâce à Kobi.

Sélectionne chaque lettre précédée d'un nombre impair de caractères et les inverse. Pour ce faire, en utilisant \Gce qui correspond à la fin de la dernière correspondance.

PHP> = 7.1, 58 octets

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

Version en ligne

APL (Dyalog) , 9 octets

Requiert ⎕IO←0(par défaut sur de nombreux systèmes) pour une définition correcte de pair et impair.

⌽@{2|⍳≢⍵}

Essayez-le en ligne!

⌽ sens inverse

@ au niveau des éléments filtrés par le masque résultent de l'application du

{ fonction anonyomous

 2| le mod-2 de

 ⍳ les indices de

 ≢ le décompte (longueur) de

 ⍵ l'argument

} sur l'argument

Röda , 34 octets

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

Essayez-le en ligne!

Explication

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

Voici une solution alternative au même bytecount

36 34 octets

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

Il s'agit d'une fonction anonyme qui prend l'entrée sous forme de chaîne du flux d'entrée.

Python 2 , 67 octets

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

Essayez-le en ligne!

OCaml , 70 octets

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

Essayez-le en ligne!

Haskell , 63 octets

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

Essayez-le en ligne! Utilisation: f "some string".

Pour les chaînes impaires comme abcdefghi, la fonction ftransmet la chaîne et son inversion à la fonction !, qui alterne en prenant les caractères des deux chaînes. Pour les chaînes paires, cela ne fonctionne pas, et nous devons d'abord ajouter un caractère fictif pour obtenir le bon décalage.

C, 69 octets

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

Assez simple. Parcourt la chaîne, imprimant le caractère actuel ou le caractère opposé.

Non golfé et expliqué:

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 octets

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

Japt , 14 13 octets

12 octets de code, +1 pour le -Pdrapeau.

1 octet enregistré grâce à @Shaggy

¬ë íU¬Åë w)c

Explication:

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

Essayez-le en ligne!

Japt , 8 octets

ó
v íUÌw

Essaye-le

K (oK) , 18 octets

Solution:

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

Essayez-le en ligne!

Exemples:

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

Explication:

Interprété principalement de droite à gauche, recherchez les caractères d'indice impair, inversez-les et remettez-les dans la chaîne

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

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

non golfé

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

explication

• (0 1$~#)]`(|.@])/.]Utilisez Clé /.pour diviser l'entrée en groupes pairs / impairs: (0 1$~#)crée la définition de groupe, en répétant 0 et 1 cycliquement à la longueur de l'entrée. Nous utilisons la forme gérondive de clé pour son verbe principal ]`(|.@]), qui applique l'identité au premier groupe et inverse le second groupe: (|.@]).
• Maintenant que nous avons les deux groupes, l'étrange inversé, il suffit de les compresser et d'aplatir: ,@,./

Essayez-le en ligne!

Python 3, 93 87 octets

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 octets

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

Essaye-le

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

Essaye-le

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

Essaye-le

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


    ]
}

J'ai dû utiliser roundrobinplutôt que zip, car zips'arrête dès que l'une des listes de saisie est épuisée.

Mathematica, 62 octets

prend en entrée une chaîne

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

Essayez-le en ligne!

APL (Dyalog) , 24 octets

Bytes a joué au golf grâce à @ Adám

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

Essayez-le en ligne!

GNU APL 1.2, 24 octets

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

APL fonctionne de droite à gauche. ⍴R←⍞attribue une entrée utilisateur à R, puis évalue sa longueur. Réduisez de moitié en multipliant par .5et appliquez la ⌊fonction de plancher. ⍳renvoie tous les nombres de 1 à l'argument.

APL fonctionne sur des tableaux, donc 2× le tableau que nous venons d'obtenir de ⍳double chaque élément, nous donnant seulement les indices pairs (indexés 1, donc s'appuie sur⎕IO 1).

Lors de l'accès à plusieurs indices d'un vecteur, APL donne les éléments de ces indices dans un vecteur. R[X←2×⍳⌊.5×⍴R←⍞]ne donne que les éléments pairs.⌽inverse les éléments. Attribuez ensuite les valeurs inversées aux indices pairs (l'attribution de ces indices à Xenregistre 6 octets).

◊est le séparateur d'instructions. Une fois l'inversion terminée, évaluez Rpour imprimer le résultat.

Perl 5, 46 + 3 pour -F flag = 49 octets

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

Utilise l' -Findicateur pour diviser automatiquement l'entrée en un tableau de caractères,@F . Boucle dans le tableau et génère cet élément pour un index pair ou cet index (plus un pour une chaîne de longueur impaire) à partir de la fin pour une entrée impaire.

Prend des entrées avec une nouvelle ligne de fin. Sans la nouvelle ligne de fin, il suffit de modifier le pré-incrément$x en un post-incrément.

Un peu plus lisible:

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 octets

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

Essayez-le en ligne!

Je suppose que la raison pour laquelle cela n'a pas été fait dans 05AB1E est parce que c'est dégoûtant ...

Une autre fois encore, zip dernier élément de la fonction blesse au lieu d'aider.

PS Si vous avez des suggestions d'amélioration sur ma réponse, postez la vôtre; il s'agit probablement d'une amélioration suffisante pour vous garantir d'obtenir des points. J'ai honte de cette réponse.

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

Solution:

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

Exemple:

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"

Explication:

Recherchez les indices impairs de la chaîne, inversez cette liste, retirez les éléments à ces points, puis réaffectez-les en place à la chaîne d'origine.

{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

Modifications:

• -9 octets; commutation countpour (#:), tilpour (!), wherepour (&:)et reversepour (|:).

• -3 octets; commutation (#:)pour (#), (&:)pour (&)et (|:)pour(|)

• -6 octets; réécriture complète

• -2 octets; utiliser l'affectation plutôt que d'appliquer

05AB1E , 12 octets

RDgÈúøvyNÉè?

Essayez-le en ligne!

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