मैट्रिक्स रैंक-वन है?


21

पूर्णांक के एक मैट्रिक्स को देखते हुए, यदि यह रैंक-वन है, तो परीक्षण करें, जिसका अर्थ है कि प्रत्येक पंक्ति एक ही वेक्टर की एक बहु है। उदाहरण के लिए, में

 2   0  -20  10  
-3   0   30 -15
 0   0   0   0

हर पंक्ति एक से अधिक है 1 0 -10 5

पंक्तियों के स्थान पर कॉलम के साथ भी यही परिभाषा काम करती है। वैकल्पिक रूप से, एक मैट्रिक्स रैंक-एक है यदि यह गुणा तालिका की तरह है:

 *    1   0  -10  5
    ----------------
 2 |  2   0  -20  10  
-3 | -3   0   30 -15
 0 |  0   0   0   0

हमने पंक्ति लेबल r[i]और स्तंभ लेबल असाइन किए हैं c[j]ताकि प्रत्येक मैट्रिक्स प्रविष्टि उसी लेबल M[i][j]का उत्पाद हो, जैसा कि M[i][j] = r[i] * c[j]

इनपुट:

अपनी पसंद के 2 डी कंटेनर के रूप में एक पूर्णांक मैट्रिक्स। उदाहरण के लिए, सूचियों की सूची, एक 2D सरणी, या समान। जब तक कि सरणी प्रारूप की आवश्यकता न हो, आपको अतिरिक्त इनपुट के रूप में चौड़ाई या ऊंचाई नहीं लेनी चाहिए।

मैट्रिक्स गैर-वर्ग हो सकता है। इसमें कम से कम एक गैर-प्रविष्टि प्रविष्टि होगी - आपको खाली या शून्य मैट्रिसेस से निपटने की आवश्यकता नहीं है।

आप मान सकते हैं कि पूर्णांक ओवरफ़्लो समस्याओं का कारण नहीं बनेंगे।

आउटपुट:

रैंक-एक मैट्रिसेस के लिए एक सुसंगत मूल्य, और अन्य मैट्रिसेस के लिए एक अलग सुसंगत मूल्य।

निर्मित-इन:

आप किसी भी अंतर्निहित रैंक का उपयोग नहीं कर सकते हैं या सीधे रैंक एक की जांच कर सकते हैं। आप अन्य बिल्ट-इन का उपयोग कर सकते हैं जैसे कि eigenvalues, decompositions, आदि, लेकिन मैं उन उत्तोलन को प्रोत्साहित करता हूं जिनके पास अधिकांश काम नहीं है।

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

रैंक-वन:

[[2, 0, -20, 10], [-3, 0, 30, -15], [0, 0, 0, 0]]
[[0, 0, 0], [0, 3, 0], [0, 0, 0]]
[[-10]]
[[0, 0, 0], [0, 4, 11], [0, -4, -11]]

रैंक-वन नहीं:

[[-2, 1], [2, 4]]
[[0, 0, 3], [-22, 0, 0]]
[[1, 2, 3], [2, 4, 6], [3, 6, 10]]
[[0, -2, 0, 0], [0, 0, 0, 1], [0, 0, -2, 0]]

लीडरबोर्ड:


2
जिज्ञासु के लिए, MatrixRank@#==1&
बिल्डिंस


2
एक सुंदर प्रमेय यह है कि स्तंभ रैंक परिमित आयामी मैट्रिक्स के लिए पंक्ति रैंक के बराबर है।
लीक नून

3
क्या हमें फ्लोट सटीक मुद्दों के बारे में चिंता करने की ज़रूरत है? वे एक रैंक -1 मैट्रिक्स को उदाहरण के लिए रैंक 2 बना सकते हैं
लुइस मेंडो

@LuisMendo आपको 1.0000000001 के एक eigenvalues ​​की तरह सटीक मुद्दों को संभालना होगा, लेकिन मान सकते हैं कि मैट्रिक्स बड़ा नहीं है और विशेष रूप से मिसकॉलिफ़ाइड होने के लिए नहीं चुना गया है।
xnor

जवाबों:


13

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

ẸÐfÆrE

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

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

ẸÐfÆrE  Main link. Argument: M (2D array)

ẸÐf     Filter by any, removing rows of zeroes.
   Ær   Interpret each row as coefficients of a polynomial and solve it over the
        complex numbers.
     E  Test if all results are equal.

