एक स्ट्रिंग को देखते हुए, इसे interleavingly रिवर्स करें। यहां बताया गया है कि इसे कैसे करें abcdefghiऔर abcdefghij, 0-अनुक्रमित:

विषम सूचकांकों पर वर्णों से भी वर्णों को अलग करें:
```
acegi
 bdfh

acegi
 bdfhj
```
विषम सूचक पर वर्णों को उल्टा करें:
```
acegi
 hfdb

acegi
 jhfdb
```
फिर से एक स्ट्रिंग में इंटरवल्व करें:
```
ahcfedgbi 

ajchefgdib
```

नियम

आपको सम-लंबाई और विषम-लंबाई दोनों तार का समर्थन करना चाहिए।
०-इंडेक्स-वाइज, आपको विषम सूचक पर चार्ट को उल्टा करना चाहिए, ऐसा भी नहीं।
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

खाली स्ट्रिंग के लिए, खाली स्ट्रिंग को ही वापस करें।

code-golf string

— आउटग्रॉफर को एरिक करें
स्रोत

1

सम्बंधित।

— मार्टिन एंडर

मुझे याद है कि यह एक प्रकार का "सीक्रेट कोड" है (इस तरह का सुअर लैटिन) जिसे हमने 80 या 90 के दशक में बच्चों के रूप में सीखा था, शब्द "बाड़" या कुछ और के साथ कुछ करना है, लेकिन मेरी स्मृति थोड़ी फजी है। मेरे मित्र और मैं इसका उपयोग गुप्त संदेशों को एनकोड करने के लिए करेंगे, और मुझे नहीं लगता कि जिन वयस्कों को हमारे पत्र मिले, उन्होंने कभी उनका पता लगाया ...

— phyrfox

@phyrfox आप रेल बाड़ सिफर के बारे में सोच रहे होंगे , जो इस के समान है।

— कारमिस्टर

आह मुझे ऐसा करना याद है।

— 12Me21 18

7

जेली , 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.

— डेनिस
स्रोत

यही मेरा समाधान है बाइट-बाय-बाइट ...

— एरिक द आउटग्राफर

3

एक जैसे दिमाग महान सोचते हैं। ;)

— डेनिस

12

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'

— लुइस मेंडो
स्रोत

5

तो 2L"पुश [2,2,1j]" है, और 5M"पुश [2,2,1j] फिर से" है ... और कुछ लोग कहते हैं कि गोल्फ भाषाएं पढ़ने योग्य नहीं हैं!

— सिंह

3

@Leo :-D 2Lएक पूर्वनिर्धारित शाब्दिक उत्पादन करता है। 5Mएक स्वचालित क्लिपबोर्ड है जो हाल ही के फ़ंक्शन कॉल के लिए इनपुट संग्रहीत करता है। यह वास्तव 2Lमें एक ही बाइट की गिनती के लिए प्रतिस्थापित किया जा सकता है

— लुइस मेंडो

7

ऐलिस , 10 बाइट्स

/ZY
\IOR@/

इसे ऑनलाइन आज़माएं!

इस कार्यक्रम के आधे बाइट्स स्रोत को सही ढंग से प्रारूपित करने पर खर्च किए जाते हैं, वास्तविक आदेश सिर्फ IYRZOइसलिए हैं , क्योंकि ऐलिस के पास इस कार्य के लिए सिर्फ सही भवन हैं।

व्याख्या

जैसा कि मैंने कहा, दर्पण ( /\), नई लाइन और @वहाँ सिर्फ सही दिशा में आईपी कदम बनाने के लिए और अंत में कार्यक्रम समाप्त कर रहे हैं। वास्तविक कोड, रेखाबद्ध, निम्नलिखित है:

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

बिल्कुल सीधा, मैं कहूंगा।

— सिंह
स्रोत

अगर केवल मैं समझ सकता हूं कि दर्पण कोनों में कैसे काम करते हैं ...

— लुइस मेंडू

