L'obiettivo di questa sfida è quello di raccogliere gli elementi selezionati in un elenco e spostarli in una determinata posizione nell'elenco.

Come esempio visivo, prendi i valori di input (rappresentati da numeri interi con riquadro nero) e un elenco corrispondente di valori di verità in cui true indica che l'elemento è selezionato (rappresentato da caselle blu, dove Tè verità ed Fè falsa):

Il primo passo logico è quello di separare gli elementi contrassegnati come verità e non verità nelle loro liste corrispondenti. Si noti che l'ordine relativo in ciascun elenco deve essere mantenuto (cioè l'ordine degli articoli selezionati deve essere 1,4,5e l'ordine degli articoli non selezionati deve essere 2,3,6,7)!

Al secondo passaggio logico viene assegnato un indice nell'elenco rimanente di elementi non selezionati, inserire tutti gli elementi selezionati prima dell'elemento nell'indice indicato. Supponendo che l'indicizzazione inizi da 0, si supponga di voler inserire la selezione in corrispondenza dell'indice 3. Ciò corrisponde al punto prima della 7casella, quindi gli elementi selezionati devono essere inseriti prima di 7.

La soluzione finale è quindi 2,3,6,1,4,5,7.

Si noti che questo diagramma logico descrive un modo in cui ciò potrebbe essere fatto; non è necessario che il programma esegua gli stessi passaggi logici purché l'output produca sempre lo stesso risultato osservabile.

Ingresso

Il tuo programma ha 3 ingressi:

1. Un elenco di numeri interi che rappresentano gli articoli. Questo potrebbe essere un elenco vuoto. Questo elenco sarà sempre composto da numeri interi positivi unici, non necessariamente in ordine (ovvero 5 non saranno inclusi nell'elenco due volte).
2. Un elenco di valori di verità / falsità della stessa lunghezza dell'elenco di articoli, in cui un valore di verità rappresenta che l'elemento nello stesso indice è stato selezionato.
3. Un numero intero che rappresenta dove inserire la selezione. È possibile scegliere quale sia l'indice del primo elemento dell'elenco purché sia ​​costante in ogni esecuzione del programma (ad esempio, il primo elemento potrebbe essere l'indice 0 o l'indice 1). Specifica a quale convenzione aderisce il tuo programma. Questo indice dovrebbe essere compreso nell'intervallo [starting_idx, ending_idx+1], ovvero sarà sempre un indice valido. Per l'indice del caso è ending_idx+1, la selezione deve essere inserita alla fine dell'elenco. Puoi presumere che questo numero intero si adatterà al tipo intero nativo della tua lingua.

L'ingresso può provenire da qualsiasi sorgente desiderata (stdio, parametro funzione, ecc.)

Produzione

L'output è un elenco che rappresenta la sequenza finale di elementi. Questo può essere per qualsiasi sorgente desiderata (stdio, valore di ritorno, parametro di uscita della funzione, ecc.). È consentito modificare qualsiasi input sul posto (ad esempio, dato un elenco modificabile come parametro di funzione e fare in modo che la propria funzione operi sul posto in tale elenco).

Casi test

Tutti i seguenti casi di test presuppongono l'indicizzazione basata su 0. Ho usato 0 e 1 per indicare rispettivamente i valori di falsità / verità per la maschera di selezione.

I casi di test hanno liste formattate come [a,b,c], ma fintanto che le liste di input rappresentano una sequenza ordinata finita che va bene.

Ingresso:

[]
[]
0

Produzione:

[]

Ingresso:

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

Produzione:

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

Ingresso:

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

Produzione:

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

Ingresso:

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

Produzione:

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

Ingresso:

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

Produzione:

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

Ingresso:

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

Produzione:

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

Ingresso:

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

Produzione:

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

punteggio

Questo è il codice golf; vince la risposta più breve in byte. Sono vietate le scappatoie standard. È consentito utilizzare qualsiasi componente incorporato desiderato.

MATL, 9 byte

&)i:&)bwv

Questa soluzione accetta un array di valori T(true) e F(false) come secondo input. Anche per il primo caso di test, con array vuoti, non produce output.

Provalo online! e una versione leggermente modificata per tutti i casi di test.

Spiegazione

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

^{Salvato 4 byte da @MartinEnder .}

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

Funzione anonima. Prende l'indice in base 1, l'elenco e i marker come input e restituisce l'elenco riordinato come output.

Haskell, 70 byte

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

Esempio di utilizzo: ([1,2,3,4,5,6,7]#[True,False,False,True,True,False,False]) 3-> [2,3,6,1,4,5,7].

Come funziona:

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 byte

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

Gelatina , 10 byte

¬+\>⁵Ḥ³oỤị

Provalo online!

Come funziona

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

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

ungolfed:

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

idee di miglioramento apprezzate.

Python 3, 91 byte

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

dove si atrova l'elenco di elementi / numeri, xè l' True/Falseelenco ed iè l'indice.

Versione multilinea per una migliore leggibilità:

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

Come funziona?

La chiamata a zip(a,x)risultati in una lista di tuple dove ognuno di essi contiene le informazioni: (element,0|1). Quindi una comprensione dell'elenco viene utilizzata per determinare gli elementi a cui è 0/Falseassociato un valore e li memorizza nella variabileb .

Quindi [c for c,z in zip(a,x)if z<1]crea un elenco che contiene tutti gli elementi a cui è associato un valore 0( False).

Dopo di che, l'elenco degli elementi che hanno un True|1valore associato (che è determinato da un controllo sugli elementi anon sono presenti in b: [c for c in a if(c in b)<1]) è inserita nella lista con tutti gli elementi che hanno un 0( Falsevalore) associato (elenco b) all'indice specificato ie l'elenco risultante viene restituito.

Python 3, 106 93 byte

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

Versione precedente:

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