Tujuan dari tantangan ini adalah untuk mengumpulkan item yang dipilih dalam daftar dan memindahkannya ke lokasi tertentu dalam daftar.

Sebagai contoh visual, ambil nilai input (diwakili oleh bilangan bulat kotak hitam) dan daftar nilai kebenaran yang sesuai di mana true menunjukkan item dipilih (diwakili oleh kotak biru, di mana Tbenar dan Fsalah):

Langkah logis pertama adalah untuk memisahkan item yang bertanda benar dan tidak benar ke dalam daftar yang sesuai. Perhatikan bahwa urutan relatif dalam setiap daftar harus dipertahankan (mis. Urutan item yang dipilih harus 1,4,5, dan urutan item yang tidak dipilih harus 2,3,6,7)!

Langkah logis kedua diberikan indeks dalam daftar item yang tidak dipilih yang tersisa, masukkan semua item yang dipilih sebelum item pada indeks yang diberikan. Dengan asumsi pengindeksan dimulai pada 0, misalkan Anda ingin memasukkan seleksi pada indeks 3. Ini sesuai dengan tempat sebelum 7kotak, sehingga item yang dipilih harus dimasukkan sebelum 7.

Solusi akhirnya adalah 2,3,6,1,4,5,7.

Perhatikan bahwa diagram logis ini menggambarkan satu cara ini bisa dilakukan; program Anda tidak perlu mengambil langkah logis yang sama selama output selalu menghasilkan hasil yang dapat diamati.

Memasukkan

Program Anda diberi 3 input:

1. Daftar bilangan bulat yang mewakili item. Ini mungkin daftar kosong. Daftar ini akan selalu terdiri dari bilangan bulat positif unik, tidak harus dalam urutan (misalnya 5 tidak akan ada dalam daftar dua kali).
2. Daftar nilai kebenaran / kepalsuan dengan panjang yang sama dengan daftar item, di mana nilai kebenaran menyatakan bahwa item pada indeks yang sama telah dipilih.
3. Integer yang mewakili tempat untuk memasukkan pilihan. Anda dapat memilih apa indeks item pertama dari daftar selama itu konstan dalam setiap program Anda (misalnya item pertama bisa menjadi indeks 0 atau indeks 1). Silakan tentukan konvensi mana yang dipatuhi oleh program Anda. Indeks ini harus berada dalam kisaran [starting_idx, ending_idx+1], yaitu indeks akan selalu menjadi indeks yang valid. Untuk indeks kasus ending_idx+1, pemilihan harus dimasukkan di akhir daftar. Anda dapat menganggap bilangan bulat ini akan cocok dengan jenis bilangan bulat asli bahasa Anda.

Input dapat berasal dari sumber yang diinginkan (stdio, parameter fungsi, dll.)

Keluaran

Outputnya adalah daftar yang mewakili urutan akhir item. Ini bisa ke sumber mana saja yang diinginkan (stdio, nilai balik, parameter keluaran fungsi, dll.). Anda diizinkan untuk memodifikasi input apa pun di tempat (misalnya, diberi daftar yang dapat dimodifikasi sebagai parameter fungsi, dan membiarkan fungsi Anda beroperasi di tempat pada daftar itu).

Uji kasus

Semua kasus uji berikut mengasumsikan pengindeksan berbasis 0. Saya telah menggunakan 0 dan 1 untuk menunjukkan nilai falsy / truthy masing-masing untuk mask seleksi.

Kasing uji kebetulan memiliki daftar yang diformat [a,b,c], tetapi selama daftar input Anda menunjukkan urutan berurutan yang terbatas, itu bagus.

Memasukkan:

[]
[]
0

Keluaran:

[]

Memasukkan:

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

Keluaran:

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

Memasukkan:

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

Keluaran:

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

Memasukkan:

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

Keluaran:

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

Memasukkan:

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

Keluaran:

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

Memasukkan:

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

Keluaran:

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

Memasukkan:

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

Keluaran:

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

Mencetak gol

Ini adalah kode golf; jawaban terpendek dalam byte menang. Celah standar dilarang. Anda diizinkan menggunakan bawaan apa pun yang diinginkan.

MATL, 9 byte

&)i:&)bwv

Solusi ini menerima array nilai T(benar) dan F(salah) sebagai input kedua. Juga untuk kasus uji pertama, dengan array kosong, tidak menghasilkan output.

Cobalah secara Online! dan versi yang sedikit dimodifikasi untuk semua kasus uji.

Penjelasan

    % 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

^{Disimpan 4 byte dari @MartinEnder .}

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

Fungsi anonim. Mengambil indeks berbasis 1, daftar, dan spidol sebagai input dan mengembalikan daftar disusun ulang sebagai 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

Contoh penggunaan: ([1,2,3,4,5,6,7]#[True,False,False,True,True,False,False]) 3 -> [2,3,6,1,4,5,7].

Bagaimana itu bekerja:

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)

Jelly , 10 byte

¬+\>⁵Ḥ³oỤị

Cobalah online!

Bagaimana itu bekerja

¬+\>⁵Ḥ³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();
    }

ide perbaikan dihargai.

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

di mana adaftar elemen / angka, xadalahTrue/False daftar dan iindeks.

Versi multiline untuk meningkatkan keterbacaan:

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

Bagaimana cara kerjanya?

Panggilan untuk zip(a,x)hasil dalam daftar tupel di mana masing-masing berisi info: (element,0|1). Kemudian pemahaman daftar digunakan untuk menentukan elemen yang memiliki 0/Falsenilai terkait dan menyimpannya dalam variabel b.

Jadi [c for c,z in zip(a,x)if z<1]buat daftar yang berisi semua elemen yang memiliki 0( False) nilai yang terkait.

Setelah itu, daftar unsur-unsur yang memiliki True|1nilai yang terkait (yang ditentukan oleh pemeriksaan yang unsur atidak hadir dalam b: [c for c in a if(c in b)<1]) dimasukkan dalam daftar dengan semua elemen yang memiliki 0( False) nilai yang terkait (daftar b) pada indeks tertentu idan daftar yang dihasilkan dikembalikan.

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

Versi yang lebih lama:

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