সমান-সূচকযুক্ত এবং বিজোড়-সূচকযুক্ত অংশগুলিতে একটি তালিকা পৃথক করুন


26

এই প্রশ্নের দ্বারা অনুপ্রাণিত :

এমন একটি ফাংশন (বা একটি সম্পূর্ণ প্রোগ্রাম) তৈরি করুন যা সংখ্যার একটি তালিকা গ্রহণ করে এবং তালিকাটিকে পুনরায় সাজানো থেকে আউটপুট দেয়, যাতে সমান-সূচক সংখ্যাগুলি প্রথম প্রদর্শিত হয় এবং বিজোড়-সূচকযুক্ত নম্বরগুলি অনুসরণ করে। সংখ্যার মানগুলি নিজেরাই অর্ডিংকে প্রভাবিত করে না - কেবল তাদের সূচকগুলি করে। সমস্ত সূচকগুলি শূন্য-ভিত্তিক।

উদাহরণ স্বরূপ:

ইনপুট: [0, 1, 2, 3, 4]

আউটপুট: [0, 2, 4, 1, 3]

আরেকটি উদাহরণ:

ইনপুট: [110, 22, 3330, 4444, 55555, 6]

আউটপুট: [110, 3330, 55555, 22, 4444, 6]

আপনার ভাষাতে তালিকাগুলির জন্য সবচেয়ে প্রাকৃতিক উপস্থাপনা ব্যবহার করুন Use জটিলতার কোনও সীমাবদ্ধতা নেই (যেমন একটি অস্থায়ী তালিকা বরাদ্দ করা ঠিক আছে - এটি জায়গায় জায়গায় করার দরকার নেই)।

PS এটি খালি তালিকার জন্য কাজ করা উচিত (খালি ইনপুট => খালি আউটপুট)।



আমরা কি ধরে নিতে পারি যে সমস্ত তালিকার উপাদানগুলি ইতিবাচক বা অ-নেতিবাচক বা কিছু?
মার্টিন ইন্ডার

@ মার্টিনব্যাটনার যুক্তিসঙ্গত কিছু মনে করুন, এমনকি তারা 0 ... 255 এর মধ্যে রয়েছে।
অ্যানাটলিগ


আমরা কমা-বিচ্ছিন্ন তালিকা আউটপুট করতে পারি?
অলিভার

উত্তর:



21

পাইথন, 23 বাইট

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

এটি অনলাইনে চেষ্টা করুন


1
কেন lambda? কেন নয় muবা nu? : পি
ক্রিটিক্সী লিথোস

1
আপনি আমার মন্তব্যটির শেষে ": পি" দ্বারা দেখতে পাচ্ছেন @ রাইরিং আমি কেবল রসিকতা করছি :)
ক্রিটসি লিথোস

5
হ্যাঁ, আপনি স্পষ্টভাবে প্রতিস্থাপন করা উচিত lambdaদ্বারা λএবং 5 দ্বারা বাইট গণনা কমাতে! : পি
আনাতোলিগ

3
পিএপি জমা দেওয়ার জন্য @ অ্যান্যাটোলিগ একটি ধারণা বলে মনে হচ্ছে !
নিক টি

2
@ থমাসকওয়া এটি কাজের সঠিক হাতিয়ার: পি
মেগো

16

পাইথ, ৫

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

জিনিয়াস! সুন্দর।
isaacg

অপেক্ষা করুন, এই কাজ কিভাবে?
justhalf

@ समायফাল্ট আমি আরও কিছু ব্যাখ্যা যোগ করেছি, এটি কি এটি পরিষ্কার করে দেয়?
FryAmTheEggman

11

সিজেম, 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]

9

ল্যাবরেথ , 28 25 24 23 22 বাইট

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

এই পাগল মজা ছিল! :) এটি এখন পর্যন্ত সবচেয়ে ঘন সংকীর্ণ ল্যাবরেথ প্রোগ্রাম যা আমি লিখেছি। আমার 20 এবং 21 বাইটে এমন অনেকগুলি সংস্করণ ছিল যা প্রায় কাজ করেছিল যে আমি এখনও সন্দেহ করছি এটিই সর্বোত্তম ...

এটি ইতিবাচক পূর্ণসংখ্যার (একটি স্বেচ্ছাসেবক ডিলিমিটার সহ) তালিকার হিসাবে ইনপুট নেয় এবং ফলাফলটি লাইনফিড-বিস্মৃত সংখ্যার হিসাবে প্রিন্ট করে ST

