Wenn Sie eine Zeichenfolge angegeben haben, kehren Sie sie interleaving um. So geht's für abcdefghiund abcdefghij, 0-indiziert:

1. Trennen Sie die Zeichen bei geraden Indizes von den Zeichen bei ungeraden Indizes:

   acegi
    bdfh
   
   acegi
    bdfhj

2. Kehren Sie die Zeichen bei ungeraden Indizes um:

   acegi
    hfdb
   
   acegi
    jhfdb

3. Verschachteln Sie erneut in eine Zeichenfolge:

   ahcfedgbi 
   
   ajchefgdib

Regeln

• Sie müssen sowohl Zeichenfolgen mit gerader als auch mit ungerader Länge unterstützen.
• 0-indexmäßig müssen Sie die Zeichen bei ungeraden Indizes umkehren, nicht bei geraden.
• 1-indexmäßig müssen Sie natürlich die Zeichen bei geraden Indizes umkehren, nicht bei ungeraden.
• Die Eingabe besteht aus druckbarem ASCII (Code-Punkte 32-126), keine Zeilenumbrüche.
• Sie können Eingaben entweder als Zeichenfolge oder als Liste von Zeichen (NICHT 1-Zeichen-Zeichenfolgen) annehmen. ZB String/ char[]oder char*sind erlaubt, aber String[]/ char[][]oder char**nicht.

Testfälle

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

Geben Sie für die leere Zeichenfolge die leere Zeichenfolge selbst zurück.

Gelee , 7 Bytes

s2ZU2¦Z

Dies ist ein volles Programm.

Probieren Sie es online!

Wie es funktioniert

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(

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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

Probieren Sie es online!

Die Hälfte der Bytes dieses Programms wird für die korrekte Formatierung der Quelle aufgewendet, die eigentlichen Befehle nur IYRZO, weil Alice genau die richtigen Buildins für diese Aufgabe hat.

Erläuterung

Wie gesagt, die mirrors ( /\), die newline und @sind da nur um die ip in die richtige richtung zu bewegen und das programm am ende zu beenden. Der eigentliche Code, linearisiert, ist der folgende:

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

Ganz einfach, würde ich sagen.

Java (OpenJDK 8) , 108 96 94 93 Bytes

1 Byte gespart durch Verwendung von @ Neils ordentlichem Trick der Verwendungs[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;}

Probieren Sie es online!

Python 2 , 52 Bytes

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

Probieren Sie es online! oder Probieren Sie alle Testfälle aus

Oktave, 32 Bytes

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

Probieren Sie es 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>

Gelee , 9 Bytes

Ḋm2U
m2żÇ

Probieren Sie es 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 dank Dennis}

Netzhaut ,17 13 Bytes

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

Probieren Sie es online!

Ein Fehler wurde behoben, der Neil zu verdanken war.

4 Bytes gespart dank Kobi.

Wählt jeden Buchstaben mit einer ungeraden Anzahl von Zeichen aus und kehrt sie um. Hierzu wird verwendet, \Gwelche Übereinstimmungen mit dem Ende der letzten Übereinstimmung übereinstimmen.

PHP> = 7.1, 58 Bytes

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

Online Version

APL (Dyalog) , 9 Bytes

Erforderlich ⎕IO←0(Standardeinstellung bei vielen Systemen) für die korrekte Definition von ungeraden und geraden Werten.

⌽@{2|⍳≢⍵}

Probieren Sie es online!

⌽ umkehren

@ Bei den durch die Maske gefilterten Elementen ergibt sich aus der Anwendung der

{ anonyme Funktion

 2| der mod-2 von

 ⍳ die Indizes von

 ≢ die Anzahl (Länge) von

 ⍵ das Argument

} auf das Argument

Röda , 34 Bytes

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

Probieren Sie es online!

Erläuterung

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

Hier ist eine alternative Lösung zum gleichen bytecount

36 34 Bytes

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

Dies ist eine anonyme Funktion, die Eingaben als Zeichenfolge aus dem Eingabestream übernimmt.

Python 2 , 67 Bytes

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

Probieren Sie es online!

OCaml , 70 Bytes

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

Probieren Sie es online!

Haskell , 63 Bytes

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

Probieren Sie es online! Verbrauch: f "some string".

Bei ungeraden Zeichenfolgen übergibt abcdefghidie Funktion fdie Zeichenfolge und ihre Umkehrung an die Funktion !, die abwechselnd Zeichen aus beiden Zeichenfolgen entnimmt. Bei geraden Strings funktioniert dies nicht und wir müssen zuerst ein Dummy-Zeichen anhängen, um den Offset richtig zu machen.

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

Ziemlich einfach. Durchläuft die Zeichenfolge und gibt entweder das aktuelle Zeichen oder das entgegengesetzte aus.

