广义列阵

22

一个简单的高尔夫开始本周！您将获得三个数组：基本数组 B，值数组 V和索引数组 I。您应该生成另一个数组，其中from的值V将插入到B由指定的索引处I。这是一个例子：

Base:    [5, 1, 4, 1, 3]
Values:  [0, 0, 7]
Indices: [5, 0, 3]

索引指向基数组中的以下位置：

[ 5, 1, 4, 1, 3 ]
 ^        ^    ^
 0        3    5

因此，从值数组中插入相应的元素，结果应为：

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

规则

您可以编写程序或函数，通过STDIN（或最接近的替代方案），命令行参数或函数自变量获取输入，并通过STDOUT（或最接近的替代方案），函数返回值或通过修改作为B参数给出的数组来输出结果。

如果您提交的内容是一种函数，I并且V可以以任何方式进行修改以及B不用于输出。

您可以对输入做出以下假设：

  • 基数和值数组的所有元素都是非负整数。
  • 该值数组最多比基本数组多一个元素。
  • 值数组和索引数组将具有相同数量的元素。
  • 索引数组将不包含重复的索引，并且所有索引都在范围内。
  • 基数组和值数组可能包含重复的元素。
  • 任何或所有数组可能为空。
  • 您不能假定索引是以任何特定顺序给出的。
  • 您可以任何方便，明确的字符串或列表格式接收输入并产生输出。您也可以选择以不同的顺序接收三个阵列。
  • 您可以在基于0的索引和基于1的索引之间进行选择。

这是代码高尔夫球，因此最短的答案（以字节为单位）获胜。

测试用例

以B V I => Result基于0的索引的格式给出。如果您使用的是基于1的索引，则将第三个数组的元素加1。

[] [] [] => []
[] [1] [0] => [1]
[1,2] [] [] => [1,2]
[1,2] [3] [0] => [3,1,2]
[1,2] [3] [1] => [1,3,2]
[1,2] [3] [2] => [1,2,3]
[0,0,0] [1,1,1,1] [0,1,2,3] => [1,0,1,0,1,0,1]
[5,1,4,1,3] [0,0,7] [5,0,3] => [0,5,1,4,7,1,3,0]
[1,2,3,4] [4,3,2,1] [4,0,3,1] => [3,1,1,2,3,2,4,4]

如果您遇到其他有趣的极端情况，请告诉我，我将添加它们。

排行榜

这是一个堆栈片段，用于按语言生成常规排行榜和获胜者概述。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以将旧分数保留在标题中，方法是将它们打掉。例如：

# Ruby, <s>104</s> <s>101</s> 96 bytes

显示代码段

code-golf  array-manipulation 
— 马丁·恩德
source
4
NULL对于使用空数组的语言，您如何看待空数组NULL？
— Alex A.
@AlexA。如果它是一个通用/ 中所述的语言（S）的空数组的表示，我与罚款。
— 马丁·恩德
3
一个简单的高尔夫？这是我整个星期在CJam所做的最困难的事情。：P
— 丹尼斯

Answers:

13

Pyth，14个字节

s.icFPQmedSCtQ

示范。

该程序将输入作为基本，索引，值顺序的三元组列表。

示例说明[5, 1, 4, 1, 3], [5, 0, 3], [0, 0, 7]：

  1. 接受输入：隐式，Q是输入。

  2. 制作索引，值对： CtQ =[(5, 0), (0, 0), (3, 7)]

  3. 将对按升序排序：SCtQ=[(0, 0), (3, 7), (5, 0)]

  4. 从每对中取值：medSCtQ=[0, 7, 0]

  5. 在索引位置拆分基本列表：cFPQ=[[], [5, 1, 4], [1, 3], []]

  6. 交错3和4：.icFPQmedSCtQ=[[], 0, [5, 1, 4], 7, [1, 3], 0, []]

  7. 合并为一个列表：s.icFPQmedSCtQ=[0, 5, 1, 4, 7, 1, 3, 0]

