Inspiriert von dieser Frage:

Erstellen Sie eine Funktion (oder ein vollständiges Programm), die eine Liste mit Zahlen empfängt und die neu geordnete Liste ausgibt, sodass geradzahlige Zahlen zuerst angezeigt werden und ungeradzahlige Zahlen folgen. Die Werte der Zahlen selbst haben keinen Einfluss auf die Reihenfolge - nur die Indizes. Alle Indizes basieren auf Null.

Beispielsweise:

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

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

Ein anderes Beispiel:

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

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

Verwenden Sie die natürlichste Darstellung für Listen in Ihrer Sprache. Es gibt keine Einschränkungen hinsichtlich der Komplexität (z. B. ist das Zuweisen einer temporären Liste in Ordnung - dies muss nicht direkt erfolgen).

PS Es sollte für die leere Liste funktionieren (leere Eingabe => leere Ausgabe).

Japt , 1 Byte

ó

Probieren Sie es online!

Python, 23 Bytes

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

Probieren Sie es online aus

Pyth, 5

o~!ZQ

Probieren Sie es online aus oder führen Sie eine Testsuite aus

Erläuterung

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 Bytes

{2/ze_}

Verschiebt einen Block (der einer unbenannten Funktion am nächsten kommt), der das oberste Stapelelement nach Bedarf transformiert.

Teste es hier.

Erläuterung

In der Erklärung wird davon ausgegangen, dass die Oberseite des Stapels das Array ist [0 1 2 3 4]. Die tatsächlichen Werte haben keinen Einfluss auf die Berechnung.

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 Bytes

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

Das hat wahnsinnig Spaß gemacht! :) Das ist mit Abstand das am dichtesten komprimierte Labyrinth-Programm, das ich bisher geschrieben habe. Ich hatte so viele Versionen mit 20 und 21 Bytes , die fast gearbeitet, ich bin immer noch Zweifel an diesen optimal ist ...

Dies nimmt Eingaben als Liste positiver Ganzzahlen (mit einem beliebigen Trennzeichen) und gibt das Ergebnis als durch Zeilenvorschub getrennte Ganzzahlen an STDOUT aus.

Die Jagd nach 20/21 Bytes: Ich habe alle Programme des Formulars überprüft

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

Wo Xist ein vernünftiger Charakter durch rohe Gewalt, aber keine gültigen Lösungen gefunden. Das bedeutet natürlich nicht, dass es keine kürzere Lösung gibt, aber es ist nicht möglich, 20-Byte-Programme zu erzwingen, ohne eine angemessene Menge von Annahmen für ihre Struktur zu treffen.

Erläuterung

(Die Erklärung ist etwas veraltet, aber ich bin immer noch nicht davon überzeugt, dass die Lösung optimal ist. Daher warte ich mit der Aktualisierung.)

Normalerweise sollen Labyrinth-Programme wie Labyrinthe aussehen. Während sich der Befehlszeiger in einem Korridor befindet, folgt er diesem Korridor. Wenn die IP auf eine beliebige Kreuzung trifft, wird die Richtung basierend auf dem oberen Wert des Labyrinth-Hauptstapels bestimmt (Labyrinth hat zwei Stapel mit einer unendlichen Anzahl von Nullen am unteren Rand). Das bedeutet normalerweise, dass jede nicht-triviale Schleife ziemlich teuer ist, denn wenn Sie überall Zellen ohne Wand haben, ist alles eine Kreuzung, und in den meisten Fällen hat die Oberseite des Stapels nicht den richtigen Wert für die IP den Weg einschlagen, den Sie einschlagen möchten. Sie vergrößern also die Schleifen so, dass sie ein Ganzes in der Mitte mit jeweils nur einem genau definierten Ein- und Ausgangspunkt haben.

Aber diesmal hatte ich wirklich Glück und alles passte so gut zusammen, dass ich alles zu einem großen Klumpen zerdrücken konnte. :)

Der Kontrollfluss beginnt _nach Süden. Der _drückt eine Null auf den Hauptstapel. Das mag wie ein No-Op erscheinen, erhöht aber die (nicht implizite) Stapeltiefe, 1die wir später benötigen.

?liest eine ganze Zahl aus STDIN. Wenn keine ganzen Zahlen mehr gelesen werden müssen, wird die Null verschoben. In diesem Fall bewegt sich die IP weiter nach Süden und @beendet das Programm sofort (da die Eingabeliste leer ist). Ansonsten dreht sich die IP nach Osten.

