El objetivo de este desafío es recopilar elementos seleccionados en una lista y moverlos a una determinada ubicación en la lista.

Como ejemplo visual, tome los valores de entrada (representados por enteros en recuadro negro) y una lista correspondiente de valores de verdad donde verdadero denota que el elemento está seleccionado (representado por cuadros azules, donde Tes verdad y Fes falso):

El primer paso lógico es separar los elementos marcados como verdaderos y no verdaderos en sus listas correspondientes. ¡Tenga en cuenta que debe mantenerse el orden relativo en cada lista (es decir, debe ser el orden de los elementos seleccionados 1,4,5y el orden de los elementos no seleccionados 2,3,6,7)!

El segundo paso lógico recibe un índice en la lista restante de elementos no seleccionados, inserte todos los elementos seleccionados antes del elemento en el índice dado. Suponiendo que la indexación comienza en 0, suponga que desea insertar la selección en el índice 3. Esto corresponde al punto antes del 7cuadro, por lo que los elementos seleccionados deben insertarse antes del 7.

La solución final es entonces 2,3,6,1,4,5,7.

Tenga en cuenta que este diagrama lógico muestra una forma en que esto podría hacerse; su programa no necesita seguir los mismos pasos lógicos siempre que la salida siempre produzca el mismo resultado observable.

Entrada

Su programa tiene 3 entradas:

1. Una lista de enteros que representan los elementos. Esta puede ser una lista vacía. Esta lista siempre constará de enteros positivos únicos, no necesariamente en orden ordenado (es decir, 5 no estará en la lista dos veces).
2. Una lista de valores de verdad / falsedad con la misma longitud que la lista de elementos, donde un valor de verdad representa que el elemento en el mismo índice ha sido seleccionado.
3. Un entero que representa dónde insertar la selección. Puede elegir cuál es el índice del primer elemento de la lista siempre que sea constante en cada ejecución de su programa (por ejemplo, el primer elemento podría ser el índice 0 o el índice 1). Especifique a qué convención se adhiere su programa. Este índice debe estar en el rango [starting_idx, ending_idx+1], es decir, siempre será un índice válido. Para el índice de casos ending_idx+1, la selección debe insertarse al final de la lista. Puede suponer que este entero se ajustará al tipo de entero nativo de su idioma.

La entrada puede provenir de cualquier fuente deseada (stdio, parámetro de función, etc.)

Salida

La salida es una lista que representa la secuencia final de elementos. Esto puede ser a cualquier fuente deseada (stdio, valor de retorno, parámetro de salida de función, etc.). Se le permite modificar cualquiera de las entradas en el lugar (por ejemplo, dada una lista modificable como parámetro de función, y hacer que su función opere en el lugar en esa lista).

Casos de prueba

Todos los siguientes casos de prueba suponen una indexación basada en 0. He usado 0 y 1 para indicar valores de falsedad / verdad respectivamente para la máscara de selección.

Los casos de prueba tienen listas formateadas como [a,b,c], pero siempre que sus listas de entrada representen una secuencia ordenada finita que esté bien.

Entrada:

[]
[]
0

Salida:

[]

Entrada:

[1,2,3,4,5,6,7]
[1,0,0,1,1,0,0]
3

Salida:

[2,3,6,1,4,5,7]

Entrada:

[1,2,3,4,5,6,7]
[1,0,0,1,1,0,0]
0

Salida:

[1,4,5,2,3,6,7]

Entrada:

[1,2,3,4,5,6,7]
[1,0,0,1,1,0,0]
4

Salida:

[2,3,6,7,1,4,5]

Entrada:

[1,2,3,4,5,6,7]
[1,1,1,1,1,1,1]
0

Salida:

[1,2,3,4,5,6,7]

Entrada:

[1,2,3,4,5,6,7]
[0,0,0,0,0,0,0]
5

Salida:

[1,2,3,4,5,6,7]

Entrada:

[1,3,2,5,4,6]
[1,0,0,1,1,0]
3

Salida:

[3,2,6,1,5,4]

Puntuación

Este es el código de golf; La respuesta más corta en bytes gana. Las lagunas estándar están prohibidas. Se le permite usar los complementos deseados.

MATL, 9 bytes

&)i:&)bwv

Esta solución acepta una matriz de T(verdadero) yF valores (falso) como la segunda entrada. También para el primer caso de prueba, con matrices vacías, no produce salida.

Pruébalo en línea! y una versión ligeramente modificada para todos los casos de prueba.

Explicación

    % Implicitly grab the first two inputs
&)  % Index into the first array using the boolean, places two items on the stack:
    % 1) The values where the boolean is TRUE and 2) the values where it is FALSE.