— 伊萨格
source
该死的。从什么时候开始有交错方法？只是想发表 ssC,cFPQamedSCtQ]。
— 雅库布2015年
5
@Jakube isaac在6天前偷偷地提交了它。
— orlp
— 2015年
3
@Jakube，因为Pyth可以解决任何问题。这就是高尔夫语言的问题。存在深奥的语言是为了深奥的语言。因为它们是*后来设计的。
— 森蒂奥2015年
@sentiao公平地说，一段时间以来，宿主语言（Python）以不同的名称进行了交错。
— Mego 2016年
16

Python 2，54

lambda B,*X:map(B.insert,*zip(*sorted(zip(*X))[::-1]))

输入为 B,I,V。B调用时修改输入（感谢MartinBüttner提醒我这是可能的）。

用于map调用B.insert每个索引/元素对。为避免列表索引随元素插入而移动的问​​题，请使用丑陋的zip / sort / unzip按降序对索引对进行排序。如果不是因为变化的问题，我们就可以做map(B.insert,*X)。

旧方法（65）：

B,V,I=input()
for i,v in sorted(zip(I,V))[::-1]:B[i:i]=v,
print B
— 异或
source
5

Haskell，62个字节

import Data.List
f b v i=map snd$sort$zip[0.5,1.5..]b++zip i v

用法示例： f [5,1,4,1,3] [0,0,7] [5,0,3] -> [0,5,1,4,7,1,3,0]。

运作方式：从0.5（例如，[(0.5,5),(1.5,1),(2.5,4),(3.5,1),(4.5,3)]）并将其与索引值对连接。排序并丢弃索引。

备注：不知道我是否在这里作弊。从数学的角度来看它的罚款，但程序员可能会认为，指数的名单[5,0,3]是不是名单Integers的要求，但名单Fractionals（准确的说，该类型是多态的，但必须属于Fractional类，如Float或Double）。

— 妮米
source
5

Ruby，60 59 53字节

->a,b,c{c.zip(b).sort.reverse.map{|i,v|a.insert i,v}}

和非高尔夫版本

def riffle(array, values, indices)
    indices.zip(values).sort.reverse.each do |index, value|
        array.insert(index, value)
    end
end
— 迪伦·弗雷斯（Dylan Frese）
source
2
您可以通过它一个匿名函数，而不是缩短这个：->a,b,c{...}。另外insert，也不需要括号。
— 马丁·恩德
@MartinBüttner我确实知道lambda的未命名函数，但是我并不觉得这是挑战的精神（通常要求一个命名函数）。不过，感谢您发现原谅。
— 迪伦·弗雷斯
除非挑战明确要求使用命名函数，否则未命名函数总是可以接受的。而且我没有要求一个命名函数（我从来没有;）。
— 马丁·恩德
5

CJam，34 23 18字节

{.\2/\ee+{0=}$1f=}

我的第一次CJam提交。欢迎提供建议，我敢肯定高尔夫有很多。

在@MartinBüttner和@Dennis的帮助下保存了16个字节。

函数期望按顺序输入堆栈 B V I（I是最高的）。

用法示例：

[5 1 4 1 3] [0 0 7] [5 0 3] {.\2/\ee+{0=}$1f=}~

方法：

  • 与数组的ith元素配对i+0.5
  • 将插入值与插入位置配对
  • 合并结果两个数组
  • 根据位置元素对数组进行排序
  • 保留价值要素
— 随机
source
这种浮点方法非常聪明，并且（不好）比我的更好。您可以q~.5fm.\2/\ee+$1f=p使用匿名函数将字节数减少到19个字节，将字节数减少到18个字节：{.5fm.\2/\ee+$1f=}
— 丹尼斯
没有浮点数技巧的相同想法：（{.\2/\ee+{0=}$1f=}仍为18个字节）
— 丹尼斯
@Dennis谢谢，我找不到的get array element运算符1f=。我将把它留为完整程序。
— randomra
你的来电。您介意我问您为什么反对发布功能吗？
— 丹尼斯
@Dennis我刚刚启动CJam，不确定如何使用这些功能。现在我想通了，所以我改变了答案。
— randomra'5
5