@LuisMendo सबसे पहले आप दर्पण से गुजरते हैं, जो आपको कार्डिनल (क्षैतिज / ऊर्ध्वाधर) से ऑर्डिनल (विकर्ण) मोड या इसके विपरीत में बदल देता है। तब यदि आप कार्डिनल मोड में हैं, तो आप लाइन / कॉलम के दूसरी तरफ लपेटते हैं, जबकि यदि आप ऑर्डिनल मोड में हैं, तो आप कोने के खिलाफ वापस उछालते हैं। इस स्थिति में दक्षिण-पूर्व दर्पण ऑर्डिनल मोड में आता है, आपको कार्डिनल पर स्विच करता है और दूसरी लाइन की शुरुआत में लपेटता है, जहां एक और दर्पण आपको ऑर्डिनल में वापस जाता है और उत्तर-पूर्व की ओर बढ़ना शुरू करता है

— लियो

आह, तो शेख़ी केवल विकर्ण में है, उसी दिशा में जहां से आप आए थे। फिर यह जितना मैंने सोचा था उससे कहीं ज्यादा सरल है। धन्यवाद!

— लुइस मेंडो

6

जावा (ओपनजेडके 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;}

इसे ऑनलाइन आज़माएं!

— क्रिकटी लिथोस
स्रोत

1

100 बाइट के तहत जावा ... कानूनी लगता है।

— बजे द एग्रिकॉलफर

" Java (OpenJDK 8 ) " तो आप पुनरावृत्ति के बिना जावा 7 पद्धति का उपयोग क्यों कर रहे हैं? जावा 8 लैम्ब्डा का उपयोग करके प्रतिस्थापित String f(char[]s)करें s->.. और आप intलूप के साथ-साथ लूप के अंदर इनिशियलाइज़ेशन डालकर बचा सकते हैं for(int a=s.length,b=0;b<a;b++):। इसे ऑनलाइन आज़माएं।

— केविन क्रूज़सेन

5

पायथन 2 , 52 बाइट्स

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

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों का प्रयास करें

— छड़ी
स्रोत

3

ऑक्टेव, 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— rahnema1
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 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>

स्निपेट का विस्तार करें

— नील
स्रोत

3

जेली , 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 बाइट डेनिस की बदौलत}

— HyperNeutrino
स्रोत

यदि आप प्रतिस्थापित ¢करते हैं Ç, तो आपको ³सहायक लिंक की आवश्यकता नहीं है ।

— डेनिस

@ डेनिस ओह मुझे क्या लगा कि मैंने ऐसा पहली बार किया है> _> नेवरमाइंड, मैंने कुछ पंगा लिया होगा। धन्यवाद!

— हाइपरएनुट्रिनो

3

रेटिना ,17 13 बाइट्स

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

इसे ऑनलाइन आज़माएं!

नील की बदौलत त्रुटि हुई।

कोबी की बदौलत 4 बाइट्स बचाए।

विषम वर्णों के पूर्ववर्ती प्रत्येक अक्षर का चयन करता है और उन्हें उलट देता है। इसका उपयोग वह करता है \Gजो पिछले मैच के अंत से मेल खाता है।

— FryAmTheEggman
स्रोत

अंतिम टेस्टकेस गलत है। आपको $इसके बजाय उपयोग करने की आवश्यकता होगी #।

— नील

@ नील व्होप्स, आप बिलकुल सही कह रहे हैं। फिक्स्ड!

— FryAmTheEggman