Wir betreten jetzt eine sehr enge Schleife mit zwei Austrittspunkten:

 !?;
 \?
  ;

!Gibt die Ganzzahl zurück zu STDOUT und belässt nur eine Null auf dem Stapel. Die IP bewegt sich weiter nach Osten und ?liest die nächste Ganzzahl. Wenn das nicht Null ist, biegen wir rechts ab und bewegen uns nach Süden. ?liest einen anderen (den nächsten geraden Index). Wenn das nicht Null ist, biegen wir rechts ab und ziehen nach Westen.

Dann wird \ein Zeilenvorschub gedruckt, ohne den Stapel zu ändern, und wir biegen erneut rechts ab und bewegen uns nach Norden. !Gibt die nächste gerade Index-Ganzzahl aus. Da es jetzt mindestens eine (positive) Ganzzahl mit ungeradem Index auf dem Stapel gibt, drehen wir weiter nach rechts und die Schleife wiederholt sich.

Sobald einer dieser ?Punkte das Ende der Liste erreicht, drücken sie eine Null und bewegen sich direkt auf den entsprechenden ;Punkt, der diese Null verwirft.

Für den Fall, dass es nur ein einziges Element in der Liste gab, sind wir fertig (weil wir das sofort gedruckt haben), sodass die IP den ganzen Weg nach Osten @wandert und das Programm erneut beendet wird (Drucken eines Trailings) Zeilenvorschub unterwegs).

Andernfalls müssen wir auch die ungeraden Indexzahlen ausgeben. In diesem Fall verschmelzen die beiden Pfade (von den beiden Ausgangspunkten der ersten Schleife) in der Mitte "und biegen in beiden Fällen nach Osten ab.

_Drückt eine Null, um zu vermeiden, dass Sie nach links in das Feld gehen @, und ;verwirft diese Null. Nun betreten wir eine neue Schleife:

     "}
     ""

