Inspirado por esta pregunta:

Haga una función (o un programa completo) que reciba una lista de números y genere la lista reorganizada, de modo que los números indexados pares aparezcan primero, y los números indexados impares sigan. Los valores de los números en sí mismos no afectan el orden, solo sus índices lo hacen. Todos los índices están basados ​​en cero.

Por ejemplo:

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

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

Otro ejemplo:

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

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

Use la representación más natural para las listas que tiene su idioma. No hay limitaciones en la complejidad (por ejemplo, asignar una lista temporal está bien, no es necesario hacerlo en el lugar).

PD: debería funcionar para la lista vacía (entrada vacía => salida vacía).

Japt , 1 byte

ó

Pruébalo en línea!

Python, 23 bytes

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

Pruébalo en línea

Pyth, 5

o~!ZQ

Pruébelo en línea o ejecute un Test Suite

Explicación

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_}

Empuja un bloque (lo más parecido a una función sin nombre) que transforma el elemento de la pila superior según sea necesario.

Pruébalo aquí.

Explicación

La explicación supone que la parte superior de la pila es la matriz [0 1 2 3 4]. Los valores reales no afectan el cálculo.

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]

Laberinto , 28 25 24 23 22 bytes

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

¡Esto fue muy divertido! :) Ese es, con mucho, el programa Labyrinth más densamente comprimido que he escrito hasta ahora. Tenía tantas versiones en 20 y 21 bytes que casi funcionaron que todavía dudo que esto sea óptimo ...

Esto toma la entrada como una lista de enteros positivos (con un delimitador arbitrario) e imprime el resultado en STDOUT como enteros delimitados por salto de línea.

La búsqueda de 20/21 bytes: he verificado todos los programas del formulario

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

donde Xhay algún carácter razonable por fuerza bruta, pero no encontró ninguna solución válida. Por supuesto, eso no significa que no exista una solución más corta, pero no es posible forzar programas de 20 bytes sin una cantidad decente de suposiciones en su estructura.

Explicación

(La explicación está un poco desactualizada, pero todavía no estoy convencido de que la solución sea óptima, por lo que esperaré con la actualización).

Por lo tanto, normalmente se supone que los programas Laberinto parecen laberintos. Mientras el puntero de instrucciones se encuentre en un corredor, seguirá ese corredor. Cuando la IP golpea cualquier tipo de cruce, la dirección se determina en función del valor superior de la pila principal de Labyrinth (Labyrinth tiene dos pilas, con una cantidad infinita de ceros en la parte inferior). Eso normalmente significa que cualquier bucle no trivial será bastante costoso, porque si tiene celdas sin pared en todo el lugar, todo es una unión, y en la mayoría de los casos la parte superior de la pila no tendrá el valor correcto para la IP tomar el camino que le gustaría tomar. Entonces, lo que debe hacer es ampliar los bucles de modo que tengan un todo en el centro con solo un punto de entrada y salida bien definido cada uno.

Pero esta vez tuve mucha suerte y todo encajó tan bien que pude juntarlo todo en un gran grupo. :)

El flujo de control comienza en el _sur. El _empuja un cero en la pila principal. Puede parecer un no-op, pero esto aumenta la profundidad de la pila (no implícita) a la 1que necesitaremos más adelante.

?lee un entero de STDIN. Si no hay más números enteros para leer, esto empuja a cero. En ese caso, la IP sigue moviéndose hacia el sur y @finaliza el programa de inmediato (porque la lista de entrada está vacía). De lo contrario, la IP gira hacia el este.

Ahora estamos entrando en un circuito muy cerrado con dos puntos de salida:

 !?;
 \?
  ;

!imprime el entero de nuevo en STDOUT, dejando solo un cero en la pila. La IP sigue avanzando hacia el este y ?lee el siguiente número entero. Si eso no es cero, giramos a la derecha y avanzamos hacia el sur. ?lee otro (el siguiente índice par). Nuevamente, si eso no es cero, giramos a la derecha y nos movemos hacia el oeste.

Luego \imprime un salto de línea sin cambiar la pila, por lo que tomamos otra derecha, moviéndonos hacia el norte. !imprime el siguiente entero de índice par. Como ahora hay al menos un entero de índice impar (positivo) en la pila, seguimos girando a la derecha y el ciclo se repite.

Una vez que cualquiera de esos ?llega al final de la lista, empujan un cero y se mueven directamente al correspondiente ;, que descarta ese cero.

En el caso de que haya un solo elemento en la lista, hemos terminado (porque lo imprimimos de inmediato), por lo que la IP seguiría moviéndose hacia el Este hasta el final @, nuevamente terminando el programa (imprimiendo un final salto de línea en el camino).

