Trong thử thách này, bạn sẽ được cung cấp một ma trận vuông A, vectơ vvà vô hướng λ. Bạn sẽ được yêu cầu xác định xem (λ, v)có phải là một trạng thái riêng tương ứng với A; có nghĩa là, có hay không Av = λv.

Sản phẩm chấm

Tích số của hai vectơ là tổng của phép nhân phần tử. Ví dụ: tích chấm của hai vectơ sau là:

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

Lưu ý rằng sản phẩm chấm chỉ được xác định giữa hai vectơ có cùng độ dài.

Phép nhân vectơ

Một ma trận là một lưới các giá trị 2D. Một ma trận mx ncó mhàng và ncột. Chúng ta có thể tưởng tượng một ma trận mx nlà mcác vectơ có độ dài n(nếu chúng ta lấy các hàng).

Phép nhân vectơ ma trận được xác định giữa ma trận mx nvà nvectơ kích thước . Nếu chúng ta nhân một ma trận mx nvà một nvectơ kích thước , chúng ta sẽ có được một mvectơ kích thước . Các igiá trị -thứ trong vector kết quả là sản phẩm chấm của ihàng -thứ của ma trận và vector gốc.

Thí dụ

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

        1
        3
Let v = 5
        7
        9

Nếu chúng ta nhân ma trận và vectơ Av = x, chúng ta sẽ nhận được như sau:

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

Vì vậy, chúng tôi nhận được Av = x = (95, 145, 195).

Nhân bản vô tính

Phép nhân của một vô hướng (một số duy nhất) và một vectơ chỉ đơn giản là phép nhân phần tử. Ví dụ , 3 * (1, 2, 3) = (3, 6, 9). Nó khá đơn giản.

Vectơ riêng

Với ma trận A, chúng ta nói rằng đó λlà một giá trị riêng tương ứng vvà vlà một hàm riêng tương ứng với λ khi và chỉ khi Av = λv . (Trường hợp Avnhân vectơ ma trận và λvlà phép nhân vô hướng).

(λ, v) là một nỗi buồn riêng.

Thông số kỹ thuật thử thách

Đầu vào

Đầu vào sẽ bao gồm ma trận, vectơ và vô hướng. Đây có thể được thực hiện theo bất kỳ thứ tự trong bất kỳ định dạng hợp lý.

Đầu ra

Đầu ra sẽ là một giá trị trung thực / giả mạo; trung thực nếu và chỉ khi vô hướng và vectơ là một cặp riêng với ma trận được chỉ định.

Quy tắc

• Áp dụng sơ hở tiêu chuẩn
• Nếu một tích hợp để xác minh một bản địa tồn tại trong ngôn ngữ của bạn, bạn không thể sử dụng nó.
• Bạn có thể cho rằng tất cả các số là số nguyên

Các trường hợp thử nghiệm

 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

Tôi sẽ thêm một chiếc 4x4 sau.

Các trường hợp kiểm tra không thể đọc được dễ dàng hơn để kiểm tra

Thạch , 5 byte

æ.⁵⁼×

Đây là một bộ ba, chương trình đầy đủ.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

æ.⁵⁼×  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.

Toán học, 10 byte

#2.#==#3#&

Lấy đầu vào như {vector, matrix, scalar}và trả về một boolean.

MATL, 7 byte

*i2GY*=

Đầu vào theo thứ tự: l, v, A.

Giải trình:

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

Câu trả lời dài đáng ngạc nhiên, nếu bạn hỏi tôi, chủ yếu là vì tôi cần một cách để có được tất cả các đầu vào chính xác. Tôi không nghĩ rằng ít hơn 5 byte là có thể, nhưng sẽ rất tuyệt nếu ai đó tìm thấy giải pháp 5 hoặc 6 byte.

Về cơ bản, điều này tính toán l*v==A*v.

CJam , 15 byte

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

Đưa đầu vào theo mẫu vector scalar matrix.

Hãy thử trực tuyến!

Giải trình

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 byte

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

Câu trả lời khá tầm thường. Xác định một hàm ẩn danh lấy các đầu vào và tính toán đẳng thức phần tử của các vectơ kết quả. Một số 0 duy nhất trong một mảng logic làm cho một mảng falsey trong MATLAB.

MATLAB, 38 byte

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

Trả về 1 hoặc 0.

MATLAB, 30 byte

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

Trả về

1
1
1

như một giá trị trung thực. Giá trị giả là một vectơ tương tự với bất kỳ hoặc tất cả các giá trị 0 thay vì 1.

C ++, 225 203 byte

Cảm ơn @Cort Ammon và @Julian Wolf vì đã tiết kiệm 22 byte!

#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;}

Hãy thử trực tuyến!

Julia, 17 byte

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

Hãy thử trực tuyến!

Python 2.7, 33 byte

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

đầu vào: m = matrix, s = vô hướng, e = eigenvalue. M và s là các mảng numpy

Con trăn 3 , 96 70 byte

Không có nội dung nào cho phép nhân vectơ ma trận hoặc vectơ vô hướng!

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

Hãy thử trực tuyến!

-26 byte bằng cách sử dụng zipnhờ @LeakyNun!

05AB1E , 11 byte

vy²*O})²³*Q

Hãy thử trực tuyến!

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

R, 30 25 byte

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

Chức năng ẩn danh, khá đơn giản. Trả về TRUEhoặc FALSE.

oK, 12 byte

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

Đây là một chức năng, nó cần [matrix;vector;scalar] .

Điều này không làm việc trong k vì những lý do tương tự mà 3.0~3cho 0kết quả là.

Các hoạt động sau đây trong k , với 14 byte :

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

Tiên đề, 27 byte

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

bài tập

(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 byte

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

avà blà mảng numpy,c là một số nguyên.

Hãy thử trực tuyến!

Clojure, 60 byte

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

Điều này kiểm tra rằng tất cả các đồng bằng bằng không, do đó thu gọn thành tập hợp số không. Ví dụ gọi:

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