आप \Gइसके बजाय लुकअप पर इस्तेमाल कर सकते हैं , और आप इसे हटा$ सकते हैं : O^`(?<=\G.).(12 बाइट्स)

— कोबी

1

@Kobi सुझावों के लिए धन्यवाद! लेकिन दुर्भाग्य से यह केवल ऐसा लग रहा था कि मैं हटा सकता हूं $क्योंकि सभी इनपुट सॉर्टेड लेक्सोग्राफ़िक क्रम में थे। मैंने एक नया परीक्षण मामला जोड़ा है जिससे आपका कोड विफल हो जाएगा।

— FryAmTheEggman

@FryAmTheEggman - यह मिल गया, अच्छी बात है। लगता है यह सिर्फ किस्मत थी।

— कोबी

2

PHP> = 7.1, 58 बाइट्स

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

ऑनलाइन संस्करण

— जार्ग हुल्सरमन
स्रोत

1

उत्तम। ओएस कहता है कि मुझे अधिक लिखना है, लेकिन उन 7 वर्णों को यह सब कहना है।

— टाइटस

2

एपीएल (डायलॉग) , 9 बाइट्स

आवश्यक है ⎕IO←0 अजीब की और यहां तक कि उचित परिभाषा के लिए (कई सिस्टम पर डिफ़ॉल्ट)।

⌽@{2|⍳≢⍵}

इसे ऑनलाइन आज़माएं!

⌽ उलटा

@ मास्क लगाने से फ़िल्टर किए गए तत्वों पर लागू होता है

{ एनोनिमस फंक्शन

2| के मॉड -2

⍳ के सूचकांकों

≢ की टैली (लंबाई)

⍵ बहस

} तर्क पर

— एडम
स्रोत

जब यह प्रश्न पोस्ट किया गया था तब भी v16 बाहर था?

— Zacharý

@ Zacharý यह बीटा में था, लेकिन यह अब भी मायने नहीं रखता ।

— अड्म

ओह, तो मुझे लगता है कि अब आप v17 का उपयोग करने वाले हैं?

— Zacharý

1

रोड़ा , 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])}

यह एक अनाम फ़ंक्शन है जो इनपुट स्ट्रीम से स्ट्रिंग के रूप में इनपुट लेता है।

— क्रिकटी लिथोस
स्रोत

1

पायथन 2 , 67 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

1

OCaml , 70 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— juloo65
स्रोत

1

हास्केल , 63 बाइट्स

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

इसे ऑनलाइन आज़माएं! उपयोग: f "some string"।

जैसे अजीब तार के लिए abcdefghi, फ़ंक्शन fस्ट्रिंग और इसके उत्क्रमण को फ़ंक्शन में !भेजता है, जो दोनों तारों से चार्ट लेने का विकल्प देता है। यहां तक कि तार के लिए यह काम नहीं करता है, और हमें ऑफसेट को सही करने के लिए पहले एक डमी चरित्र को जोड़ना होगा।

— Laikoni
स्रोत

1

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

— क्वेंटिन
स्रोत

1

गणितज्ञ, 82 बाइट्स

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

— user202729
स्रोत

1

जाप , 14 13 बाइट्स

-Pध्वज के लिए कोड के 12 बाइट्स, +1 ।

@ बस्ती के लिए 1 बाइट का धन्यवाद सहेजा गया

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

इसे ऑनलाइन आज़माएं!

— ओलिवर
स्रोत

हम्म, ë2,1बल्कि बदसूरत है। मुझे लगता है कि आप ó oइसके बजाय, शायद कर सकते हैं ...

— ETHproductions

@ETHproductions हाँ, मुझे लगता है कि Åëकाम भी करता है।

— ओलिवर

ओह, एक अच्छा :-)

— ETHproductions

1

जाप , 8 बाइट्स

ó
v íUÌw

झसे आज़माओ

— झबरा
स्रोत

1

के (ओके) , 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

— streetster
स्रोत

1

जे, 26 बाइट्स

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

ungolfed

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

व्याख्या

(0 1$~#)]`(|.@])/.]/.इनपुट को सम / विषम समूहों में विभाजित करने के लिए कुंजी का उपयोग करें : (0 1$~#)समूह की परिभाषा बनाता है, इनपुट की लंबाई तक 0 और 1 को दोहराकर। हम कुंजी के gerundial रूप का उपयोग इसके मुख्य क्रिया के लिए करते हैं ]`(|.@]), जो पहले समूह की पहचान को लागू करता है और दूसरे समूह को उलट देता है:(|.@]).
अब जब हमारे पास दो समूह हैं, तो जो विषम है, हम उन्हें एक साथ जोड़ते हैं और समतल करते हैं: ,@,./

इसे ऑनलाइन आज़माएं!

— जोनाह
स्रोत

21 bytes with (\:2|#\)({~/:)#\<.#\. and 19 bytes with [:,@,./]]|./.~2|#`

— miles

thanks miles. is there a typo in the second one? I'm getting an error

— Jonah

@miles also the first one: i understand how it parses and technically what's happening, but i'm not seeing the overall strategy. can you clarify?

— Jonah

oh yes, it's supposed to be [:,@,./]]`|./.~2|#\, the ticks got parsed out

— miles

17 bytes with 0,@|:]]`|./.~2|#\

— miles

0

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]

— Trelzevir
स्रोत

Replace reversed(s[1::2]) with s[1::2][::-1] to save 4 bytes

— Mr. Xcoder

It comes down to 83 bytes and golfable, in the end: f=lambda s,j="".join:j(j(t)for t in zip(s[::2],s[1::2][::-1]))+("",s[-1])[len(s)%2]

— Mr. Xcoder

0

Perl 6, 63 58 55 bytes

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

Test it

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

Test it

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

Test it

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


    ]
}

I had to use roundrobin rather than zip, because zip stops as soon as one of the input lists is exhausted.

— Brad Gilbert b2gills
स्रोत

0

Mathematica, 62 bytes

takes as input a string

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

Try it online!

— J42161217
स्रोत

0

APL (Dyalog), 24 bytes

Bytes golfed thanks to @Adám

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

Try it online!

— Kritixi Lithos
स्रोत

1

Are you going to explain your code?

— Adám

0

GNU APL 1.2, 24 bytes

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

APL works from right to left. ⍴R←⍞ assigns user input to R and then evaluates its length. Halve this by multiplying by .5 and apply ⌊ floor function. ⍳ returns all numbers from 1 to the argument.

APL operates on arrays, so 2× the array we just got from ⍳ doubles each element, giving us just the even indices (1-indexed, so relies on ⎕IO being 1).

When accessing multiple indices of a vector, APL gives the elements at those indices in a vector. R[X←2×⍳⌊.5×⍴R←⍞] gives just the even-indexed elements. ⌽ reverses the elements. Then, assign the reversed values back to the even indices (assigning these indices to X saves 6 bytes).

◊ is the statement separator. After the reversing is done, evaluate R to print the result.

— Arc676
स्रोत

0

Perl 5, 46 + 3 for -F flag = 49 bytes

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

Uses the -F flag to auto split the input into an array of characters, @F. Loops through the array and outputs that element for an even index or that index (plus one for an odd length string) from the end for an odd input.

Takes input with a trailing newline. Without the trailing newline, can just change the pre-increment on $x to a post-increment.

A little more readable:

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

— Chris
स्रोत

0

05AB1E, 21 bytes

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

Try it online!

I'm guessing the reason this wasn't done in 05AB1E yet is because it's gross...

Yet another time the zip function's auto-drop-last-element hurts instead of helps.

P.S. If you have improvement suggestions on my answer, post your own; it's likely enough of an improvement to warrant you getting the points. I am pretty ashamed of this answer.

— Magic Octopus Urn
स्रोत

0

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

Solution:

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

Example:

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"

Explanation:

Find the odd indices of the string, reverse this list, pull out elements at these points and then reassign them in-place to the original string.

{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

Edits:

-9 bytes; switching out count for (#:), til for (!), where for (&:) and reverse for (|:).
-3 bytes; switching out (#:) for (#), (&:) for (&) and (|:) for (|)
-6 bytes; complete re-write
-2 bytes; using assignment rather than apply

— streetster
स्रोत

0

05AB1E, 12 bytes

RDgÈúøvyNÉè?

Try it 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

— scottinet
स्रोत

उलट-पलट करना

नियम

परीक्षण के मामलों

जेली , 7 बाइट्स

यह काम किस प्रकार करता है

MATL , 8 बाइट्स

व्याख्या

ऐलिस , 10 बाइट्स

व्याख्या

जावा (ओपनजेडके 8) , 108 96 94 93 बाइट्स

पायथन 2 , 52 बाइट्स

ऑक्टेव, 32 बाइट्स

जावास्क्रिप्ट (ईएस 6), 48 बाइट्स

जेली , 9 बाइट्स

रेटिना ,17 13 बाइट्स

PHP> = 7.1, 58 बाइट्स

एपीएल (डायलॉग) , 9 बाइट्स

रोड़ा , 34 बाइट्स

व्याख्या

36 34 बाइट्स

पायथन 2 , 67 बाइट्स

OCaml , 70 बाइट्स

हास्केल , 63 बाइट्स

सी, 69 बाइट्स

असंगठित और समझाया गया:

गणितज्ञ, 82 बाइट्स

जाप , 14 13 बाइट्स

स्पष्टीकरण:

जाप , 8 बाइट्स

के (ओके) , 18 बाइट्स

जे, 26 बाइट्स

ungolfed

व्याख्या

Python 3, 93 87 bytes

Perl 6, 63 58 55 bytes

Mathematica, 62 bytes

APL (Dyalog), 24 bytes

GNU APL 1.2, 24 bytes

Perl 5, 46 + 3 for -F flag = 49 bytes

05AB1E, 21 bytes

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

05AB1E, 12 bytes