De lo contrario, también necesitamos imprimir los enteros de índice impar. En ese caso, los dos caminos (desde los dos puntos de salida del primer bucle) se fusionan en el medio ", girando hacia el este en cualquier caso.

_empuja un cero para evitar girar a la izquierda @y ;descarta ese cero. Ahora entramos en un nuevo bucle:

     "}
     ""

El IP ingresa esto en la celda inferior izquierda, moviéndose hacia el norte, girando alrededor del bucle en sentido horario. El }desplaza la parte superior de la pila principal a la pila auxiliar. Si bien todavía hay un elemento en la pila, la IP sigue haciendo lo suyo. Una vez que todo se ha desplazado a la pila auxiliar (y se ha revertido en el proceso), la IP continúa moviéndose hacia el Este, ingresando al último bucle:

       \{@
       #!

\imprime un salto de línea nuevamente, {mueve un elemento de la pila auxiliar de nuevo a main. Si todavía era un elemento de la lista, será positivo, y la IP gira hacia el sur, donde se imprime el elemento !. Luego #empuja la profundidad de la pila (y ahora aquí es donde la inicial _es importante, porque esto #asegura una profundidad de pila positiva), de modo que la IP todavía gire a la derecha, a través de la \y {otra vez.

Después de que imprimimos todo, {sacamos un cero de la parte inferior de la pila auxiliar, la IP continúa hacia el Este y @finaliza el programa.

MATLAB, 24

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

similar a la pitón.

¡Gracias @LuisMendo por guardar 2 bytes!

Haskell , 37 bytes

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

Pruébalo en línea!

El foldrrecursivo construye la lista par y la lista impar. Anteponer un elemento a la lista se actualiza anteponiéndolo a la lista impar y llamándolo la nueva lista par, y llamando a la lista par anterior la nueva lista impar. Entonces, el par [l,r]se concaterna a l++r.

Gracias a Ørjan Johansen por guardar 5 bytes usando listas de dos elementos en lugar de tuplas.

42 bytes:

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

Agrega índices a la lista ly filtra los pares o los impares.

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

Otro formato más, para 44. La función gtoma todos los elementos indexados pares. Los índices impares se obtienen soltando primero un elemento y luego aplicando g. Si lse garantizara que no está vacío, podríamos hacerlo tailde forma segura por 41

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]

Pruébalo en línea!

Espera entrada a través de salpicaduras, como se muestra en el enlace TIO.

Crea una matriz $lcomo una matriz de matrices, luego canaliza la entrada $argsen un bucle |%{}. Cada vez a través del ciclo, agregamos un elemento a una de las dos matrices secundarias de $lflip-flop de la $fvariable usando lógica booleana. La primera vez, $fes $null, la !cual es $true, o 1cuando se indexa en una matriz. Esto significa que el primer elemento se coloca en la segunda matriz de $l, por lo que $l[1]primero se genera la salida.

Apoyos para TessellatingHeckler para la asistencia de golf y esta variación.
-2 bytes gracias a mazzy.

Advertencias

Siguiendo estrictamente como está escrita la pregunta, esto es técnicamente inválido, ya que PowerShell no tiene un concepto de "listas" como objetos pseudo-inmutables, solo matrices o tablas hash (también conocidos como diccionarios). Por lo tanto, estoy tratando la línea de la pregunta " Use la representación más natural para las listas que tiene su idioma " como preguntando sobre matrices, ya que es lo más cercano que tiene PowerShell. Además, la salida es un elemento por línea, ya que esa es la forma predeterminada de PowerShell de escribir una matriz. Esto significa una entrada de (0,1,2,3,4)will output 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 ([],[])||>(@)

Basado en una de las respuestas de Haskell

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

Primero indexamos la lista, luego la dividimos con criterios: primer elemento (el índice) y suma 1 igual a 0.
Eso nos da un par de listas de pares; La primera lista contiene todos los pares indexados y el otro las cuotas indexadas.
A partir de eso, reensamblamos las dos listas con el operador append y finalmente descartamos el índice.

Editar: se perdió uno obvio, no hay necesidad de nombrar el argumento "xs" (hábitos), por lo que puede reducirse a un nombre de 1 letra

También tengo un potencial de 76 bytes, que es básicamente el mismo pero definido como composición de funciones. El problema es que no se compila como un valor, pero funcionará efectivamente con cualquier argumento de lista dado, así que no estoy seguro de si está bien o no:

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

Nota: List.indexed solo está disponible desde F # 4.0 a pesar de que aún no está documentado en MSDN

JavaScript (ES6), 52 bytes

También lo hace de una pasada

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$~#

Este es un verbo monádico (un argumento), utilizado de la siguiente manera:

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

Explicación

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

Jalea , 4 bytes

s2ZF

Pruébalo en línea!

Basado en la respuesta de Martin CJam

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]] arrojará un error.