शुद्धता

Ærसंख्यात्मक विधियों का उपयोग करता है, इसलिए इसके परिणाम आमतौर पर अक्षम होते हैं। उदाहरण के लिए, इनपुट [6, -5, 1] , जो बहुपद 6 - 5x + x² का प्रतिनिधित्व करता है , जड़ों में परिणाम 3.0000000000000004 और 1.99999999999998 है । हालांकि, एक बहुपद के सभी गुणांक को एक ही गैर-शून्य स्थिर परिणाम से समान रूप से अक्षम जड़ों में गुणा किया जाता है। उदाहरण के लिए, [6, -5, 1] और [6 × 10 100 , -5 × 10 100 , 10 100 ] केÆr लिए समान जड़ें प्राप्त करता है ।

ऐसा नहीं है कि की सीमित परिशुद्धता ध्यान दिया जाना चाहिए नाव और जटिल प्रकार के कर सकते हैं त्रुटि दिखाते हैं। उदाहरण के लिए, [1, 1] और [10 100 , 10 100 + 1] केÆr लिए समान जड़ें प्राप्त करेंगे । चूँकि हम यह मान सकते हैं कि मैट्रिक्स बड़ा नहीं है और विशेष रूप से मिसकैलिफ़ाइड होने के लिए नहीं चुना गया है , इसलिए यह ठीक होना चाहिए।


5
एक गैर-शून्य निरंतर परिणाम से एक बहुपद के सभी गुणांकों को गुणा करना समान रूप से अक्षम जड़ों में एक शानदार दृष्टिकोण है
लुइस मेंडो

8

हास्केल , 50 बाइट्स

rयदि मैट्रिक्स में रैंक एक है, अन्यथा , Integerएस और रिटर्न की सूची की एक सूची लेता है ।FalseTrue

r l=or[map(x*)b<map(y*)a|a<-l,b<-l,(x,y)<-zip a b]

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

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

  • सभी जोड़े पंक्तियों aऔर b(समान पंक्तियों सहित), और प्रत्येक जोड़ी के लिए, इसी तत्वों के माध्यम से चलने xऔर yचलाने देता है ।
  • गुणा करता पंक्ति bसे xऔर पंक्ति aसे y। मैट्रिक्स में रैंक एक होगा यदि और केवल तभी परिणाम हमेशा बराबर होंगे।
  • चूंकि जोड़े दोनों आदेशों में उत्पन्न होते हैं, इसलिए <यह जांचने के लिए उपयोग किया जा सकता है कि क्या कभी असमानता है। यदि कोई गैर-आनुपातिक पंक्तियाँ हैं or, Trueतो परीक्षण परिणामों की सूची को जोड़ दिया जाता है ।

7

गणितज्ञ, ५१ ३३ बाइट्स

RowReduce@#~Count~Except@{0..}<2&

इनपुट

[{{2,0, -20,10} {- 3,0,30, -15} {0,0,0,0}}]

User202729 से 14 बाइट्स
3 और बाइट्स junghwanmin से बचाया


मेरा सुझाव है कि, इसके बराबर की लंबाई वाली एक तालिका का निर्माण करने के बजाय First@#, आप गणना कर सकते हैं कि 0First@#0 गुणन सब कुछ के साथ 0 है, और गुणन करने योग्य है। इसके अलावा, आप Tr[1^<list>]किसी सूची की लंबाई की गणना करने के लिए उपयोग करने पर विचार कर सकते हैं ।
user202729

बहुत अच्छा।मैं संपादित करूँगा!
J42161217

इसके बजाय 0#&@@#, {0..}भी काम करेगा। और फिर Infixकाम करता है, इसलिए RowReduce@#~Count~{0..}==Tr[1^#]-1&2 बाइट की बचत करते हुए अंतिम कोड हो सकता है ।
जंगहवान मिन

दरअसल, सामान से Exceptछुटकारा पाने के लिए इस्तेमाल किया जा सकता है Tr। -3 बाइट्स:RowReduce@#~Count~Except@{0..}==1&
जुंगह्वान मिन सिप

मुझे लगता है कि पंक्ति-कम की गई मैट्रिक्स को नॉनज़रो होने की गारंटी है (क्योंकि मूल मैट्रिक्स नॉनज़ेरो है), इस प्रकार गणना परिणाम एक सकारात्मक पूर्णांक होगा, इस प्रकार <2इसका उपयोग किया जा सकता है ==1
user202729

