这项挑战的目标是收集列表中的选定项目并将其移动到列表中的特定位置。

作为一个直观示例，请使用输入值（用黑框整数表示）和相应的真值列表，其中true表示已选择项目（用蓝色框表示，其中T真是F虚假）：

逻辑上的第一步是将标记为“真”和“不真”的项目分成相应的列表。请注意，必须保持每个列表中的相对顺序（即，所选项目的顺序必须为1,4,5，而未选中项目的顺序必须为2,3,6,7）！

第二个逻辑步骤是在未选择项的其余列表中指定一个索引，在给定索引处将所有选择的项插入到该项之前。假设索引从0开始，假设您要在索引3处插入选择。这对应于7框前的位置，因此所选项目应插入之前7。

最终的解决方案是2,3,6,1,4,5,7。

注意，此逻辑图描述了可以完成此操作的一种方法。只要输出始终产生相同的可观察结果，您的程序就无需采取相同的逻辑步骤。

输入值

您的程序有3个输入：

1. 代表项目的整数列表。这可能是一个空列表。此列表将始终由唯一的正整数组成，而不必按排序顺序排列（即，列表中5不会出现两次）。
2. 真/假值列表，其长度与项目列表的长度相同，其中真值表示已选择具有相同索引的项目。
3. 一个整数，表示要插入选择的位置。您可以选择列表中第一项的索引，只要它在程序的每次运行中都保持不变即可（例如，第一项可以是索引0或索引1）。请指定您的程序遵守的约定。该索引应在范围内[starting_idx, ending_idx+1]，即它将始终是有效索引。如果案例索引为ending_idx+1，则选择内容应插入列表的末尾。您可能会认为此整数适合您语言的本机整数类型。

输入可以来自任何所需的来源（stdio，功能参数等）

输出量

输出是代表项目最终顺序的列表。这可以是任何所需的源（stdio，返回值，函数输出参数等）。允许您就地修改任何输入（例如，给定一个可修改列表作为函数参数，并让您的函数在该列表上就地操作）。

测试用例

以下所有测试用例均假定基于0的索引。我使用0和1分别表示选择蒙版的虚假/真实值。

测试用例碰巧具有格式为的列表[a,b,c]，但是只要您的输入列表表示一个有限的有序序列就可以了。

输入：

[]
[]
0

输出：

[]

输入：

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

输出：

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

输入：

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

输出：

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

输入：

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

输出：

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

输入：

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

输出：

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

输入：

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

输出：

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

输入：

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

输出：

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

计分

这是代码高尔夫；以字节为单位的最短答案获胜。禁止出现标准漏洞。允许您使用所需的任何内置函数。

MATL，9个字节

&)i:&)bwv

此解决方案接受T（true）和F（false）值的数组作为第二个输入。同样对于第一个用空数组的测试用例，它不产生任何输出。

在线尝试！以及所有测试用例的略微修改版本。

说明

    % 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字节

^{从@MartinEnder保存了4个字节。}

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

匿名函数。将基于1的索引，列表和标记作为输入，并将重新排序的列表作为输出返回。

Haskell，70个字节

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

用法示例：([1,2,3,4,5,6,7]#[True,False,False,True,True,False,False]) 3-> [2,3,6,1,4,5,7]。

怎么运行的：

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个字节

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

果冻，10 字节

¬+\>⁵Ḥ³oỤị

在线尝试！

怎么运行的

¬+\>⁵Ḥ³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个字节

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

松开

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

改进想法表示赞赏。

Python 3，91个字节

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

其中a是元素/号码列表，x是True/False列表，i是索引。

多行版本可提高可读性：

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

它是如何工作的？

对的调用会生成zip(a,x)一个元组列表，其中每个元组都包含信息：(element,0|1)。然后，使用列表推导确定具有0/False关联值的元素，并将其存储在变量中b。

因此，将[c for c,z in zip(a,x)if z<1]创建一个包含所有与0（False）值关联的元素的列表。

在此之后，其具有的元素的列表True|1相关联的值（这是由检查哪些元素确定a不存在于b：[c for c in a if(c in b)<1]）插入与具有所有元素列表0（False相关联的（列表）的值b中指定索引处）i并返回结果列表。

Python 3，106 93字节

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

旧版本：

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