एक पूर्णांक मैट्रिक्स के निर्धारक

Question

इनपुट के रूप में एक वर्ग पूर्णांक मैट्रिक्स को देखते हुए, मैट्रिक्स के निर्धारक को आउटपुट करता है।

नियम

• आप मान सकते हैं कि मैट्रिक्स में सभी तत्व, मैट्रिक्स के निर्धारक और मैट्रिक्स में कुल तत्वों की संख्या आपकी भाषा के लिए पूर्णांकों की प्रतिनिधित्व योग्य सीमा के भीतर है।
• 0 के भिन्नात्मक भाग के साथ दशमलव / फ्लोट मान को आउटपुट 42.0करने की अनुमति है (जैसे इसके बजाय 42)।
• बिल्डिंस को अनुमति दी जाती है, लेकिन आपको एक समाधान शामिल करने के लिए प्रोत्साहित किया जाता है जो बिलिन का उपयोग नहीं करता है।

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

[[42]] -> 42
[[2, 3], [1, 4]] -> 5
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] -> 0
[[13, 17, 24], [19, 1, 3], [-5, 4, 0]] -> 1533
[[372, -152, 244], [-97, -191, 185], [-53, -397, -126]] -> 46548380
[[100, -200, 58, 4], [1, -90, -55, -165], [-67, -83, 239, 182], [238, -283, 384, 392]] -> 571026450
[[432, 45, 330, 284, 276], [-492, 497, 133, -289, -28], [-443, -400, 56, 150, -316], [-344, 316, 92, 205, 104], [277, 307, -464, 244, -422]] -> -51446016699154
[[416, 66, 340, 250, -436, -146], [-464, 68, 104, 471, -335, -442], [159, -407, 310, -489, -248, 370], [62, 277, 446, -325, 47, -193], [460, 460, -418, -28, 234, -374], [249, 375, 489, 172, -423, 125]] -> 39153009069988024
[[-246, -142, 378, -156, -373, 444], [186, 186, -23, 50, 349, -413], [216, 1, -418, 38, 47, -192], [109, 345, -356, -296, -47, -498], [-283, 91, 258, 66, -127, 79], [218, 465, -420, -326, -445, 19]] -> -925012040475554
[[-192, 141, -349, 447, -403, -21, 34], [260, -307, -333, -373, -324, 144, -190], [301, 277, 25, 8, -177, 180, 405], [-406, -9, -318, 337, -118, 44, -123], [-207, 33, -189, -229, -196, 58, -491], [-426, 48, -24, 72, -250, 160, 359], [-208, 120, -385, 251, 322, -349, -448]] -> -4248003140052269106
[[80, 159, 362, -30, -24, -493, 410, 249, -11, -109], [-110, -123, -461, -34, -266, 199, -437, 445, 498, 96], [175, -405, 432, -7, 157, 169, 336, -276, 337, -200], [-106, -379, -157, -199, 123, -172, 141, 329, 158, 309], [-316, -239, 327, -29, -482, 294, -86, -326, 490, -295], [64, -201, -155, 238, 131, 182, -487, -462, -312, 196], [-297, -75, -206, 471, -94, -46, -378, 334, 407, -97], [-140, -137, 297, -372, 228, 318, 251, -93, 117, 286], [-95, -300, -419, 41, -140, -205, 29, -481, -372, -49], [-140, -281, -88, -13, -128, -264, 165, 261, -469, -62]] -> 297434936630444226910432057

Comments

सैंडबॉक्स , प्रासंगिक मेटा पोस्ट

— मेगो

क्या मैट्रिक्स का अधिकतम आकार है जिसे समर्थन करने की आवश्यकता है या यह मनमाना है?

— टेलर स्कॉट

@TaylorScott पहले नियम सूचीबद्ध:You may assume that all elements in the matrix, the determinant of the matrix, and the total number of elements in the matrix are within the representable range of integers for your language.

— Mego

आप जानते हैं कि आपके पास एक दिलचस्प चुनौती है जब आपके पास 4 जेली उत्तर हैं जो लगातार एक-दूसरे को बाहर करते हैं ...

— अमानवीय

Answer 1

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

LŒ!ðŒcIṠ;ị"Pð€S

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

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

LŒ!ðŒcIṠ;ị"Pð€S   input
L                 length
 Œ!               all_permutations
   ð        ð€    for each permutation:
    Œc                take all unordered pairs
      I               calculate the difference between
                      the two integers of each pair
       Ṡ              signum of each difference
                      (positive -> 1, negative -> -1)
        ;             append:
         ị"             the list of elements generated by taking
                        each row according to the index specified
                        by each entry of the permutation
           P          product of everything
              S   sum

यह क्यों काम करता है - मैथी संस्करण

ऑपरेटर det एक मैट्रिक्स लेता है और एक अदिश देता है। एक n -by- n मैट्रिक्स को लंबाई n के n वैक्टर के संग्रह के रूप में सोचा जा सकता है , इसलिए det वास्तव में एक फ़ंक्शन है जो n vectors को and ⁿ से लेता है और एक स्केलर लौटाता है।

इसलिए, मैं लिखना det ( v ₁ , वी ₂ , वी ₃ , ..., वी _एन के लिए) det [ v ₁ वी ₂ वी ₃ ... वी _एन ]।

सूचना है कि det प्रत्येक तर्क में रेखीय है, यानी det ( v ₁ + λ डब्ल्यू ₁ , वी ₂ , वी ₃ , ..., वी _एन ) = det ( v ₁ , वी ₂ , वी ₃ , ..., वी _एन ) + λ हिरासत ( डब्ल्यू ₁ , वी ₂ , वी ₃ , ..., वी _एन )। इसलिए, यह से (ℤ एक रेखीय नक्शा है ⁿ ) ^{⊗ n} से ℤ

यह रैखिक मानचित्र के तहत आधार की छवि निर्धारित करने के लिए पर्याप्त है। की (ℤ आधार ⁿ ) ^{⊗ n} के होते हैं n ℤ के आधार तत्वों के गुना टेन्सर उत्पादों ⁿ , ieeg ई ₅ ⊗ ई ₃ ⊗ ई ₁ ⊗ ई ₅ ⊗ ई ₁ । एक समान टेनसरों को शामिल करने वाले सेंसर उत्पादों को शून्य पर भेजा जाना चाहिए, क्योंकि एक मैट्रिक्स का निर्धारक जिसमें दो कॉलम समान हैं, शून्य है। यह जांचने के लिए रहता है कि अलग-अलग आधार तत्वों के टेंसर उत्पादों को क्या भेजा जाता है। टेंसर उत्पाद में वैक्टर के सूचकांक एक आक्षेप का निर्माण करते हैं, अर्थात एक क्रमपरिवर्तन, जिसमें क्रमपरिवर्तन भी 1 को भेजे जाते हैं और विषम क्रमपरिवर्तन -1 में भेजे जाते हैं।