4

जावास्क्रिप्ट (ईएस 6), 68 67 65 बाइट्स

यह नील के 05AB1E उत्तर पर आधारित है और मेरे मूल दृष्टिकोण से काफी अधिक कुशल है।

falseरैंक-वन और trueअन्यथा के लिए रिटर्न ।

f=(a,R,V,X)=>a.some(r=>r.some((v,x)=>R?v*V-r[X]*R[x]:f(a,r,v,x)))

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


मूल उत्तर, 84 बाइट्स

falseरैंक-वन और trueअन्यथा के लिए रिटर्न ।

a=>a.some(r=>r.some((x,i)=>(isNaN(x/=a.find(r=>r.some(x=>x))[i])?r:1/r[0]?r=x:x)-r))

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

कैसे?

a => a.some(r =>          // given a matrix a, for each row r of a:
  r.some((x, i) =>        //   for each value x of r at position i:
    (                     //
      isNaN(x /=          //     divide x by a[ref][i]
        a.find(r =>       //       where ref is the index of the first row that
          r.some(x => x)  //       contains at least one non-zero value
        )[i]              //       (guaranteed to exist by challenge rules)
      ) ?                 //     we get NaN for 0/0, in which case:
        r                 //       use r, so that this column is ignored
      :                   //     else:
        1 / r[0] ?        //       if r is still holding the current row:
          r = x           //         set it to x (either a float, +Inf or -Inf)
        :                 //       else:
          x               //         use x
    ) - r                 //     subtract r from the value set above (see table)
  )                       //   end of some()
)                         // end of every()

कोड के अंत में किया जाने वाला घटाव कई अलग-अलग स्थितियों को जन्म दे सकता है, जिन्हें नीचे संक्षेप में प्रस्तुत किया गया है:

A                   | B              | A - B       | False / True
--------------------+----------------+-------------+-------------
array of 1 number   | same array     | 0           | False
array of 2+ numbers | same array     | NaN         | False
a number            | same number    | 0           | False
+Infinity           | +Infinity      | NaN         | False
-Infinity           | -Infinity      | NaN         | False
a number            | another number | <> 0        | True
+Infinity           | -Infinity      | +Infinity   | True
-Infinity           | +Infinity      | -Infinity   | True
a number            | +/-Infinity    | +/-Infinity | True
+/-Infinity         | a number       | +/-Infinity | True

परीक्षण ही हम एक truthy मूल्य प्राप्त के रूप में विफल रहता है: यह होता है जब हम दो अलग-अलग अनुपात (अलावा अन्य मुठभेड़ 0/0 के बीच) एक (i, y) और एक (मैं, आर) किसी भी पंक्ति में वाई मैट्रिक्स, जहां की r एक गैर-शून्य पंक्ति का सूचकांक है।


हुह, मैं खुद सोच रहा था कि ...
नील

@ नील आप इसे एक नए उत्तर के रूप में पोस्ट करना चाहेंगे? बस मुझे पता है।
अरनुलद


3

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

ẸÐfµ÷"ЀZE€Ẹ

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

व्याख्या

ẸÐfµ÷"ЀZE€Ẹ  Main link
 Ðf           Filter; keep all elements where
Ẹ             At least one element is truthy (remove zero-rows)
      Ѐ      For each row on the right side
    ÷"        Divide it by each row in the original
        Z     Zip the array
          €   For each submatrix
         E    Are all rows equal?
           Ẹ  Is at least one of the elements from above truthy?

स्पष्टीकरण थोड़ा गलत हो सकता है क्योंकि यह मेरी मूल एल्गोरिथ्म के मील के गोल्फ की मेरी व्याख्या है

-5 बाइट मील के लिए धन्यवाद


... आपका कोड पैसे का आदी है। (मैं
डेजा वु

@icrieverytim अरे कम से कम डॉलर के संकेतों की संख्या इस बार कोड की लंबाई के आधे से भी कम है! : पी
हाइपरनेट्रिनो

1
@icrieverytim ने एक बग तय किया और अब और भी कम डॉलर के संकेत: P
HyperNeutrino

मेरा मानना ​​है कि यह 12 बाइट्स ẸÐfµ÷"ЀZE€Ẹ TIO के
मील

@ मीलों अच्छा! आपके लिए दृष्टिकोण थोड़ा अलग है (मुझे लगता है?) इसलिए आप पोस्ट कर सकते हैं कि आप अपने खुद के जवाब के रूप में पसंद करेंगे :)
HyperNeutrino 23'17

