Terinspirasi oleh pertanyaan ini :

Buat fungsi (atau program lengkap) yang menerima daftar angka dan output daftar disusun ulang, sehingga nomor genap diindeks muncul terlebih dahulu, dan nomor diindeks ganjil mengikuti. Nilai angka-angka itu sendiri tidak mempengaruhi pemesanan - hanya indeks mereka yang melakukannya. Semua indeks berbasis nol.

Sebagai contoh:

Memasukkan: [0, 1, 2, 3, 4]

Keluaran: [0, 2, 4, 1, 3]

Contoh lain:

Memasukkan: [110, 22, 3330, 4444, 55555, 6]

Keluaran: [110, 3330, 55555, 22, 4444, 6]

Gunakan sebagian besar representasi alami untuk daftar yang dimiliki bahasa Anda. Tidak ada batasan kompleksitas (mis. Mengalokasikan daftar sementara tidak masalah - tidak perlu melakukannya di tempat).

PS Ini harus bekerja untuk daftar kosong (input kosong => output kosong).

Japt , 1 byte

ó

Cobalah online!

Python, 23 byte

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

Cobalah online

Pyth, 5

o~!ZQ

Cobalah online , atau jalankan Test Suite

Penjelasan

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 byte

{2/ze_}

Menekan blok (hal terdekat ke fungsi yang tidak disebutkan namanya) yang mengubah elemen tumpukan atas sesuai kebutuhan.

Uji di sini.

Penjelasan

Penjelasan mengasumsikan bahwa bagian atas tumpukan adalah array [0 1 2 3 4]. Nilai aktual tidak memengaruhi perhitungan.

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]

Labyrinth , 28 25 24 23 22 byte

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

Ini sangat menyenangkan! :) Itu adalah program Labirin yang paling padat yang saya tulis sejauh ini. Saya memiliki begitu banyak versi pada 20 dan 21 byte yang hampir berfungsi sehingga saya masih meragukan ini optimal ...

Ini mengambil input sebagai daftar bilangan bulat positif (dengan pembatas arbitrer), dan mencetak hasilnya ke STDOUT sebagai bilangan bulat yang dibatasi linefeed.

Perburuan untuk 20/21 byte: Saya telah memeriksa semua program formulir

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

di mana Xada karakter yang masuk akal dengan kekerasan, tetapi tidak menemukan solusi yang valid Tentu saja itu tidak berarti bahwa solusi yang lebih pendek tidak ada, tetapi itu tidak mungkin untuk memaksa program 20-byte tanpa jumlah asumsi yang layak pada strukturnya.

Penjelasan

(Penjelasannya agak ketinggalan jaman, tapi saya masih tidak yakin solusinya optimal, jadi saya akan menunggu dengan memperbarui ini.)

Jadi, biasanya program Labirin seharusnya terlihat seperti labirin. Sementara penunjuk instruksi berada di koridor, itu akan mengikuti koridor itu. Ketika IP mencapai segala jenis persimpangan, arah ditentukan berdasarkan nilai teratas tumpukan utama Labyrinth (Labyrinth memiliki dua tumpukan, dengan jumlah nol yang tak terbatas di bagian bawah). Itu biasanya berarti bahwa setiap loop non-sepele akan cukup mahal, karena jika Anda memiliki sel-sel non-dinding di semua tempat semuanya adalah persimpangan, dan dalam kebanyakan kasus bagian atas tumpukan tidak akan memiliki nilai yang tepat untuk IP untuk mengambil jalan yang Anda inginkan. Jadi apa yang Anda lakukan adalah memperbesar loop sehingga mereka memiliki keseluruhan di tengah dengan hanya satu titik masuk dan keluar yang ditentukan masing-masing.

Tapi kali ini aku benar-benar beruntung dan semuanya cocok satu sama lain, sehingga aku bisa meremasnya menjadi satu rumpun besar. :)

Aliran kendali dimulai dari _Selatan yang sedang berjalan. The _mendorong nol ke stack utama. Itu mungkin tampak seperti no-op, tetapi ini meningkatkan kedalaman stack (non-implisit) 1yang akan kita butuhkan nanti.