20/21 বাইটের জন্য অনুসন্ধান: আমি ফর্মের সমস্ত প্রোগ্রাম চেক করেছি

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

Xনিষ্ঠুর বাহিনী দ্বারা কোন যুক্তিসঙ্গত চরিত্র যেখানে , কিন্তু কোন কার্যকর সমাধান খুঁজে পায় নি। অবশ্যই এর অর্থ এই নয় যে একটি সংক্ষিপ্ত সমাধানের অস্তিত্ব নেই, তবে 20-বাইট প্রোগ্রামকে এর কাঠামোর উপরে শালীন পরিমাণ অনুমান ছাড়া জোর করা সম্ভব নয়।

ব্যাখ্যা

(ব্যাখ্যাটি খানিকটা পুরানো, তবে আমি এখনও সমাধানটি সর্বোত্তম নয় বলে আমি নিশ্চিত নই, তাই আমি এটি আপডেট করে অপেক্ষা করব))

সুতরাং, সাধারণত লাইব্রের্থ প্রোগ্রামগুলি ম্যাজেসের মতো দেখায়। নির্দেশ পয়েন্টারটি যখন একটি করিডরে রয়েছে, এটি সেই করিডোরটি অনুসরণ করবে। আইপি যখন কোনও ধরণের জংশনকে আঘাত করে, তখন দিকটি ল্যাবরেথের প্রধান স্ট্যাকের শীর্ষ মানের উপর ভিত্তি করে নির্ধারিত হয় (ল্যাবরেথের দুটি স্তূপ রয়েছে, নীচে একটি অসীম পরিমাণ শূন্য রয়েছে)। এর সাধারণ অর্থ হ'ল যে কোনও অ-তুচ্ছ লুপটি বেশ ব্যয়বহুল হবে, কারণ আপনার যদি সমস্ত জায়গায় নন-ওয়াল কোষ থাকে তবে সমস্ত কিছু একটি জংশন এবং বেশিরভাগ ক্ষেত্রে স্ট্যাকের শীর্ষের আইপির জন্য সঠিক মান থাকবে না because আপনি যে পথটি নিতে চান তা অবলম্বন করতে। সুতরাং আপনি যা করেন তা কি আপনি লুপগুলি প্রসারিত করুন যেগুলি কেবলমাত্র একটির সুস্পষ্ট সংজ্ঞায়িত এন্ট্রি এবং প্রস্থান পয়েন্ট সহ কেন্দ্রের পুরো অংশে রয়েছে।

তবে এবার আমি সত্যিই ভাগ্যবান এবং সবকিছু এত ভালভাবে একসাথে ফিট হচ্ছিল যে আমি এগুলি সমস্ত বড় স্ক্র্যামে স্কোয়াশ করতে পারি। :)

নিয়ন্ত্রণ প্রবাহ _দক্ষিণে চলছে। _প্রধান স্ট্যাকের সম্মুখের একটি শূন্য push কর্মের। এটি কোনও অপ-বিকল্পের মতো বলে মনে হতে পারে তবে এটি 1আমাদের পরে প্রয়োজন এমন (অব্যক্ত) স্ট্যাকের গভীরতা বৃদ্ধি করে ।

?STDIN থেকে একটি পূর্ণসংখ্যা পড়ে। যদি পড়ার মতো আর কোনও পূর্ণসংখ্যা না থাকে তবে এটি শূন্যের দিকে ঠেলে দেয়। সেক্ষেত্রে আইপি দক্ষিণে অগ্রসর হয় এবং এই @মুহুর্তে প্রোগ্রামটি বন্ধ করে দেয় (কারণ ইনপুট তালিকাটি খালি)। অন্যথায়, আইপি পূর্ব দিকে পরিণত হয়।

আমরা এখন দুটি বহির্গমন পয়েন্ট সহ একটি খুব টান লুপ প্রবেশ করছি:

 !?;
 \?
  ;

!স্ট্যাকের উপরে কেবল একটি শূন্য রেখে, পূর্ণসংখ্যাটি STDOUT এ ফিরে যায়। আইপি পূর্ব দিকে অগ্রসর হয়, এবং ?পরবর্তী পূর্ণসংখ্যা পড়ে। যদি তা শূন্য হয় না, তবে আমরা একটি ডান নিয়ে দক্ষিণে চলে যাই। ?অন্য একটি পড়ে (পরের এমনকি সূচক)। আবার, যদি তা শূন্য হয় তবে আমরা একটি ডান নিয়ে পশ্চিম দিকে চলে যাই।

