Давши рядок, переверніть її перемежовуючи. Ось як це зробити для abcdefghiта abcdefghij0-індексованого:

1. Відокремте знаки на парні індекси від символів за непарними показниками:

   ацегі
    bdfh
   
   ацегі
    bdfhj

2. Зворотній знак символів на непарні показники:

   ацегі
    hfdb
   
   ацегі
    jhfdb

3. Переплутайтеся в один рядок:

   ahcfedgbi 
   
   ajchefgdib

Правила

• Ви повинні підтримувати як парні, так і непарні довжини.
• 0-індекс, ви повинні повернути символи за непарними індексами, навіть не парними.
• Звичайно, 1-індексний, звичайно, ви повинні змінювати символи на парні індекси, а не непарні.
• Вхід буде складатися з друкованого ASCII (кодові точки 32-126), без нових рядків.
• Ви можете приймати введення або як рядок, або як список знаків (НЕ 1-рядових рядків). Наприклад, String/ char[]або char*дозволено, але String[]/ char[][]або char**ні.

Тестові кейси

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

Для порожнього рядка поверніть сам порожній рядок.

Желе , 7 байт

s2ZU2¦Z

Це повна програма.

Спробуйте в Інтернеті!

Як це працює

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 байт

t2L)P5M(

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Пояснення

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'

Аліса , 10 байт

/ZY
\IOR@/

Спробуйте в Інтернеті!

Половина байтів цієї програми витрачається на правильне форматування джерела, фактичні команди справедливі IYRZO, тому що Аліса має лише правильні вбудовані для цього завдання.

Пояснення

Як я вже сказав, дзеркала ( /\), новий рядок і @вони є лише для того, щоб ip рухався в правильному напрямку і припиняв програму наприкінці. Фактичний код, лінеалізований, такий:

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

Я б сказала, що прямо, просто.

Java (OpenJDK 8) , 108 96 94 93 байт

Збережено 1 байт за допомогою @ акуратний трюк Нейла використанняs[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;}

Спробуйте в Інтернеті!

Python 2 , 52 байти

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

Спробуйте в Інтернеті! або Спробуйте всі тестові приклади

Октава, 32 байти

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

Спробуйте в Інтернеті!

JavaScript (ES6), 48 байт

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>

Желе , 9 байт

Ḋm2U
m2żÇ

Спробуйте в Інтернеті!

Ḋ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 байт завдяки Деннісу}

Сітківка ,17 13 байт

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

Спробуйте в Інтернеті!

Виправлена ​​помилка завдяки Нілу.

Збережено 4 байти завдяки Кобі.

Вибирає кожну букву, перед якою перебуває непарна кількість символів, і повертає їх назад. Це робить, використовуючи, \Gякий відповідає кінці останнього матчу.

PHP> = 7,1, 58 байт

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

Інтернет-версія

APL (Dyalog) , 9 байт

Потрібно ⎕IO←0(для багатьох систем за замовчуванням) для правильного визначення непарних і парних.

⌽@{2|⍳≢⍵}

Спробуйте в Інтернеті!

⌽ реверс

@ на елементи, відфільтровані за допомогою маски, є результатом нанесення

{ анонімна функція

 2| мод-2

 ⍳ показники

 ≢ відрізок (довжина)

 ⍵ аргумент

} на аргумент

Рода , 34 байти

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

Спробуйте в Інтернеті!

Пояснення

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

Ось альтернативне рішення за тим же рахунковим рахунком

36 34 байт

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

Це анонімна функція, яка приймає введення як рядок із вхідного потоку.

Python 2 , 67 байт

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

Спробуйте в Інтернеті!

OCaml , 70 байт

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

Спробуйте в Інтернеті!

Haskell , 63 байти

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

Спробуйте в Інтернеті!Використання: f "some string".

Для непарних рядків, таких як abcdefghi, функція fпередає рядок та його повернення до функції !, яка чергує взяття символів з обох рядків. Для рівних рядків це не спрацьовує, і нам потрібно спочатку додати фіктивний символ, щоб отримати правильне зміщення.

C, 69 байт

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

Досить просто. Проходить рядок, друкуючи або поточний символ, або протилежний.

Необережений і пояснив:

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

