एक सूची को सम-अनुक्रमित और विषम-अनुक्रमित भागों में अलग करें

Question

इस सवाल से प्रेरित :

एक फ़ंक्शन (या एक पूर्ण प्रोग्राम) बनाएं जो संख्याओं की एक सूची प्राप्त करता है और पुनर्व्यवस्थित सूची को आउटपुट करता है, ताकि समान-अनुक्रमित संख्याएं पहले दिखाई दें, और विषम-अनुक्रमित संख्याओं का पालन करें। संख्याओं के मूल्य स्वयं आदेश को प्रभावित नहीं करते हैं - केवल उनके सूचकांक करते हैं। सभी सूचकांक शून्य-आधारित हैं।

उदाहरण के लिए:

इनपुट: [0, 1, 2, 3, 4]

आउटपुट: [0, 2, 4, 1, 3]

एक और उदाहरण:

इनपुट: [110, 22, 3330, 4444, 55555, 6]

आउटपुट: [110, 3330, 55555, 22, 4444, 6]

आपकी भाषा के पास सूचियों के लिए सबसे अधिक प्राकृतिक प्रतिनिधित्व का उपयोग करें। जटिलता पर कोई सीमाएं नहीं हैं (उदाहरण के लिए एक अस्थायी सूची आवंटित करना ठीक है - इसे जगह में करने की आवश्यकता नहीं है)।

PS इसे खाली सूची (खाली इनपुट => खाली आउटपुट) के लिए काम करना चाहिए।

Comments

यह प्रभावी रूप से इस प्रश्न के वर्तमान उत्तरों

— पीटर टेलर

क्या हम मान सकते हैं कि सभी सूची तत्व सकारात्मक या गैर-नकारात्मक या कुछ और हैं?

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

@ मार्टिनबटनर कुछ भी उचित मान लेते हैं, हो सकता है कि वे भी 0 ... 255 की सीमा में हों।

— अनातोलीजी

संबंधित

— एलेक्स ए।

क्या हम अल्पविराम से अलग की गई सूची को आउटपुट कर सकते हैं?

— ओलिवर

Answer 1

जाप , 1 बाइट

ó

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

Comments

क्या यह मान्य है ??

— एएससीआईआई-केवल

मेरे पास यह मूल रूप से भी था। यह पूछने लायक हो सकता है कि क्या आउटपुट फॉर्मेट स्वीकार्य है।

— झबरा

Answer 2

पायथन, 23 बाइट्स

lambda x:x[::2]+x[1::2]

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

Comments

क्यों lambda? क्यों muया नहीं nu? : पी

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

@rayryeng मैं केवल अपनी टिप्पणी के अंत में ": P" के रूप में देख सकता था, मजाक कर रहा था :)

— Kritii Lithos

हाँ, आप निश्चित रूप से बदल दिया जाना चाहिए lambdaद्वारा λऔर 5 से बाइट गिनती कम! : पी

— अनातोलीग

पीईपी जमा करने के लिए @anatolyg एक विचार की तरह लगता है !

— निक टी

@ThomasKwa यह काम का सही उपकरण है: P

— Mego

Answer 3

अजगर, ५

o~!ZQ

इसे ऑनलाइन आज़माएं , या टेस्ट सूट चलाएं

व्याख्या

o~!ZQ    ## implicit: Z = 0; Q = eval(input)
o   Q    ## sort Q using a supplied function
 ~!Z     ## Use the old value of Z, then set Z to be not Z
         ## This assigns a weight to each number in the list, for example given [0,1,2,3,4]
         ## This will give (value, weight) = [(0,0), (1,1), (2,0), (3,1), (4,0)]
         ## The values are sorted by weight and then by index
         ## This happens because Pyth is written in Python, which performs stable sorts

Comments

प्रतिभाशाली! सुंदर।

— 7

रुको, यह कैसे काम करता है?

— जस्ट

@ अन्याय मैंने कुछ और स्पष्टीकरण जोड़ दिए हैं, क्या यह स्पष्ट है?

— FryAmTheEggman

Answer 4

सीजेएम, 7 बाइट्स