Burlesque, 12 bytes

J2ENj[-2EN_+

Uso como en:

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}

Explicación:

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

Aunque una vez que se lanza la nueva actualización, puede hacerlo con el nuevo Unmerge incorporado (que hace lo contrario de la fusión **incorporada):

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 para -ap. Lee una cadena delimitada por espacios de 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

Cuando la entrada está vacía, imprime un solo espacio, que consideraría equivalente a una lista vacía. Si no, se puede arreglar a un costo de 4 bytes con:

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

(requiere Perl 5.10+, imprime una nueva línea final)

o a un costo de 5 bytes con:

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

(sin espacios en blanco al final)

Cómo funciona

Esta solución utiliza el -aindicador, que divide la entrada en espacios en blanco y coloca los resultados en la @Fmatriz.

La verdadera magia ocurre en push:

push@{$|--},$_

La $|variable se usa normalmente para forzar el vaciado de salida, pero tiene otra propiedad interesante: cuando se disminuye repetidamente, su valor alterna entre 0 y 1.

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

Aprovechando el hecho de que no hay restricciones en los identificadores especificados a través de la desreferencia simbólica , alternativamente empujamos los elementos de la matriz a las matrices @0y @1, por lo que @0termina con todos los elementos indexados pares y @1con las probabilidades. Luego simplemente concatenamos las matrices en cadena para obtener nuestra salida.

C, 70

Nada especial, solo una función de mapeo de índice.

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

Menos 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 bytes

+%2Q%2tQ

Relativamente simple

Vitsy, 22 bytes

Vitsy realmente no fue hecha para hacer esto ...

r '' Vl2 / \ [N {VO] l \ [NVO]
r Invierta la pila de entrada numérica implícita.
 '' V Guarde el carácter "espacio" como una variable final global.
     l2 / \ [....] Repita las cosas entre paréntesis la longitud de la entrada
                        pila dividida por 2.
          N {VO Muestra el elemento superior de la pila como un número, luego cambia
                        la pila una vez a la izquierda, empuja un espacio, dale salida.
               l \ [...] Para el resto de la pila, repita eso muchas veces ...
                  NVO Muestra el elemento superior de la pila como un número separado 
                        por un espacio

Perl 6 , 25 bytes

Esta es la lambda más corta que se me ocurrió.

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

Pruébalo aquí

Explicació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 bytes

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

Llámalo como q (bla). O, si x ya contiene la lista para reorganizar, entonces

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

son solo 35 bytes.

F #, 64

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

Inspirado por la respuesta de Sehnsucht (pero no suficiente representante para comentar).

Asigna cada valor a una tupla donde la segunda entrada es el módulo del índice de la lista, ordena por módulo, luego asigna de nuevo al valor original.

Prólogo, 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).

Ejemplo

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

bash y GNU coreutils, 68 bytes

Suponemos que la lista está separada por una nueva línea y se pasa por entrada estándar.

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

Desafortunadamente, esto ignorará cualquier entrada más allá del índice 1999, por lo que no cumple con las especificaciones.

También registra un archivo temporal codificado ('x'), que podría ser problemático si se ejecuta en paralelo, y no lo elimina después. ¡Lo siento por eso!

PHP, 78 69 bytes

PHP puede fragmentar y cortar, pero no intercalar matrices; eso hace que esto sea un poco voluminoso:

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

Llame por referencia o pruébelo en línea .

primer enfoque (programas para 78 bytes):

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

imprime una coma inicial; inserte [!$i]antes del primero $argvpara eliminarlo.

Otras dos soluciones de 78 bytes (imprima una coma inicial y una final):

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

Corre php -nr '<code>' <arguments>o pruébalos en línea

Japt , 3 bytes

ñÏu

Intentalo

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

ó c

Intentalo

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

Clojure / ClojureScript, 52 bytes

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

Escrito en un ClojureScript REPL, también debe ser válido Clojure.

K, 10 bytes

{x@<2!!#x}

Basado en la respuesta Pyth de 5 bytes.

Hasio , 191 bytes

Este fue bastante largo :(
Lee la matriz de args, así que ejecute esto conhassium 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("  ", "")+"]");}

Ejecute y vea expandido con el caso de prueba aquí