i   % Explicitly grab the third input (N)
:   % Create an array from 1...N
&)  % Index into the FALSE group using this array as an index. Puts two items on the stack:
    % 1) The first N elements of the FALSE group and 2) other members of the FALSE group
b   % Bubble the TRUE members up to the top of the stack
w   % Flip the top two stack elements to get things in the right order
v   % Vertically concatenate all arrays on the stack
    % Implicitly display the result

Mathematica, 66 62 bytes

^{Guardado 4 bytes de @MartinEnder .}

a=#2~Extract~Position[#3,#4>0]&;##&@@@Insert[##~a~0,##~a~1,#]&

Función anónima. Toma el índice basado en 1, la lista y los marcadores como entrada y devuelve la lista reordenada como salida.

Haskell, 70 bytes

m%n=[e|(e,b)<-zip m n,b]
(l#s)p|(h,t)<-splitAt p$l%(not<$>s)=h++l%s++t

Ejemplo de uso: ([1,2,3,4,5,6,7]#[True,False,False,True,True,False,False]) 3-> [2,3,6,1,4,5,7].

Cómo funciona:

m%n=[e|(e,b)<-zip m n,b]        -- helper function, that extracts the elements of m
                                -- with corresponding True values in n
(l#s)p                          -- l: list of values
                                   s: list of booleans
                                   p: position to insert
  |                   (not<$>s) -- negate the booleans in s
                    l%          -- extract elements of l
          splitAt p             -- split this list at index p
   (h,t)<-                      -- bind h to the part before the split
                                -- t to the part after the split
     = h++l%s++t                -- insert elements at True positions between h and t

JavaScript (ES6), 76 bytes

(a,b,c)=>(d=a.filter((_,i)=>!b[i]),d.splice(c,0,...a.filter((_,i)=>b[i])),d)

Jalea , 10 bytes

¬+\>⁵Ḥ³oỤị

Pruébalo en línea!

Cómo funciona

¬+\>⁵Ḥ³oỤị  Main link.
            Arguments: x (list of Booleans), y (list of inputs), z (index)
¬           Logical NOT; invert all Booleans in x.
 +\         Take the cumulative sum.
            This replaces each entry with the number of zeroes up to that entry.
   >⁵       Compare the results with z.
            This yields 0 for the first z zeroes, 1 for all others. The behavior
            for ones is not important.
    Ḥ       Unhalve; multiply the previous resulting by 2.
     ³o     Take the element-wise logical NOT of x and the previous result.
            This replaces all but the first z zeroes in x with twos.
       Ụ    Grade up; sort the indices of the result according to the corr. values.
        ị   Retrieve the items of y at those indices.

C #, 132 bytes

int[]r(int[]a,bool[]b,int l){var x=a.Where((i,j)=>!b[j]);return x.Take(l).Concat(a.Where((i,j)=>b[j])).Concat(x.Skip(l)).ToArray();}

sin golf:

    public static int[] r(int[] a,bool[] b,int l)
    {
        var x = a.Where((i, j) => !b[j]);
        return x.Take(l).Concat(a.Where((i, j) => b[j])).Concat(x.Skip(l)).ToArray();
    }

ideas de mejora apreciadas.

Python 3, 91 bytes

def f(a,x,i):b=[c for c,z in zip(a,x)if z<1];return b[:i]+[c for c in a if(c in b)<1]+b[i:]

donde aestá la lista de elementos / números, xes la True/Falselista y ies el índice.

Versión multilínea para mejorar la legibilidad:

def f(a,x,i):
    b=[c for c,z in zip(a,x)if z<1]
    return b[:i]+[c for c in a if(c in b)<1]+b[i:] 

¿Como funciona?

La llamada a zip(a,x)los resultados en una lista de tuplas, donde cada uno de ellos contiene la información: (element,0|1). Luego, se utiliza una lista de comprensión para determinar los elementos que tienen un 0/Falsevalor asociado y los almacena en la variableb .

Entonces [c for c,z in zip(a,x)if z<1]crea una lista que contiene todos los elementos que tienen un 0(False valor ) asociado.

Después de eso, la lista de elementos que tienen un True|1valor asociado (que se determina mediante la comprobación de qué elementos de ano están presentes en b: [c for c in a if(c in b)<1]) se inserta en la lista con todos los elementos que tienen una 0( Falsevalor) asociado (lista b) en el índice especificado iy se devuelve la lista resultante.

Python 3, 106 93 bytes

def f(x,y,z):
 t,f=[],[]
 for n in range(len(x)):(f,t)[y[n]].append(x[n])
 f[z:z]=t
 return f

Versión antigua:

def f(x,y,z):
 t,f=[],[]
 for n in range(len(x)):
  if y[n]:t+=[x[n]]
  else:f+=[x[n]]
 f[z:z]=t
 return f