Учитывая строку, переверните ее чередование. Вот как это сделать для 0 abcdefghiи abcdefghij0:

1. Отделите символы с четными индексами от символов с нечетными:

   Acegi
    bdfh
   
   Acegi
    bdfhj

2. Поменяйте местами символы с нечетными индексами:

   Acegi
    hfdb
   
   Acegi
    jhfdb

3. Снова чередовать в одну строку:

   ахфедгби 
   
   айчефгдиб

правила

• Вы должны поддерживать строки как четной, так и нечетной длины.
• При 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 байт с помощью хитрого трюка @ Neil с использованием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 (Дьялог) , 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

Вот альтернативное решение на тот же bytecount

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

Mathematica, 82 байта

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

Джапт , 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 (ок) , 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$~#)]`(|.@])/.]

ungolfed

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

объяснение

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

Попробуйте онлайн!

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останавливается, как только один из списков ввода исчерпан.

Mathematica, 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-индексированный, поэтому полагается на ⎕IO1).

При доступе к нескольким индексам вектора 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функция auto-drop-last-element вместо помощи помогает.

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