ได้รับแรงบันดาลใจจากคำถามนี้ :

ทำให้ฟังก์ชั่น (หรือโปรแกรมเต็มรูปแบบ) ที่ได้รับรายการของตัวเลขและเอาท์พุทรายการที่จัดเรียงใหม่ดังนั้นตัวเลขที่จัดทำดัชนีแม้ปรากฏขึ้นก่อนและหมายเลขคี่ทำดัชนีตามมา ค่าของตัวเลขนั้นไม่มีผลต่อการสั่งซื้อ - เฉพาะดัชนีของพวกเขาเท่านั้น ดัชนีทั้งหมดเป็นศูนย์

ตัวอย่างเช่น:

การป้อนข้อมูล: [0, 1, 2, 3, 4]

เอาท์พุท: [0, 2, 4, 1, 3]

ตัวอย่างอื่น:

การป้อนข้อมูล: [110, 22, 3330, 4444, 55555, 6]

เอาท์พุท: [110, 3330, 55555, 22, 4444, 6]

ใช้การนำเสนอที่เป็นธรรมชาติที่สุดสำหรับรายการที่ภาษาของคุณมี ไม่มีข้อ จำกัด ด้านความซับซ้อน (เช่นการจัดสรรรายการชั่วคราวก็โอเค - ไม่จำเป็นต้องทำแทน)

PS มันควรจะทำงานกับรายการที่ว่างเปล่า (ว่างเปล่า = => การส่งออกที่ว่างเปล่า)

Japt 1 ไบต์

ó

ลองออนไลน์!

Python ขนาด 23 ไบต์

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

ลองออนไลน์

Pyth, 5

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

CJam, 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]

เขาวงกต , 28 25 24 23 22 ไบต์

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

สนุกมาก! :) นั่นคือโปรแกรมเขาวงกตที่ถูกบีบอัดหนาแน่นที่สุดเท่าที่ฉันเคยเขียนมา ฉันมีหลายเวอร์ชันที่ 20 และ 21 ไบต์ซึ่งเกือบจะใช้ได้ว่าฉันยังสงสัยว่ามันดีที่สุด ...

นี้จะเข้าเป็นรายการของบวกจำนวนเต็ม (ด้วยการคั่นพล) และพิมพ์ผลให้ STDOUT เป็นจำนวนเต็มเลื่อนบรรทัดที่คั่น

กำลังตามล่าสำหรับ 20/21 ไบต์:ฉันได้ตรวจสอบโปรแกรมทั้งหมดของแบบฟอร์มแล้ว

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

Xตัวละครที่สมเหตุสมผลอยู่ที่ไหนโดยใช้กำลังดุร้าย แต่ไม่พบวิธีแก้ไขปัญหาที่ถูกต้อง แน่นอนว่านั่นไม่ได้หมายความว่าจะไม่มีทางออกที่สั้นกว่า แต่ก็เป็นไปไม่ได้ที่จะบังคับให้โปรแกรมขนาด 20 ไบต์โดยไม่มีข้อสันนิษฐานในโครงสร้างที่เหมาะสม

คำอธิบาย

(คำอธิบายนั้นล้าสมัยเล็กน้อย แต่ฉันก็ยังไม่มั่นใจว่าวิธีแก้ปัญหานั้นดีที่สุดดังนั้นฉันจะรอการอัปเดตนี้)

ดังนั้นโดยปกติโปรแกรมเขาวงกตควรจะดูเหมือนเขาวงกต ในขณะที่ตัวชี้คำแนะนำอยู่ในทางเดินมันจะทำตามทางเดินนั้น เมื่อ IP ชนกับทางแยกชนิดใดทิศทางจะถูกกำหนดตามค่าสูงสุดของสแต็กหลักของเขาวงกต (เขาวงกตมีสองสแต็คโดยมีเลขศูนย์เป็นศูนย์ที่ด้านล่าง) นั่นหมายความว่าโดยปกติแล้วการวนซ้ำที่ไม่สำคัญจะมีราคาค่อนข้างแพงเพราะถ้าคุณมีเซลล์ที่ไม่ติดผนังทั่วทุกที่ทุกอย่างจะเป็นจุดเชื่อมต่อและในกรณีส่วนใหญ่ด้านบนของสแต็กจะไม่มีค่าที่เหมาะสมสำหรับ IP เพื่อไปตามเส้นทางที่คุณต้องการ ดังนั้นสิ่งที่คุณทำคือคุณขยายลูปให้มากขึ้นโดยที่พวกเขามีทั้งหมดอยู่ตรงกลางโดยมีจุดเข้าและทางออกที่กำหนดไว้เพียงจุดเดียวเท่านั้น

