Bir dize verildiğinde, serpiştirerek ters çevirin. abcdefghiVe abcdefghij0 dizinli için nasıl yapılacağı aşağıda açıklanmıştır :

1. Hatta endekslerdeki karakterleri tek endekslerdeki karakterlerden ayırın:

   Acegi
    bdfh
   
   Acegi
    bdfhj

2. Tek endekslerdeki karakterleri tersine çevir:

   Acegi
    hfdb
   
   Acegi
    jhfdb

3. Tekrar bir dizeye serpiştirin:

   ahcfedgbi 
   
   ajchefgdib

kurallar

• Hem eşit uzunlukta hem de tek uzunlukta dizeleri desteklemelisiniz.
• 0-index-wise olarak, tek endekslerdeki karakterleri tersine çevirmelisiniz, çift değil.
• 1-index-wise, tabii ki, garip değil, hatta indekslerde karakterleri tersine çevirmelisiniz.
• Giriş yazdırılabilir ASCII'den (kod noktaları 32-126) oluşur, satırsonu içermez.
• Girdiyi dize olarak veya karakter listesi olarak alabilirsiniz (1 karakterlik karakter dizileri DEĞİL). Örneğin String/ char[]veya char*bunlara izin verilir, ancak String[]/ char[][]veya izin verilmez char**.

Test senaryoları

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

Boş dize için boş dizenin kendisini döndürün.

Jöle , 7 bayt

s2ZU2¦Z

Bu tam bir program.

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

t2L)P5M(

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

açıklama

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 bayt

/ZY
\IOR@/

Çevrimiçi deneyin!

Bu programın baytlarının yarısı kaynağı doğru bir şekilde biçimlendirmek için harcanır, gerçek komutlar sadece IYRZO, çünkü Alice'in bu görev için doğru yapılara sahip olması.

açıklama

Dediğim gibi, aynalar ( /\), satırsonu ve @sadece ip doğru yönde hareket yapmak ve sonunda programı sonlandırmak için var. Doğrusallaştırılmış gerçek kod aşağıdaki gibidir:

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

Oldukça açık, diyebilirim.

Java (OpenJDK 8) , 108 96 94 93 bayt

@ Neil'in kullanma hilesi kullanılarak 1 bayt kaydedildis[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;}

Çevrimiçi deneyin!

Python 2 , 52 bayt

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

Çevrimiçi deneyin! veya Tüm test senaryolarını deneyin

Oktav, 32 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 48 bayt

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>

Jöle , 9 bayt

Ḋm2U
m2żÇ

Çevrimiçi deneyin!

Ḋ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

^{Dennis sayesinde -1 bayt}

Retina ,17 13 bayt

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

Çevrimiçi deneyin!

Neil sayesinde bir hata düzeltildi.

Kobi sayesinde 4 bayt tasarruf etti.

Öncesinde tek sayıda karakter olan her harfi seçer ve tersine çevirir. Bunu \G, son eşleşmenin sonuyla eşleşen eşlemeyi kullanarak yapar.

PHP> = 7,1, 58 Bayt

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

Çevrimiçi sürüm

APL (Dyalog) , 9 bayt

Gerektirir ⎕IO←0uygun tanım garip ve hatta için (birçok sistemlerde varsayılan).

⌽@{2|⍳≢⍵}

Çevrimiçi deneyin!

⌽ ters

@ maske tarafından filtrelenen elemanlarda

{ anonim işlev

 2| mod-2

 ⍳ endeksleri

 ≢ taksitli (uzunluk)

 ⍵ argüman

} tartışmada

Röda , 34 bayt

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

Çevrimiçi deneyin!

açıklama

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

İşte aynı baytta alternatif bir çözüm

36 34 bayt

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

Bu, girdiyi girdi akışından dize olarak alan anonim bir işlevdir.

Python 2 , 67 bayt

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

Çevrimiçi deneyin!

OCaml , 70 bayt

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

Çevrimiçi deneyin!

Haskell , 63 bayt

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

Çevrimiçi deneyin! Kullanımı:f "some string" .

Gibi garip dizeler için abcdefghi, işlev fdizeyi ve tersini !her iki dizeden karakter almayı değiştiren işleve geçirir . Hatta dizeler için bu işe yaramaz ve ofseti doğru elde etmek için önce sahte bir karakter eklememiz gerekir.

C, 69 bayt

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

Gayet basit. Geçerli karakteri veya karşı karakteri yazdırarak dizeyi yürür.

Açık ve açık:

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 bayt

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

Japt , 14 13 bayt

12 bayt kod, -Pbayrak için +1 .

@Shaggy sayesinde 1 bayt kaydedildi

¬ë íU¬Åë w)c

