计算矩阵向量

14

给定一个至少包含两个元素的整数数组，输出该数组的矩阵向量（定义如下）。

为了计算Matrix-Vector，首先旋转通过nsize - input数组以创建一个size的矩阵n x n，该数组的第一个元素位于主对角线之后。这形成矩阵部分。对于向量，垂直翻转输入数组。然后执行普通矩阵乘法。输出向量是结果。

例如，

a = [1, 2, 3]

首先，将阵列向右旋转两次，以获得[3, 1, 2]和[2, 3, 1]，然后将它们堆叠以形成3x3矩阵

[[1, 2, 3]
 [3, 1, 2]
 [2, 3, 1]]

接下来，垂直翻转数组以形成向量

[[1, 2, 3]    [[1]
 [3, 1, 2]  x  [2]
 [2, 3, 1]]    [3]]

执行通常的矩阵乘法

[[1, 2, 3]    [[1]    [[1+4+9]    [[14]
 [3, 1, 2]  x  [2]  =  [3+2+6]  =  [11]
 [2, 3, 1]]    [3]]    [2+6+3]]    [11]]

输出为[14, 11, 11]或[[14], [11], [11]]（您选择是否展平）。

范例＃2

a = [2, 5, 8, 3]

[[2, 5, 8, 3]    [[2]    [[4+25+64+9]     [[102]
 [3, 2, 5, 8]  x  [5]  =  [6+10+40+24]  =  [80]
 [8, 3, 2, 5]     [8]     [16+15+16+15]    [62]
 [5, 8, 3, 2]]    [3]]    [10+40+24+6]]    [80]]

[102, 80, 62, 80]

规则

可以假定输入和输出适合您语言的本机整数类型。
输入和输出可以任何方便的格式给出。
完整的程序或功能都是可以接受的。如果是函数，则可以返回输出而不是打印输出。
如果可能，请提供一个在线测试环境的链接，以便其他人可以尝试您的代码！
禁止出现标准漏洞。
这是代码高尔夫球，因此所有常用的高尔夫规则都适用，并且最短的代码（以字节为单位）获胜。

code-golf math array-manipulation matrix

— AdmBorkBork
source

Answers:

8

果冻，5个字节

ṙJṚæ.

在线尝试！

说明

首先：

这里是行向量，是列向量。v_kx

这表明矩阵乘法只是行和列之间的点积。

然后，实际上是旋转到右侧，并且被旋转到右侧，等等。v₁v0v_kvk-1

从另一个角度，被旋转到左边，并且被旋转到左边，等v₁vnv_nv1

怎么运行的

ṙJṚæ.   input: z (a list of length n)
ṙJ      [rot(z,1), rot(z,2), ..., rot(z,n)] (to the left)
  Ṛ     [rot(z,n), ..., rot(z,2), rot(z,1)]
   æ.   [rot(z,n).z , ..., rot(z,2).z , rot(z,1).z] (dot product)

— 漏尼姑
source

5

Python 2，68个字节

lambda x:[sum(map(int.__mul__,x,x[i:]+x[:i]))for i in range(len(x))]

在线尝试！

— 竿
source

4

Python 2，73个字节

def f(v):r=range(len(v));return[sum(v[i]*(v*2)[i+j]for i in r)for j in r]

在线尝试！

— 阿菲
source

(v*2)[i+j]绝招

— Leaky Nun

4

Pyth，10个字节

ms*VQ.>QdU

测试套件。

— 漏尼姑
source

3

果冻，9字节

LḶN⁸ṙæ×W€

在线尝试！

返回垂直数组的函数。作为完整程序，它看起来好像返回一个水平数组。要返回一个水平数组，您可以这样做LḶN⁸ṙ×⁸S€。

— 暴民埃里克
source

3

05AB1E，11个字节

DgGDÁ})ε*}O

在线尝试！

— 暴民埃里克
source

2

Haskell，49个字节

f v=sum.zipWith(*)v.fst<$>zip(iterate tail$v++v)v

在线尝试！

输入 v=[1,2]

iterate tail$v++v 产生清单 [[1,2,1,2],[2,1,2],[1,2],[2],[],...]
fst<$>zip l v与take(length v)l和相同[[1,2,1,2],[2,1,2]]
sum.zipWith(*)v 映射到每个元素上并产生矢量矩阵行积。

— 莱科尼
source

比我的答案聪明得多！我fst<$>zip l v非常喜欢。

— jferard '17

2

R，66 62字节

sapply(length(n<-scan()):1,function(i)c(n[-(1:i)],n[1:i])%*%n)