{2/ze_}

एक ब्लॉक (एक अनाम फ़ंक्शन के सबसे निकटतम चीज) को धक्का देता है जो आवश्यकतानुसार शीर्ष स्टैक तत्व को बदल देता है।

इसका परीक्षण यहां करें।

व्याख्या

स्पष्टीकरण मानता है कि स्टैक के शीर्ष पर सरणी है [0 1 2 3 4]। वास्तविक मान अभिकलन को प्रभावित नहीं करते हैं।

2/  e# Split the array into chunks of two: [[0 1] [2 3] [4]]
z   e# Zip/transpose, which works on ragged arrays: [[0 2 4] [1 3]]
e_  e# Flatten the result: [0 2 4 1 3]

Answer 5

भूलभुलैया , 28 25 24 23 22 बाइट्स

" >
?!?:|}\{@
@\?"":)!

यह पागल मज़ा था! :) यह अब तक का सबसे घनी संकुचित भूलभुलैया कार्यक्रम है जो मैंने अब तक लिखा है। मेरे पास 20 और 21 बाइट्स में कई संस्करण थे जो लगभग काम करते थे कि मुझे अभी भी संदेह है कि यह इष्टतम है ...

यह सकारात्मक पूर्णांकों की सूची के रूप में इनपुट लेता है (एक मनमाने ढंग से सीमांकक के साथ), और परिणाम को STDOUT को लाइनफीड-सीमांकित पूर्णांक के रूप में प्रिंट करता है।

20/21 बाइट्स के लिए शिकार: मैंने फॉर्म के सभी कार्यक्रमों की जाँच की है

" XX
?!?X}\{@
@\?XX)!

Xब्रूट बल द्वारा कोई भी उचित चरित्र कहां है, लेकिन कोई भी वैध समाधान नहीं मिला। बेशक इसका मतलब यह नहीं है कि एक छोटा समाधान मौजूद नहीं है, लेकिन इसकी संरचना के लिए सभ्य मान्यताओं के बिना 20-बाइट कार्यक्रमों को बाध्य करना संभव नहीं है।

व्याख्या

(स्पष्टीकरण थोड़ा पुराना है, लेकिन मैं अभी भी आश्वस्त नहीं हूं कि समाधान इष्टतम है, इसलिए मैं इसे अपडेट करने के साथ इंतजार करूंगा।)

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

लेकिन इस बार मैं वास्तव में भाग्यशाली था और सब कुछ इतनी अच्छी तरह से एक साथ फिट हो गया, कि मैं इसे एक बड़े झुरमुट में डाल सकता था। :)

_दक्षिण की ओर जाने पर नियंत्रण प्रवाह शुरू होता है । _मुख्य ढेर पर एक शून्य धक्का। यह एक नो-ऑप की तरह लग सकता है, लेकिन इससे (गैर-निहित) स्टैक की गहराई बढ़ जाती है, 1जिसकी हमें बाद में आवश्यकता होगी।

?STDIN से एक पूर्णांक पढ़ता है। यदि पढ़ने के लिए अधिक पूर्णांक नहीं हैं, तो यह शून्य को धक्का देता है। उस स्थिति में, आईपी दक्षिण चलती रहती है और @कार्यक्रम को तुरंत समाप्त कर देती है (क्योंकि इनपुट सूची खाली है)। अन्यथा, आईपी पूर्व में बदल जाता है।

अब हम दो निकास बिंदुओं के साथ बहुत तंग पाश में प्रवेश कर रहे हैं:

 !?;
 \?
  ;

!स्टैक पर केवल एक शून्य छोड़कर STDOUT में पूर्णांक को प्रिंट करता है। आईपी ​​पूर्व की ओर बढ़ता रहता है, और ?अगले पूर्णांक को पढ़ता है। यदि यह गैर-शून्य है, तो हम एक अधिकार लेते हैं और दक्षिण को स्थानांतरित करते हैं। ?एक और एक (अगले भी सूचकांक) पढ़ता है। फिर, अगर वह गैर-शून्य है, तो हम एक अधिकार लेते हैं और पश्चिम को स्थानांतरित करते हैं।