তারপরে \স্ট্যাকটি পরিবর্তন না করেই একটি লাইনফিড মুদ্রণ করে, সুতরাং আমরা উত্তরে অন্যদিকে চলে যাব। !প্রিন্ট করে যে পরের সম-সূচক পূর্ণসংখ্যার। যেহেতু এখন স্ট্যাকের মধ্যে কমপক্ষে একটি (ধনাত্মক) বিজোড়-সূচক পূর্ণসংখ্যা রয়েছে, তাই আমরা ডানদিকে ঘুরতে থাকি এবং লুপটি পুনরাবৃত্তি করে।

এইগুলির মধ্যে একবারে ?তালিকার শেষে হিট হয়ে গেলে তারা একটি শূন্যকে ধাক্কা দেয় এবং সরাসরি সম্পর্কিত দিকে চলে যায় ;, যা সেই শূন্যটিকে ছাড়িয়ে যায়।

তালিকায় কেবলমাত্র একটি একক উপাদান ছিল সে ক্ষেত্রে, আমরা সম্পন্ন করেছি (কারণ আমরা এখনই এটি প্রিন্ট করেছি), তাই আইপি পূর্বদিকে পুরোদিকে চলে যেতে থাকবে @, আবার প্রোগ্রামটি সমাপ্ত করে (একটি ট্রেলিং মুদ্রণ করা) পথে লাইনফিড)।

অন্যথায়, আমাদের পাশাপাশি বিজোড়-সূচক পূর্ণসংখ্যার মুদ্রণ করা দরকার। সেক্ষেত্রে দুটি পাথ (প্রথম লুপের দুটি প্রস্থান পয়েন্ট থেকে) মাঝখানে মিশে যায় ", উভয় ক্ষেত্রেই পূর্ব দিকে ঘুরে যায়।

_একটি বাম দিকে রোধ করতে এড়াতে শূন্যের দিকে ঠেলে দেয় @এবং সেই ;শূন্যটিকে ছাড় দেয়। এখন আমরা একটি নতুন লুপ লিখুন:

     "}
     ""

