在这个挑战中，您将得到一个方矩阵A，一个向量v和一个标量λ。您将需要确定是否(λ, v)对应于的本征对A。即，是否Av = λv。

点积

两个向量的点积是逐元素相乘的总和。例如，以下两个向量的点积为：

(1, 2, 3) * (4, 5, 6) = 1*4 + 2*5 + 3*6 = 32

注意，点积仅定义在两个相同长度的向量之间。

矩阵向量乘法

矩阵是2D值网格。的mX n矩阵具有m行和n列。我们可以将mx n矩阵想象成长度m向量n（如果我们取行）。

在mx n矩阵和大小n向量之间定义矩阵向量乘法。如果我们将mx n矩阵与大小n向量相乘，我们将获得大小m向量。i结果向量中的-th值是i矩阵的第-行与原始向量的点积。

例

        1 2 3 4 5
Let A = 3 4 5 6 7
        5 6 7 8 9

        1
        3
Let v = 5
        7
        9

如果将矩阵和向量相乘，将Av = x得到以下结果：

x ₁ = A ^T ₁ * v /* AT1 means the first row of A; A1 would be the first column */=（1,2,3,4,5）*（1,3,5,7,9）= 1 * 1 + 2 * 3 + 3 * 5 + 4 * 7 + 5 * 9 = 1 + 6 + 15 + 28 + 45 = 95

x ₂ = A ^T ₂ * v =（3,4,5,6,7）*（1,3,5,7,9）= 3 * 1 + 4 * 3 + 5 * 5 + 6 * 7 + 7 * 9 = 3 + 12 + 25 + 42 + 63 = 145

x ₃ = A ^T ₃ * v =（5,6,7,8,9）*（1,3,5,7,9）= 5 * 1 + 6 * 3 + 7 * 5 + 8 * 7 + 9 * 9 = 5 + 18 + 35 + 56 + 81 = 195

因此，我们得到了Av = x = (95, 145, 195)。

标量乘法

标量（单个数）与向量的乘法只是元素逐个乘法。例如，3 * (1, 2, 3) = (3, 6, 9)。这很简单。

特征值和特征向量

鉴于矩阵A，我们说λ是对应于特征值v和v对应于一个特征向量λ 当且仅当 Av = λv。（这里Av是矩阵矢量乘法，λv是标量乘法）。

(λ, v) 是一个本征对。

挑战规格

输入项

输入将包含一个矩阵，一个向量和一个标量。这些可以以任何合理格式的任何顺序进行。

输出量

输出将是真实/虚假值；当且仅当标量和向量是具有指定矩阵的本征对时，才为真。

规则

• 适用标准漏洞
• 如果您的语言中存在用于验证本征对的内置函数，则可能无法使用它。
• 您可以假设所有数字都是整数

测试用例

 MATRIX  VECTOR  EIGENVALUE
 2 -3 -1    3
 1 -2 -1    1    1    ->    TRUE
 1 -3  0    0

 2 -3 -1    1
 1 -2 -1    1    -2   ->    TRUE
 1 -3  0    1

 1  6  3    1
 0 -2  0    0    4    ->    TRUE
 3  6  1    1

 1  0 -1    2
-1  1  1    1    7    ->    FALSE
 1  0  0    0

-4 3    1    
 2 1    2    2    ->    TRUE

2    1    2    ->    TRUE

稍后再添加4x4。

不可读的测试用例，更易于测试

果冻，5个字节

æ.⁵⁼×

这是一个三合一的完整程序。

在线尝试！

怎么运行的

æ.⁵⁼×  Main link
       Left argument:  v (eigenvector)
       Right argument: λ (eigenvalue)
       Third argument: A (matrix)

  ⁵    Third; yield A.
æ.     Take the dot product of v and A, yielding Av.
    ×  Multiply v and λ component by component, yielding λv.
   ⁼   Test the results to the left and to the right for equality.

Mathematica，10个字节

#2.#==#3#&

接受类似的输入{vector, matrix, scalar}并返回一个布尔值。

MATL，7个字节

*i2GY*=

输入顺序为：l，v，A。

说明：

*  % implicitly get l and v, multiply.
i  % get A
2G % get second input, i.e., v again
Y* % perform matrix multiplication
=  % test equality of both multiplications

如果您问我，答案出奇的长，主要是因为我需要一种正确获取所有输入的方法。我认为少于5个字节是不可能的，但是如果有人找到5或6个字节的解决方案，那将很酷。

