इस चुनौती में, आपको एक वर्ग मैट्रिक्स A, एक वेक्टर vऔर एक स्केलर दिया जाएगा λ। आपको यह निर्धारित करने की आवश्यकता होगी कि क्या (λ, v)यह इसी के अनुरूप है A; वह है, चाहे या नहीं Av = λv।

डॉट उत्पाद

दो वैक्टर का डॉट उत्पाद तत्व-वार गुणन का योग है। उदाहरण के लिए, निम्न दो वैक्टर का डॉट उत्पाद है:

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

ध्यान दें कि डॉट उत्पाद केवल एक ही लंबाई के दो वैक्टर के बीच परिभाषित किया गया है।

मैट्रिक्स-वेक्टर गुणन

एक मैट्रिक्स मूल्यों का 2 डी ग्रिड है। एक mx nमैट्रिक्स में mरो और nकॉलम होते हैं। हम लंबाई के वैक्टर के रूप में एक mएक्स nमैट्रिक्स की कल्पना कर सकते हैं (यदि हम पंक्तियों को लेते हैं)।mn

मैट्रिक्स-वेक्टर गुणा को mx nमैट्रिक्स और एक आकार -वेक्टर के बीच परिभाषित किया गया है n। यदि हम एक mx nमैट्रिक्स और एक आकार- nवेक्टर को गुणा करते हैं , तो हम एक आकार- mवेक्टर प्राप्त करते हैं । iपरिणाम वेक्टर में मई के मूल्य के डॉट उत्पाद है 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, हम कहते हैं कि λएक eigenvalue के लिए इसी है vऔर vएक आइजन्वेक्टर करने के लिए इसी है λ यदि और केवल यदि Av = λv । (जहां Avमैट्रिक्स-वेक्टर गुणन है और λvअदिश गुणन है)।

(λ, v) एक eigenpair है।

चुनौती विनिर्देशों

इनपुट

इनपुट में एक मैट्रिक्स, एक वेक्टर और एक स्केलर होगा। इन्हें किसी भी क्रम में किसी भी उचित प्रारूप में लिया जा सकता है।

उत्पादन

आउटपुट एक सत्य / मिथ्या मूल्य होगा; सत्य अगर और केवल अगर स्केलर और वेक्टर निर्दिष्ट मैट्रिक्स के साथ एक eigenpair हैं।

नियम

मानक खामियां लागू होती हैं
यदि आपकी भाषा में एक eigenpair सत्यापित करने के लिए अंतर्निहित है, तो आप इसका उपयोग नहीं कर सकते हैं।
आप मान सकते हैं कि सभी संख्या पूर्णांक हैं

परीक्षण के मामलों

 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 जोड़ूंगा।

अपठनीय परीक्षण मामले जो परीक्षण के लिए आसान हैं

— HyperNeutrino
स्रोत

सम्बंधित।

— मार्टिन एंडर

@MartinEnder धन्यवाद मेरे पास मूल रूप से मनमाने आकार के मेट्रिसेस के लिए एक समान चुनौती थी, जहां आप प्रत्येक अद्वितीय आइगेंसस्पेस के लिए एक आधार की गणना करने के लिए थे, लेकिन यह अभी भी सैंडबॉक्स में है क्योंकि यह बहुत भ्रामक लगता है।

— हाइपरन्यूट्रिनो

यदि इनपुट में 3x3 के अलावा अन्य आयाम हो सकते हैं, तो आपको अपने परीक्षण मामलों में कुछ को कवर करना चाहिए।

— मार्टिन एंडर

1

@HyperNeutrino हाँ, यह मदद नहीं करता है ... मुझे यह समझाने की कोशिश मत करो: मैं हाई स्कूल में जीसीएसई के लिए गणित की पढ़ाई कर रहा हूं, इसलिए यह सिर्फ मुझ पर खो गया।

— caird coinheringaahing

1

@ user00001 यदि आपको सहायता की आवश्यकता है, तो आपके लिए eigenpair-aphrase । : पी

— mbomb007

11

जेली , 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.

— डेनिस
स्रोत

> _> यह बहुत छोटा है: P अच्छा जवाब

— HyperNeutrino

6

वह पागल बात है! : पी

— डेनिस

आप कुछ लिखते हैं, और सोचते हैं कि "कुछ भी छोटा नहीं हो सकता!"। तब MATL साथ आता है और आपके कोड साइज़ को आधा कर देता है। इसके बाद जेली साथ आती है और

— रुक जाती

@HyperNeutrino सेब की तुलना संतरे से न करें। गोल्फ की भाषाओं में प्रति ऑपरेशन एक बाइट जितना कम होता है, कुछ सामान्य भाषाओं में शायद ही कभी होता है। युक्ति में तीन ऑपरेशन (दो गुणन और एक समानता) हैं, और एक अतिरिक्त बाइट को डुप्लिकेट करने के लिए vचार बाइट्स की अपेक्षा कम हो सकती है।

— सांचेस

2

