Biorąc pod uwagę ciąg, odwróć go przeplatając. Oto jak to zrobić abcdefghii dla abcdefghij0-indeksowane:

1. Oddziel znaki przy parzystych indeksach od znaków przy nieparzystych indeksach:

   acegi
    bdfh
   
   acegi
    bdfhj

2. Odwróć znaki przy nieparzystych indeksach:

   acegi
    hfdb
   
   acegi
    jhfdb

3. Przeplataj ponownie w jeden ciąg:

   ahcfedgbi 
   
   ajchefgdib

Zasady

• Musisz obsługiwać zarówno łańcuchy o parzystej, jak i nieparzystej długości.
• 0-indeksowo, musisz odwracać znaki przy nieparzystych indeksach, nawet parzyste.
• 1-indeksowo, oczywiście, musisz odwracać znaki przy parzystych indeksach, a nie nieparzystych.
• Dane wejściowe będą składały się z drukowalnego kodu ASCII (punkty kodowe 32-126), bez znaków nowej linii.
• Możesz przyjmować dane wejściowe jako ciąg znaków lub jako listę znaków (NIE ciągów 1-znakowych). Np. String/ char[]Lub char*są dozwolone, ale String[]/ char[][]lub char**nie.

Przypadki testowe

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

Dla pustego ciągu zwróć sam pusty ciąg.

Galaretka , 7 bajtów

s2ZU2¦Z

To jest pełny program.

Wypróbuj online!

Jak to działa

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 bajtów

t2L)P5M(

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

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 bajtów

/ZY
\IOR@/

Wypróbuj online!

Połowa bajtów tego programu jest wydawana na poprawne formatowanie źródła, rzeczywiste polecenia są po prostu IYRZO, ponieważ Alice ma odpowiednie wbudowane funkcje do tego zadania.

Wyjaśnienie

Jak powiedziałem, mirrors ( /\), nowa linia i @są po to, aby ip ruszył we właściwym kierunku i zakończył program na końcu. Rzeczywisty, zlinearyzowany kod jest następujący:

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

Powiedziałbym, że to całkiem proste.

Java (OpenJDK 8) , 108 96 94 93 bajty

1 bajt zapisany przy użyciu @ zgrabny sztuczki Neila korzystanias[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;}

Wypróbuj online!

Python 2 , 52 bajty

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

Wypróbuj online! lub Wypróbuj wszystkie przypadki testowe

Oktawa, 32 bajty

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

Wypróbuj online!

JavaScript (ES6), 48 bajtów

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>

Galaretka , 9 bajtów

Ḋm2U
m2żÇ

Wypróbuj 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 bajt dzięki Dennisowi}

Siatkówka ,17 13 bajtów

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

Wypróbuj online!

Naprawiono błąd dzięki Neilowi.

Zaoszczędzono 4 bajty dzięki Kobi.

Wybiera każdą literę poprzedzoną nieparzystą liczbą znaków i odwraca je. Czyni to, używając \Gdopasowania, które pasuje do końca ostatniego dopasowania.

PHP> = 7,1, 58 bajtów

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

Wersja online

APL (Dyalog) , 9 bajtów

Wymaga ⎕IO←0(domyślnie w wielu systemach) do poprawnej definicji parzystych i nieparzystych.

⌽@{2|⍳≢⍵}

Wypróbuj online!

⌽ rewers

@ na elementy filtrowane przez maskę wynikają z zastosowania

{ funkcja anonimowa

 2| mod-2 z

 ⍳ wskaźniki

 ≢ suma (długość) z

 ⍵ argument

} na argument

Röda , 34 bajty

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

Wypróbuj online!

Wyjaśnienie

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

Oto alternatywne rozwiązanie na tym samym bajcie

36 34 bajtów

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

Jest to anonimowa funkcja, która pobiera dane wejściowe jako ciąg ze strumienia wejściowego.

Python 2 , 67 bajtów

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

Wypróbuj online!

OCaml , 70 bajtów

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

Wypróbuj online!

Haskell , 63 bajty

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

Wypróbuj online! Zastosowanie: f "some string".

W przypadku takich nieparzystych ciągów abcdefghifunkcja fprzekazuje ciąg i jego odwrócenie do funkcji !, która na przemian pobiera znaki z obu ciągów. W przypadku parzystych ciągów to nie działa i musimy najpierw dodać fikcyjny znak, aby uzyskać prawidłowe przesunięcie.

C, 69 bajtów

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

Dość proste. Przechodzi ciąg, wypisując bieżący lub przeciwny znak.

Nie golfił i wyjaśnił:

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 bajty

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

Japt , 14 13 bajtów

12 bajtów kodu, +1 dla -Pflagi.

Zaoszczędzono 1 bajt dzięki @Shaggy