फिर \स्टैक को बदलने के बिना एक लाइनफीड प्रिंट करता है, इसलिए हम उत्तर की ओर बढ़ते हुए एक और अधिकार लेते हैं। !अगले-इंडेक्स पूर्णांक को प्रिंट करता है। चूंकि अब स्टैक पर कम से कम एक (पॉजिटिव) विषम-इंडेक्स पूर्णांक है, हम दाएं मुड़ते हैं और लूप दोहराता है।

एक बार या तो ?सूची के अंत को हिट करने के बाद, वे एक शून्य को धक्का देते हैं और सीधे उसी पर चलते हैं ;, जो उस शून्य को छोड़ देता है।

इस मामले में कि सूची में केवल एक ही तत्व था, हम कर रहे हैं (क्योंकि हमने तुरंत ही छाप दिया है), इसलिए आईपी पूर्व के सभी तरह से आगे बढ़ेगा @, फिर से कार्यक्रम को समाप्त करना (एक अनुगामी छापना) रास्ते में लाइनफीड)।

अन्यथा, हमें विषम-इंडेक्स पूर्णांक को भी प्रिंट करने की आवश्यकता है। उस स्थिति में दोनों मार्ग (पहले लूप के दो निकास बिंदुओं से) मध्य में विलीन हो जाते हैं ", दोनों में पूर्व की ओर मुड़ते हैं।

_शून्य को धकेलने से बचने के लिए बाईं ओर ले जाता है @, और ;उस शून्य को छोड़ देता है। अब हम एक नया लूप दर्ज करते हैं:

     "}
     ""