उदाहरण के लिए, [[1, 2], [3, 4]] के निर्धारक को खोजने के लिए: ध्यान दें कि कॉलम [1, 3] और [2, 4] हैं। हम (1 ई ₁ + 3 ई ₂ ) और (2 ई ₁ + 4 ई ₂ ) देने के लिए विघटित करते हैं । टेंसर उत्पाद में संबंधित तत्व है (1 ई _{1 1} 2 ई ₁ + 1 ई ₁ e 4 ई ₂ + 3 ई ₂ e 2 ई ₁ + 3 ई ₂ e 4 ई ₂ ), जिसे हम सरल करते हैं (2 ई ₁₎ ⊗ e ₁ + 4 e _{1 2} e ₂ + 6 e ₂ + e ₁ + 12 e _{2 2} e ₂)। इसलिए:

det [[1, 2], [3, 4]]
= det (1 e ₁ + 3 e ₂ , 2 e ₁ + 4 e ₂ )
= det (2 e _{1 1} e ₁ + 4 e _{1 2} e ₂ + 6 e ₂ e e ₁ + 12 e ₂ ) e ₂ )
= det (2 e _{1 1} e ₁ ) + det (4 e _{1 2} e ₂ ) + det (6 e _{2 1} e ₁ ) + det (12 e)₂ ⊗ e ₂ )
= 2 det (e ₁ ) e ₁ ) + 4 det (e _{1 2} e ₂ ) + 6 det (e _{2 1} e ₁ ) + 12 det (e _{2 2} e ₂ )
= 2 (0) + 4 (1) + 6 (-1) + 12 (0)
= 4 - 6
= -2

अब यह साबित होता है कि क्रमचय की समानता को खोजने का सूत्र मान्य है। मेरा कोड क्या करता है अनिवार्य रूप से व्युत्क्रमों की संख्या ज्ञात करता है, अर्थात उन स्थानों पर जहां बाईं ओर एक तत्व दाईं ओर एक तत्व से बड़ा है (जरूरी नहीं कि लगातार)।

उदाहरण के लिए, क्रमचय 3614572 में, 9 व्युत्क्रम (31, 32, 61, 64, 65, 62, 42, 52, 72) हैं, इसलिए क्रमपरिवर्तन विषम है।

औचित्य यह है कि प्रत्येक ट्रांसपोज़िशन (दो तत्वों की अदला-बदली) या तो एक व्युत्क्रम को जोड़ता है या एक व्युत्क्रम को दूर ले जाता है, व्युत्क्रमों की संख्या की समता की अदला-बदली करता है, और क्रमपरिवर्तन की संख्या की समता के लिए क्रमपरिवर्तन की समता है।

इसलिए, निष्कर्ष में, हमारे सूत्र द्वारा दिया गया है:

यह क्यों काम करता है - गैर-मैथी संस्करण

जहां σ 𝕊 का क्रमपरिवर्तन है _n पर सभी क्रमपरिवर्तन की समूह n पत्र, और sgn क्रमचय के हस्ताक्षर, उर्फ है (-1) क्रमपरिवर्तन की समता को उठाया, और एक _ij (है ij ) ^वें में प्रवेश मैट्रिक्स ( मैं नीचे, j भर में)।

Comments

वह "नॉन-मैथी संस्करण" बहुत लानत है।

— एमडी एक्सएफ

@MDXF फ़ार्मुलों और प्रतीकों और संख्याओं का गणित शायद ही बनता है। गणित, अमूर्तता और सामान्यीकरण और प्रतीकों के औपचारिक हेरफेर के पीछे का तर्क है।

— लीक नन

@JAB जेली अपने कस्टम कोड पेज को लागू करती है । (इन दिनों में से एक, TIO में कोड पेज का लिंक शामिल होगा ...)

— fullhuman

@Mego "sum-of-diagonal-products" केवल 1x1, 2x2 और 3x3 मैट्रिसेस के लिए काम करते हैं। बड़े मैट्रिसेस के लिए, आपको सभी क्रमपरिवर्तन और उनकी समता पर विचार करने की आवश्यकता है।

— लीक नून

+1 के लिए वास्तव में कहने के बजाय पोस्ट में प्रमाण शामिल करें "क्योंकि यह सूत्र पृष्ठ पर सूचीबद्ध है abcxyz यह सच होना चाहिए"।

— user202729

Answer 2

आर , 3 बाइट्स

साधारण समाधान

det

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

आर , 94 92 बाइट्स

फिर से लागू समाधान

जारको डबेलडैम द्वारा किया गया बहिर्गमन

d=function(m)"if"(x<-nrow(m),m[,1]%*%sapply(1:x,function(y)(-1)^(y-1)*d(m[-y,-1,drop=F])),1)

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

मैट्रिक्स के पहले कॉलम के नीचे नाबालिगों द्वारा पुन: विस्तार का उपयोग किया जाता है।

f <- function(m){
 x <- nrow(m)                 # number of rows of the matrix
 if(sum(x) > 1){              # when the recursion reaches a 1x1, it has 0 rows
                              # b/c [] drops attributes
  minor <- function(y){
   m[y] * (-1)^(y-1) *
   d(m[-y,-1])                # recurse with the yth row and first column dropped
   }
  minors <- sapply(1:x,minor) # call on each row
  sum(minors)                 # return the sum
 } else {
  m                           # return the 1x1 matrix
 }
}

Comments

32 बाइट्स

— JAD

Answer 3

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

Ḣ×Zß-Ƥ$Ṛḅ-

लाप्लास विस्तार का उपयोग करता है । 3 5 बाइट्स से गोल्फ के लिए @ मीलों के लिए धन्यवाद !

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

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

Ḣ×Zß-Ƥ$Ṛḅ-  Main link. Argument: M (matrix / 2D array)

Ḣ           Head; pop and yield the first row of M.
      $     Combine the two links to the left into a monadic chain.
  Z         Zip/transpose the matrix (M without its first row).
   ß-Ƥ      Recursively map the main link over all outfixes of length 1, i.e., over
            the transpose without each of its rows.
            This yields an empty array if M = [[x]].
 ×          Take the elementwise product of the first row and the result on the
            right hand. Due to Jelly's vectorizer, [x] × [] yields [x].
       Ṛ    Reverse the order of the products.
        ḅ-  Convert from base -1 to integer.
                [a]          -> (-1)**0*a
                [a, b]       -> (-1)**1*a + (-1)**0*b = b - a
                [a, b, c]    -> (-1)**2*a + (-1)**1*b + (-1)**0*c = c - b + a
                etc.