3

05AB1E , 16 बाइट्स

2ãεø2ãε`R*`Q}W}W

इसे ऑनलाइन आज़माएं! गुणन तालिका संपत्ति का उपयोग करता है कि किसी भी आयत के विपरीत कोनों में एक ही उत्पाद होता है। स्पष्टीकरण:

2ãε           }     Loop over each pair of rows
   ø                Transpose the pair into a row of pairs
    2ãε     }       Loop over each pair of columns
       `R*`Q        Cross-multiply and check for equality
             W W    All results must be true

3

टीआई-बेसिक (TI-83 श्रृंखला), 28 27 28 बाइट्स (62 अक्षर)

:Prompt [A]
:{0→X
:Matr►list(ref([A])ᵀ,L₁,X
:not(max(abs(ᶫX

मैट्रिक्स की पंक्ति-इक्वेलन रूप की गणना करता है [A], अपनी पहली पंक्ति (में खारिज होने वाली) L₁और दूसरी पंक्ति में संग्रहीत करता है ᶫX। फिर max(abs(ᶫXशून्य होगा यदि ᶫXकेवल शून्य होते हैं, और एक सकारात्मक मूल्य अन्यथा, जो not(कि 1 में बदल जाता है यदि मैट्रिक्स रैंक एक है, 0 अन्यथा।

1-पंक्ति मैट्रिक्स के लिए, तब ᶫXसेट किया जाता है {0}और तब बदला नहीं जाता है जब हम मैट्रिक्स की कोई भी दूसरी पंक्ति को देखने का प्रयास नहीं करते हैं।


स्कॉट मिलनर को -1 बाइट

1-पंक्ति मैट्रिक्स के लिए आयाम त्रुटि को ठीक करने के लिए +1 बाइट। यदि आप केवल एक पंक्ति के साथ मैट्रिक्स से दूसरी पंक्ति को निकालने का प्रयास करते हैं, तो कमांड को चालू करता है Matr►list( ; हालाँकि, यदि आप मैट्रिक्स से पहली और दूसरी पंक्ति निकालने की कोशिश करते हैं, तो यह चुपचाप विफल हो जाएगी।


1
आप के Prompt [A]बजाय के साथ एक बाइट बचा सकते हैं Ans→[A]
स्कॉट मिलनर

@ScottMilner धन्यवाद! वहाँ शायद एक तरह से बचने के लिए अगर हम कुछ का उपयोग ClrListकरने के लिए शुरू करना है ᶫX, लेकिन मैं काफी कम जगह में काम करने के लिए नहीं मिला है।
मीशा लावरोव

दूसरी पंक्ति से छुटकारा पाएं, क्योंकि Matr►list(यह सूची को अधिलेखित कर देगा, भले ही यह मौजूद नहीं है, और आप 5 बाइट्स बचाएंगे।
kamoroso94

1
@ kamoroso94 दूसरी पंक्ति का बिंदु एक सूची बनाने के लिए नहीं है जब यह मौजूद नहीं है: दूसरी पंक्ति का बिंदु दूसरी पंक्ति के लिए एक डिफ़ॉल्ट मान बनाना है जब मैट्रिक्स केवल एक पंक्ति है। यदि आप दूसरी पंक्ति से छुटकारा पाते हैं, तो कोड 1xN मैट्रिसेस के लिए क्रैश हो जाता है।
मीशा लावरोव

2
@ kamoroso94 हमें L1 को notY से बदलना होगा, Y से नहीं; अन्यथा, कैलकुलेटर "मैट्रिक्स की वाई-वें पंक्ति को एक्सएक्सएक्स" पर ले जाने के लिए सोचेगा, न कि "पहली पंक्ति को secondY तक, और दूसरी पंक्ति को "X"।
मीशा लावरोव

3

ब्रेकीलॉग , 27 बाइट्स

{⊇Ċ}ᶠzᵐ{↰₁ᶠ{⟨hz{t↔}⟩×ᵐ=}ᵐ}ᵐ

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

नील के "प्रत्येक आयत के विपरीत कोनों के उत्पादों को बराबर होना चाहिए" के दृष्टिकोण का उपयोग करता है। क्रॉस उत्पाद महंगा है और 10 पूरे बाइट्स लेता है, लेकिन यह अभी भी मेरे द्वारा किए गए किसी भी विभाजन आधारित दृष्टिकोण की तुलना में कम है, मुख्य रूप से सत्य के लिए दो सुसंगत आउटपुट के स्टीप्युलेशन और प्रश्न में फाल्सी के कारण - फाल्सी बनाना केवल एक होना चाहिए false., और कभी-कभी आवश्यकता नहीं है विभाजन-दर-शून्य त्रुटि, बहुत से बाइट्स का उपयोग करता है।

{⊇Ċ}ᶠzᵐ{↰₁ᶠ{⟨hz{t↔}⟩×ᵐ=}ᵐ}ᵐ
{⊇Ċ}ᶠ                        Get each pair of rows from the matrix
                             eg.: [ [[a, b, c], [k, l, m]], ... ]
     zᵐ                      Zip each pair's elements
                                  [ [[a, k], [b, l], [c, m]], ... ]
       {                 }ᵐ  Map this over each pair of rows:
                                  [[a, k], [b, l], [c, m]]
        ↰₁ᶠ                  Get each pair of paired elements from the rows
                                  [[[a, k], [b, l]], [[b, l], [c, m]], [[a, k], [c, m]]]
           {           }ᵐ    Map this over each pair of pairs
                                  [[a, k], [b, l]]
            ⟨hz{t↔}⟩         Zip the first pair with the reverse of the second
                                  [[a, l], [k, b]]
                    ×ᵐ       Multiply within each sublist
                                  [al, kb]
                      =      The results should be equal
                             (If the results are unequal for any pair, the whole predicate fails,
                              and outputs false.)

तत्व-वार डिवीजन ( 30 बाइट्स ) के आधार पर वैकल्पिक दृष्टिकोण :

{≡ᵉ¬0&}ˢ\↰₁ˢ{c׬0&⟨hz∋⟩ᶠ/ᵐ²=ᵐ}

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



1

सेजमैथ, 40 बाइट्स

lambda M:any(M.rref()[1:])*(M.nrows()>1)

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

यह अनाम फ़ंक्शन देता है Falseयदि मैट्रिक्स रैंक-एक है, और Trueअन्यथा।

फ़ंक्शन Mइनपुट के रूप में एक मैट्रिक्स लेता है , इसे कम रो-इकोलोन फॉर्म ( M.rref()) में परिवर्तित करता है , और anyपहले गैर-शून्य होने वाली पंक्तियों के लिए परीक्षण करता है। फिर, उस मान को गुणा किया जाता है M.nrows()>1(क्या मैट्रिक्स में एक से अधिक पंक्ति है?)।


1

पायथन 3 , 93 91 बाइट्स

lambda m,e=enumerate:any(h*g-r[j]*s[i]for r in m for i,h in e(r)for s in m for j,g in e(s))

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

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

जाँचता है कि क्या किसी 2-नाबालिग में नॉनज़ेरो निर्धारक है। यदि यह मामला है तो रैंक कम से कम 2 होना चाहिए: "एक गैर-लुप्त पी-माइनर (गैर शून्य निर्धारक के साथ p × p सबमेट्रिक्स) से पता चलता है कि उस सबमेट्रिक्स की पंक्तियाँ और स्तंभ रैखिक रूप से स्वतंत्र हैं, और इस तरह से पंक्तियाँ और पंक्तियाँ पूर्ण मैट्रिक्स के स्तंभ रैखिक रूप से स्वतंत्र होते हैं (पूर्ण मैट्रिक्स में), इसलिए पंक्ति और स्तंभ रैंक कम से कम बड़े होते हैं जैसे निर्धारक रैंक "( विकिपीडिया से )

नोट: उपयोगकर्ता 71546 की टिप्पणी के लिए दो बाइट्स मुंडा।


1
91 - यदि फ़ंक्शन तर्कों में f=lambda m,e=enumerate:any(h*g-r[j]*s[i]for r in m for i,h in e(r)for s in m for j,g in e(s))
गूढ़ता है

@ user71546 धन्यवाद! कर दिया!
लुका सिटी

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.