আইপি ঘড়ির কাঁটার দিক দিয়ে লুপের চারদিকে ঘুরে উত্তর দিকে চলে যাওয়া নীচে-বাম কক্ষে এটি প্রবেশ করে। }অক্জিলিয়ারী স্ট্যাকের উপর প্রধান স্ট্যাকের উপরে জনতার। স্ট্যাকের মধ্যে এখনও একটি উপাদান রয়েছে, আইপি তার জিনিসটি চালিয়ে যাচ্ছে। সবসময় সহায়ক স্ট্যাকে স্থানান্তরিত হয়ে যায় (এবং প্রক্রিয়াটিতে বিপরীত হয়), আইপি তার পরিবর্তে পূর্বদিকে চলে যায়, শেষ লুপটিতে প্রবেশ করে:

       \{@
       #!

\আবার একটি লাইনফিড মুদ্রণ করে, {সহায়ক স্ট্যাক থেকে একটি আইটেমকে প্রধানতে নিয়ে যায়। যদি এটি এখনও তালিকার কোনও আইটেম ছিল তবে এটি ইতিবাচক হবে এবং আইপিটি দক্ষিণে পরিণত হয় যেখানে আইটেমটি মুদ্রিত হয় !। তারপর #স্ট্যাকের গভীরতা পাহাড় জমে (এবং এখন এই যেখানে প্রাথমিক হয় _গুরুত্বপূর্ণ কারণ এই, #একটি ইতিবাচক স্ট্যাক গভীরতা নিশ্চিত করে), যাতে আইপি এখনো মাধ্যমে ঠিক দেখা যাচ্ছে, \এবং {আবার।

আমরা সমস্ত মুদ্রণ করার পরে, {সহায়ক স্ট্যাকের নীচে থেকে একটি শূন্য টানুন, আইপি পূর্বদিকে চালিয়ে @যায় এবং প্রোগ্রামটি সমাপ্ত করে।


8

ম্যাটল্যাব, ২৪

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

পাইথনের মতোই।

2 লাইট সংরক্ষণের জন্য লুইস মেন্ডোকে ধন্যবাদ!


1
হে! আপনাকে পিপিসিজিতে দেখে ভাল লাগল!
লুইস মেন্ডো

3
একটু খাটো:@(x)x([1:2:end 2:2:end])
লুইস মেন্ডো

@ লুইসমেডো হাহা আমি কোডগল্ফ থেকে কিছুটা ভয় পেয়েছি, তবে এটি ম্যাটল্যাবের পক্ষে খুব সহজ ছিল! টিপটির জন্য ধন্যবাদ;)
ব্রেইন গাইড

6

হাস্কেল , 37 বাইট

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

এটি অনলাইন চেষ্টা করুন!

foldrযাও recursively এমনকি তালিকা এবং বিজোড় তালিকা তৈরী করে। তালিকায় একটি উপাদান প্রস্তুত করা তা বিজোড় তালিকায় প্রিপেন্ড করে এবং এটিটিকে নতুন এমনকি তালিকায় কল করে এবং পূর্ববর্তী এমনকি তালিকাকে নতুন বিজোড় তালিকায় কল করে আপডেট করা হয়। তারপরে, জুটিটি [l,r]সংমিশ্রিত হয় l++r

টিউপসগুলির স্থলে দ্বি-উপাদানগুলির তালিকা ব্যবহার করে 5 বাইট সংরক্ষণ করার জন্য Ørjan জোহানসেনকে ধন্যবাদ।


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 এর জন্য The ফাংশনটি gপ্রতিটি সম-সূচক উপাদান নেয় takes বিজোড় সূচকগুলি প্রথমে একটি উপাদানটি ফেলে রেখে প্রয়োগ করা হয় g। যদি lখালি-খালি নিশ্চিত করা হয়, তবে আমরা নিরাপদে কেবল tail41 টির জন্য করতে পারি

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

1
এখনও অন্য বৈকল্পিক (39 বাইট): l#(a:b:c)=a:(l++[b])#c;l#x=x++l;f=([]#)সঙ্গে fপ্রধান ফাংশন হচ্ছে।
নিমি

@ নিমি এটি দুর্দান্ত সমাধান, আপনার এটি পোস্ট করা উচিত।
xnor

না, দয়া করে এটি আপনার পোস্টে অন্তর্ভুক্ত করুন। এটি আপনার # 2 এবং # 3 এর সংমিশ্রণ মাত্র।
নিমি

1
তালিকাগুলি ব্যবহার করে এবং concatটিপলস এবং এর পরিবর্তে আপনি আপনার দ্বিতীয় সংস্করণে 5 বাইট সংরক্ষণ করতে পারেন uncurry(++)
janrjan জোহানসেন

5

পাওয়ারশেল ভি 3 +, 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]প্রথম আউটপুট পায়।

গল্ফিং সহায়তা এবং এই পরিবর্তনের জন্য টেসেলেলটিংহেকলারের কাছে প্রপস ।
-2 বাইট মজির ধন্যবাদ।


আদেশ সহকারে

প্রশ্নটি লিখিতভাবে কঠোরভাবে যাচ্ছেন, এটি প্রযুক্তিগতভাবে অবৈধ, কারণ পাওয়ারশেলের সিউডো-অবিচ্ছেদ্য বস্তু হিসাবে কেবল "তালিকা" তৈরি করার ধারণা নেই, কেবল অ্যারে বা হ্যাশ টেবিল (ওরফে অভিধান)। সুতরাং, আমি প্রশ্নের লাইনটি চিকিত্সা করছি " আপনার ভাষায় যে তালিকা রয়েছে তার জন্য সর্বাধিক প্রাকৃতিক উপস্থাপনা ব্যবহার করুন " যেমন অ্যারে সম্পর্কে জিজ্ঞাসা করা হচ্ছে, এটি পাওয়ারশেলের কাছে নিকটতম। অতিরিক্তভাবে, আউটপুট প্রতি লাইন প্রতি একটি উপাদান, যেহেতু এটি অ্যারে লেখার জন্য ডিফল্ট পাওয়ারশেল উপায়। এর অর্থ (0,1,2,3,4)উইল আউটপুট এর একটি ইনপুট 0\r\n2\r\n4\r\n1\r\n3\r\n


47 বাইট - এর $argsপরিবর্তে $inputএবং ,@()*2পরিবর্তে @(),@()
স্প্ল্যাটিং

4

এফ #, 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 দিয়ে অঙ্কিত
That যা আমাদের জোড়া তালিকার একটি জোড়া দেয়; প্রথম তালিকায় সমস্ত সূচিকর্মী সন্ধ্যায় এবং অন্যান্য সূচিকৃত প্রতিক্রিয়া থাকবে।
এটি থেকে আমরা অ্যাপেন্ড অপারেটরের সাথে দুটি তালিকা পুনরায় সংশ্লেষ করি এবং শেষ পর্যন্ত সূচিটি বাতিল করে দিন।

সম্পাদনা: একটি স্পষ্টতাকে মিস করেছেন, আরগের "xs" (অভ্যাস) নাম রাখার দরকার নেই তাই 1-অক্ষরের নাম হ্রাস করতে পারে


আমারও একটি সম্ভাব্য 76 বাইট রয়েছে যা মূলত একই তবে ফাংশন কম্পোজিশন হিসাবে সংজ্ঞায়িত। সমস্যাটি হ'ল এটি কোনও মান হিসাবে সংকলন করে না তবে কার্যকরভাবে কোনও তালিকা যুক্তির সাথে কার্যকরভাবে কাজ করবে যদি তা ঠিক থাকে না তবে নিশ্চিত নয়:

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

দ্রষ্টব্য: এমএসডিএন-তে এখনও নথিভুক্ত না হওয়া সত্ত্বেও list.indexed কেবল F # 4.0 থেকে উপলব্ধ


কাটিং-এজ প্রযুক্তি, দুর্দান্ত!
অ্যানাটলিগ

1
@ এনাটলিগ fun, তাই না?
কনর ও'ব্রায়েন

আমি মনে করি এটি পার্ল 6 কোডের মতো যা আমি প্রথমে চেষ্টা করেছি। -> \xs { xs.pairs.classify( *.key%%2, :as( *.value ) ).map( *.value.Slip ) }ধরে নেওয়া যাক |>এফ # প্রায় দক্ষিণমুখে ফিড অপারেটর সমতূল্য ==>পার্ল 6. আমি একমাত্র কি হিসেবে অনুমান করছি fst>>(&&&)1>>(=)0না
ব্র্যাড গিলবার্ট b2gills

4

জাভাস্ক্রিপ্ট (ES6), 52 বাইট

এটি এক পাসেও করে

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


আপনি F=শুরু থেকে বাদ দিতে পারেন ; আপনি এটি ব্যবহার করে একটি বাইট সংরক্ষণ করতে পারেন:(i*=2)>=(z=x.length)?i-z+--z%2:i
কনর ও'ব্রায়েন

@ CᴏɴᴏʀO'Bʀɪᴇɴ চমৎকার ধারণা ধন্যবাদ!
জর্জ রিথ


3

জে, 8 বাইট

/:0 1$~#

এটি একটি monadic (এক-যুক্তি) ক্রিয়া, নিম্নলিখিত হিসাবে ব্যবহৃত:

  (/: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

1
একটি বিকল্প /:0:`1:\যা 8 বাইট হয়।
মাইল

3

জেলি , 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]

2

গণিত, 40 বাইট

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

{}[[2;;;;2]] একটি ত্রুটি নিক্ষেপ করবে।


2

বার্লেস্ক, 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

যদিও নতুন আপডেট প্রকাশিত হওয়ার পরে আপনি এটি নতুন আনমার্ট বিল্ট-ইন (যা অন্তর্নির্মিত বিল্ট-ইন এর বিপরীতে **করে) দিয়ে এটি করতে পারেন:

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

2

পার্ল, 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 এর মধ্যে decremented, তার মান টগল করে।

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

প্রতীকী ডেরেফারেন্সিংয়ের মাধ্যমে নির্দিষ্ট করা শনাক্তকারীদের উপর কোনও বিধিনিষেধ নেই এই সুযোগটি গ্রহণ করে আমরা পর্যায়ক্রমে অ্যারে উপাদানগুলিকে @0এবং @1অ্যারেগুলিতে চাপিয়ে দেই , সুতরাং @0সমস্ত সম-সূচক উপাদানগুলি এবং @1প্রতিকূলতার সাথে শেষ হয়। তারপরে আমরা কেবল আমাদের আউটপুট পেতে স্ট্রিংযুক্ত অ্যারেগুলি সংযুক্ত করে থাকি।


2

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


1

Vitsy, 22 বাইট

ভিট্টি সত্যিই এটি করার জন্য তৈরি করা হয়নি ...

r '' ভিএল 2 / \ [এন {ভিও] এল \ [এনভিও]
অন্তর্নিহিত সংখ্যাযুক্ত ইনপুট স্ট্যাকটি বিপরীত করুন।
 '' ভি বিশ্বব্যাপী চূড়ান্ত পরিবর্তনশীল হিসাবে "স্থান" অক্ষর সংরক্ষণ করুন।
     l2 / \ [....] বন্ধনীগুলিতে ইনপুটটির দৈর্ঘ্যটি পুনরাবৃত্তি করুন
                        স্ট্যাক 2 দ্বারা বিভক্ত।
          N {VO একটি সংখ্যা হিসাবে স্ট্যাকের শীর্ষ আইটেম আউটপুট করুন, তারপরে শিফট করুন
                        বাম দিকে একবার স্ট্যাক, একটি স্থান ধাক্কা, এটি আউটপুট।
               l \ [...] বাকী স্ট্যাকের জন্য, এটি বহুবার পুনরাবৃত্তি করুন ...
                  NVO স্ট্যাকের শীর্ষস্থানীয় আইটেমটিকে পৃথক করে একটি সংখ্যা হিসাবে আউটপুট দেয় 
                        একটি স্থান দ্বারা

1

পার্ল 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␤

1

মিনকোলং 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.

1

আর, 49 বাইট

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

এটিকে q (blah) হিসাবে ডেকে আনুন। অথবা, যদি x এর মধ্যে ইতিমধ্যে তালিকাটি পুনরায় সাজানো থাকে তবে তা

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

মাত্র 35 বাইট।


1

এফ #, 64

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

সেহেনসুচের জবাব থেকে অনুপ্রাণিত (তবে মন্তব্য করার মতো যথেষ্ট প্রতিনিধি নয়)।

প্রতিটি মানকে এমন একটি দ্বিখণ্ডিত মানচিত্র যেখানে দ্বিতীয় এন্ট্রি তালিকার সূচকের মডুলো হয়, মডিউল অনুসারে বাছাই করে মূল মানটিতে ফিরে আসে।


1

প্রোলোগ, 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]

1

বাশ এবং জিএনইউ কোর্টিল, 68 বাইট

আমরা ধরে নিই যে তালিকাটি নতুন লাইন দ্বারা পৃথক এবং স্ট্যান্ডার্ড ইনপুট এ গেছে।

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

দুর্ভাগ্যক্রমে এটি সূচী 1999 এর বাইরে থাকা কোনও ইনপুট উপেক্ষা করবে, সুতরাং এটি যথেষ্ট অনুমানের সাথে মিলবে না।

এটি একটি হার্ডকডযুক্ত অস্থায়ী ফাইল ('x') ক্লোবারও করে, যা সমান্তরালভাবে চালিত হলে সমস্যা হতে পারে এবং এটি পরে এটি সরাবে না। এর জন্যে দুঃখিত!


1

পিএইচপি, 78 69 বাইট

পিএইচপি হ্রাস এবং টুকরো টুকরো করতে পারে, তবে ইন্টারলিভ অ্যারেগুলিতে নয়; এটি এটিকে কিছুটা বিশাল করে তোলে:

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

রেফারেন্স দিয়ে কল করুন বা এটি অনলাইনে চেষ্টা করুন


প্রথম পদ্ধতির (by 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>বা অনলাইনে চেষ্টা করুন



0

ক্লোজার / ক্লোজার স্ক্রিপ্ট, 52 বাইট

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

ক্লোজারস্ক্রিপ্ট আরপিএলে লিখিত, বৈধ Clojure হওয়া উচিত।


0

কে, 10 বাইট

{x@<2!!#x}

5 বাইট পাইথ উত্তরের উপর ভিত্তি করে।


0

হাসিয়াম , 191 বাইট

এটি বেশ দীর্ঘ ছিল :(
এটি আরোগুলি থেকে অ্যারেটি পড়ে, তাই এটি দিয়ে চালান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("  ", "")+"]");}

চালান এবং পরীক্ষা ক্ষেত্রে প্রসারিত দেখুন এখানে

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.