Answer 4

14 और 42 बाइट्स के बीच वोल्फ्राम लैंग्वेज (मैथेमेटिका)

हमारे पास एक 3-बाइट बिल्ट-इन और एक 53-बाइट समाधान है जो पूरी तरह से बिल्ट-इन से बचा जाता है, इसलिए यहां कुछ वीयरर समाधान कहीं बीच में हैं।

Wolfram भाषा है का एक बहुत सरल संरचना के साथ अन्य मैट्रिक्स के उत्पादों में मैट्रिक्स सड़ते के लिए बहुत तीव्र कार्य करता है। सरल लोगों में से एक (जिसका अर्थ मैंने पहले सुना है) जॉर्डन अपघटन है। प्रत्येक मैट्रिक्स एक विशिष्ट संरचना के साथ विकर्ण ब्लॉकों से बना एक (संभवतः जटिल-मूल्यवान) ऊपरी त्रिकोणीय मैट्रिक्स के समान है, जिसे मैट्रिक्स का जॉर्डन अपघटन कहा जाता है। समानता निर्धारकों को संरक्षित करती है, और त्रिकोणीय मैट्रिक्स का निर्धारक विकर्ण तत्वों का उत्पाद है, इसलिए हम निम्नलिखित 42 बाइट्स के साथ निर्धारक की गणना कर सकते हैं :

1##&@@Diagonal@Last@JordanDecomposition@#&

निर्धारक गुणक के गुणक के गुणनफल के गुणनफल के बराबर भी होता है। सौभाग्य से, वुल्फराम का ईजेनवल्यू फ़ंक्शन मल्टीपैलिटी (यहां तक ​​कि गैर-तिरछे मेट्रिसेस के लिए) का ट्रैक रखता है, इसलिए हमें निम्नलिखित 20 बाइट समाधान मिलते हैं:

1##&@@Eigenvalues@#&

अगला समाधान धोखाधड़ी की तरह है और मुझे वास्तव में यकीन नहीं है कि यह क्यों काम करता है। N फ़ंक्शन की एक सूची का Wronskian कार्यों के पहले n -1 डेरिवेटिव के मैट्रिक्स का निर्धारक है । यदि हम Wronskianफ़ंक्शन को पूर्णांक का एक मैट्रिक्स देते हैं और कहते हैं कि भेदभाव का चर 1 है, तो किसी तरह यह मैट्रिक्स के निर्धारक को बाहर निकालता है। यह अजीब है, लेकिन इसमें " Det" अक्षर शामिल नहीं हैं और यह केवल 14 बाइट्स है ...

#~Wronskian~1&

(Casoratian निर्धारक के रूप में अच्छी तरह से काम करता है, 1 अधिक बाइट के लिए: #~Casoratian~1&)

अमूर्त बीजगणित के दायरे में, n  x  n मैट्रिक्स (निर्धारक के रूप में गुणा k → k कि गुणक के रूप में सोचा जाता है) के निर्धारक मैट्रिक्स की n वीं बाहरी शक्ति है (एक आइसोमोर्फिज्म k → ⋀ ⁿ k को चुनने के बाद) ⁿ )। वोल्फ्राम भाषा में, हम निम्न 26 बाइट्स के साथ ऐसा कर सकते हैं :