แต่ครั้งนี้ฉันโชคดีจริง ๆ และทุกอย่างลงตัวเข้าด้วยกันอย่างลงตัวฉันสามารถบีบมันทั้งหมดออกเป็นกลุ่มก้อนใหญ่ :)

การควบคุมการไหลเริ่มต้นที่ทาง_ใต้ การ_กดศูนย์ลงบนสแต็กหลัก ที่อาจดูเหมือนไม่มี op แต่สิ่งนี้จะเพิ่มความลึกของสแต็ก (ไม่แน่นอน) 1ที่เราต้องการในภายหลัง

?อ่านจำนวนเต็มจาก STDIN หากไม่มีจำนวนเต็มที่จะอ่านค่านี้จะส่งค่าศูนย์ ในกรณีดังกล่าว IP จะเคลื่อนที่ไปทางใต้และ@ยุติโปรแกรมทันที (เนื่องจากรายการอินพุตว่างเปล่า) มิฉะนั้น IP จะเปลี่ยนเป็นตะวันออก

ตอนนี้เรากำลังเข้าสู่วงวนที่แน่นมากด้วยสองจุดออก:

 !?;
 \?
  ;

!พิมพ์จำนวนเต็มกลับไปที่ STDOUT โดยเหลือเพียงศูนย์บนสแต็ก IP เคลื่อนไปทางตะวันออกเรื่อย ๆ และ?อ่านจำนวนเต็มถัดไป หากนั่นไม่ใช่ศูนย์เราจะเลี้ยวขวาและเคลื่อนไปทางใต้ ?อ่านอีกอันหนึ่ง (ดัชนีคู่ถัดไป) อีกครั้งถ้านั่นไม่ใช่ศูนย์เราเลี้ยวขวาแล้วเคลื่อนที่ไปทางตะวันตก

จากนั้น\พิมพ์ตัวป้อนบรรทัดโดยไม่เปลี่ยนสแต็กดังนั้นเราจึงเลี้ยวขวาอีกทิศ !พิมพ์จำนวนเต็มคู่ดัชนีถัดไป เนื่องจากขณะนี้มีเลขคี่ดัชนีอย่างน้อยหนึ่งค่า (บวก) บนสแต็กเราจะเลี้ยวขวาและวนซ้ำ

เมื่อทั้งสองรายการ?เข้ามาถึงจุดสิ้นสุดของรายการพวกเขาจะผลักศูนย์และย้ายตรงไปยังรายการที่ตรงกัน;ซึ่งจะละทิ้งศูนย์นั้น

ในกรณีที่มีเพียงองค์ประกอบเดียวในรายการเราทำเสร็จแล้ว (เพราะเราพิมพ์ออกมาทันที) ดังนั้น IP จะย้ายไปทางตะวันออกเรื่อยไปจนถึง@สิ้นสุดโปรแกรมอีกครั้ง (พิมพ์ต่อท้าย linefeed ระหว่างทาง)

มิฉะนั้นเราจะต้องพิมพ์จำนวนเต็มคี่ดัชนีเช่นกัน ในกรณีนั้นทั้งสองเส้นทาง (จากจุดทางออกที่สองของลูปแรก) จะรวมกันที่กึ่งกลาง"โดยเปลี่ยนทิศตะวันออกเป็นกรณีใดกรณีหนึ่ง

_ดันศูนย์เพื่อหลีกเลี่ยงการทิ้งให้เข้า@และ;ทิ้งศูนย์นั้น ตอนนี้เราเข้าสู่วงใหม่:

     "}
     ""