Açıklama:

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

Çevrimiçi deneyin!

Japt , 8 bayt

ó
v íUÌw

Dene

K (oK) , 18 bayt

Çözüm:

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

Çevrimiçi deneyin!

Örnekler:

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

Açıklama:

Çoğunlukla sağdan sola yorumlanır, tek endeks karakterlerini bulur, tersine çevirir ve dizeye geri koyar

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

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

ungolfed

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

açıklama

• (0 1$~#)]`(|.@])/.]/.Girdiyi çift / tek gruplara ayırmak için Key'i kullanın : (0 1$~#)0 ve 1'i girişin uzunluğuna döngüsel olarak tekrarlayarak grup tanımını oluşturur. Anahtarın gerundial formunu ]`(|.@]), kimliğini ilk gruba uygulayan ve ikinci grubu tersine çeviren ana fiili için kullanıyoruz :(|.@]) .
• Şimdi iki grubumuz var, garip olan tersine döndü, onları birleştirip düzleştiriyoruz: ,@,./

Çevrimiçi deneyin!

Python 3, 93 87 bayt

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 bayt

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

Dene

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

Dene

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

Dene

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


    ]
}

Bunun roundrobinyerine kullanmak zorunda kaldım zip, çünkü zipgiriş listelerinden biri biter bitmez durur.

Mathematica, 62 bayt

bir dize girdi olarak alır

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

Çevrimiçi deneyin!

APL (Dyalog) , 24 bayt

@ Adám sayesinde baytlar golf oynadı

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

Çevrimiçi deneyin!

GNU APL 1.2, 24 bayt

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

APL sağdan sola doğru çalışır. ⍴R←⍞kullanıcı girişini atar Rve uzunluğunu değerlendirir. Bunu katlayarak katlayın .5ve ⌊zemin işlevini uygulayın . ⍳1'den bağımsız değişkene tüm sayıları döndürür.

APL dizilerde çalışır, bu yüzden 2×yeni elde ettiğimiz dizi⍳ her öğeyi iki katına çıkarır ve bize sadece eşit indeksleri verir (1 dizinli, bu yüzden ⎕IO1 olmaya güvenir ).

Bir vektörün birden çok indeksine erişirken, APL bu indekslerdeki elemanları bir vektörde verir. R[X←2×⍳⌊.5×⍴R←⍞]yalnızca çift dizinli öğeleri verir. ⌽elemanları tersine çevirir. Ardından, ters değerleri çift dizinlere geri atayın (bu dizinleriX 6 bayt tasarrufuna ).

◊deyim ayırıcıdır. Tersine çevirme işlemi tamamlandıktan Rsonra sonucu yazdırmayı değerlendirin .

-F bayrağı için Perl 5, 46 + 3 = 49 bayt

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

-FGirişi otomatik olarak bir karakter dizisine bölmek için bayrağı kullanır ,@F . Dizi boyunca döngüler oluşturur ve bu öğeyi çift dizin için veya bu dizinden (artı tek uzunluk dizesi için bir tane) tek bir girdi için sondan çıkarır.

Sondaki satırsonu ile girdi alır. Sondaki satırsonu olmadan, sadece ön artışı değiştirebilir$x bir artış sonrası .

Biraz daha okunabilir:

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 bayt

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

Çevrimiçi deneyin!

Bunun 05AB1E'de yapılmamasının nedenini tahmin ediyorum çünkü bu iğrenç ...

Yine başka bir zaman zipişlevi otomatik bırak-son-eleman yardımcı olmak yerine acıyor.

PS Cevabımla ilgili iyileştirme önerileriniz varsa, kendiniz gönderin; puan almanızı garanti edecek bir gelişme olması muhtemeldir. Bu cevaptan oldukça utanıyorum.

q / KDB + 70 56 47 38 35 29 27 bayt

Çözüm:

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

Örnek:

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"

Açıklama:

Dizenin tek dizinlerini bulun, bu listeyi tersine çevirin, bu noktalardaki öğeleri dışarı çekin ve ardından bunları orijinal dizeye yeniden atayın.

{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

Düzenlemeler:

• -9 bayt; geçiş countyapmak (#:),til için (!), whereiçin (&:)ve reverseiçin (|:).

• -3 bayt; değiştirme(#:) için (#), (&:)için (&)ve (|:)için(|)

• -6 bayt; yeniden yazmayı tamamla

• -2 bayt; uygulamak yerine ödev kullanma

05AB1E , 12 bayt

RDgÈúøvyNÉè?

Çevrimiçi deneyin!

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