在线尝试！

— 漏尼姑
source

使用Map(function(i)c(n[-(1:i)],n[1:i])%*%n,length(n<-scan()):1)短了3个字节；它只返回矩阵列表。

— 朱塞佩

for循环for(i in seq(n<-scan()))F=c(c(n[-(1:i)],n[1:i])%*%n,F);F[1:i]为61个字节，而没有返回奇怪的输出格式。

— 朱塞佩

2

Mathematica，35个字节

Most@FoldList[RotateRight,#,1^#].#&

在线尝试！

来自@不是树的-9个字节

— J42161217
source

2

使用Mathematica自己的矩阵乘法要短于自己重新创建矩阵乘法Most@FoldList[RotateRight,#,1^#].#&。（但最好使用技巧Fold代替Nest！）

— 不是一棵树

1

CJam，17个字节

{__,,\fm>\f.*::+}

在线尝试！

— 暴民埃里克
source

1

GolfScript，37个字节

{..,({.)\+}[*]{[1$\]zip{~*}%{+}*}%\;}

在线尝试！

— 暴民埃里克
source

1

Python 3 + numpy，68个字节

lambda v:dot([roll(v,i)for i in range(len(v))],v)
from numpy import*

在线尝试！

— Notjagan
source

1

J，14个字节

+/ .*~#\.1&|.]

在线尝试！

说明

+/ .*~#\.1&|.]  Input: array M
      #\.       Length of each suffix, forms the range [len(M), ..., 2, 1]
             ]  Identity, get M
         1&|.   For each 'x' in the suffix lengths, rotate left M  by 'x'
+/ .*~          Dot product with M

— 英里
source

很好一个问题。当您不1&|.绑定1时|.，就创建一个monad吗？但是随后您将那个monad与左arg和右arg一起使用，左一个决定它被应用了多少次。这里发生了什么？

— 约拿（Jonah）

@Jonah这是的特殊格式&。当用作时u n&f v，它正在执行(n&f)^:u v。请参阅bond的底部以了解更多解析。

— 英里

啊，TIL。是您经常使用的东西吗？

— 约拿（Jonah）

@Jonah在许多情况下对打高尔夫球很有用。在这种情况下，可以使用rank在相同数量的字节中完成此操作#\.|."{]，但是在尝试替代方法之前，我发布了最先提出的最短方法。

— 英里

1

APL，17个字节

(↑¯1⌽(⍳≢)⌽¨⊂)+.×⍪

说明：

(↑¯1⌽(⍳≢)⌽¨⊂)+.×⍪

 ↑                      matrix format of
  ¯1⌽                   right rotate by 1 of
     (⍳≢)               the 1..[length N]
         ⌽¨             rotations of
           ⊂            the enclosed input
             +.×        inner product with
                ⍪       1-column matrix of input

— 马里纳斯
source

1

八度，34字节

@(a)a*toeplitz(a,shift(flip(a),1))

在线尝试！

— Alephalpha
source

1

Haskell，56 55 52字节

f l=[sum$zipWith(*)l$drop i$l++l|i<-[0..length l-1]]

在线尝试！

@Laikoni节省了一个字节

保存了三个字节：l++l而不是cycle l

— 杰费拉德
source

您可以使用保存一个字节zipWith(*)l$drop i$cycle l。

— Laikoni'7

1

外壳，11个字节

mΣ§‡*´ṀKoṫ¢

在线尝试！

说明

mΣ§‡*´ṀKoṫ¢  Implicit input, e.g. [1,2,3]
          ¢  Cycle: [1,2,3,1,2,3,...
        oṫ   Tails: [[1,2,3,1,2,3...],[2,3,1,2,3...],[3,1,2,3...]...
     ´ṀK     Replace each element of input with input: [[1,2,3],[1,2,3],[1,2,3]]
   ‡*        Vectorized multiplication (truncated with respect to shortest list)
  §          applied to the last two results: [[1,4,9],[2,6,3],[3,2,6]]
mΣ           Sum of each row: [14,11,11]

— 兹加布
source

1

八度-67 48字节

感谢Luis Mendo将代码缩减了19个字节！

注意：此代码只能在Octave中运行。MATLAB不支持可以创建变量的函数内部的表达式，同时评估创建变量的表达式。

n=numel(a=input(''));a(mod((x=0:n-1)-x',n)+1)*a'

您可以在此处找到MATLAB中的原始代码，但可以在任何版本的MATLAB中运行。这段代码是67个字节：

a=input('');n=numel(a)-1;a(mod(bsxfun(@minus,0:n,(0:n)'),n+1)+1)*a'

说明

a=input('');-通过标准输入从用户接收（行）向量。您必须以八度形式输入矢量（即[1,2,3]）。
n=numel(...); -获取输入向量中元素的总数。
x=0:n-1-创建一个行向量，该向量从递增0到n-11。
(x=0:n-1)-x'-执行广播，以便我们有一个n x n矩阵，使得每一行i都是从0到最大n-1元素，行中的每个元素都i减去i。
mod(..., n)+1-确保所有负值都环绕到，n以便每一行i包含从0到最大的向量n-1 向左循环移位i元素。我们将1加为MATLAB / Octave以1开始索引向量或矩阵。
a(...) -创建一个 n x n矩阵，其中使用（4），我们访问由（4）中的每个值指示的输入矢量的正确索引，从而获得所需的矩阵。
(...)*a' -通过转置/翻转执行矩阵矢量乘法 a在进行乘法运算之前，使其成为列向量。

示例运行

>> n=numel(a=input(''));a(mod((x=0:n-1)-x',n)+1)*a'
[1,2,3]

ans =

         14.00
         11.00
         11.00

>> n=numel(a=input(''));a(mod((x=0:n-1)-x',n)+1)*a'
[2,5,8,3]

ans =

        102.00
         80.00
         62.00
         80.00

在线尝试！

— rayryeng-恢复莫妮卡
source

您可以使用隐式扩展代替bsxfun。n没有定义也-1节省了一些字节。如果您限制使用Octave，则可以随时分配a和分配0:n变量，并保存更多内容。另外，经常来这里！:-D

— 路易斯·门多

@LuisMendo啊，是的。我忘了Octave已支持隐式扩展。在input函数中保存变量也是一个绝妙的技巧。我认为它不能支持这一点。根据我自己的经验，我仅在C或C ++中看到过它。谢谢！

— rayryeng-恢复莫妮卡

1

@LuisMendo我将尽快将您建议的更改作为修改内容。我一直很忙，但是我没有将其作为优先事项，因为该条目肯定不会赢得字节数。

— rayryeng-恢复莫妮卡

@LuisMendo已更改。非常感谢您：)我在更改上面的解释时了解了代码。

— rayryeng-恢复莫妮卡

很高兴能为您提供帮助：-)

— 路易斯·门多

0

Javascript 79字节

接受输入数组并输出矩阵向量的数组

a=>(b=[...a],a.map(x=>([...b].reduce((m,n,i)=>m+=n*a[i],0,b.push(b.shift())))))

说明

a=>(
    b=[...a],                    // copy the input into b
    a.map(x=>(                   // transform a into a new array
        [...b].reduce(           // copy b into a new array and reduce
            (m,n,i)=>m+=n*a[i],  // memo += the element in the array * the ith
                                 // element in a
            0,                   // start memo at 0
            b.push(b.shift())    // shift the first element in b to the end
                                 // not used by reduce, but performing this op
                                 // here saves a few bytes
        )
    ))
)

— 傲慢的
source

0

Clojure，80个字节

#(map(fn[_ c](apply +(map * c %)))%(iterate(fn[c](into[(last c)](butlast c)))%))

iterate产生无限序列，但(take (count %) (iterate ...))我没有使用停止它，而是将其%用作的额外参数map。

— 尼古妮
source

0

Perl 5，65 +1（-a）= 66字节

@o=@F;for(@o){$r=0;$r+=$_*$F[$i++%@F]for@o;say$r;unshift@F,pop@F}

在线尝试！

将输入向量作为空格分隔的数字。输出换行符分隔的数字，表示结果向量。

— Xcali
source

0

C（gcc），126字节

i,j;int*f(int*a,int n){int*r=malloc(n*sizeof(int));for(i=0;i<n;i++){r[i]=0;for(j=0;j<n;j++)r[i]+=a[j]*a[(j-i+n)%n];}return r;}

在线尝试！

数组可以在输入中表示为指针和长度。

— 漏尼姑
source

0

Common Lisp，78个字节

(lambda(x)(loop as i on(append x x)as y in x collect(reduce'+(mapcar'* i x))))

在线尝试！

将数组加倍（在这种情况下为Lisp列表），并使用i（使用x，到y，停止迭代）遍历子列表。然后，通过将的每个元素x与的每个元素相乘的结果相加来计算结果的下一个元素i（在较短的列表终止时再次停止）。

— 伦佐
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.