मुझे पसंद है कि कैसे जेली और MATL दोनों मैट्रिक्स गुणा के लिए दो बाइट्स का उपयोग करते हैं, जिसका अर्थ है कि यह उत्तर वास्तव में दिखाता है कि इनपुट लेने में जेली कितना अच्छा है, बाकी सभी समान हैं।

— सांचेस

13

गणितज्ञ, 10 बाइट्स

#2.#==#3#&

इनपुट की तरह लेता है {vector, matrix, scalar}और एक बूलियन देता है।

— मार्टिन एंडर
स्रोत

1

> _> यह गणितज्ञ के लिए बहुत आसान था। +1: P

— हाइपरएनुट्रिनो

9

@ हायपरनेट्रिनो और अब हम MATL का इंतजार करते हैं ...

— मार्टिन

2

खैर MATL दिखाई दिया है> _>

— HyperNeutrino

1

उन क्षणों में से एक जब आपको लगता है कि कुछ भी कम नहीं हो सकता है और MATL अचानक पॉप हो जाता है :)

— श्री एक्सकोडर

@ Mr.Xcoder और फिर जेली दिखाता है।

— स्टेडीबॉक्स

11

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।

— Sanchises
स्रोत

"हैरानी की बात है" मैं कम से कम 20 बाइट्स की उम्मीद कर रहा था> _> अच्छा जवाब हालांकि: P

— HyperNeutrino

2

खैर, यह देखते हुए कि MATLAB का जवाब 16 बाइट्स में आएगा @(A,v,l)A*v==v*l, यह काफी वर्बोज़ लगता है, और मुझे लगता है कि अगर मुझे इनपुट कुछ ज्यादा ही अच्छा लगता है तो मुझे 6 का अनुभव होना चाहिए।

— Sanchises

जाहिरा तौर पर यह 38 बाइट्स में आया था, लेकिन मुझे पूरा यकीन है कि इसे नीचे गिराया जा सकता है।

— हाइपरनेत्रिनो

3

@HyperNeutrino ने पिछली टिप्पणी को सच करने के लिए मुझे अपना जोड़ा। (या

— सच्चाई

6

सीजेएम , 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

— बिजनेस कैट
स्रोत

5

MATLAB, 16 बाइट्स

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

बल्कि तुच्छ उत्तर। इनपुट लेने वाले एक अनाम फ़ंक्शन को परिभाषित करता है, और परिणामी वैक्टर की तत्व-वार समानता की गणना करता है। तार्किक सरणी में एक एकल शून्य MATLAB में एक सरणी को गलत बनाता है।

— Sanchises
स्रोत

(उदाहरण के लिए [true,false], मुझे सिखाने के लिए धन्यवाद =) के दोष के बारे में पता नहीं था

— दोष

1

@flawr Suever (जो MATLAB के लिए भी लागू है) द्वारा यह उत्तर देखें । मूल रूप से, लगभग-लेकिन-नहीं-काफी (खाली मैट्रिक्स []अलग है) अंतर्निहित all()को इनपुट पर कहा जाता है if, whileआदि

— Sanchises

2

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

एक सत्य मूल्य के रूप में। एक गलत मान किसी भी या सभी मानों के साथ समान वेक्टर है 1 के बजाय 0।

— Steadybox
स्रोत

मैं MATLAB नहीं जानता, लेकिन क्या इस isequalसमारोह को छोटा किया जा सकता है ==?

— हाइपरनेत्रिनो

1

@ हाइपेंटरिनो की isequalजरूरत होगी अगर आउटपुट की जरूरत है trueया falseएक सत्य या गलत मूल्य के बजाय। चुनौती खड़ी है, ==वास्तव में पर्याप्त है।

— Sanchises

@ हैपरनेट्रिनो यह एक वेक्टर होगा जिसमें दो वैक्टरों के तत्वों की तुलना के परिणाम होंगे।

— स्टेडीबॉक्स

ओह ठीक है। हालांकि अच्छा जवाब!

— हाइपरनेत्रिनो

एक वार्षिक समारोह छोटा नहीं होगा?

— बैटमैन

2

सी ++, 225 203 बाइट्स

22 बाइट बचाने के लिए @Cort Ammon और @Julian वुल्फ को धन्यवाद!

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

इसे ऑनलाइन आज़माएं!

— Steadybox
स्रोत

1

using std::vector;यह बंद दो बाइट्स गोल्फ सकता है। इसकी लागत 18 बाइट्स है, लेकिन 4 std::एस को हटा सकता है , जिससे 20 की बचत होगी।

— कॉर्ट अमन - मोनिका

2

बेहतर अभी तक, using V=std::vector<float>;या समान

— जूलियन वुल्फ

2

जूलिया, 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Rɪᴋᴇʀ
स्रोत

2

पायथन 2.7, 33 बाइट्स

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

इनपुट: एम = मैट्रिक्स, एस = स्केलर, ई = ईजेनवेल्यू। एम और एस सुन्न सरणियाँ हैं

— HonzaB
स्रोत

2

यह अच्छा लग रहा है, लेकिन मैं आप में से बाइट गिनती शामिल करने की ज़रूरत लगता है import npयह मान्य होने के लिए

— DJMcMayhem

1

आपकी पिछली print(m,s,e)बयान काम नहीं होता क्योंकि चर m, sहै, और eअभी तक असाइन नहीं थे / में परिभाषित किया। इसके अलावा, आप कोलन के बाद की जगह को हटा सकते हैं। इसके अलावा, आप `एन` भाग के रूप में हटा सकते हैं और numpyबाद में उपयोग कर सकते हैं ; चूंकि आप केवल एक बार इसका उपयोग करते हैं, इसलिए पूर्ण नाम का उपयोग करके वास्तव में एक बाइट बचती है।

— हाइपरन्यूट्रिनो

1

ठीक है, मैं अब समझ गया। सुझाव के लिए धन्यवाद, हर बिट निचोड़ :)