IP, बायीं ओर घूमते हुए, घड़ी की सूई में लूप के चारों ओर जाते हुए, नीचे-बाएँ सेल में प्रवेश करता है। }सहायक ढेर करने पर मुख्य ढेर के शीर्ष बदलाव। जबकि स्टैक पर अभी भी एक तत्व है, आईपी अपनी बात करता रहता है। एक बार सब कुछ सहायक स्टैक में स्थानांतरित कर दिया गया (और प्रक्रिया में उलट), आईपी अंतिम लूप में प्रवेश करने के बजाय पूर्व की ओर बढ़ रहा है:

       \{@
       #!

\फिर से एक लाइनफीड प्रिंट करता है, {एक आइटम को सहायक स्टैक से वापस मुख्य पर ले जाता है। यदि वह अभी भी सूची का एक आइटम था, तो यह सकारात्मक होगा, और आईपी दक्षिण में बदल जाता है, जहां आइटम के साथ मुद्रित किया जाता है !। फिर #स्टैक गहराई को धक्का देता है (और अब यह वह जगह है जहां प्रारंभिक _महत्वपूर्ण है, क्योंकि #यह एक सकारात्मक स्टैक गहराई सुनिश्चित करता है), ताकि आईपी अभी भी फिर से \और {फिर से सही हो जाए।

जब हमने सबकुछ छाप दिया, {तो सहायक स्टैक के नीचे से एक शून्य खींचता है, आईपी पूर्व को जारी रखता है, और @कार्यक्रम को समाप्त करता है।

Answer 6

MATLAB, 24

@(x)x([1:2:end 2:2:end])

अजगर के समान।

2 बाइट बचाने के लिए धन्यवाद @LuisMendo!

Comments

अरे! पीपीसीजी में आपको देखकर अच्छा लगा!

— लुइस मेंडो

थोड़ा छोटा:@(x)x([1:2:end 2:2:end])

— लुइस मेंडू

@LuisMendo Haha मुझे कोडगुल्फ़ से थोड़ा डर लगता है, लेकिन MATLAB के लिए यह इतना आसान था! टिप के लिए धन्यवाद;)

— ब्रेन गाइडर

Answer 7

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

concat.foldr(\x[l,r]->[x:r,l])[[],[]]

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

foldrरिकर्सिवली भी सूची और अजीब सूची बनाता है। किसी तत्व को सूची में प्रस्तुत करना उसे विषम सूची में प्रस्तुत करने और उसे नई सूची में कॉल करने से अद्यतन किया जाता है, और पिछली कॉल को भी नई विषम सूची में सूचीबद्ध किया जाता है। फिर, जोड़ी [l,r]को समवर्ती किया जाता है l++r।

ट्यूपल्स के स्थान पर दो-तत्व सूचियों का उपयोग करके 5 बाइट्स को बचाने के लिए अर्जन जोहान्स का धन्यवाद।

---

42 बाइट्स:

f l=[x|p<-[even,odd],(i,x)<-zip[0..]l,p i]

सूची में सूचकांक जोड़ता है lऔर यहां तक ​​कि या विषम लोगों को भी फ़िल्टर करता है।

---

g(a:_:l)=a:(g l)
g l=l
f l=g l++(g$drop 1 l)

फिर भी एक और प्रारूप, 44 के लिए। फ़ंक्शन gहर समान-अनुक्रमित तत्व को लेता है। अजीब सूचकांक पहले एक तत्व को गिराकर प्राप्त होते हैं, फिर आवेदन करते हैं g। यदि lगैर-रिक्त की गारंटी दी गई थी, तो हम सुरक्षित रूप से केवल tail41 के लिए कर सकते थे

g(a:_:l)=a:(g l)
g l=l
f l=g l++g(tail l)

Comments

अभी तक एक और संस्करण (39 बाइट्स): मुख्य कार्य होने के l#(a:b:c)=a:(l++[b])#c;l#x=x++l;f=([]#)साथ f।

— nimi

@ नमि यह एक अच्छा उपाय है, आपको इसे पोस्ट करना चाहिए।

— xnor

नहीं, कृपया इसे अपनी पोस्ट में शामिल करें। यह आपके # 2 और # 3 का संयोजन मात्र है।

— nimi

आप सूचियों का उपयोग करके और concatटुपल्स के बजाय अपने दूसरे संस्करण में 5 बाइट्स बचा सकते हैं और uncurry(++)।

— अर्जन जोहान्सन

Answer 8

PowerShell v3 +, 75 67 49 47 बाइट्स

$l=,@()*2
$args|%{$l[($f=!$f)]+=$_}
$l[0]
$l[1]

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

टीआईओ लिंक पर दिखाए गए अनुसार इनपुट के माध्यम से इनपुट की अपेक्षा करता है।

$lऐरे के एक सरणी के रूप में एक मैट्रिक्स बनाता है , फिर इनपुट $argsको लूप में पाइप करता है |%{}। लूप के माध्यम से हर बार, हम बूलियन तर्क का उपयोग करके चर $lको फ्लिप-फ्लॉप करके दो बच्चे सरणियों में से एक में एक तत्व जोड़ते हैं $f। पहली बार के माध्यम से, $fहै $null, !जिनमें से एक है $true, या 1जब एक सरणी में अनुक्रमित। इसका मतलब यह है कि पहला तत्व दूसरे सरणी में डाल दिया जाता है $l, इसलिए $l[1]पहले आउटपुट प्राप्त होता है।

गोल्फ सहायता और इस भिन्नता के लिए TessellatingHeckler को सहारा ।
-2 बाइट्स mazzy के लिए धन्यवाद।

---

चेतावनियां

प्रश्न के लिखे जाने के अनुसार कड़ाई से जाना, यह तकनीकी रूप से अमान्य है, क्योंकि PowerShell में छद्म-अपरिवर्तनीय वस्तुओं, केवल सरणियों या हैश टेबल (उर्फ शब्दकोशों) के रूप में "सूचियों" की अवधारणा नहीं है। इसलिए, मैं प्रश्न की पंक्ति का इलाज कर रहा हूं " सूची के लिए सबसे प्राकृतिक प्रतिनिधित्व का उपयोग करें जो आपकी भाषा में है " सरणियों के बारे में पूछते हुए, जैसा कि निकटतम पॉवरशेल में है। इसके अतिरिक्त, आउटपुट प्रति पंक्ति एक तत्व है, क्योंकि यह एक सरणी को लिखने के लिए डिफ़ॉल्ट PowerShell तरीका है। इसका मतलब है (0,1,2,3,4)विल आउटपुट का इनपुट 0\r\n2\r\n4\r\n1\r\n3\r\n।

Comments

47 बाइट्स - $args+ $inputऔर ,@()*2इसके बजाय ब्याह@(),@()

— 10

Answer 9

एफ #, 79 77 56

fun x->List.foldBack(fun x (l,r)->x::r,l)x ([],[])||>(@)

हास्केल उत्तर में से एक पर आधारित है

fun x->x|>List.indexed|>List.partition(fst>>(&&&)1>>(=)0)||>(@)|>List.map snd

हम पहले सूची को अनुक्रमित करते हैं, फिर इसे मापदंड के साथ विभाजित करते हैं: पहला आइटम (सूचकांक) और 1 बराबर 0 के साथ थी।
यह हमें जोड़े की सूची का एक जोड़ा देता है; पहली सूची में सभी अनुक्रमित evens और दूसरी अनुक्रमित ऑड्स शामिल होंगी।
उस से हम परिशिष्ट ऑपरेटर के साथ दो सूची को फिर से इकट्ठा करते हैं और अंत में सूचकांक को छोड़ देते हैं।

संपादित करें: एक स्पष्ट याद किया कि arg "xs" (आदतों) को नाम देने की कोई आवश्यकता नहीं है, इसलिए 1-अक्षर के नाम को कम कर सकते हैं

---

मेरे पास एक संभावित 76 बाइट्स भी हैं जो मूल रूप से एक ही हैं लेकिन फ़ंक्शन रचना के रूप में परिभाषित किया गया है। समस्या यह है कि यह एक मूल्य के रूप में संकलित नहीं करता है, लेकिन प्रभावी रूप से किसी भी सूची तर्क के साथ काम करेगा यदि यह ठीक है या नहीं तो अनिश्चित है:

List.indexed>>List.partition(fst>>(&&&)1>>(=)0)>>fun(e,o)->e@o|>List.map snd

---

नोट: List.indexed अभी तक MSDN में प्रलेखित नहीं होने के बावजूद F # 4.0 से उपलब्ध है

Comments

अत्याधुनिक तकनीक, शांत!

— अनातोलीजी

@anatolyg यह fun, है ना?

— कॉनर ओ'ब्रायन

मुझे लगता है कि यह पर्ल 6 कोड के समान है जिसे मैंने पहली बार आज़माया था। F # में -> \xs { xs.pairs.classify( *.key%%2, :as( *.value ) ).map( *.value.Slip ) }मान |>लेना लगभग ==>Perl में सही फीड ऑपरेटर के बराबर है। मैं भी केवल अनुमान लगा रहा हूं कि क्या fst>>(&&&)1>>(=)0है

— ब्रैड गिल्बर्ट b2gills

Answer 10

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

इसे एक पास में भी करता है

x=>x.map((v,i)=>x[(i*=2)>=(z=x.length)?i-z+--z%2:i])

F=x=>x.map((v,i)=>x[(i*=2)>=(z=x.length)?i-z+--z%2:i])

input.oninput = setValue;

function setValue() {
  var arr = input.value.match(/\d+/g) || [];
  unsorted.innerHTML = arr.join(', ');
  sorted.innerHTML = F(arr).join(', ');
}

setValue();

* {
  font-family: monospace
}

th {
  text-align: right;
  padding-right: 0.5em;
}

<input id="input" type="text" value="0 1 2 3 4 5 6"/>
<hr/>
<table>
  <tr>
    <th>Unsorted:</th>
    <td id="unsorted"></td>
  </tr>
  <tr>
    <th>Sorted:</th>
    <td id="sorted"></td>
  </tr>
</table>

Comments

आप F=शुरुआत से ही छोड़ सकते हैं ; आप इसका उपयोग करके एक बाइट को बचा सकते हैं:(i*=2)>=(z=x.length)?i-z+--z%2:i

— Conor O'Brien

@ C @O'Bʀɪᴇɴ अच्छा विचार धन्यवाद!

— जॉर्ज रीथ

Answer 11

जूलिया, 23 बाइट्स

i->i[[1:2:end;2:2:end]]

Answer 12

जे, 8 बाइट्स

/:0 1$~#

यह एक अद्वैत (एक-तर्क) क्रिया है, जिसका उपयोग इस प्रकार है:

  (/:0 1$~#) 110 22 3330 4444 55555 6
110 3330 55555 22 4444 6

व्याख्या

/:        Sort the input array according to
  0 1     the array 0 1
     $~   repeated enough times to be of length
       #  length of input

Comments

एक विकल्प /:0:`1:\जो 8 बाइट्स भी है।

— मील

Answer 13

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

s2ZF

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

मार्टिन के सीजेम उत्तर के आधार पर

s2ZF - Main link. Argument: L (a list) e.g.  [110, 22, 3330, 4444, 55555, 6]
s2   - Split into chunks of length 2         [[110, 22], [3330, 4444], [55555, 6]]
  Z  - Columns                               [[110, 3330, 55555], [22, 4444, 6]]
   F - Flatten                               [110, 3330, 55555, 22, 4444, 6]

Answer 14

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

#[[;;;;2]]~Join~If[#=={},#,#[[2;;;;2]]]&

{}[[2;;;;2]] एक त्रुटि फेंक देंगे।

Answer 15

बर्लेस्क, 12 बाइट्स

J2ENj[-2EN_+

उपयोग के रूप में:

blsq ) {0 1 2 3 4}J2ENj[-2EN_+
{0 2 4 1 3}
blsq ) {110 22 3330 4444 55555 6}J2ENj[-2EN_+
{110 3330 55555 22 4444 6}

स्पष्टीकरण:

J     -- duplicate
2EN   -- every 2nd element
j     -- swap
[-    -- tail
2EN   -- every 2nd element
_+    -- concatenate parts

हालाँकि एक बार नया अपडेट जारी हो जाने के बाद आप इसे नए Unmerge बिल्ट-इन (जो मर्ज बिल -इन के विपरीत होता **है) के साथ कर सकते हैं:

blsq ) {110 22 3330 4444 55555 6}J2ENj[-2EN**
{110 22 3330 4444 55555 6}

Answer 16

पर्ल, 35 33 बाइट्स

perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'

के लिए 31 बाइट्स + 2 बाइट्स -ap। STDIN से एक अंतरिक्ष-सीमांकित स्ट्रिंग पढ़ता है:

$ echo 0 1 2 3 4 | perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'
0 2 4 1 3

$ echo 110 22 3330 4444 55555 6 | perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'
110 3330 55555 22 4444 6

जब इनपुट खाली होता है, तो एक सिंगल स्पेस प्रिंट करता है, जिसे मैं एक खाली सूची के बराबर मानता हूं। यदि नहीं, तो 4 बाइट्स की लागत के साथ तय किया जा सकता है:

perl -anE 'push@{$|--},$_ for@F;$,=$";say@0,@1'

(पर्ल 5.10+ की आवश्यकता है, एक अनुगामी न्यूलाइन प्रिंट करता है)

या के साथ 5 बाइट्स की लागत पर:

perl -ape 'push@{$|--},$_ for@F;$_=join$",@0,@1'

(कोई अनुगामी व्हॉट्सएप नहीं)

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

यह समाधान -aध्वज का उपयोग करता है , जो व्हाट्सएप पर इनपुट को विभाजित करता है और परिणामों को @Fसरणी में डालता है ।

असली जादू में होता है push:

push@{$|--},$_

$|चर सामान्य रूप से उत्पादन फ्लशिंग मजबूर करने के लिए प्रयोग किया जाता है, लेकिन यह एक और दिलचस्प संपत्ति है: जब बार-बार 0 और 1 के बीच कम कर, अपने मूल्य टॉगल होता है।

perl -E 'say $|-- for 0..4'
0
1
0
1
0

इस तथ्य का लाभ उठाते हुए कि प्रतीकात्मक डीरेफरिंग के माध्यम से निर्दिष्ट पहचानकर्ताओं पर कोई प्रतिबंध नहीं है , हम वैकल्पिक रूप से सरणी तत्वों को ऐरे @0और @1एरे पर रखते हैं, इसलिए @0सभी समान-अनुक्रमित तत्वों और @1बाधाओं के साथ समाप्त होता है । तब हम अपने उत्पादन को प्राप्त करने के लिए कठोर सरणियों का उपयोग करते हैं।

Answer 17

सी, 70

कुछ खास नहीं, सिर्फ एक इंडेक्स मैपिंग फंक्शन।

a=0;main(int c,int** v){for(c--;a<c;)puts(v[1+a*2%c+!(a++<c/2|c%2)]);}

कम गोल्फ वाला

a=0;
main(int c, int** v) {
  for(c--; a<c;)
    puts(v[1 + a*2%c + !(a++ < c/2 | c%2) ]);
}

Answer 18

पायथ, 8 बाइट्स

+%2Q%2tQ

सापेक्षया सरल

Answer 19

विटसी, 22 बाइट्स

Vitsy वास्तव में ऐसा करने के लिए नहीं बनाया गया था ...

r '' Vl2 / \ [N {VO] l \ [NVO]
Rev निहित संख्यात्मक इनपुट स्टैक को उल्टा करें।
 "V" वैश्विक अंतिम चर के रूप में "स्पेस" वर्ण को सहेजें।
     l2 / \ [....] कोष्ठक में सामान को इनपुट की लंबाई दोहराएं
                        2 से विभाजित।
          N {VO एक नंबर के रूप में स्टैक के शीर्ष आइटम को आउटपुट करता है, फिर शिफ्ट होता है
                        एक बार बाईं ओर ढेर, एक जगह धक्का, यह उत्पादन।
               l \ [...] स्टैक के बाकी हिस्सों के लिए, कई बार दोहराएं ...
                  एक संख्या के रूप में NVO आउटपुट के शीर्ष आइटम को अलग कर दिया गया 
                        एक स्थान से।

Answer 20

पर्ल 6 , 25 बाइट्स

यह सबसे छोटा मेमना है जिसके साथ मैं आ सकता था।

{|.[0,2...*],|.[1,3...*]} # 25 byte "Texas" version
{|.[0,2…*],|.[1,3…*]}     # 25 byte "French" version

say {|.[0,2…*],|.[1,3…*]}( ^5 ); # (0 2 4 1 3)␤

say ((0..4),('m'..'q'),(5..9)).map: {|.[0,2…*],|.[1,3…*]}
# ((0 2 4 1 3) (m o q n p) (5 7 9 6 8))␤


# bind it as a lexical sub
my &foo = {|.[0,2…*],|.[1,3…*]}

say foo [110, 22, 3330, 4444, 55555, 6]; # (110 3330 55555 22 4444 6)␤

say [~] foo 'a'..'z' # acegikmoqsuwybdfhjlnprtvxz␤

Answer 21

मिंकोलंग 0.12 , 15 बाइट्स

$nI2:[i1+g]r$N.

इसे यहाँ आज़माएँ।

व्याख्या

$n                 Read in all of input as numbers
  I2:              The length of the stack divided by 2 (n)
     [             Open for loop that repeats n times
      i1+          Loop counter + 1
         g         Gets the (i+1)th item from the stack and puts it on top
          ]        Close for loop
           r       Reverse the stack (for outputting)
            $N.    Output the whole stack as numbers and stop.

Answer 22

आर, 49 बाइट्स

q<-function(x)c(x[seq(x)%%2==1],x[seq(x)%%2==0])

इसे क्यू (ब्ला) कहते हैं। या, यदि x में पहले से ही पुनर्व्यवस्थित होने की सूची है, तो

c(x[seq(x)%%2==1],x[seq(x)%%2==0])

सिर्फ 35 बाइट्स है।

Answer 23

एफ #, 64

fun x->List.mapi(fun i l->l,i%2)x|>List.sortBy snd|>List.map fst

सेहनेसट के उत्तर से प्रेरित (लेकिन टिप्पणी करने के लिए पर्याप्त प्रतिनिधि नहीं)।

प्रत्येक मान को एक tuple पर मैप करें जहां दूसरी प्रविष्टि सूची इंडेक्स का modulo है, modulo द्वारा सॉर्ट करता है, फिर मूल मान पर वापस मैप करता है।

Answer 24

प्रोलॉग, 103 बाइट्स

r([E,O|T],[E|A],[O|B]):-r(T,A,B).
r([],[],[]).
r([E],[E],[]).
p(L):-r(L,A,B),append(A,B,X),write(X).

उदाहरण

>p([1,2,3,4,5]).
[1,3,5,2,4]

Answer 25

बैश और जीएनयू कोरुटिल्स, 68 बाइट्स

हम मानते हैं कि सूची न्यूलाइन-अलग है और मानक इनपुट पर पारित की गई है।

(paste - <(seq 0 5 9999)|tee x|grep 0$;grep 5$<x)|cut -f1|grep -v ^$

दुर्भाग्य से यह इंडेक्स 1999 से परे किसी भी इनपुट को अनदेखा करेगा, इसलिए यह कल्पना को पूरा नहीं करता है।

यह हार्डकोड अस्थाई फ़ाइल ('x') को भी बंद कर देता है, जो समानांतर में चलने पर समस्याग्रस्त हो सकता है, और इसे बाद में नहीं हटाता है। उसके लिए माफ़ करना!

Answer 26

PHP, 78 69 बाइट्स

PHP चंक और स्लाइस कर सकती है, लेकिन इंटरलेव एरे को नहीं; जो इसे थोड़ा भारी बनाता है:

function(&$a){while($i++<count($a)>>1)$a[]=array_splice($a,$i,1)[0];}

संदर्भ से कॉल करें या इसे ऑनलाइन आज़माएं ।

---

पहला दृष्टिकोण (78 बाइट्स के लिए कार्यक्रम):

for(;++$i<$argc;)echo",",$argv[$i++];for($i=1;++$i<$argc;)echo",",$argv[$i++];

एक प्रमुख अल्पविराम छापता है; इसे निकालने के लिए [!$i]सबसे पहले डालें $argv।

दो अन्य 78 बाइट समाधान (एक अग्रणी और एक अनुगामी अल्पविराम प्रिंट करें):

for($n=$argc-2|1;++$i<$argc*2;)$i&1?print",".$argv[$i]:$argv[$n+=2]=$argv[$i];
for($n=$argc-2;++$i<$argc*2;)$i&1?print",".$argv[$i]:$argv[1|$n+=2]=$argv[$i];

ऑनलाइन चलाएं php -nr '<code>' <arguments>या उन्हें आज़माएं

Answer 27

जाप , 3 बाइट्स

ñÏu

कोशिश करो

ñÏu     :Implicit input of array
ñ       :Sort by
 Ï      :Passing the 0-based index of each through a function
  u     :  Modulo 2 of index

---

ó c

कोशिश करो

ó c     :Implicit input of array
ó       :Split into 2 arrays of every 2nd item
  c     :Flatten
        :Implicit output

Answer 28

क्लोजर / क्लोजुरस्क्रिप्ट, 52 बाइट्स

(defn f[l](flatten(map #(take-nth 2 %)[l(rest l)])))

एक ClojureScript REPL में लिखा गया है, मान्य Clojure भी होना चाहिए।

Answer 29

के, 10 बाइट्स

{x@<2!!#x}

5-बाइट पायथ उत्तर के आधार पर।

Answer 30

हासियम , 191 बाइट्स

यह एक बहुत लंबा था :(
यह args से सरणी पढ़ता है, इसलिए इस के साथ चलाएंhassium file.has 0 1 2 3 4

func main(){a=args;e,o=[]for(c=0;c<a.length;c++)if(c%2==0)e.add(a[c])else o.add(a[c])print("["+(e+o).toString().replace("{", "").replace("}", "").replace("Array", "").replace("  ", "")+"]");}

यहां परीक्षण मामले के साथ विस्तार करें और देखें