Математика, 82 байти

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

Japt , 14 13 байт

12 байт коду, +1 для -P прапора.

Збережено 1 байт завдяки @Shaggy

¬ë íU¬Åë w)c

Пояснення:

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

Спробуйте в Інтернеті!

Japt , 8 байт

ó
v íUÌw

Перевірте це

K (oK) , 18 байт

Рішення:

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

Спробуйте в Інтернеті!

Приклади:

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

Пояснення:

Інтерпретується здебільшого справа наліво, знайдіть символи непарних індексів, переверніть їх і поверніть їх у рядок

{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 байт

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

неозорий

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

пояснення

• (0 1$~#)]`(|.@])/.]Використовуйте клавішу, /.щоб розділити вхід на парні / непарні групи: (0 1$~#)створює визначення групи, циклічно повторюючи 0 і 1 на довжину введення. Ми використовуємо герундиальну форму Key для свого основного дієслова ]`(|.@]), яке застосовує тотожність до першої групи та обертає другу групу:(|.@]) .
• Тепер, коли у нас є дві групи, непарна перевернута, ми просто з’єднуємо їх і сплющуємо: ,@,./

Спробуйте в Інтернеті!

Python 3, 93 87 байт

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 байт

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

Перевірте це

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

Перевірте це

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

Перевірте це

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


    ]
}

Мені довелося скористатися, roundrobinа не zipтому, що zipзупиняється, як тільки вичерпується один із вхідних списків.

Математика, 62 байти

приймає за введення рядок

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

Спробуйте в Інтернеті!

APL (Діалог) , 24 байти

Байти в гольф завдяки @ Adám

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

Спробуйте в Інтернеті!

GNU APL 1.2, 24 байти

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

APL працює справа наліво. ⍴R←⍞призначає користувальницьке введення Rта потім оцінює його довжину. Половину цього перемножимо на множення на .5і застосуємо ⌊функцію підлоги.⍳повертає всі числа від 1 до аргументу.

APL працює на масивах, тому 2×масив, який ми щойно отримали з ⍳подвоєння кожного елемента, дає нам просто рівні показники (1-індексований, тож покладається на⎕IO 1).

При доступі до декількох індексів вектора APL надає елементи цих індексів у векторі. R[X←2×⍳⌊.5×⍴R←⍞]дає просто парні елементи. ⌽обертає елементи. Потім присвойте повернені значення назад рівним індексам (привласнення цих індексів Xзберігає 6 байт).

◊є роздільником заяви. Після завершення реверсування оцініть Rдля друку результату.

Perl 5, 46 + 3 для прапора -F = 49 байт

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

Використовує -Fпрапор для автоматичного розділення введення на масив символів,@F . Проводиться через масив і виводить цей елемент для парного індексу або індексу (плюс один для рядка непарної довжини) з кінця для непарного введення.

Здійснює введення за допомогою наступного рядка. Без останнього нового рядка можна просто змінити попередній приріст на$x приріст.

Ще трохи читабельніше:

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 байт

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

Спробуйте в Інтернеті!

Я здогадуюсь, причина цього не було зроблено в 05AB1E, але це тому, що це валовий ...

Але в інший раз zipфункція автоматичного падіння останнього елемента завдає шкоди замість допомоги.

PS Якщо у вас є пропозиції щодо вдосконалення моєї відповіді, опублікуйте свою власну; це, ймовірно, достатньо покращення, щоб гарантувати отримання балів. Мені дуже соромно за цю відповідь.

q / kdb +, 70 56 47 38 35 29 27 байт

Рішення:

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

Приклад:

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"

Пояснення:

Знайдіть непарні індекси рядка, скасуйте цей список, витягніть елементи в цих точках, а потім переставте їх на місце початковому рядку.

{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

Зміни:

• -9 байт; вимикання countдля (#:), tilдля (!), whereдля (&:)і reverseдля (|:).

• -3 байти; вимикання (#:)для (#), (&:)для (&)і (|:)для(|)

• -6 байт; завершити перезапис

• -2 байти; використовуючи завдання, а не застосовувати

05AB1E , 12 байт

RDgÈúøvyNÉè?

Спробуйте в Інтернеті!

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