Ungolfed und erklärte:

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 Byte Code, +1 für das -PFlag.

1 Byte dank @Shaggy gespeichert

¬ë íU¬Åë w)c

Erläuterung:

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

Probieren Sie es online!

Japt , 8 Bytes

ó
v íUÌw

Probier es aus

K (oK) , 18 Bytes

Lösung:

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

Probieren Sie es online!

Beispiele:

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

Erläuterung:

Meistens von rechts nach links interpretiert, finden Sie die ungeraden Indexzeichen, kehren Sie sie um und setzen Sie sie wieder in die Zeichenfolge

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

ungolfed

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

Erläuterung

• (0 1$~#)]`(|.@])/.]Verwenden Sie die Taste /., um die Eingabe in gerade / ungerade Gruppen aufzuteilen: (0 1$~#)Erstellt die Gruppendefinition, indem Sie 0 und 1 zyklisch zur Länge der Eingabe wiederholen. Wir verwenden die gerundial Form von Key für seine Hauptverb ]`(|.@]), die die Identität der ersten Gruppe gilt und kehrt die zweite Gruppe: (|.@]).
• Nachdem wir nun die zwei Gruppen haben, die eine ist umgekehrt, packen wir sie einfach zusammen und drücken sie flach: ,@,./

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

Probier es aus

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

Probier es aus

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

Probier es aus

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


    ]
}

Ich musste roundrobineher als verwenden zip, da zipstoppt sobald eine der Eingabelisten erschöpft ist.

Mathematica, 62 Bytes

Nimmt als Eingabe einen String

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

Probieren Sie es online!

APL (Dyalog) , 24 Bytes

Bytes golfen dank @ Adám

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

Probieren Sie es online!

GNU APL 1.2, 24 Bytes

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

APL arbeitet von rechts nach links. ⍴R←⍞Weist Benutzereingaben zu Rund wertet dann deren Länge aus. Halbieren Sie dies durch Multiplikation mit .5und wenden Sie die ⌊Bodenfunktion an. ⍳Gibt alle Zahlen von 1 an das Argument zurück.

APL arbeitet mit Arrays. 2×Das Array, das wir gerade erhalten haben, ⍳verdoppelt jedes Element und gibt uns nur die geraden Indizes (1-indiziert, also abhängig von⎕IO dass es 1 ist).

Beim Zugriff auf mehrere Indizes eines Vektors gibt APL die Elemente an diesen Indizes in einem Vektor an. R[X←2×⍳⌊.5×⍴R←⍞]gibt nur die geradzahligen Elemente an. ⌽kehrt die Elemente um. Weisen Sie dann die umgekehrten Werte den geraden Indizes zu (indem Sie diese Indizes so zuweisen, dass sie X6 Byte speichern).

◊ist das Anweisungstrennzeichen. Nachdem die Umkehrung abgeschlossen ist, bewerten Sie R, um das Ergebnis auszudrucken.

Perl 5, 46 + 3 für -F flag = 49 Bytes

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

Verwendet das -FFlag, um die Eingabe automatisch in ein Array von Zeichen aufzuteilen @F. Durchläuft das Array und gibt das Element für einen geraden Index oder den Index (plus eins für einen String mit ungerader Länge) vom Ende für eine ungerade Eingabe aus.

Nimmt Eingaben mit einem nachgestellten Zeilenumbruch entgegen. Ohne die nachfolgende Zeile kann nur das Vorinkrement auf $xein Nachinkrement geändert werden .

Ein bisschen besser lesbar:

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

Probieren Sie es online!

Ich vermute, der Grund, warum dies in 05AB1E noch nicht gemacht wurde, ist, dass es eklig ist ...

Ein weiteres Mal zipschmerzt das Auto-Drop-Last-Element der Funktion, anstatt zu helfen.

PS Wenn Sie Verbesserungsvorschläge zu meiner Antwort haben, posten Sie Ihre eigenen; Es ist wahrscheinlich genug für eine Verbesserung, um zu garantieren, dass Sie die Punkte bekommen. Ich schäme mich ziemlich für diese Antwort.

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

Lösung:

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

Beispiel:

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"

Erläuterung:

Suchen Sie die ungeraden Indizes der Zeichenfolge, kehren Sie diese Liste um, ziehen Sie Elemente an diesen Punkten heraus und weisen Sie sie der ursprünglichen Zeichenfolge erneut zu.

{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

Bearbeitungen:

• -9 Bytes; ausschalten countfür (#:), tilfür (!), wherefür (&:)undreverse für(|:) .

• -3 Bytes; Schalt out (#:)für (#), (&:)für(&) und (|:)für(|)

• -6 Bytes; komplett neu schreiben

• -2 Bytes; mit Zuordnung statt gelten

05AB1E , 12 Bytes

RDgÈúøvyNÉè?

Probieren Sie es 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