IP เข้าสู่สิ่งนี้บนเซลล์ด้านล่างซ้ายเคลื่อนไปทางเหนือวิ่งวนไปวนมาตามเข็มนาฬิกา }กะด้านบนของกองหลักไปยังกองเสริม ในขณะที่ยังมีองค์ประกอบอยู่ในสแต็ค แต่ IP ก็ยังคงทำหน้าที่อยู่ เมื่อทุกอย่างเปลี่ยนไปเป็นสแต็คเสริม (และย้อนกลับในกระบวนการ) IP ก็จะเคลื่อนที่ไปทางตะวันออกแทนเข้าสู่วงสุดท้าย:

       \{@
       #!

\พิมพ์ linefeed อีกครั้ง{ย้ายรายการจากสแต็คเสริมกลับไปที่หลัก หากยังคงเป็นรายการของรายการก็จะเป็นบวกและ IP !เปลี่ยนภาคใต้ที่รายการที่จะพิมพ์ด้วย จากนั้นจึง#ผลักความลึกของสแต็ก (และตอนนี้นี่เป็นจุดเริ่มต้นที่_สำคัญเนื่องจากเป็นการ#รับรองความลึกของสแต็กในเชิงบวก) เพื่อให้ IP ยังคงเลี้ยวขวาผ่าน\และ{อีกครั้ง

หลังจากที่เราพิมพ์ทุกอย่างให้{ดึงศูนย์จากด้านล่างของสแต็คเสริม IP ดำเนินการต่อไปทางตะวันออกและ@ยกเลิกโปรแกรม

MATLAB, 24

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

คล้ายกับงูหลามหนึ่ง

ขอบคุณ @LuisMendo สำหรับการบันทึก 2 ไบต์!

Haskell , 37 ไบต์

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

ลองออนไลน์!

การfoldrสร้างรายการแบบคู่ซ้ำและรายการคี่ การเตรียมองค์ประกอบให้กับรายการนั้นได้รับการอัปเดตโดยการเพิ่มไปที่รายการคี่และเรียกมันว่ารายการคู่ใหม่และเรียกก่อนหน้านี้แม้กระทั่งรายการรายการคี่ใหม่ จากนั้นทั้งคู่[l,r]ก็ตกลงl++rกันที่

ขอบคุณØrjan Johansen สำหรับการบันทึก 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)

PowerShell v3 +, 75 67 49 47 ไบต์

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

ลองออนไลน์!

คาดว่าจะมีการป้อนข้อมูลผ่านการกระจายดังที่แสดงในลิงก์ TIO

สร้างเมทริกซ์$lเป็นอาร์เรย์ของอาร์เรย์แล้วท่อป้อนข้อมูลลงในวง$args |%{}แต่ละครั้งที่ผ่านลูปเราจะเพิ่มอิลิเมนต์หนึ่งในสองอาร์เรย์ชายด์ของการ$lพลิก$fตัวแปรโดยใช้บูลีนลอจิก ผ่านครั้งแรก$fเป็น$nullที่!ซึ่งเป็น$trueหรือ1เมื่อการจัดทำดัชนีเป็นอาร์เรย์ นี่หมายความว่าองค์ประกอบแรกจะถูกใส่เข้าไปในอาร์เรย์ที่สองของ$lดังนั้นจึง$l[1]ได้รับการส่งออกก่อน

อุปกรณ์ประกอบฉากเพื่อTessellatingHecklerสำหรับความช่วยเหลือการเล่นกอล์ฟและรูปแบบนี้
-2 ไบต์ต้องขอบคุณ

คำเตือน

การทำตามคำถามอย่างเคร่งครัดนี่เป็นเทคนิคที่ไม่ถูกต้องเนื่องจาก PowerShell ไม่มีแนวคิดของ "รายการ" ในฐานะที่เป็นวัตถุที่ไม่เปลี่ยนรูปแบบเทียมโดยใช้อาร์เรย์หรือตารางแฮชเท่านั้น (อาคาพจนานุกรม) ดังนั้นฉันจึงรักษาบรรทัดคำถามนั้น " ใช้การแสดงที่เป็นธรรมชาติที่สุดสำหรับรายการที่ภาษาของคุณมี " เป็นการถามเกี่ยวกับอาร์เรย์เนื่องจาก PowerShell ที่ใกล้เคียงที่สุดมี นอกจากนี้เอาต์พุตเป็นหนึ่งองค์ประกอบต่อบรรทัดเนื่องจากเป็นวิธี PowerShell เริ่มต้นในการเขียนอาร์เรย์ ซึ่งหมายความว่าการป้อนข้อมูลของส่งออกจะ(0,1,2,3,4)0\r\n2\r\n4\r\n1\r\n3\r\n

F #, 79 77 56

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

ตามหนึ่งในคำตอบของ Haskell

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

เราสร้างดัชนีรายการก่อนแล้วจึงแบ่งพาร์ติชั่นด้วยเงื่อนไข: ไอเท็มแรก (ดัชนี) และหารด้วย 1 เท่ากับ 0
นั่นทำให้เรามีคู่ของรายการคู่ รายการแรกจะมีการจัดทำดัชนีทั้งหมดและอื่น ๆ อัตราต่อรองที่จัดทำดัชนี
จากนั้นเรารวมสองรายการอีกครั้งด้วยตัวดำเนินการผนวกและสุดท้ายทิ้งดัชนี

แก้ไข: พลาดสิ่งที่เห็นได้ชัดโดยไม่จำเป็นต้องตั้งชื่อ arg "xs" (นิสัย) ดังนั้นสามารถลดเป็นชื่อ 1 ตัวอักษร

ฉันยังมีความเป็นไปได้ที่ 76 ไบต์ซึ่งโดยพื้นฐานแล้วจะเหมือนกัน แต่ถูกกำหนดเป็นองค์ประกอบของฟังก์ชั่น ปัญหาคือมันไม่ได้รวบรวมเป็นค่าแต่จะทำงานได้อย่างมีประสิทธิภาพกับอาร์กิวเมนต์รายการใด ๆ ที่ได้รับดังนั้นไม่แน่ใจว่ามันตกลงหรือไม่:

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

หมายเหตุ: List.indexed มีให้เฉพาะจาก F # 4.0 แม้ว่าจะยังไม่มีการบันทึกใน MSDN

JavaScript (ES6), 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>

Julia, 23 ไบต์

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

J, 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

เยลลี่ขนาด 4 ไบต์

s2ZF

ลองออนไลน์!

ตามคำตอบ CJamของ Martin

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]

Mathematica ขนาด 40 ไบต์

#[[;;;;2]]~Join~If[#=={},#,#[[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

แม้ว่าเมื่อมีการปล่อยการอัปเดตใหม่คุณสามารถทำได้ด้วย Unmergeในตัว (ซึ่งจะตรงกันข้ามกับการผสาน**ในตัว):

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

Perl, 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'

(ต้องใช้ Perl 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มีการจัดทำดัชนีและอัตราต่อรอง จากนั้นเราก็เชื่อมต่ออาร์เรย์ที่ผ่านการทำให้เป็นสตริงเพื่อให้ได้ผลลัพธ์ของเรา

C, 70

ไม่มีอะไรพิเศษเพียงฟังก์ชั่นการทำดัชนีดัชนี

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

น้อย golfed

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

Pyth, 8 ไบต์

+%2Q%2tQ

ค่อนข้างง่าย

Vitsy, 22 ไบต์

Vitsy จริงๆไม่ได้ทำจะทำเช่นนี้ ...

r '' Vl2 / \ [N {VO] l \ [NVO]
r ย้อนกลับสแต็กอินพุตตัวเลขโดยนัย
 '' V บันทึกอักขระ "space" เป็นตัวแปรสุดท้ายระดับโลก
     l2 / \ [.... ] ทำซ้ำสิ่งต่าง ๆ ในวงเล็บความยาวของอินพุต
                        สแต็กหารด้วย 2
          N {VO ส่งออกรายการด้านบนของสแต็กเป็นตัวเลขจากนั้นเลื่อน
                        สแต็คมากกว่าหนึ่งครั้งไปทางซ้ายดันพื้นที่ส่งออก
               l \ [... ] สำหรับสแต็กที่เหลือให้ทำซ้ำหลาย ๆ ครั้ง ...
                  NVO เอาท์พุทรายการด้านบนของสแต็กเป็นตัวเลขคั่นด้วย 
                        โดยช่องว่าง

Perl 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␤

Minkolang 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.

R, 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 ไบต์

F #, 64

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

แรงบันดาลใจจากคำตอบของ Sehnsucht (แต่ตัวแทนไม่เพียงพอที่จะแสดงความคิดเห็น)

แม็พแต่ละค่ากับ tuple โดยที่รายการที่สองคือโมดูโลของดัชนีรายการเรียงตามโมดูโลจากนั้นแมปกลับไปที่ค่าดั้งเดิม

Prolog, 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]

bash และ GNU coreutils, 68 ไบต์

เราคิดว่ารายการนั้นมีการขึ้นบรรทัดใหม่และคั่นด้วยอินพุตมาตรฐาน

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

น่าเสียดายที่สิ่งนี้จะไม่สนใจอินพุตใด ๆ ที่นอกเหนือจากดัชนีปี 1999 ดังนั้นจึงไม่ค่อยตรงตามข้อกำหนด

นอกจากนี้ยังอุดตันไฟล์ชั่วคราวแบบฮาร์ดโค้ด ('x') ซึ่งอาจมีปัญหาหากใช้งานแบบขนานและจะไม่ลบออกในภายหลัง ขอโทษสำหรับเรื่องนั้น!

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>หรือลองพวกเขาออนไลน์

Japt , 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

Clojure / ClojureScript, 52 ไบต์

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

เขียนใน ClojureScript REPL ก็ควรเป็น Clojure ที่ถูกต้อง

K, 10 ไบต์

{x@<2!!#x}

อ้างอิงจากคำตอบ Pyth 5 ไบต์

Hassium , 191 Bytes

อันนี้ค่อนข้างยาว :(
มันอ่านอาเรย์จาก 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("  ", "")+"]");}

เรียกใช้และดูแบบขยายด้วยกรณีทดสอบที่นี่