Bu zorluğun amacı, seçili öğeleri bir listede toplamak ve bunları listede belirli bir konuma taşımaktır.

Görsel bir örnek olarak, giriş değerlerini (kara kutulu tamsayılarla temsil edilir) ve true öğesinin seçildiğini gösteren doğru değerler listesini alın (mavi kutularla temsil edilir, burada Tdoğruluk ve Fsahtedir):

İlk mantıklı adım, doğrulukla işaretlenmiş olan öğeleri doğru olmayan listelere ayırmaktır. Her listedeki göreli sıralamanın sürdürülmesi gerektiğini unutmayın (örn. Seçilen öğelerin 1,4,5sırası ve seçili olmayan öğelerin sırası olmalıdır 2,3,6,7)!

İkinci mantıksal adım, seçili olmayan öğelerin geri kalan listesinde bir dizin verilir, seçilen tüm öğeleri belirtilen dizindeki öğeden önce ekleyin. Dizin oluşturmanın 0'da başladığını varsayarsak, seçimi dizin 3'e eklemek istediğinizi varsayalım. Bu, 7kutunun önündeki noktaya karşılık gelir , bu nedenle seçili öğeler 7.

Nihai çözüm o zaman 2,3,6,1,4,5,7.

Bu mantıksal diyagramın bunun yapılabileceği bir yolu gösterdiğini unutmayın; çıktı her zaman aynı gözlemlenebilir sonucu ürettiği sürece programınızın aynı mantıksal adımları atmasına gerek yoktur.

Giriş

Programınıza 3 giriş verilir:

1. Öğeleri temsil eden tamsayıların bir listesi. Bu boş bir liste olabilir. Bu liste her zaman benzersiz pozitif tamsayılardan oluşacaktır, sıralı sıraya göre değil (yani 5 listede iki kez olmayacaktır).
2. Bir doğruluk değerinin aynı dizindeki öğenin seçildiğini temsil ettiği, öğeler listesiyle aynı uzunlukta doğruluk / falsy değerlerinin listesi.
3. Seçimin nereye ekleneceğini gösteren bir tam sayı. Listenin ilk öğesinin dizininin, programınızın her çalışmasında sabit olduğu sürece seçebilirsiniz (örneğin, ilk öğe dizin 0 veya dizin 1 olabilir). Lütfen programınızın hangi kurala uyduğunu belirtin. Bu dizin aralıkta olmalıdır [starting_idx, ending_idx+1], yani her zaman geçerli bir dizin olacaktır. Vaka dizini ending_idx+1için seçim listenin sonuna eklenmelidir. Bu tamsayının dilinizin yerel tamsayı türüne uygun olacağını varsayabilirsiniz.

Giriş istenen herhangi bir kaynaktan gelebilir (stdio, fonksiyon parametresi, vb.)

Çıktı

Çıktı, öğelerin son sırasını temsil eden bir listedir. Bu istenen herhangi bir kaynağa (stdio, dönüş değeri, fonksiyon çıkış parametresi, vb.) Olabilir. Herhangi bir girdiyi yerinde değiştirmenize izin verilir (örneğin, işlev parametresi olarak değiştirilebilen bir liste verilir ve işlevinizin bu listede yerinde çalışmasını sağlar).

Test senaryoları

Aşağıdaki test durumlarının tümü 0 tabanlı dizine ekleme olduğunu varsayar. Seçim maskesi için sırasıyla yanlış / doğruluk değerlerini belirtmek için 0 ve 1'i kullandım.

Test senaryoları [a,b,c], giriş listelerinizin sonlu sıralı bir sırayı temsil ettiği sürece listelerin biçimlendirilmiş olduğu görülür.

Giriş:

[]
[]
0

Çıktı:

[]

Giriş:

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

Çıktı:

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

Giriş:

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

Çıktı:

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

Giriş:

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

Çıktı:

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

Giriş:

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

Çıktı:

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

Giriş:

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

Çıktı:

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

Giriş:

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

Çıktı:

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

puanlama

Bu kod golf; baytlarda en kısa cevap kazanır. Standart boşluklar yasaktır. İstediğiniz yerleşikleri kullanma izniniz var.

MATL, 9 bayt

&)i:&)bwv

Bu çözüm , ikinci girdi olarak bir dizi T(true) ve F(false) değerini kabul eder. Ayrıca ilk test durumunda, boş dizilerle çıktı üretmez.

Çevrimiçi deneyin! ve tüm test senaryoları için biraz değiştirilmiş bir versiyon .

açıklama

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

^{@MartinEnder tarafından 4 bayt kaydedildi .}

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

Anonim işlev. 1 tabanlı dizini, listeyi ve işaretçileri girdi olarak alır ve yeniden sıralanmış listeyi çıktı olarak döndürür.

Haskell, 70 bayt

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

Kullanım örneği: ([1,2,3,4,5,6,7]#[True,False,False,True,True,False,False]) 3-> [2,3,6,1,4,5,7].

Nasıl çalışır:

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 bayt

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

Jöle , 10 bayt

¬+\>⁵Ḥ³oỤị

Çevrimiçi deneyin!

Nasıl çalışır

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

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

iyileştirme fikirleri takdir.

Python 3, 91 bayt

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

nerede aelemanları / numaralar listesi, xolduğu True/Falseliste ve iendeksidir.

Daha iyi okunabilirlik için çok satırlı sürüm:

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 nasıl çalışır?

Çağrısı zip(a,x)bunların her bilgi içeren dizilerini liste halinde sonuçları: (element,0|1). Daha sonra 0/Falseilişkili bir değere sahip elemanları belirlemek ve bunları değişkente saklamak için bir liste kavrama kullanılır b.

Böylece [c for c,z in zip(a,x)if z<1], 0( False) değeri ilişkilendirilmiş tüm öğeleri içeren bir liste oluşturur .

Bundan sonra, bir olması elemanların listesi True|1(unsurları kontrol bununla ilişkili değer amevcut değildir b: [c for c in a if(c in b)<1]) bir bütün elemanlar listedeki sokulur 0( False(liste ilgili olarak) bir değer bbelirtilen dizine) ive sonuçta oluşan liste döndürülür.

Python 3, 106 93 bayt

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

Eski versiyon:

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