¬ë íU¬Åë w)c

Wyjaśnienie:

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

Wypróbuj online!

Japt , 8 bajtów

ó
v íUÌw

Sprawdź to

K (oK) , 18 bajtów

Rozwiązanie:

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

Wypróbuj online!

Przykłady:

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

Wyjaśnienie:

Zinterpretowany głównie od prawej do lewej, znajdź znaki o nieparzystych indeksach, odwróć je i umieść z powrotem w ciągu

{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 bajtów

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

bez golfa

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

wyjaśnienie

• (0 1$~#)]`(|.@])/.]Użyj klawisza, /.aby podzielić dane wejściowe na grupy parzyste / nieparzyste: (0 1$~#)tworzy definicję grupy, powtarzając cyklicznie 0 i 1 do długości danych wejściowych. Używamy gerundialnej formy Klucza do jej głównego czasownika ]`(|.@]), który stosuje tożsamość do pierwszej grupy i odwraca drugą grupę:(|.@]) .
• Teraz, gdy mamy dwie grupy, nieparzystą odwróconą, po prostu je spakowujemy i spłaszczamy: ,@,./

Wypróbuj online!

Python 3, 93 87 bajtów

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 bajtów

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

Sprawdź to

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

Sprawdź to

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

Sprawdź to

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


    ]
}

Musiałem roundrobinraczej użyć zamiast zip, ponieważ zipzatrzymuje się, gdy tylko jedna z list wejściowych zostanie wyczerpana.

Mathematica, 62 bajty

przyjmuje jako dane wejściowe ciąg

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

Wypróbuj online!

APL (Dyalog) , 24 bajty

Bajty grały w golfa dzięki @ Adám

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

Wypróbuj online!

GNU APL 1.2, 24 bajty

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

APL działa od prawej do lewej. ⍴R←⍞przypisuje dane wejściowe od użytkownika, Ra następnie ocenia jego długość. Zmniejsz to o połowę, mnożąc przez .5i zastosuj⌊ funkcję podłogi. ⍳zwraca wszystkie liczby od 1 do argumentu.

APL działa na tablicach, więc 2×tablica, którą właśnie otrzymaliśmy⍳ podwaja każdy element, dając nam tylko parzyste indeksy (indeksowane 1, więc opiera się na⎕IO byciu 1).

Podczas uzyskiwania dostępu do wielu indeksów wektora APL podaje elementy przy tych indeksach w wektorze. R[X←2×⍳⌊.5×⍴R←⍞]daje tylko parzyste indeksowane elementy. ⌽odwraca elementy. Następnie przypisz odwrócone wartości z powrotem do wskaźników parzystych (przypisanie tych wskaźników do Xzapisania 6 bajtów).

◊jest separatorem instrukcji. Po zakończeniu cofania oceń, Raby wydrukować wynik.

Perl 5, 46 + 3 dla flagi -F = 49 bajtów

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

Wykorzystuje -F flagi do automatycznego podziału danych wejściowych na tablicę znaków,@F . Pętle przechodzą przez tablicę i wyprowadzają ten element dla indeksu parzystego lub tego indeksu (plus jeden dla łańcucha nieparzystej długości) od końca dla nieparzystego wejścia.

Pobiera dane wejściowe z końcowym znakiem nowej linii. Bez końcowego znaku nowej linii można po prostu zmienić wstępny przyrost$x przyrostowy.

Trochę bardziej czytelny:

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 bajtów

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

Wypróbuj online!

Zgaduję, że powodem, dla którego jeszcze tego nie zrobiono w 05AB1E, jest obrzydliwe ...

Jeszcze raz zip funkcja automatycznego upuszczania ostatniego elementu boli zamiast pomaga.

PS Jeśli masz sugestie dotyczące ulepszenia mojej odpowiedzi, opublikuj własne; prawdopodobnie poprawa jest wystarczająca, aby uzyskać punkty. Bardzo się wstydzę tej odpowiedzi.

q / kdb +, 70 56 47 38 35 29 27 bajtów

Rozwiązanie:

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

Przykład:

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"

Wyjaśnienie:

Znajdź nieparzyste wskaźniki łańcucha, odwróć tę listę, wyciągnij elementy w tych punktach, a następnie przypisz je w miejscu oryginalnego łańcucha.

{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

Edycje:

• -9 bajtów; zamiana countna (#:), tilna (!), wherena (&:)i reversena (|:).

• -3 bajty; zamiana (#:)na (#), (&:)na (&)i (|:)na(|)

• -6 bajtów; dokończ pisanie

• -2 bajty; używając przydziału zamiast aplikować

05AB1E , 12 bajtów

RDgÈúøvyNÉè?

Wypróbuj 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