Die IP-Adresse wird in der unteren linken Zelle eingegeben. Sie bewegt sich nach Norden und umläuft die Schleife im Uhrzeigersinn. Das }verschiebt die Oberseite des Hauptstapels auf den Hilfsstapel. Solange sich noch ein Element auf dem Stack befindet, macht die IP weiter. Sobald alles auf den Zusatzstapel verschoben wurde (und in diesem Prozess umgekehrt wurde), bewegt sich die IP weiter nach Osten und tritt in die letzte Schleife ein:

       \{@
       #!

\Druckt einen Zeilenvorschub erneut und {verschiebt ein Element vom Hilfsstapel zurück zum Hauptstapel. Wenn das noch ein Element der Liste war, ist es positiv, und die IP dreht sich nach Süden, wo das Element mit gedruckt wird !. Dann #drückt die Stack - Tiefe (und das ist jetzt , wo die anfängliche _wichtig ist, weil dies #eine positive Stapeltiefe gewährleistet), so dass der IP noch nach rechts abbiegt, durch die \und {wieder.

Nachdem wir alles gedruckt haben, {zieht die IP eine Null vom unteren Rand des Zusatzstapels nach Osten und @beendet das Programm.

MATLAB, 24

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

ähnlich wie bei der Python.

Danke @LuisMendo für das Speichern von 2 Bytes!

Haskell , 37 Bytes

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

Probieren Sie es online!

Das foldrbaut rekursiv die gerade Liste und die ungerade Liste auf. Das Voranstellen eines Elements in der Liste wird aktualisiert, indem es der ungeraden Liste vorangestellt und als neue gerade Liste und die vorherige gerade Liste als neue ungerade Liste bezeichnet wird. Dann ist das Paar [l,r]anwesend l++r.

Dank an Ørjan Johansen für das Speichern von 5 Bytes mithilfe von Listen mit zwei Elementen anstelle von Tupeln.

42 Bytes:

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

Fügt der Liste Indizes hinzu lund filtert entweder die geraden oder die ungeraden.

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

Noch ein anderes Format für 44. Die Funktion gakzeptiert jedes gerade indizierte Element. Die ungeraden Indizes werden ermittelt, indem zuerst ein Element abgelegt und dann angewendet wird g. Wenn lgarantiert nicht leer wäre, könnten wir sicher nur tailfür 41 tun

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

PowerShell v3 +, 75 67 49 47 Bytes

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

Probieren Sie es online!

Erwartet eine Eingabe per Splatting, wie auf dem TIO-Link gezeigt.

Erstellt eine Matrix $lals Array von Arrays und leitet die Eingabe dann $argsin eine Schleife weiter |%{}. Jedes Mal, wenn wir die Schleife durchlaufen, fügen wir einem der beiden untergeordneten Arrays von ein Element hinzu, $lindem wir die $fVariable mithilfe der Booleschen Logik kippen . Das erste Mal durch,$f ist $null, !von denen $trueoder 1beim Indizieren in ein Array. Dies bedeutet, dass das erste Element in das zweite Array von gestellt $lwird. Deshalb $l[1]wird es zuerst ausgegeben.

Requisiten an TessellatingHeckler für die Golfunterstützung und diese Variante.
-2 Bytes dank mazzy.

Vorbehalte

Genau genommen ist dies technisch ungültig, da PowerShell kein Konzept für "Listen" als pseudo-unveränderliche Objekte hat, sondern nur für Arrays oder Hash-Tabellen (auch als Wörterbücher bezeichnet). Daher behandle ich die Zeile der Frage " Verwenden Sie die natürlichste Darstellung für Listen in Ihrer Sprache " als Fragen zu Arrays, da dies die nächstgelegene Zeile in PowerShell ist. Darüber hinaus ist die Ausgabe ein Element pro Zeile, da dies die standardmäßige PowerShell-Methode zum Schreiben eines Arrays ist. Dies bedeutet eine Eingabe von (0,1,2,3,4)Willensausgaben 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 ([],[])||>(@)

Basierend auf einer der Haskell-Antworten

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

Wir indizieren zuerst die Liste und partitionieren sie dann mit den folgenden Kriterien: erstes Element (der Index) und 1 = 0.
Das ergibt ein Paar von Paarlisten ; Die erste Liste enthält alle indizierten Ereignisse und die andere die indizierten Gewinnchancen.
Danach setzen wir die beiden Listen mit dem Operator append wieder zusammen und verwerfen schließlich den Index.

Bearbeiten: Verpasste eine offensichtliche, es gibt keine Notwendigkeit, das Argument "xs" (Gewohnheiten) zu benennen, so kann auf einen Namen mit einem Buchstaben reduziert werden

Ich habe auch ein Potential von 76 Bytes, das im Grunde das gleiche ist, aber als Funktionszusammensetzung definiert ist. Das Problem ist, dass es nicht als Wert kompiliert wird, sondern effektiv mit allen angegebenen Listenargumenten funktioniert, sodass Sie sich nicht sicher sind, ob es in Ordnung ist oder nicht:

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

Hinweis: List.indexed ist nur ab F # 4.0 verfügbar, obwohl es noch nicht in MSDN dokumentiert ist

JavaScript (ES6), 52 Byte

Es macht es auch in einem Durchgang

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 Bytes

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

J, 8 Bytes

/:0 1$~#

Dies ist ein monadisches Verb (ein Argument), das wie folgt verwendet wird:

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

Erläuterung

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

Gelee , 4 Bytes

s2ZF

Probieren Sie es online!

Basierend auf Martins CJam-Antwort

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 Bytes

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

{}[[2;;;;2]] wird einen Fehler auslösen.

Burlesque, 12 Bytes

J2ENj[-2EN_+

Verwendung wie in:

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}

Erläuterung:

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

Sobald das neue Update veröffentlicht ist, können Sie dies mit dem neuen integrierten Unmerge - Tool tun (das das Gegenteil des integrierten Merge **- Tools bewirkt ):

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

Perl, 35 33 Bytes

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

31 Bytes + 2 Bytes für -ap. Liest eine durch Leerzeichen getrennte Zeichenfolge aus 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

Wenn die Eingabe leer ist, wird ein einzelnes Leerzeichen gedruckt, was meiner Meinung nach einer leeren Liste entspricht. Wenn nicht, kann zu einem Preis von 4 Bytes behoben werden mit:

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

(Benötigt Perl 5.10+, druckt eine abschließende Newline)

oder zu einem Preis von 5 Bytes mit:

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

(kein abschließendes Leerzeichen)

Wie es funktioniert

Bei dieser Lösung wird das -aFlag verwendet, das die Eingabe in Leerzeichen aufteilt und die Ergebnisse in das Feld einfügt@F Array schreibt.

Die wahre Magie geschieht in push:

push@{$|--},$_

Die $|Variable wird normalerweise verwendet, um das Löschen der Ausgabe zu erzwingen, hat jedoch eine andere interessante Eigenschaft: Wenn sie wiederholt dekrementiert wird, wechselt ihr Wert zwischen 0 und 1.

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

Ausgehend von der Tatsache, dass die über die symbolische Dereferenzierung angegebenen Bezeichner nicht eingeschränkt sind , werden abwechselnd Array-Elemente auf die Arrays @0und @1verschoben, sodass @0alle Elemente @1mit geradem Index und die Gewinnchancen angezeigt werden. Dann verketten wir einfach die stringierten Arrays, um unsere Ausgabe zu erhalten.

C 70

Nichts Besonderes, nur eine Index-Mapping-Funktion.

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

Weniger golfen

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

Pyth, 8 Bytes

+%2Q%2tQ

Relativ einfach

Vitsy, 22 Bytes

Vitsy war wirklich nicht dafür gemacht ...

r '' Vl2 / \ [N {VO] l \ [NVO]
r Kehren Sie den impliziten numerischen Eingabestapel um.
 '' V Speichern Sie das "Leerzeichen" als globale Endvariable.
     l2 / \ [....] Wiederholen Sie die Angaben in den Klammern in der Länge der Eingabe
                        Stapel geteilt durch 2.
          N {VO Das oberste Element des Stapels als Zahl ausgeben und dann verschieben
                        Bewegen Sie den Stapel einmal nach links, drücken Sie ein Leerzeichen und geben Sie es aus.
               l \ [...] Wiederholen Sie dies für den Rest des Stapels so oft ...
                  NVO Gibt das oberste Element des Stapels als Zahl getrennt aus 
                        durch ein Leerzeichen.

Perl 6 , 25 Bytes

Dies ist der kürzeste Lambda, den ich finden konnte.

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

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

Probieren Sie es hier aus.

Erläuterung

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

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

Nenne es q (bla). Oder wenn x bereits die neu anzuordnende Liste enthält, dann

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

ist nur 35 Bytes.

F #, 64

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

Inspiriert von Sehnsuchts Antwort (aber nicht genug Repräsentanten, um einen Kommentar abzugeben).

Ordnet jeden Wert einem Tupel zu, wobei der zweite Eintrag das Modulo des Listenindex ist, sortiert nach Modulo und ordnet dann den ursprünglichen Wert zu.

Prolog, 103 Bytes

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

Beispiel

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

Bash- und GNU-Coreutils, 68 Bytes

Wir gehen davon aus, dass die Liste durch Zeilenumbrüche getrennt und an die Standardeingabe übergeben wird.

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

Leider werden alle Eingaben über den Index 1999 hinaus ignoriert, sodass die Spezifikation nicht ganz erfüllt wird.

Es blockiert auch eine fest codierte temporäre Datei ('x'), die bei paralleler Ausführung problematisch sein kann, und entfernt sie anschließend nicht. Das tut mir leid!

PHP, 78-69 Bytes

PHP kann Blöcke aufteilen, aber keine Arrays verschachteln. das macht das ein bisschen sperrig:

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

Rufen Sie an oder probieren Sie es online .

erster Ansatz (Programme für 78 Bytes):

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

druckt ein führendes Komma; [!$i]vor dem ersten einfügen $argv, um es zu entfernen.

Zwei weitere 78-Byte-Lösungen (geben Sie ein führendes und ein nachfolgendes Komma aus):

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

Laufen Sie mit php -nr '<code>' <arguments>oder probieren Sie sie online aus

Japt , 3 Bytes

ñÏu

Versuch es

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

ó c

Versuch es

ó 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)])))

Geschrieben in einem ClojureScript REPL, sollte auch Clojure gültig sein.

K, 10 Bytes

{x@<2!!#x}

Basierend auf der 5-Byte-Pyth-Antwort.

Hassium , 191 Bytes

Dieser war ziemlich lang :(
Er liest das Array von args, also starte ihn mithassium 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("  ", "")+"]");}

Und sehen , mit Testfall erweitert hier