HodgeDual[TensorWedge@@#]&

और यहाँ एक समाधान है जो केवल सकारात्मक निर्धारकों के लिए काम करता है। यदि हम एक n -dimensional इकाई हाइपरक्यूब लेते हैं और इसे एक रैखिक परिवर्तन लागू करते हैं, तो परिणामी क्षेत्र का n -dimensional "वॉल्यूम" परिवर्तन के निर्धारक का पूर्ण मूल्य है। एक घन में एक रैखिक परिवर्तन लागू करने से एक समानता प्राप्त होती है, और हम निम्नलिखित 39 बाइट्स के साथ इसकी मात्रा ले सकते हैं :

RegionMeasure@Parallelepiped[Last@#,#]&

Comments

इन लाइनों के साथ जो समाधान मेरे पास था Exp@*Tr@*MatrixLog, लेकिन दुर्भाग्य से यह विलक्षण मैट्रीस के लिए काम नहीं करता है।

— मिशा लावरोव

@ मिशलारोव ओह, यह चतुर है! मुझे लगता है कि आप इसे ठीक कर सकते हैं Check[E^Tr@MatrixLog@#,0]&।

— एक पेड़ नहीं

एक दम बढ़िया! मुझे Checkपहले पता नहीं था ।

— मिशा लावरोव

मैंने कुछ समय पहले जॉर्डन डिकम्पोजिशन के लिए एक चुनौती बनाई । आप भी इसमें दिलचस्पी ले सकते हैं। क्या शानदार जवाब है!

— Mego

Answer 5

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

-3 बाइट्स लिन का धन्यवाद। एक और एक क्रेग रॉय को धन्यवाद देता है।

f[]=1
f(h:t)=foldr1(-)[v*f[take i l++drop(i+1)l|l<-t]|(i,v)<-zip[0..]h]

इसे ऑनलाइन आज़माएं! अनुकूलन प्रयोजनों के लिए जोड़ा गया -Oध्वज। यह आवश्यक नहीं है।

स्पष्टीकरण (पुराना)

f पुनरावर्ती कोफ़ेक्टर विस्तार लागू करता है।

f[[x]]=x

यह रेखा 1 × 1 मैट्रिक्स के आधार मामले को कवर करती है , जिस स्थिति में निर्धारणकर्ता होता है mat[0, 0]।

f(h:t)=

यह मैट्रिक्स को एक सिर (पहली पंक्ति) और एक पूंछ (मैट्रिक्स के बाकी हिस्सों ) में तोड़ने के लिए मिलान पैटर्न का उपयोग करता है ।

          [                                     |(i,v)<-zip[0..]h]

मैट्रिक्स के सिर की गणना करें (पूरी संख्याओं और सिर की अनंत सूची को जोड़कर) और उस पर पुनरावृति करें।

           (-1)*i*v

नतीजे के आधार पर नेगेट करें कि क्या इसका सूचकांक तब भी है क्योंकि निर्धारक की गणना में वैकल्पिक जोड़ और घटाव शामिल है।

                     [take i l++drop(i+1)l|l<-t]

यह अनिवार्य रूप से i तत्वों को ले जाकर पूंछ के ith कॉलम को हटाता है और पूंछ में हर पंक्ति के लिए गिराए गए पहले (i + 1) वें तत्वों के साथ पंक्ति के साथ इसे सम्मिलित करता है ।

                   *f

उपरोक्त परिणाम के निर्धारक की गणना करें और इसके परिणाम के साथ गुणा करें (-1)*i*v।

       sum

ऊपर दी गई सूची का परिणाम और वापस लौटें।

Comments

आप 1 बाइट बचा सकते हैं यदि आप के sum[(-1)^i*...साथ प्रतिस्थापित करते हैंfoldr(-)0[...

— क्रेग रॉय

Answer 6

प्रोटॉन , 99 बाइट्स

f=m=>(l=len(m))==1?m[0][0]:sum((-1)**i*m[0][i]*f([[m[k][j]for k:1..l]for j:0..l if j-i])for i:0..l)

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

-3 बाइट्स मिस्टर एक्सकोडर
-3 बाइट्स की बदौलत एरिक आउटग्रोफर को धन्यवाद

पहली पंक्ति में विस्तार

Comments

सिर्फ इसलिए कि प्रोटॉन निर्धारक के लिए बिल्टइन नहीं है।

— user202729

103 बाइट्स । ((~i%2)*2-1)->((-i%2)|1)

— श्री Xcoder

इसके अलावा 102 की जगह बाइट्स j!=iके साथ j-iया i-j।

— बजे मिस्टर एक्सकोडर

99 बाइट्स

— निकोलगर्फ़

@EriktheOutgolfer आह हाँ, धन्यवाद!

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

Answer 7

ऑक्टेव , 28 बाइट्स

@(x)round(prod(diag(qr(x))))

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

यह एक मैट्रिक्स एक्स के क्यूआर अपघटन को एक ऑर्थोनल मैट्रिक्स क्यू और एक ऊपरी त्रिकोणीय मैट्रिक्स आर में उपयोग करता है । X का निर्धारक Q और के गुणनफल है R । एक ऑर्थोगोनल मैट्रिक्स में यूनिट निर्धारक होता है, और त्रिकोणीय मैट्रिक्स के लिए निर्धारक इसकी विकर्ण प्रविष्टियों का उत्पाद होता है। ऑक्टेव के qrएक आउटपुट के साथ बुलाया फ़ंक्शन आर देता है ।

परिणाम निकटतम पूर्णांक के लिए गोल है। बड़े इनपुट मैट्रिस के लिए, फ्लोटिंग-पॉइंट अशुद्धि एक त्रुटि से अधिक उत्पन्न कर सकती है 0.5और इस प्रकार एक गलत परिणाम उत्पन्न करती है।

Comments

यह detबिलियन से बाहर निकलने का एक दिलचस्प तरीका है । ;)

— tomsmeding

@tomsmeding :-) इसके अलावा, यह पहले से ही स्टीवी के जवाब

— लुइस मेंडू

Answer 8

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

p%(l:r)=l!!0*f(tail<$>p++r)-(p++[l])%r
[]%_=1
p%_=0
f=([]%)

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

Answer 9

सी,  176  125 बाइट्स

42 बाइट्स के लिए @ceilingcat का धन्यवाद, और एक बाइट को बचाने के लिए @Lynn और @Jonathan दोनों को धन्यवाद!

d(M,n)int*M;{int i=n--,s=*M*!n,c,T[n*n];for(;i--;s+=M[i]*(1-i%2*2)*d(T,n))for(c=n*n;c--;T[c]=M[n-~c+c/n+(c%n>=i)]);return s;}

पहली पंक्ति के साथ लाप्लास विस्तार का उपयोग करके निर्धारक की गणना करता है ।

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

unrolled:

d(M, n)int*M;
{
    int i=n--, s=*M*!n, c, T[n*n];
    for (; i--; s+=M[i]*(1-i%2*2)*d(T,n))
        for (c=n*n; c--;)
            T[c] = M[n-~c+c/n+(c%n>=i)];
    return s;
}

Comments

(i%2*-2+1)→ (1-i%2*2)एक और बाइट बचाता है।

— लिन

n+1+cहो सकता है n-~c।

— जोनाथन फ्रीच

सुझाएँ i=sबजायreturn s

— ceilingcat

Answer 10

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

अंत में मैंने एक गोल्फ भाषा में अपना गैर-बिल्टिन समाधान लिखना शुरू कर दिया है!

ḣ⁹’’¤;ṫḊ€Ç×⁸ị@⁹’¤¤ḷ/¤
çЀ⁸J‘¤µJ-*×NS
ÇḢḢ$Ṗ?

एक बाइट को बचाने के लिए HyperNeutrino को धन्यवाद !

इसे ऑनलाइन आज़माएं! (स्पष्टता के लिए कोड दिया गया)

एक सूची से n'th तत्वों को निकालने के लिए बहुत लंबा रास्ता, बाद में सुधार होगा

---

इस जवाब को हाइपरन्यूट्रिनो, डेनिस और लीकी नन के जवाबों से बढ़ा दिया गया था। जेली है एक गोल्फिंग भाषा के रूप बहुत लोकप्रिय है।

त्वरित स्पष्टीकरण:

ÇḢḢ$Ṗ?    Main link.
     ?    If
    Ṗ     after remove the last element, the value is not empty (truthy)
Ç         then execute the last link
 ḢḢ$      else get the element at index [1, 1].

çЀ⁸J‘¤µJ-*×NS     Helper link 1, take input as a matrix.
çЀ                Apply the previous link, thread right argument to
   ⁸J‘¤            the range [2, 3, ..., n+1]
       µ           With the result,
        J-*        generate the range [-1, 1, -1, 1, ...] with that length
           ×N      Multiply by negative
             S     Sum

ḣ⁹’’¤;ṫḊ€Ç×⁸ị@⁹’¤¤ḷ/¤    Helper link 2, take left input as a matrix, right input as a number in range [2..n+1]
ḣ
 ⁹’’¤                    Take head ρ-2 of the matrix
     ;                   concatenate with 
      ṫ                  tail ρ (that is, remove item ρ-1)
       Ḋ€                Remove first column
         Ç               Calculate determinant of remaining matrix
          ×         ¤    multiply by
                  ḷ/     the first column,
            ị@           row #
              ⁹’¤        ρ-1 (just removed in determinant calculation routine) of
           ⁸     ¤       the matrix.

Answer 11

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

œcL’$ṚÑ€
J-*×Ḣ€×ÇSµḢḢ$Ṗ?

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

व्याख्या

œcL’$ṚÑ€         Helper Link; get the next level of subdeterminants (for Laplace Expansion)
œc               Combinations without replacement of length:
  L’$            Length of input - 1 (this will get all submatrices, except it's reversed)
     Ṛ           Reverse the whole thing
      р         Get the determinant of each of these
J-*×Ḣ€×ÇSµḢḢ$Ṗ?  Main Link
              ?  If the next value is truthy
             Ṗ   Remove the last element (truthy if the matrix was at least size 2)
J-*×Ḣ€×ÇSµ       Then expand
          ḢḢ$    Otherwise, get the first element of the first element (m[0][0] in Python)
J                [1, 2, ..., len(z)]
 -*              (-1 ** z) for each z in the length range
   ×             Vectorizing multiply with
    Ḣ€           The first element of each (this gets the first column); modifies each row (makes it golfier yay)
      ×Ç         Vectorizing multiply with the subdeterminants
        S        Sum

उपयोगकर्ता 202029 के समाधान के लिए -2 बाइट्स धन्यवाद

Answer 12

Matl , 3 बाइट्स / 5 बाइट्स

बिल्ट-इन फ़ंक्शन के साथ

&0|

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

बिना बिल्ट-इन

गलती को इंगित करने के लिए मिशा लावरोव को धन्यवाद , अब सही किया गया

YvpYo

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

यह निर्धारक के गुणन को गणना करता है, जो फ्लोटिंग-पॉइंट अशुद्धि से बचने के लिए निकटतम पूर्णांक तक गोल होता है।

Yv       % Implicit input. Push vector containing the eigenvalues
p        % Product
Yo       % Round. Implicit display

Comments

क्या विलक्षण मानों का गुणनफल आपको केवल निर्धारक का निरपेक्ष मान नहीं बताएगा?

— मिशा लावरोव

@ मिशालारोव आप पूरी तरह से सही हैं! ध्यान देने के लिए धन्यवाद। मैंने इसे विलक्षण मानों के बजाय आइजनवेल्यूज़ का उपयोग करके ठीक किया ... और जो 4 बाइट्स \ / /

— लुइस मेंडो

Answer 13

आर , 32 बाइट्स

function(m)Re(prod(eigen(m)$va))

मैट्रिक्स के eigenvalues ​​लेने और उनके उत्पाद का वास्तविक हिस्सा लेने के लिए न कि ट्री के एल्गोरिथ्म का उपयोग करता है।

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

Comments

बहुत खूबसूरत! +1।

— Giuseppe

Answer 14

ऑक्टेव , 30 बाइट्स

@(x)-prod(diag([~,l,~]=lu(x)))

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

या, उबाऊ 4 बाइट समाधान (लुइस मेंडो के लिए 6 बाइट्स को बचाया) (बिलिन कार्यों के नियमों को भूल गया):

@det

स्पष्टीकरण:

आ रहा है! :)

Answer 15

टीआई-बेसिक, 2 बाइट्स

det(Ans

ठीक है।

कृपया तुच्छ उत्तर न दें।

_{एक हाई स्कूल के छात्र के रूप में (जो इन कैलकुलेटरों में से एक के लिए मजबूर है), यह फ़ंक्शन हेला उपयोगी है इसलिए ...}

Comments

यह अभी भी कॉलेज में उपयोगी है - रेखीय बीजगणित दूर नहीं जाता है

— टेलर स्कॉट

@TaylorScott वास्तव में, यह विभेदक समीकरणों में प्रतिशोध के साथ वापस आता है।

— Mego

@ मेगो - आप उस पर सही हैं; हालांकि किसी कारण के लिए उन्होंने मुझे बछड़े के सभी ले जाने और रैखिक से पहले: /

— टेलर स्कॉट

@TaylorScott मेरे विश्वविद्यालय के गणित विभाग द्वारा एक नज़र रखने के कारण, जब मैंने इसे लिया, तो लेनिग diffeq के लिए कोई शर्त नहीं थी। जब मेरे प्रोफेसर ने महसूस किया कि, उन्होंने जल्दी से हमें 3 दिन का क्रैश कोर्स दिया।

— Mego

Answer 16

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

a#((b:c):r)=b*d(a++map tail r)-(a++[c])#r
_#_=0
d[]=1
d l=[]#l

इसे ऑनलाइन आज़माएं! (फुहारे के समाधान के साथ परीक्षण के मामले

dपहले स्तंभ के साथ लाप्लास विस्तार का उपयोग करके निर्धारक की गणना करता है। स्थायी की तुलना में तीन बाइट्स की आवश्यकता होती है ।

Answer 17

पायथन 2 , 95 बाइट्स

-12 बाइट्स लिन को धन्यवाद।

मेरे हास्केल उत्तर का पोर्ट ।

f=lambda m:sum((-1)**i*v*f([j[:i]+j[i+1:]for j in m[1:]])for i,v in enumerate(m[0]))if m else 1

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

Comments

यहां, आप []आधार मामले के रूप में भी उपयोग कर सकते हैं : f=lambda m:sum((-1)**i*v*f([j[:i]+j[i+1:]for j in m[1:]])for i,v in enumerate(m[0]))if m else 195 बाइट्स के लिए!

— लिन

m==[]or sum(...)92 बाइट्स

— बुबलर

Answer 18

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 53 52 बाइट्स

1##&@@@(t=Tuples)@#.Signature/@t[Range@Tr[1^#]&/@#]&

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

दुर्भाग्य से, एक की निर्धारक कंप्यूटिंग एन से n मैट्रिक्स इस तरह का उपयोग करता है ओ ( एन ^एन ) स्मृति, जो कहते हैं बड़े परीक्षण मामलों पहुंच से बाहर।

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

पहला भाग, 1##&@@@(t=Tuples)@#दिए गए मैट्रिक्स की प्रत्येक पंक्ति से किसी शब्द के सभी संभावित उत्पादों की गणना करता है।t[Range@Tr[1^#]&/@#]उसी लंबाई की सूची देता है जिसके तत्व चीजें हैं {3,2,1}या जैसे हैं{2,2,3} कह जो प्रत्येक पंक्ति की प्रविष्टि है जो हमने संबंधित उत्पाद के लिए निकाली थी।

हम Signatureदूसरी सूची पर लागू होते हैं , जो क्रमपरिवर्तन के लिए भी मैप करता है1 , विषम क्रमपरिवर्तन -1और गैर-क्रमपरिवर्तन के लिए करता है0 । यह ठीक गुणांक है, जिसके साथ संबंधित उत्पाद निर्धारक में दिखाई देता है।

अंत में, हम दो सूचियों के डॉट उत्पाद लेते हैं।

---

अगर Signatureबिल्ट-इन बहुत ज्यादा है, तो 73 बाइट्स में हम ले सकते हैं

1##&@@@(t=Tuples)@#.(1##&@@Order@@@#~Subsets~{2}&/@t[Range@Tr[1^#]&/@#])&

द्वारा प्रतिस्थापित किया जा रहा है 1##&@@Order@@@#~Subsets~{2}&। यह Signatureक्रमचय Orderके तत्वों के सभी जोड़े के लिए लागू के उत्पाद को ले कर संभवतः-क्रमपरिवर्तन की गणना करता है । अगर जोड़ी आरोही क्रम में है, अगर यह अवरोही क्रम में है, और यदि वे समान हैं तो Orderदे देंगे ।1-10

---

-1 बाइट थैंक्यू @ user202729

Comments

52 बाइट्स (यदि आप इस गणितज्ञ गोल्फ टिप को नहीं जानते हैं)

— user202729

मैंने किया, लेकिन किसी तरह यहां के बारे में भूल गया। धन्यवाद!

— मिशा लावरोव

Answer 19

पायथन 3 , 238 बाइट्स , 227 बाइट्स , 224 बाइट्स , 216 बाइट्स

from functools import*
from itertools import*
r=range;n=len;s=sum
f=lambda l:s(reduce(lambda p,m:p*m,[l[a][b]for a,b in zip(r(n(l)),j)])*(-1)**s(s(y<j[x]for y in j[x:])for x in r(n(l)))for j in permutations(r(n(l))))

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

मेरा समाधान गणना के लिए एक निर्धारक की परिभाषा का उपयोग करता है। दुर्भाग्य से, इस एल्गोरिथ्म की जटिलता है n!और मैं अंतिम परीक्षण के पारित होने को नहीं दिखा सकता हूं, लेकिन सिद्धांत रूप में यह संभव है।

Answer 20

CJam ( 50 45 बाइट्स)

{:A_,{1$_,,.=1b\)/:CAff*A@zf{\f.*1fb}..-}/;C}

यह एक अनाम ब्लॉक (फ़ंक्शन) है जो स्टैक पर 2 डी सरणी लेता है और स्टैक पर एक पूर्णांक छोड़ता है।

ऑनलाइन टेस्ट सूट

विच्छेदन

यह Faddeev-LeVerrier एल्गोरिथ्म को लागू करता है , और मुझे लगता है कि यह उस दृष्टिकोण को लेने का पहला उत्तर है।

$c_k$$n\times n$$A$

$$p(\lambda )\equiv \det(\lambda I_{n}-A)=\sum _{k=0}^{n}c_{k}\lambda ^{k}$$ $c_n = 1$$c_0 = (−1)^n \det A$

गुणांक सहायक मैट्रिस डिंट द्वारा, ऊपर से नीचे की ओर पुन: निर्धारित किया जाता है$M$

$$\begin{aligned}M_{0}&\equiv 0&c_{n}&=1\qquad &(k=0)\\M_{k}&\equiv AM_{k-1}+c_{n-k+1}I\qquad \qquad &c_{n-k}&=-{\frac {1}{k}}\mathrm {tr} (AM_{k})\qquad &k=1,\ldots ,n~.\end{aligned}$$

$c_{n-k}$$M_k$$(-1)^k c_{n-k}$$(-1)^{k+1}AM_k$

$$(-1)^k c_{n-k} = \frac1k \mathrm{tr} ((-1)^{k+1} AM_{k}) \\ (-1)^{k+2} AM_{k+1} = (-1)^k c_{n-k}A - A((-1)^{k+1}A M_k)$$

{               e# Define a block
  :A            e#   Store the input matrix in A
  _,            e#   Take the length of a copy
  {             e#     for i = 0 to n-1
                e#       Stack: (-1)^{i+2}AM_{i+1} i
    1$_,,.=1b   e#       Calculate tr((-1)^{i+2}AM_{i+1})
    \)/:C       e#       Divide by (i+1) and store in C
    Aff*        e#       Multiply by A
    A@          e#       Push a copy of A, bring (-1)^{i+2}AM_{i+1} to the top
    zf{\f.*1fb} e#       Matrix multiplication
    ..-         e#       Matrix subtraction
  }/
  ;             e#   Pop (-1)^{n+2}AM_{n+1} (which incidentally is 0)
  C             e#   Fetch the last stored value of C
}

Answer 21

वोल्फ्राम भाषा (गणितज्ञ) , 3 बाइट्स

Det

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

प्रति मेटा आम सहमति , मुख्य रूप से nontrivial समाधान है कि लिखने के लिए प्रयास करना वोट दें।

Answer 22

पायथन 2 , 75 बाइट्स

f=lambda m,p=[]:m[0][0]*f(zip(*p+m[1:])[1:])-f(m[1:],p+m[:1])if m else[]==p

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

Answer 23

सेजमैथ , विभिन्न

यहाँ निर्धारक की गणना के लिए विधियों का एक समूह है जो मुझे दिलचस्प लगा, सभी को साधुमठ में क्रमादेशित किया गया। वे सभी यहाँ कोशिश की जा सकती है ।

बिलिन, 3 बाइट्स

det

यह बहुत दिलचस्प नहीं है। ऋषि कई सामान्य ऑपरेशनों के लिए वैश्विक स्तर के उपनाम प्रदान करता है जो सामान्य रूप से ऑब्जेक्ट तरीके होंगे, इसलिए यह इससे छोटा हैlambda m:m.det() ।

---

Eigenvalues ​​के उत्पाद का वास्तविक हिस्सा, 36 बाइट्स

lambda m:real(prod(m.eigenvalues()))

दुर्भाग्य से, eigenvaluesउन वैश्विक स्तर के उपनामों में से एक नहीं है। इस तथ्य के साथ, कि ऋषि के पास कार्यों की रचना करने का एक अच्छा तरीका नहीं है, इसका मतलब है कि हम एक महंगी कीमत के साथ फंस गए हैं lambda। यह फ़ंक्शन प्रतीकात्मक मान जो मुद्रित होने पर स्वचालित रूप से संख्यात्मक मान में बदल जाता है, इसलिए कुछ आउटपुट में कुछ फ़्लोटिंग अशुद्धि मौजूद हो सकती है।

---

जॉर्डन नॉर्मल फॉर्म, 60 बाइट्स में विकर्ण का उत्पाद

lambda m:prod(m.jordan_form()[x,x]for x in range(m.nrows()))

जॉर्डन सामान्य रूप में, एक NxN मैट्रिक्स को ब्लॉक मैट्रिक्स के रूप में दर्शाया जाता है, जिसमें विकर्ण पर N ब्लॉक होता है। प्रत्येक ब्लॉक में एक एकल eigenvalue, या विकर्ण पर एक दोहराया eigenvalue के साथ एक MxM मैट्रिक्स होता है और1 सुपर-विकर्ण (ऊपर का विकर्ण और "मुख्य" विकर्ण के दाईं ओर) होता है। इसका परिणाम मुख्य विकर्ण पर सभी eigenvalues ​​(बहुलता के साथ) और कुछ में मैट्रिक्स होता है1 सुपर-विकर्ण पर s को दोहराया eigenvalues ​​के अनुरूप होता है। यह जॉर्डन के विकर्ण के उत्पाद को सामान्य रूप में लौटाता है, जो कि आइगेनवेल्यूज (गुणक के साथ) का उत्पाद है, इसलिए यह पिछले समाधान के समान ही संगणना प्रदर्शन करने का एक अधिक गोल चक्कर तरीका है।

क्योंकि ऋषि चाहते हैं कि जॉर्डन सामान्य रूप मूल मैट्रिक्स के रूप में एक ही अंगूठी पर हो, यह केवल तभी काम करता है जब सभी eigenvalues ​​तर्कसंगत हैं। जटिल स्वदेशी परिणाम में त्रुटि होती है (जब तक कि मूल मैट्रिक्स रिंग के ऊपर न हो CDF(जटिल डबल फ़्लोट) याSR )। हालांकि, इसका मतलब यह है कि उपरोक्त समाधान की तुलना में वास्तविक हिस्सा लेना आवश्यक नहीं है।

---

स्मिथ अपघटन में विकर्ण का उत्पाद

lambda m:prod(m.smith_form()[0].diagonal())

जॉर्डन सामान्य रूप के विपरीत, स्मिथ सामान्य रूप मूल मैट्रिक्स के समान क्षेत्र में होने की गारंटी है। Eigenvalues ​​की गणना करने और ब्लॉक विकर्ण मैट्रिक्स के साथ उनका प्रतिनिधित्व करने के बजाय, स्मिथ अपघटन मैट्रिक्स के प्राथमिक विभाजकों (जो इस पोस्ट के लिए थोड़ा बहुत जटिल विषय है) की Dगणना करता है, उन्हें एक विकर्ण मैट्रिक्स में डालता है , और इकाई के साथ दो मैट्रिक्स की गणना करता है निर्धारक Uऔर Vऐसा D = U*A*V(जहां Aमूल मैट्रिक्स है)। के बाद से मैट्रिक्स के उत्पाद के निर्धारक मैट्रिक्स (के निर्धारकों के उत्पाद के बराबर होती है det(A*B*...) = det(A)*det(B)*...), और Uऔर Vइकाई निर्धारकों के लिए परिभाषित कर रहे हैं,det(D) = det(A) । एक विकर्ण मैट्रिक्स का निर्धारक केवल विकर्ण पर तत्वों का उत्पाद है।

लाप्लास विस्तार, 109 बाइट्स

lambda m:m.nrows()>1and sum((-1)**j*m[0,j]*L(m[1:,:j].augment(m[1:,j+1:]))for j in range(m.ncols()))or m[0,0]

यह एक पुनरावर्ती दृष्टिकोण का उपयोग करके पहली पंक्ति के साथ लाप्लास विस्तार करता है। det([[a]]) = aबेस केस के लिए उपयोग किया जाता है। यह det([[]]) = 1बेस केस के लिए उपयोग करने के लिए कम होना चाहिए , लेकिन उस कार्यान्वयन पर मेरे प्रयास में एक बग था जिसे मैं अभी तक ट्रैक नहीं कर पाया।

---

लिबनीज का फॉर्मूला, 100 बाइट्स

L2 = lambda m:sum(sgn(p)*prod(m[k,p[k]-1]for k in range(m.ncols()))for p in Permutations(m.ncols()))

यह सीधे लिबनीज के सूत्र को लागू करता है। सूत्र की बहुत बेहतर व्याख्या के लिए और यह काम करता है कि मैं संभवतः क्यों लिख सकता हूं, इस उत्कृष्ट उत्तर को देखें ।

---

का वास्तविक हिस्सा e^(Tr(ln(M))), 48 बाइट्स

lambda m:real(exp(sum(map(ln,m.eigenvalues()))))

यह फ़ंक्शन प्रतीकात्मक अभिव्यक्ति देता है। एक संख्यात्मक अनुमान प्राप्त करने के लिए, कॉल करेंn(result) मुद्रण से पहले ।

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

आज्ञा Aदेना एक वर्ग मैट्रिक्स पर reals है। परिभाषा के अनुसार, के निर्धारक Aगुणनफल के गुणनफल के बराबर होता है A। का पता लगाने के Aयोगों के योग के बराबर है A। वास्तविक संख्या r_1और r_2, exp(r_1) * exp(r_2) = exp(r_1 + r_2)। चूंकि मैट्रिक्स घातीय फ़ंक्शन को स्केलर घातीय फ़ंक्शन (विशेषकर पिछली पहचान में) के अनुरूप माना जाता है, और मैट्रिक्स घातीय को मैट्रिक्स को विकर्ण करके और स्केलर घातीय फ़ंक्शन को विकर्ण पर प्रतिजन में लागू करके गणना की जा सकती है, हम कह सकते हैं det(exp(A)) = exp(trace(A))(के exp(λ)प्रत्येक eigenvalue के लिए के उत्पाद eigenvalues λके Aबराबर होती हैexp(A) )। इस प्रकार, यदि हम एक मैट्रिक्स पा सकते हैं, तो हमL ऐसेexp(L) = A, हम गणना कर सकते हैं det(A) = exp(trace(L))।

हम Lकंप्यूटिंग द्वारा इस तरह के मैट्रिक्स को पा सकते हैं log(A)। मैट्रिक्स लघुगणक को उसी तरह से गणना की जा सकती है जैसे कि मैट्रिक्स घातांक: स्केलर लॉगरिथम फ़ंक्शन को प्रत्येक eigenvalue में लागू करके एक वर्ग विकर्ण मैट्रिक्स बनाते हैं A(यही कारण है कि हम Aवास्तविकों के लिए प्रतिबंधित है)। चूँकि हम केवल ट्रेस के बारे में परवाह करते हैं L, हम निर्माण को छोड़ सकते हैं और सीधे सीधे प्रतिजन के घातांक को जोड़ सकते हैं। मैट्रिक्स जटिल रिंग के ऊपर नहीं होने पर भी आइजेनवल जटिल हो सकते हैं, इसलिए हम योग का वास्तविक हिस्सा लेते हैं।

Comments

अंतिम भाग एक आकर्षक विचार है, लेकिन हेडर और स्पष्टीकरण कोड से मेल नहीं खाते हैं, जो मैट्रिक्स लॉगरिदम नहीं लेता है। यह सिर्फ real(prod(m.eigenvalues()))अपुष्ट है।

— पीटर टेलर

Answer 24

जावा 8, 266 261 259 258 बाइट्स

long d(int[][]m){long r=0;int i=0,j,k,l=m.length,t[][]=new int[l-1][l-1],q=m[0][0];if(l<3)return l<2?q:q*m[1][1]-m[0][1]*m[1][0];for(;i<l;r+=m[0][i]*(1-i++%2*2)*d(t))for(j=0;++j<l;)for(k=l;k-->0;){q=m[j][k];if(k<i)t[j-1][k]=q;if(k>i)t[j-1][k-1]=q;}return r;}

देखो माँ, कोई बिल्ड-इन .. _{क्योंकि जावा में कोई नहीं है ..>>}

-7 बाइट्स @ceilingcat की बदौलत ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ। (केवल अंतिम परीक्षण का मामला longआकार 2 ⁶³ -1 में फिट होने के लिए बहुत बड़ा है ।)

long d(int[][]m){             // Method with integer-matrix parameter and long return-type
  long r=0;                   //  Return-long, starting at 0
  int i=0,j,k,                //  Index-integers
      l=m.length,             //  Dimensions of the square matrix
      t[][]=new int[l-1][l-1],//  Temp-matrix, one size smaller than `m`
      q=m[0][0];              //  The first value in the matrix (to reduce bytes)
  if(l<3)                     //  If the dimensions are 1 or 2:
    return l<2?               //   If the dimensions are 1:
      q                       //    Simply return the only item in it
     :                        //   Else (the dimensions are 2):
      q*m[1][1]-m[0][1]*m[1][0];
                              //    Calculate the determinant of the 2x2 matrix
                              //  If the dimensions are 3 or larger: 
  for(;i<l;                   //  Loop (1) from 0 to `l` (exclusive)
      r+=                     //    After every iteration: add the following to the result:
         m[0][i]              //     The item in the first row and `i`'th column,
         *(1-i++%2*2)         //     multiplied by 1 if `i` is even; -1 if odd,
         *d(t))               //     multiplied by a recursive call with the temp-matrix
    for(j=0;                  //   Reset index `j` to 0
        ++j<l;)               //   Inner loop (2) from 0 to `l` (exclusive)
      for(k=l;k-->0;){        //    Inner loop (3) from `l-1` to 0 (inclusive)
        q=m[j][k];            //     Set the integer at location `j,k` to reduce bytes
        if(k<i)               //     If `k` is smaller than `i`:
          t[j-1][k]=q;        //      Set this integer at location `j-1,k`
        if(k>i)               //     Else-if `k` is larger than `i`:
          t[j-1][k-1]=q;      //      Set this integer at location `j-1,k-1`
                              //     Else: `k` and `i` are equals: do nothing (implicit)
      }                       //    End of inner loop (3)
                              //   End of inner loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
  return r;                   //  Return the result-long
}                             // End of method

Answer 25

जावास्क्रिप्ट (ईएस 6), 91

पुनरावर्ती लाप्लास

q=(a,s=1)=>+a||a.reduce((v,[r],i)=>v-(s=-s)*r*q(a.map(r=>r.slice(1)).filter((r,j)=>j-i)),0)

कम गोल्फ वाला

q = (a,s=1) => // s used as a local variable
  a[1] // check if a is a single element array 
       // if array, recursive call expanding along 1st column
  ? a.reduce((v,[r],i) => v-(s=-s)*r*q(a.map(r=>r.slice(1)).filter((r,j)=>j-i)),0) 
  : +a // single element, convert to number

परीक्षा

q=(a,s=1)=>+a||a.reduce((v,[r],i)=>v-(s=-s)*r*q(a.map(r=>r.slice(1)).filter((r,j)=>j-i)),0)

TestCases=`[[42]] -> 42
[[2, 3], [1, 4]] -> 5
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] -> 0
[[13, 17, 24], [19, 1, 3], [-5, 4, 0]] -> 1533
[[372, -152, 244], [-97, -191, 185], [-53, -397, -126]] -> 46548380
[[100, -200, 58, 4], [1, -90, -55, -165], [-67, -83, 239, 182], [238, -283, 384, 392]] -> 571026450
[[432, 45, 330, 284, 276], [-492, 497, 133, -289, -28], [-443, -400, 56, 150, -316], [-344, 316, 92, 205, 104], [277, 307, -464, 244, -422]] -> -51446016699154`
.split('\n')

TestCases.forEach(r=>{
  [a,k] = r.split (' -> ')
  a = eval(a)
  d = q(a)
  console.log('Test '+(k==d ? 'OK':'KO')+
    '\nMatrix '+a.join('|')+
    '\nResult '+d+
    '\nCheck  '+k)
})

Comments

83 बाइट्स एक ही व्यवहार के साथ

— Arnauld

या खाली मैट्रिक्स (जिसका निर्धारक 1 होना चाहिए ) का समर्थन करने के लिए 85 बाइट्स ।

— अरनुलद

(मैंने इस उत्तर में वही अनुकूलन किया , जो आप से लिया गया है।)

— अरनौल्ड

Answer 26

पायथन 2 + सुन्न , 29 बाइट्स

from numpy.linalg import*
det

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

Answer 27

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

det

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

Answer 28

परी / जीपी , 6 बाइट्स

matdet

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

Answer 29

जावा (ओपनजेडके 8) , 195 192 177 बाइट्स

long d(int[][]m){long D=0;for(int l=m.length-1,t[][]=new int[l][l],i=0,j,k;i<=l;D+=m[0][i]*(1-i++%2*2)*(l<1?1:d(t)))for(j=0;j<l*l;)t[j/l][k=j%l]=m[1+j++/l][k<i?k:k+1];return D;}

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

कई अन्य उत्तरों की तरह, यह लाप्लास फॉर्मूला का भी उपयोग करता है। थोड़ा कम गोल्फ वाला संस्करण:

long d(int[][]m){
  long D=0;
  int l=m.length-1,t[][]=new int[l][l],i=0,j,k;
  for(;i<=l;)
    for(j=0;j<l*l;)
      t[j/l][k=j%l]=m[1+j++/l][k<i?k:k+1];
    D+=m[0][i]*(1-i++%2*2)*(l<1?1:d(t));
  return D;
}

Answer 30

जे , 5 बाइट्स

-/ .*

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