?membaca bilangan bulat dari STDIN. Jika tidak ada lagi bilangan bulat untuk dibaca, ini mendorong nol. Dalam hal ini, IP terus bergerak ke Selatan dan segera @menghentikan program (karena daftar input kosong). Kalau tidak, IP berubah menjadi Timur.

Kami sekarang memasuki lingkaran yang sangat ketat dengan dua titik keluar:

 !?;
 \?
  ;

!mencetak bilangan bulat kembali ke STDOUT, hanya menyisakan nol pada tumpukan. IP terus bergerak ke Timur, dan ?membaca bilangan bulat berikutnya. Jika itu bukan nol, kita ambil kanan dan bergerak ke Selatan. ?membaca yang lain (indeks genap berikutnya). Sekali lagi, jika itu bukan nol, kita ambil kanan dan bergerak Barat.

Kemudian \mencetak umpan baris tanpa mengubah tumpukan, jadi kami ambil kanan lagi, bergerak ke Utara. !mencetak bilangan bulat bahkan indeks berikutnya. Karena sekarang ada setidaknya satu integer indeks ganjil (positif) pada stack, kami terus berbelok ke kanan dan loop berulang.

Begitu salah satu dari mereka ?mencapai akhir daftar, mereka menekan nol dan bergerak langsung ke yang sesuai ;, yang membuang nol itu.

Dalam hal hanya ada satu elemen dalam daftar, kita sudah selesai (karena kita sudah mencetaknya segera), sehingga IP akan terus bergerak ke Timur hingga ke @, lagi-lagi mengakhiri program (mencetak trailing linefeed di jalan).

Kalau tidak, kita perlu mencetak bilangan bulat indeks ganjil juga. Dalam hal ini dua jalur (dari dua titik keluar dari loop pertama) bergabung di tengah ", berbelok ke Timur dalam kedua kasus.

_mendorong nol untuk menghindari mengambil kiri ke dalam @, dan ;membuang nol itu. Sekarang kita masuk ke loop baru:

     "}
     ""