基本上，这是计算l*v==A*v。

CJam，15个字节

q~W$f.*::+@@f*=

以形式输入vector scalar matrix。

在线尝试！

说明

q~               e# Read and eval the input
  W$             e# Copy the bottom most value (the vector)
    f.*::+       e# Perform element-wise multiplication with each row of the matrix, then
                 e#   sum the results of each (ie dot product with each row) 
          @@     e# Move the resulting vector to the bottom of the stack
            f*   e# Element-wise multiplication of the scalar and the vector
              =  e# Check if the two vectors are equal

MATLAB，16个字节

@(A,v,l)A*v==v*l

比较简单的答案。定义一个接受输入的匿名函数，并计算所得向量的逐元素相等性。逻辑数组中的单个零会使MATLAB中的数组变为假。

MATLAB，38个字节

function r=f(m,v,s);r=isequal(m*v,s*v)

返回1或0。

MATLAB，30个字节

function r=f(m,v,s);r=m*v==s*v

退货

1
1
1

作为真实的价值。虚假值是一个相似的向量，其中任何或所有值均为0而不是1。

C ++，225203字节

感谢@Cort Ammon和@Julian Wolf节省了22个字节！

#import<vector>
#define F(v,i)for(i=0;i<v.size();++i)
using V=std::vector<float>;int f(std::vector<V>m,V v,float s){V p;int i,j;F(m,i){p.push_back(0);F(v,j)p[i]+=v[j]*m[i][j];}F(v,i)v[i]*=s;return v==p;}

在线尝试！

朱莉娅，17个字节

(a,b,c)->a*b==b*c

在线尝试！

Python 2.7，33个字节

f=lambda m,s,e:all(m.dot(s)==e*s)

输入：m =矩阵，s =标量，e =特征值。M和s是numpy数组

Python 3中，96 70个字节

没有用于矩阵向量或标量向量乘法的内置函数！

lambda A,L,v:all(L*y==sum(i*j for i,j in zip(x,v))for x,y in zip(A,v))

在线尝试！

通过使用zip@LeakyNun -26个字节！

05AB1E，11个字节

vy²*O})²³*Q

在线尝试！

vy²*O})     # Vectorized product-sum.
       ²³*  # Vector * scalar.
          Q # Equivalence.

R，30 25字节

s=pryr::f(all(a%*%v==λ*v))

匿名函数，相当简单。返回TRUE或FALSE。

OK，12个字节

{y~z%+/y*+x}

这是一个函数，它带有[matrix;vector;scalar]。

由于3.0~3给出的相同原因，这在k中不起作用0。

The following works in k, with 14 bytes:

{(y*z)~+/y*+x}

Axiom, 27 bytes

f(a,b,c)==(a*b=c*b)@Boolean

exercises

(17) -> m:=matrix[[2,-3,-1],[1,-2,-1],[1,-3,0] ]; v:=matrix[[3],[1],[0]];
(18) -> f(m,v,1)
   (18)  true

(19) -> m:=matrix[[2,-3,-1],[1,-2,-1],[1,-3,0] ]; v:=matrix[[1],[1],[1]];
(20) -> f(m,v,-2)
   (20)  true

(21) -> m:=matrix[[1,6,3],[0,-2,0],[3,6,1] ]; v:=matrix[[1],[0],[1]];
(22) -> f(m,v,4)
   (22)  true

(23) -> m:=matrix[[1,0,-1],[-1,1,1],[1,0,0] ]; v:=matrix[[2],[1],[0]];
(24) -> f(m,v,7)
   (24)  false

(25) -> m:=matrix[[-4,3],[2,1] ]; v:=matrix[[1],[2]];
(26) -> f(m,v,2)
   (26)  true

(27) -> f(2,1,2)
   (27)  true

Python, 26 bytes

lambda a,b,c:c*b==a.dot(b)

a and b are numpy arrays, c is an integer.

Try it online!

Clojure, 60 bytes

#(=(set(map(fn[a v](apply -(* v %3)(map * a %2)))% %2))#{0})

This checks that all deltas are zero, thus collapsing into the set of zero. Calling example:

(def f #(=(set(map(fn[a v](apply -(* v %3)(map * a %2)))% %2))#{0}))
(f [[1 6 3][0 -2 0][3 6 1]] [1 0 1] 4)