Le but de ce défi est de collecter les éléments sélectionnés dans une liste et de les déplacer vers un certain emplacement dans la liste.

À titre d'exemple visuel, prenez les valeurs d'entrée (représentées par des nombres entiers encadrés en noir) et une liste correspondante de valeurs véridiques où true indique que l'élément est sélectionné (représenté par des cases bleues, où Test véridique et Fest faux):

La première étape logique consiste à séparer les éléments marqués véridique et non véridique dans leurs listes correspondantes. Notez que l'ordre relatif dans chaque liste doit être maintenu (c'est-à-dire que l'ordre des éléments sélectionnés doit être 1,4,5, et l'ordre des éléments non sélectionnés doit être 2,3,6,7)!

La deuxième étape logique reçoit un index dans la liste restante des éléments non sélectionnés, insérez tous les éléments sélectionnés avant l'élément à l'index donné. En supposant que l'indexation commence à 0, supposons que vous souhaitiez insérer la sélection à l'index 3. Cela correspond au point avant la 7boîte, donc les éléments sélectionnés doivent être insérés avant le 7.

La solution finale est alors 2,3,6,1,4,5,7.

Notez que ce diagramme logique illustre une façon de procéder; votre programme n'a pas besoin de suivre les mêmes étapes logiques tant que la sortie produit toujours le même résultat observable.

Contribution

Votre programme reçoit 3 entrées:

1. Une liste d'entiers représentant les éléments. Cela peut être une liste vide. Cette liste sera toujours constituée d'entiers positifs uniques, pas nécessairement dans l'ordre trié (c'est-à-dire que 5 ne figureront pas deux fois dans la liste).
2. Une liste de valeurs véridiques / fausses de la même longueur que la liste des éléments, où une valeur véridique représente que l'élément du même index a été sélectionné.
3. Un entier représentant où insérer la sélection. Vous pouvez choisir quel est l'index du premier élément de la liste tant qu'il est constant à chaque exécution de votre programme (par exemple, le premier élément pourrait être l'index 0 ou l'index 1). Veuillez préciser à quelle convention votre programme adhère. Cet index doit être dans la plage [starting_idx, ending_idx+1], c'est-à-dire qu'il sera toujours un index valide. Pour l'index de cas ending_idx+1, la sélection doit être insérée à la fin de la liste. Vous pouvez supposer que cet entier s'adaptera au type d'entier natif de votre langue.

L'entrée peut provenir de n'importe quelle source souhaitée (stdio, paramètre de fonction, etc.)

Production

Le résultat est une liste représentant la séquence finale des éléments. Cela peut être à n'importe quelle source souhaitée (stdio, valeur de retour, paramètre de sortie de fonction, etc.). Vous êtes autorisé à modifier n'importe laquelle des entrées sur place (par exemple, étant donné une liste modifiable en tant que paramètre de fonction et que votre fonction fonctionne sur place dans cette liste).

Cas de test

Tous les cas de test suivants supposent une indexation basée sur 0. J'ai utilisé 0 et 1 pour indiquer des valeurs fausses / véridiques respectivement pour le masque de sélection.

Les cas de test ont des listes formatées [a,b,c], mais tant que vos listes d'entrée représentent une séquence ordonnée finie, c'est bien.

Contribution:

[]
[]
0

Production:

[]

Contribution:

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

Production:

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

Contribution:

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

Production:

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

Contribution:

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

Production:

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

Contribution:

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

Production:

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

Contribution:

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

Production:

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

Contribution:

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

Production:

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

Notation

C'est le golf de code; la réponse la plus courte en octets l'emporte. Les failles standard sont interdites. Vous êtes autorisé à utiliser toutes les fonctions intégrées souhaitées.

MATL, 9 octets

&)i:&)bwv

Cette solution accepte un tableau de valeurs T(vraies) et F(fausses) comme deuxième entrée. Également pour le premier cas de test, avec des tableaux vides, il ne produit aucune sortie.

Essayez-le en ligne! et une version légèrement modifiée pour tous les cas de test.

Explication

    % 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 octets

^{4 octets enregistrés de @MartinEnder .}

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

Fonction anonyme. Prend l'index basé sur 1, la liste et les marqueurs en entrée et renvoie la liste réorganisée en sortie.

Haskell, 70 octets

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

Exemple d'utilisation: ([1,2,3,4,5,6,7]#[True,False,False,True,True,False,False]) 3-> [2,3,6,1,4,5,7].

Comment ça fonctionne:

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 octets

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

Gelée , 10 octets

¬+\>⁵Ḥ³oỤị

Essayez-le en ligne!

Comment ça fonctionne

¬+\>⁵Ḥ³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 octets

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();}

non 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();
    }

des idées d'amélioration appréciées.

Python 3, 91 octets

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

où aest la liste des éléments / nombres, xest laTrue/False liste et iest l'index.

Version multiligne pour une meilleure lisibilité:

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

Comment ça marche?

L'appel à des zip(a,x)résultats dans une liste de tuples où chacun d'eux contient l'info: (element,0|1). Ensuite, une compréhension de liste est utilisée pour déterminer les éléments qui ont une 0/Falsevaleur associée et les stocke dans la variable b.

Ainsi , [c for c,z in zip(a,x)if z<1]crée une liste qui contient tous les éléments qui ont une 0( Falsevaleur) associée.

Après cela, la liste des éléments qui ont une True|1valeur associée (qui est déterminée par la vérification que les éléments de asont pas présents dans b: [c for c in a if(c in b)<1]) est inséré dans la liste avec tous les éléments qui ont une 0( Falsevaleur) associé (liste bà l'index spécifié) iet la liste résultante est retournée.

Python 3, 106 93 octets

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

Ancienne version:

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