IP memasuki ini di sel kiri bawah, bergerak ke utara, berputar di sekitar searah jarum jam. The }menggeser atas tumpukan utama ke tumpukan tambahan. Meskipun masih ada elemen di stack, IP terus melakukan tugasnya. Setelah semuanya telah bergeser ke tumpukan bantu (dan terbalik dalam proses), IP terus bergerak ke Timur sebagai gantinya, memasuki loop terakhir:

       \{@
       #!

\mencetak linefeed lagi, {memindahkan item dari tumpukan tambahan kembali ke utama. Jika itu masih merupakan item dari daftar, itu akan menjadi positif, dan IP berbelok ke Selatan, di mana item tersebut dicetak !. Kemudian #dorong kedalaman tumpukan (dan sekarang inilah awal _yang penting, karena ini #memastikan kedalaman tumpukan positif), sehingga IP masih berbelok ke kanan, melewati \dan {lagi.

Setelah kami mencetak semuanya, {menarik nol dari bagian bawah tumpukan tambahan, IP melanjutkan ke Timur, dan @menghentikan program.

MATLAB, 24

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

mirip dengan yang python.

Terima kasih @LuisMendo karena telah menghemat 2 byte!

Haskell , 37 byte

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

Cobalah online!

The foldrrekursif membangun daftar bahkan dan daftar aneh. Menambahkan elemen ke daftar diperbarui dengan menambahkannya ke daftar ganjil dan menyebutnya daftar genap baru, dan memanggil daftar genap sebelumnya daftar ganjil baru. Kemudian, pasangan [l,r]didekati untuk l++r.

Terima kasih kepada Ørjan Johansen karena menyimpan 5 byte menggunakan daftar dua elemen sebagai ganti tuple.

42 byte:

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

Tambahkan indeks ke daftar ldan filter baik yang genap atau yang ganjil.

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

Namun format lain, untuk 44. Fungsi ini gmengambil setiap elemen bahkan diindeks. Indeks ganjil didapat dengan menjatuhkan elemen terlebih dahulu, lalu menerapkannya g. Kalau ldijamin non-kosong, kita bisa aman melakukannya tailuntuk 41

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

PowerShell v3 +, 75 67 49 47 byte

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

Cobalah online!

Diharapkan input melalui splatting, seperti yang ditunjukkan pada tautan TIO.

Membuat matriks $lsebagai array array, lalu menyalurkan input $argske dalam sebuah loop |%{}. Setiap kali melalui loop, kita menambahkan elemen ke salah satu dari dua array anak $ldengan membalik $fvariabel menggunakan logika Boolean. Pertama kali melalui, $fadalah $null, yang !mana $true, atau 1saat pengindeksan ke dalam array. Ini berarti elemen pertama dimasukkan ke dalam array kedua $l, jadi itu sebabnya $l[1]mendapat output pertama.

Props to TessellatingHeckler untuk bantuan golf dan variasi ini.
-2 byte berkat mazzy.

Peringatan

Secara ketat seperti pertanyaan yang ditulis, ini secara teknis tidak valid, karena PowerShell tidak memiliki konsep "daftar" sebagai objek pseudo-abadi, hanya array atau tabel hash (alias kamus). Jadi, saya memperlakukan baris pertanyaan " Gunakan representasi paling alami untuk daftar yang bahasa Anda miliki " sebagai bertanya tentang array, karena itulah PowerShell terdekat. Selain itu, output adalah satu elemen per baris, karena itulah cara PowerShell default untuk menulis sebuah array. Ini berarti input dari (0,1,2,3,4)output akan 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 ([],[])||>(@)

Berdasarkan salah satu jawaban Haskell

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

Kami pertama-tama mengindeks daftar, kemudian mempartisi dengan kriteria: item pertama (indeks) dan anded dengan 1 sama dengan 0.
Itu memberi kita sepasang daftar pasangan; daftar pertama akan berisi semua acara indeks dan yang lainnya peluang diindeks.
Dari situ kita rangkai kembali dua daftar dengan append operator dan akhirnya buang indeksnya.

Sunting: tidak terjawab jelas tidak perlu memberi nama arg "xs" (kebiasaan) sehingga dapat direduksi menjadi nama 1 huruf

Saya juga memiliki 76 byte potensial yang pada dasarnya sama tetapi didefinisikan sebagai komposisi fungsi. Masalahnya adalah itu tidak dikompilasi sebagai nilai tetapi secara efektif akan bekerja dengan argumen daftar yang diberikan begitu tidak yakin apakah itu ok atau tidak:

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

Catatan: List.indexed hanya tersedia dari F # 4.0 meskipun belum didokumentasikan dalam MSDN

JavaScript (ES6), 52 byte

Itu juga melakukannya dalam satu pass

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 byte

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

J, 8 byte

/:0 1$~#

Ini adalah kata kerja monadik (satu argumen), digunakan sebagai berikut:

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

Penjelasan

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

Jelly , 4 byte

s2ZF

Cobalah online!

Berdasarkan jawaban CJam dari 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 byte

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

{}[[2;;;;2]] akan melempar kesalahan.

Burlesque, 12 Bytes

J2ENj[-2EN_+

Penggunaan seperti pada:

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}

Penjelasan:

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

Meskipun setelah pembaruan baru dirilis, Anda dapat melakukan ini dengan built-in Unmerge baru (yang melakukan kebalikan dari gabungan **built-in):

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

Perl, 35 33 byte

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

31 byte + 2 byte untuk -ap. Membaca string yang dibatasi ruang dari 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

Ketika input kosong, mencetak satu ruang, yang saya anggap setara dengan daftar kosong. Jika tidak, dapat diperbaiki dengan biaya 4 byte dengan:

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

(membutuhkan Perl 5.10+, mencetak baris tambahan)

atau dengan biaya 5 byte dengan:

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

(tanpa spasi spasi tambahan)

Bagaimana itu bekerja

Solusi ini menggunakan -aflag, yang membagi input pada spasi putih dan menempatkan hasilnya dalam @Farray.

Keajaiban nyata terjadi di push:

push@{$|--},$_

The $|variabel biasanya digunakan untuk memaksa output pembilasan, tetapi memiliki properti lain yang menarik: ketika dikurangi berulang kali, matikan nilainya antara 0 dan 1.

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

Mengambil keuntungan dari fakta bahwa tidak ada batasan pada pengidentifikasi yang ditentukan melalui dereferencing simbolik , kami secara bergantian mendorong elemen array ke array @0dan @1, sehingga @0berakhir dengan semua elemen bahkan diindeks dan @1dengan peluang. Kemudian kita cukup menggabungkan array yang dirangkai untuk mendapatkan hasil.

C, 70

Tidak ada yang istimewa, hanya fungsi pemetaan indeks.

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

Kurang golf

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

Pyth, 8 byte

+%2Q%2tQ

Relatif sederhana

Vitsy, 22 Bytes

Vitsy benar - benar tidak dibuat untuk melakukan ini ...

r '' Vl2 / \ [N {VO] l \ [NVO]
r Membalik tumpukan input numerik implisit.
 '' V Simpan karakter "spasi" sebagai variabel akhir global.
     l2 / \ [....] Ulangi barang di dalam kurung, panjang input
                        tumpukan dibagi 2.
          N {VO Keluarkan item teratas dari tumpukan sebagai angka, lalu bergeser
                        tumpukan sekali ke kiri, dorong spasi, keluarkan.
               l \ [...] Untuk sisa tumpukan, ulangi berkali-kali ...
                  NVO Output item teratas dari tumpukan sebagai angka yang dipisahkan 
                        oleh spasi.

Perl 6 , 25 byte

Ini adalah lambda terpendek yang bisa kutemukan.

{|.[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 byte

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

Coba di sini.

Penjelasan

$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 byte

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

Sebut saja sebagai q (bla). Atau, jika x sudah berisi daftar untuk disusun ulang, maka

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

hanya 35 byte.

F #, 64

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

Terinspirasi oleh jawaban Sehnsucht (tetapi tidak cukup perwakilan untuk berkomentar).

Memetakan setiap nilai ke tuple di mana entri kedua adalah modulo dari indeks daftar, mengurutkan berdasarkan modulo, lalu memetakan kembali ke nilai aslinya.

Prolog, 103 byte

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

Contoh

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

bash dan GNU coreutils, 68 byte

Kami berasumsi bahwa daftar ini dipisahkan oleh baris baru dan diteruskan dengan input standar.

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

Sayangnya ini akan mengabaikan input di luar indeks 1999, sehingga tidak cukup memenuhi spesifikasi.

Itu juga clobbers file sementara hardcoded ('x'), yang bisa bermasalah jika dijalankan secara paralel, dan itu tidak menghapusnya setelah itu. Maaf soal itu!

PHP, 78 69 byte

PHP dapat melakukan chunk dan slice, tetapi bukan array interleave; yang membuat ini agak tebal:

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

Panggil dengan referensi atau coba online .

pendekatan pertama (program untuk 78 byte):

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

mencetak koma terkemuka; masukkan [!$i]sebelum yang pertama $argvuntuk menghapusnya.

Dua solusi 78 byte lainnya (cetak koma depan dan belakang):

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];

Jalankan dengan php -nr '<code>' <arguments>atau coba online

Japt , 3 byte

ñÏu

Cobalah

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

ó c

Cobalah

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

Clojure / ClojureScript, 52 byte

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

Ditulis dalam REPL ClojureScript, juga harus Clojure valid.

K, 10 byte

{x@<2!!#x}

Berdasarkan jawaban Pyth 5-byte.

Hassium , 191 Bytes

Yang ini cukup panjang :(
Bunyinya array dari args, jadi jalankan ini denganhassium 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("  ", "")+"]");}

Jalankan dan lihat diperluas dengan test case di sini