K，22 21字节

{,//+(y@<z;(z@<z)_ x)}

我们定义了一个3参数的功能{…}与隐变量x，y并z代表首发名单，值列表和索引列表，分别。“剪切”运算符（_）用于在给定索引（(z@<z)）的排序列表处将起始列表分开。我们通过形成一个列表（(a;b)），取其转置（+）并展平结果（,//），将值（在对它们进行相应地排序之后）与原始数组的分割后的块进行交织。

用法示例：

  f:{,//+(y@<z;(z@<z)_ x)}
{,//+(y@<z;(z@<z)_ x)}

  f[1 2 3 4;4 3 2 1;4 0 3 1]
3 1 1 2 3 2 4 4

  f[5 1 4 1 3;0 0 7;5 0 3]
0 5 1 4 7 1 3 0

下划线周围必须有空格，因为K允许标识符中使用下划线。K5消除了这种潜在的歧义。如果我们可以指望索引以升序出现并且下划线不是有效的标识符，那么我们可以使用更好的13字节程序：

{,//+(y;z_x)}

（叹。）

编辑：

{,//+(y@<z;(z@<z)_ x)} / before
{,//+(y@<z;z[<z]_ x)}  / after

破坏对称性，但是我们可以使用方括号索引（[…]）代替中缀@索引运算符来保存字节。通常，这会使程序变长，但是在这种情况下，z在执行剪切之前，无论如何我们都需要对parens进行排序。

— 约翰
source
4

Pyth，17个字节

ssC,cFPQamedSCtQ]

@isaacg已经击败了我的解决方案。但是，既然我完成了文档的编写，无论如何我都会将其发布。

这将采用格式的输入B, I, V。您可以在这里尝试：演示或测试套件

说明：

我正在使用B = [5,1,4,1,3], I = [5,0,3], V = [0,0,7]OP中的示例。

                    implicit: Q = input()
      PQ            all elements but last of Q   => [[5,1,4,1,3], [5,0,3]]
    cF              split B it the indices in I  => [[], [5,1,4], [1,3], []]

              tQ    all elements but first of Q  => [[5,0,3], [0,0,7]]
             C      zip                          => [(5,0), (0,0), (3,7)]
            S       sort                         => [(0,0), (3,7), (5,0)]
         med        extract the end of each pair => [0,7,0]
        a       ]   append an empty list         => [0,7,0,[]]

   ,                create a pair => ([[], [5,1,4], [1,3], []], [0,7,0,[]])
  C                 zip           => [([],0), ([5,1,4],7), ([1,3],0), ([],[])]
 s                  sum           => ([],0,[5,1,4],7,[1,3],0,[],[])
s                   sum           => [0,5,1,4,7,1,3,0]
— 雅库比
source
4

JavaScript（ES6），75

具有3个数组参数的函数，返回一个数组。奇怪的是，此函数修改了其i参数（如OP所允许）

测试运行该片段，Firefox仅照常运行。 

f=(b,v,i,j=0)=>b.concat(v).map(p=>(p=i.indexOf(j))<0?b[j++]:(i[p]=-1,v[p]))

// TEST
out=x=>O.innerHTML+=x+'\n'

test=[
{ b:[], v:[], i:[], k:[] },
{ b:[], v:[1], i:[0], k:[1] },
{ b:[1,2], v:[], i:[], k:[1,2] },
{ b:[1,2], v:[3], i:[0], k:[3,1,2] },
{ b:[1,2], v:[3], i:[1], k:[1,3,2] },
{ b:[1,2], v:[3], i:[2], k:[1,2,3] },
{ b:[0,0,0], v:[1,1,1,1], i:[0,1,2,3], k:[1,0,1,0,1,0,1] },
{ b:[5,1,4,1,3], v:[0,0,7], i:[5,0,3], k:[0,5,1,4,7,1,3,0] },
{ b:[1,2,3,4], v:[4,3,2,1], i:[4,0,3,1], k:[3,1,1,2,3,2,4,4] }
];

test.forEach(x=>{
  r = f(x.b,x.v,x.i.slice(0)) // pass a copy of i, as the function will alter it
  ok = ''+r==''+x.k
  s='Test ' + (ok?'OK':'FAIL')
  +'\n B ['+x.b
  +']\n V ['+x.v
  +']\n I ['+x.i
  +']\n Result ['+r
  +']\n Check  ['+x.k
  +']\n'
  out(s)
  
})
<pre id=O></pre>
展开摘要

— edc65
source
出于好奇，该代码如何使其特定于Firefox？是因为它是ES6吗？
— Alex A.
@AlexA。是因为它是ES6。特别是在fat arrow function甚至没有在Chrome（据我所知）的开发者版本中实现
— edc65
确实，甚至连Canary的Chrome版本都不支持它。
— DocMax
4

Mathematica，52岁 51字节

Last/@(Tr@#2->#&~MapIndexed~#⋃Thread[#3+.5->#2])&

例：

In[1]:= f = Last/@(Tr@#2->#&~MapIndexed~#⋃Thread[#3+.5->#2])&;

In[2]:= f[{5, 1, 4, 1, 3}, {0, 0, 7}, {5, 0, 3}]

Out[2]= {0, 5, 1, 4, 7, 1, 3, 0}

说明：

使用上面的示例。

  • Tr@#2->#&~MapIndexed~# => {1 -> 5, 2 -> 1, 3 -> 4, 4 -> 1, 5 -> 3}
  • Thread[#3+.5->#2] => {5.5 -> 0, 0.5 -> 0, 3.5 -> 7}
  • 然后采用这两个列表的（排序的）并集。（=>{0.5 -> 0, 1 -> 5, 2 -> 1, 3 -> 4, 3.5 -> 7, 4 -> 1, 5 -> 3, 5.5 -> 0}）
  • 然后取每对的最后一个元素。（=> {0, 5, 1, 4, 7, 1, 3, 0}）
— Alephalpha
source
3

R，75个字节

function(b,v,i){n=b;j=0;for(g in v)n=append(n,g,i[j<-j+1]+sum(i<i[j])-1);n}

这将创建一个未命名的函数。要给它起个名字，例如f=function...。注意，数组必须是1索引的，因为这就是R滚动的方式。

取消+说明：

f <- function(b, v, i) {
    # Initialize the output vector to b
    n <- b

    # Initialize an index over the indices
    j <- 0

    # Loop over the values to insert
    for(g in v) {
        # Get the index of the next given insertion index
        j <- j + 1

        # Insert g into n.
        # The position at which to insert the value is determined by
        # adding the number of indices less than the current one and
        # subtracting 1. The subtraction is because we're using the
        # `after` argument in the `append` function.

        n <- append(n, g, i[j] + sum(i < i[j]) - 1)
    }

    # Return n
    n
}

例子：

> f(c(), c(), c())
[1] NULL

> f(c(0, 0, 0), c(1, 1, 1, 1), c(1, 2, 3, 4))
[1] 1 0 1 0 1 0 1

> f(c(5, 1, 4, 1, 3), c(0, 0, 7), c(6, 1, 4))
[1] 0 5 1 4 7 1 3 0

一如既往地欢迎提出建议！

— 亚历克斯·A
source
2

CJam，19个字节

l~_,)N*q~.{t}~.\N-p

这是一个完整的程序，可从STDIN 读取数组B，I和V（每行一个，按此顺序）。

在CJam解释器中在线尝试。

怎么运行的

l~    e# Evaluate the first line of input.
_,)   e# Compute the array length and add 1.
N*    e# Push a string of that many linefeeds.
q~    e# Evaluate the remaining input.
.{t}~ e# Vectorized array set: for each index in the array from line 2, replace the
      e# LF at that index by the corresponding element of the array from line 3.
.\    e# Interleave the two arrays on the stack.
N-    e# Remove the linefeeds.
p     e# Print.

CJam，20个字节

{Qa+@@.{a2$2$=+t}e_}

这是一个匿名函数，它从堆栈中弹出B，V和I（从上到下），并在堆栈中留下单个数组作为回报。

在CJam解释器中在线尝试。

怎么运行的

Qa+      e# Append [[]] to B.
@@       e# Rotate V and I on top of B.
.{       e# For each v in V and the corresponding i in I:
   a     e#     Push [v].
   2$2$= e#     Retrieve b := B[i].
   +     e#     Append to push [v b].
         e#     The stack now consists of: B i [v b]
   t     e#     Set B[i] := [v b].
}        e#
e_       e# Flatten B.
— 丹尼斯
source
1

Ruby，48个字节

我认为这符合规则，但请检查。

->b,v,i{l=-1;i.map{|j|b[j]=[v[l+=1],b[j]]};b*?:}

将三个数组作为输入的未命名函数。使用ruby表达式输出可以明确解析为数字数组的字符串x.split(/:+/).map(&:to_i)。

测试用例ideone。

我可以再多保存3个字节，但是输出格式[1,2,[nil,5]]对规则的扩展过于严格，尽管它是明确的。

— 蓝橙
source
我认为目前的格式还可以。具有交织nil值的嵌套数组有点麻烦。但是无论哪种情况，这都没有赢得比赛，所以我也不是很担心。
— 马丁·恩德
1

R，60

作为采用b，v和i的未命名函数

function(b,v,i){e=c(NA,rbind(b,NA));e[i*2+1]=v;e[!is.na(e)]}

用NA扩展b用v填充所需的空格返回没有NA的向量

> f=function(b,v,i){e=c(NA,rbind(b,NA));e[i*2+1]=v;e[!is.na(e)]}
> f(c(), c(), c())
logical(0)
> f(c(0, 0, 0), c(1, 1, 1, 1), c(0, 1, 2, 3))
[1] 1 0 1 0 1 0 1
> f(c(5, 1, 4, 1, 3), c(0, 0, 7), c(5, 0, 3))
[1] 0 5 1 4 7 1 3 0
— 米奇
source
1

Java，253、226、219， 209

并非完全是赢家，但是哦。

假设B，V和I不为null。v（小写的v）是“值/索引”数组的长度。R是返回的数组。r是返回数组的长度。x，y和i均为临时整数。

int[]f(int[]B,int[]V,int[]I){int v=V.length,r=B.length+v,x,y,i;int[]R=java.utils.Arrays.copyOf(B,r);for(x=0;x<v;x++){i=I[x];for(y=0;y<x;y++)if(I[x]>I[y])i++;for(y=r-2;y>=i;y--)R[y+1]=R[y];R[i]=V[x];}return R;}

扩展：

int[]f( int[] B, int[] V, int[] I ) {
    int v = V.length, //length of Values
        r = B.length + v, //length of the result
        x, y, i; //temps
        int[] R = java.utils.Arrays.copyOf( B, r );       
        for( x = 0; x < v; x++ ) {
        i = I[x];
        for( y = 0; y < x; y++ )
            if( I[x] > I[y] )
                i++;
        for( y = r - 2; y >= i; y-- )
            R[y+1] = R[y];
        R[i] = V[x];
    }
    return R;
}
— 杰克·阿莫
source
1

APL，22个字节

{(∊⌽2↑⍵)[⍋(2⊃⍵),⍳≢⊃⍵]}

在⎕IO←0中匹配测试用例。

这是一种标准算法：第一个参数的索引向量附加到给定的索引（第三个参数）上。⍋计算将按升序对索引进行排序的排列。由于APL的排序算法从定义上来说是稳定的，因此计算的置换将第二个和第一个参数的串联元素放在正确的位置。

例如：

    {(∊⌽2↑⍵)[⍋(2⊃⍵),⍳≢⊃⍵]}(5 1 4 1 3)(0 0 7)(5 0 3)
0 5 1 4 7 1 3 0
— 斯蒂芬诺
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.