— HonzaB

2

allइसके बजाय नहीं होना चाहिए any? और मुझे लगता sहै कि वेक्टर है, स्केलर नहीं, जब तक कि मैं कुछ याद नहीं कर रहा हूं

— लुइस मेंडो

1

स्ट्रिंग अभ्यावेदन की तुलना करना भी कम होगा। tio.run/nexus/python2#jZDPCoMwDIfP@hQ9tiOV/hEHgk/…

— डेनिस

2

पायथन 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 बाइट्स !

— HyperNeutrino
स्रोत

ज़िप का उपयोग करने का प्रयास करें:f=lambda A,L,v:all(L*y==sum(i*j for i,j in zip(x,v))for x,y in zip(A,v))

— लीक नून

1

05AB1E , 11 बाइट्स

vy²*O})²³*Q

इसे ऑनलाइन आज़माएं!

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

— जादू ऑक्टोपस Urn
स्रोत

1

आर, 30 25 बाइट्स

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

अनाम फ़ंक्शन, काफी सीधा। लौटाता है TRUEया FALSE।

— rturnbull
स्रोत

0

ओ.के., 12 बाइट्स

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

यह एक फ़ंक्शन है, यह अंदर लेता है [matrix;vector;scalar]।

यह कश्मीर में उन्हीं कारणों से काम नहीं करता है जो परिणाम 3.0~3देता है 0।

14 बाइट्स के साथ कश्मीर में निम्नलिखित काम करता है :

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

— zgrep
स्रोत

0

Axiom, 27 बाइट्स

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

अभ्यास

(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

— RosLuP
स्रोत

मैंने पहले इस भाषा को नहीं देखा, अच्छा जवाब! क्या करता @Booleanहै?

— हाइपरएन्यूट्रीनो

(a = b) @ बूलियन का अर्थ होगा "अनुमत = ऑपरेटर (टाइप 1, टाइप 2) में से किसी एक का चयन इसका परिणाम बूलियन है"; कुछ शब्दों में "a a = b" का बूलियन होना है

— RosLuP

0

पायथन, 26 बाइट्स

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

aऔर bसुन्न सरणियाँ हैं, cएक पूर्णांक है।

इसे ऑनलाइन आज़माएं!

— Rɪᴋᴇʀ
स्रोत

2

क्या c*bवास्तव में आसपास के परिनियोजन आवश्यक हैं?

— xnor

@ एक्सनॉर थैंक्स, फिक्स्ड।

— 22

यह केवल छोटे सरणियों के लिए काम करता है, क्योंकि NumPy बड़े सरणी स्ट्रिंग अभ्यावेदन को निरस्त करता है।

— user2357112

@ user2357112 उदाहरण? मुझे नहीं पता तुम्हारा क्या मतलब है।

— Rɪᴋᴇʀ

यदि c*b1000 से अधिक तत्व हैं, तो NumPy अधिकांश तत्वों को बदल देगा ...। डेमो।

— user2357112

0

क्लोजर, 60 बाइट्स

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

यह जांचता है कि सभी डेल्टा शून्य हैं, इस प्रकार शून्य के सेट में ढह जाते हैं। कॉलिंग उदाहरण:

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

— NikoNyrh
स्रोत

Eigenpairs सत्यापित करें

डॉट उत्पाद

मैट्रिक्स-वेक्टर गुणन

उदाहरण

स्केलर गुणज

आइगेनवैल्यूज़ एवं आइगेनवेक्टर्स

चुनौती विनिर्देशों

इनपुट

उत्पादन

नियम

परीक्षण के मामलों

जेली , 5 बाइट्स

यह काम किस प्रकार करता है

गणितज्ञ, 10 बाइट्स

MATL, 7 बाइट्स

सीजेएम , 15 बाइट्स

MATLAB, 16 बाइट्स

MATLAB, 38 बाइट्स

MATLAB, 30 बाइट्स

सी ++, 225 203 बाइट्स

जूलिया, 17 बाइट्स

पायथन 2.7, 33 बाइट्स

पायथन 3 , 96 70 बाइट्स

05AB1E , 11 बाइट्स

आर, 30 25 बाइट्स

ओ.के., 12 बाइट्स

Axiom, 27 बाइट्स

पायथन, 26 बाइट्स

क्लोजर, 60 बाइट्स