รับเมทริกซ์จำนวนเต็มจตุรัสเป็นอินพุตให้ส่งออกดีเทอร์มิแนนต์ของเมทริกซ์

กฎระเบียบ

• คุณอาจสมมติว่าองค์ประกอบทั้งหมดในเมทริกซ์ดีเทอร์มิแนนต์ของเมทริกซ์และจำนวนองค์ประกอบทั้งหมดในเมทริกซ์อยู่ในช่วงของจำนวนเต็มที่แทนได้สำหรับภาษาของคุณ
• อนุญาตให้แสดงค่าทศนิยม / ทศนิยมด้วยส่วนที่เป็นเศษส่วนของ 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

เยลลี่ 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ดังนั้นเดชอุดมมันฟังก์ชั่นที่ใช้nเวกเตอร์จากℤ ⁿและผลตอบแทนเกลา

ดังนั้นฉันเขียนเดช ( v ₁ , v ₂ , v ₃ , ... , v _n ) สำหรับเดช [ v ₁ v ₂ v ₃ ... v _n ]

ขอให้สังเกตว่าเดชเป็นเชิงเส้นในแต่ละอาร์กิวเมนต์เช่นdet ( v ₁ + λ w ₁ , v ₂ , v ₃ , ... , v _n ) = เดช ( v ₁ , v ₂ , v ₃ , ... , v _n ) + λ det ( w ₁ , v ₂ , v ₃ , ... , v _n ) ดังนั้นจึงเป็นแผนที่เชิงเส้นจาก (ℤ ⁿ ) ^{⊗ n} ถึงℤ

มันเพียงพอสำหรับการกำหนดภาพพื้นฐานภายใต้แผนที่เชิงเส้น พื้นฐานของ (ℤ ⁿ ) ^{⊗ n}ประกอบด้วยnผลิตภัณฑ์เมตริกซ์เท่าขององค์ประกอบพื้นฐานของℤ ⁿ , ieeg อี₅ ⊗อี₃ ⊗อี₁ ⊗อี₅ ⊗อี1 ผลิตภัณฑ์เทนเซอร์ที่มีเทนเซอร์ที่เหมือนกันจะต้องถูกส่งไปที่ศูนย์เนื่องจากดีเทอร์มีแนนต์ของเมทริกซ์ที่คอลัมน์สองคอลัมน์เหมือนกันนั้นเป็นศูนย์ มันยังคงเพื่อตรวจสอบสิ่งที่ผลิตภัณฑ์เทนเซอร์ขององค์ประกอบพื้นฐานที่แตกต่างกันจะถูกส่งไป ดัชนีของเวกเตอร์ในผลิตภัณฑ์เทนเซอร์ก่อให้เกิด bijection คือการเปลี่ยนรูปซึ่งแม้แต่การเรียงสับเปลี่ยนจะถูกส่งไปที่ 1 และการเปลี่ยนลำดับคี่จะถูกส่งไปที่ -1

ตัวอย่างเช่นในการค้นหาดีเทอร์มิแนนต์ของ [[1, 2], [3, 4]]: โปรดทราบว่าคอลัมน์คือ [1, 3] และ [2, 4] เราย่อยสลาย [1, 3] เพื่อให้ (1 e ₁ + 3 e ₂ ) และ (2 e ₁ + 4 e ₂ ) องค์ประกอบที่เกี่ยวข้องในผลิตภัณฑ์เทนเซอร์คือ (1 e ₁ ⊗ 2 e ₁ + 1 e ₁ ⊗ 4 e ₂ + 3 e ₂ ⊗ 2 e ₁ + 3 e ₂ ⊗ 4 e ₂ ) ซึ่งเราลดความซับซ้อนลงไป (2 e ₁ ⊗ e ₁ + 4 e ₁ ⊗ e ₂ + 6 e ₂ ⊗ e ₁ + 12 e ₂ ⊗ e ₂) ดังนั้น:

เดช [[1, 2], [3, 4]]
= เดช (1 e ₁ + 3 e ₂ , 2 e ₁ + 4 e ₂ )
= det (2 e ₁ ⊗ e ₁ + 4 e ₁ ⊗ e ₂ + 6 e ₂ ⊗ e ₁ + 12 e ₂ ⊗ e ₂ )
= det (2 e ₁ ⊗ e ₁ ) + det (4 e ₁ ⊗ e ₂ ) + det (6 e ₂ ⊗ e ₁ ) + det (12 e₂ ⊗ e ₂ )
= 2 เดช (e ₁ ⊗ e ₁ ) + 4 เดช (e ₁ ⊗ e ₂ ) + 6 เดช (e ₂ ⊗ e ₁ ) + 12 เดช (e ₂ ⊗ e ₂ )
= 2 (0) + 4 (1) + 6 (-1) + 12 (0)
= 4 - 6
= -2

ตอนนี้ก็ยังคงพิสูจน์ให้เห็นว่าสูตรสำหรับการค้นหาความเท่าเทียมกันของการเปลี่ยนแปลงที่ถูกต้อง สิ่งที่รหัสของฉันทำคือค้นหาจำนวนผู้รุกรานเช่นสถานที่ที่องค์ประกอบด้านซ้ายใหญ่กว่าองค์ประกอบด้านขวา (ไม่จำเป็นต้องต่อเนื่องกัน)

ตัวอย่างเช่นในการเรียงสับเปลี่ยน 3614572 มีการเรียก 9 ครั้ง (31, 32, 61, 64, 65, 62, 42, 52, 72) ดังนั้นการเรียงสับเปลี่ยนจึงแปลก

เหตุผลก็คือว่าการขนย้ายแต่ละครั้ง (การสลับสององค์ประกอบ) ทั้งเพิ่มการผกผันหรือเอาไปหนึ่งการผกผันแลกเปลี่ยนความเท่าเทียมกันของจำนวนการรุกรานและความเท่าเทียมกันของการเปลี่ยนแปลงคือความเท่าเทียมกันของจำนวน transpositions ที่จำเป็นเพื่อให้เกิดการเปลี่ยนแปลง

ดังนั้นโดยสรุปสูตรของเราได้รับจาก:

ทำไมมันถึงใช้งานได้ - ไม่ใช่รุ่นที่คณิตศาสตร์

ที่σคือการเปลี่ยนแปลงของ𝕊 _nกลุ่มพีชคณิตทั้งหมดเกี่ยวกับnตัวอักษรและSGNเป็นสัญญาณของการเปลี่ยนแปลงที่เด๊ะ (-1) ยกความเท่าเทียมกันของการเปลี่ยนแปลงและ_IJเป็น ( IJ ) ^THรายการใน เมทริกซ์ ( ฉันลงjข้าม)

R , 3 ไบต์

โซลูชันเล็กน้อย

det

ลองออนไลน์!

R , 94 92 ไบต์

โซลูชันที่นำมาใช้ใหม่

outgolfed โดยJarko Dubbeldam

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

เยลลี่ , 16 15 12 10 ไบต์

Ḣ×Zß-Ƥ$Ṛḅ-

ใช้การขยายตัวของ Laplace ขอบคุณ @miles สำหรับการเล่นกอล์ฟ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.

ภาษา Wolfram (Mathematica)ระหว่าง 14 ถึง 42 ไบต์

เรามีวิธีแก้ปัญหาแบบบิวท์อิน3 ไบต์และ53- ไบต์ที่หลีกเลี่ยงการใช้งานภายในอย่างสมบูรณ์ดังนั้นนี่คือวิธีแก้ปัญหาแบบไวร์เดอร์บางตัว

วุลแฟรมภาษามีจำนวนมากของฟังก์ชั่นที่รุนแรงมากสำหรับย่อยสลายเมทริกซ์เป็นผลิตภัณฑ์ของการฝึกอบรมอื่น ๆ ที่มีโครงสร้างที่เรียบง่าย หนึ่งในสิ่งที่ง่ายกว่า (หมายถึงฉันเคยได้ยินมาก่อน) คือการสลายตัวของจอร์แดน เมทริกซ์ทุกตัวมีความคล้ายคลึงกับเมทริกซ์สามเหลี่ยมด้านบน (อาจซับซ้อน - มูลค่า) ที่ทำจากบล็อกในแนวทแยงที่มีโครงสร้างเฉพาะที่เรียกว่าการสลายตัวของจอร์แดนของเมทริกซ์นั้น ความคล้ายคลึงกันจะเก็บรักษาดีเทอร์มิแนนต์และดีเทอร์มิแนนต์ของเมทริกซ์สามเหลี่ยมเป็นผลิตภัณฑ์ขององค์ประกอบในแนวทแยงดังนั้นเราจึงสามารถคำนวณดีเทอร์มีแนนต์ได้ด้วย42 ไบต์ต่อไปนี้:

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

ดีเทอร์มีแนนต์ก็เท่ากับผลคูณของค่าลักษณะเฉพาะของเมทริกซ์ที่มีหลายหลาก โชคดีที่ฟังก์ชั่นค่าเฉพาะของ Wolfram ติดตามความหลากหลาย (แม้สำหรับเมทริกซ์ที่ไม่ทแยงมุม) ดังนั้นเราจึงได้คำตอบ20 ไบต์ต่อไปนี้:

1##&@@Eigenvalues@#&

ทางออกต่อไปคือการโกงและฉันก็ไม่แน่ใจว่าทำไมมันถึงได้ผล wronskian ของรายการของnฟังก์ชั่นเป็นปัจจัยของเมทริกซ์ในครั้งแรกที่n -1 อนุพันธ์ของฟังก์ชั่น ถ้าเราให้Wronskianฟังก์ชันเป็นเมทริกซ์ของจำนวนเต็มและบอกว่าตัวแปรของความแตกต่างคือ 1, อย่างใดมันจะแยกดีเทอร์มีแนนต์ของเมทริกซ์ มันแปลก แต่ไม่เกี่ยวข้องกับตัวอักษร " Det" และมีเพียง14 ไบต์ ...

#~Wronskian~1&

(ปัจจัย Casoratian ทำงานเป็นอย่างดีสำหรับอีก 1 ไบต์: #~Casoratian~1&)

ในดินแดนของพีชคณิตนามธรรมปัจจัยของนั้นn  x  nเมทริกซ์ (คิดว่าเป็นแผนที่ k → k ว่ามีการคูณโดยปัจจัย) เป็นnอำนาจ th ภายนอกของเมทริกซ์ (หลังจากที่เธอหยิบมอร์ฟ k →⋀ ⁿ k ⁿ ) ในภาษา Wolfram เราสามารถทำได้ด้วย26 ไบต์ต่อไปนี้:

HodgeDual[TensorWedge@@#]&

และนี่คือวิธีแก้ปัญหาที่ใช้สำหรับปัจจัยบวกเท่านั้น หากเราใช้หน่วย hypercube แบบn -dimensional และใช้การแปลงเชิงเส้นกับมันn "มิติ" ปริมาตร "ของพื้นที่ผลลัพธ์เป็นค่าสัมบูรณ์ของดีเทอร์มิแนนต์ของการเปลี่ยนแปลง การนำการแปลงเชิงเส้นไปใช้กับคิวบ์นั้นให้ขนานกันและเราสามารถนำปริมาณของมันไปใช้กับโค้ด39 ไบต์ต่อไปนี้:

RegionMeasure@Parallelepiped[Last@#,#]&

Haskell , 71 ไบต์

-3 ไบต์ด้วย Lynn ฝุ่นอีกหนึ่งไบต์ต้องขอบคุณเครกรอย

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 × 1mat[0, 0]เมทริกซ์ซึ่งในกรณีนี้ปัจจัยคือ

f(h:t)=

สิ่งนี้ใช้การจับคู่รูปแบบของ Haskell เพื่อแยกเมทริกซ์ออกเป็นส่วนหัว (แถวแรก) และส่วนท้าย (ส่วนที่เหลือของเมทริกซ์)

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

แจกแจงส่วนหัวของเมทริกซ์ (โดยการซิปรายการจำนวนเต็มและส่วนหัว) แล้ววนซ้ำไปเรื่อย ๆ

           (-1)*i*v

ลบล้างผลลัพธ์ที่ขึ้นอยู่กับว่าดัชนีนั้นเป็นเลขคู่หรือไม่เนื่องจากการคำนวณของดีเทอร์มิแนนต์เกี่ยวข้องกับการบวกและการลบแบบอื่น

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

สิ่งนี้จะลบคอลัมน์ithของส่วนท้ายโดยการใช้องค์ประกอบiและเชื่อมต่อกับแถวที่มีองค์ประกอบแรก(i + 1)องค์ประกอบที่ลดลงสำหรับทุกแถวในส่วนท้าย

                   *f

(-1)*i*vคำนวณปัจจัยของผลดังกล่าวข้างต้นและคูณด้วยผลมาจากการ

       sum

รวมผลลัพธ์ของรายการด้านบนและส่งคืน

โปรตอน , 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 ไบต์ขอบคุณ Mr. Xcoder
-3 ไบต์ขอบคุณ Erik the Outgolfer

การขยายช่วงแถวแรก

อ็อกเทฟ 28 ไบต์

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

ลองออนไลน์!

สิ่งนี้ใช้การสลายตัว QRของเมทริกซ์Xเป็นเมทริกซ์ orthgonal Qและบนสามเหลี่ยมเมทริกซ์R ปัจจัยของX เป็นผลิตภัณฑ์ของพวกQและR เมทริกซ์มุมฉากมีตัวกำหนดหน่วยและสำหรับเมทริกซ์สามเหลี่ยมตัวกำหนดนั้นเป็นผลคูณของรายการในแนวทแยง qrฟังก์ชั่นของอ็อกเทฟที่เรียกว่าพร้อมเอาต์พุตเดียวให้ R

ผลลัพธ์จะถูกปัดเศษเป็นจำนวนเต็มที่ใกล้เคียงที่สุด สำหรับเมทริกซ์อินพุตขนาดใหญ่ความคลาดเคลื่อนของจุดลอยตัวอาจก่อให้เกิดข้อผิดพลาดเกินกว่า0.5และทำให้เกิดผลลัพธ์ที่ผิด

Haskell , 59 ไบต์

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

ลองออนไลน์!

C,  176  125 ไบต์

ขอบคุณ @ceilingcat สำหรับการเล่นกอล์ฟขนาด 42 ไบต์และต้องขอบคุณ @Lynn และ @Jonathan Frech สำหรับการบันทึกไบต์แต่ละตัว!

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

คำนวณดีเทอร์มิแนนต์โดยใช้การขยายแบบ Laplaceตามแถวแรก

ลองออนไลน์!

คลี่:

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

เยลลี่ 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

-2 ไบต์ขอบคุณการแก้ปัญหาของ user202729

MATL , 3 ไบต์ / 5 ไบต์

ด้วยฟังก์ชั่นในตัว

&0|

ลองออนไลน์!

ไม่มีในตัว

ขอบคุณMisha Lavrov ที่ชี้ให้เห็นข้อผิดพลาดตอนนี้ได้รับการแก้ไข

YvpYo

ลองออนไลน์!

สิ่งนี้คำนวณหาดีเทอร์มิแนนต์เป็นผลคูณของค่าลักษณะเฉพาะ, ปัดเศษเป็นจำนวนเต็มที่ใกล้ที่สุดเพื่อหลีกเลี่ยงความไม่ถูกต้องของจุดลอยตัว

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

R , 32 ไบต์

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

ใช้อัลกอริทึมของ Not a Tree เพื่อรับค่าลักษณะเฉพาะของเมทริกซ์และการมีส่วนร่วมที่แท้จริงของผลิตภัณฑ์

ลองออนไลน์!

เยลลี่ 43 ไบต์

ในที่สุดฉันก็ได้เขียนวิธีการแก้ปัญหาที่ไม่ใช่ builtin ของฉันในภาษากอล์ฟ!

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

ขอบคุณHyperNeutrinoสำหรับการบันทึกไบต์!

ลองออนไลน์! (รหัสเว้นระยะเพื่อความชัดเจน)

ทางยาวมากในการลบองค์ประกอบที่ไม่อยู่ในรายการจะปรับปรุงในภายหลัง

คำตอบนี้ถูก outgolfed โดยคำตอบของ HyperNeutrino, Dennis และ Leaky Nun เยลลี่เป็นที่นิยมมากในฐานะภาษากอล์ฟ

คำอธิบายอย่างรวดเร็ว:

ÇḢḢ$Ṗ?    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.

อ็อกเทฟ 30 ไบต์

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

ลองออนไลน์!

หรือโซลูชัน 4 ไบต์ที่น่าเบื่อ (บันทึกได้ 6 ไบต์ขอบคุณ Luis Mendo (ลืมกฎที่ทำหน้าที่สร้างฟังก์ชันในตัว)):

@det

คำอธิบาย:

กำลังจะมา! :)

TI-Basic, 2 ไบต์

det(Ans

อ่า

โปรดอย่าตอบคำถามเล็กน้อย

_{ในฐานะนักเรียนมัธยมปลาย (ผู้ที่ถูกบังคับให้เป็นเจ้าของเครื่องคิดเลขเหล่านี้) ฟังก์ชั่นนี้มีประโยชน์สำหรับเฮลลา ...}

Haskell, 62 ไบต์

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

ลองออนไลน์! (ส่วนท้ายพร้อมกรณีทดสอบที่นำมาจากโซลูชันของ @ totalhuman)

dคำนวณดีเทอร์มิแนนต์โดยใช้การขยายแบบ Laplace ตามคอลัมน์แรก ความสามไบต์มากกว่าถาวร

Python 2 , 95 ไบต์

-12 ไบต์ขอบคุณ Lynn

ท่าเรือคำตอบ Haskell ของฉัน

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

ลองออนไลน์!

ภาษา Wolfram (Mathematica) , 53 52 ไบต์

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

ลองออนไลน์!

โชคไม่ดีที่การคำนวณดีเทอร์มีแนนต์ของnโดยnเมทริกซ์ด้วยวิธีนี้ใช้ O ( 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ถ้าทั้งคู่อยู่ในลำดับจากมากไปหาน้อย-1หากอยู่ในลำดับจากมากไปน้อยและ0หากพวกเขาเท่ากัน

-1 ไบต์ต้องขอบคุณ @ user202729

Python 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!และฉันไม่สามารถแสดงเนื้อเรื่องของการทดสอบครั้งสุดท้าย แต่ในทางทฤษฎีแล้วสิ่งนี้เป็นไปได้

CJam ( 50 45 ไบต์)

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

นี่คือบล็อกที่ไม่ระบุชื่อ (ฟังก์ชั่น) ซึ่งรับอาร์เรย์ 2D บนสแต็กและปล่อยจำนวนเต็มในสแต็ก

ชุดทดสอบออนไลน์

การผ่า

นี่ใช้อัลกอริทึมของ 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$

{               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
}

ภาษา Wolfram (Mathematica)ขนาด 3 ไบต์

Det

ลองออนไลน์!

ตามฉันทามติ metaส่วนใหญ่ upvote โซลูชั่นที่ไม่สำคัญที่ใช้ความพยายามในการเขียน

Python 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

ลองออนไลน์!

SageMathต่างๆ

นี่คือวิธีการมากมายสำหรับการคำนวณดีเทอร์มิแนนต์ที่ฉันคิดว่าน่าสนใจทั้งหมดนี้ตั้งโปรแกรมใน SageMath พวกเขาทั้งหมดสามารถลองได้ที่นี่

สร้างขึ้นภายใน 3 ไบต์

det

อันนี้ไม่น่าสนใจเกินไป ปราชญ์มอบนามแฝงระดับโลกให้กับการดำเนินงานทั่วไปหลายอย่างซึ่งโดยปกติจะเป็นวิธีการของวัตถุดังนั้นสิ่งนี้จึงสั้นกว่าlambda m:m.det()ให้นามแฝงระดับโลกระดับการดำเนินงานทั่วไปจำนวนมากที่ปกติจะเป็นวิธีการวัตถุดังนั้นนี้จะสั้นกว่า

ส่วนที่แท้จริงของผลิตภัณฑ์ของค่าลักษณะเฉพาะ, 36 ไบต์

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

น่าเสียดายที่eigenvaluesไม่ใช่นามแฝงระดับโลกคนหนึ่ง ที่รวมกับความจริงที่ว่า Sage lambdaไม่ได้มีวิธีที่ประณีตฟังก์ชั่นการเขียนหมายถึงเรากำลังติดอยู่กับค่าใช้จ่าย ฟังก์ชั่นนี้เป็นค่าสัญลักษณ์ซึ่งถูกแปลงเป็นค่าตัวเลขโดยอัตโนมัติเมื่อพิมพ์ดังนั้นบางจุดที่ไม่ถูกต้องอาจมีอยู่ในเอาต์พุตบางตัว

ผลิตภัณฑ์ในแนวทแยงในรูปแบบปกติของจอร์แดน, 60 ไบต์

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

ในรูปแบบ Jordan Normal เมทริกซ์ NxN ถูกแทนด้วยเมทริกซ์บล็อกโดยมีบล็อก N อยู่บนเส้นทแยงมุม แต่ละบล็อกประกอบด้วย eigenvalue เดียวหรือเมทริกซ์ MxM ที่มี eigenvalue ซ้ำ ๆ บนเส้นทแยงมุมและ1 s บนเส้นทแยงมุมซุปเปอร์ (เส้นทแยงมุมด้านบนและด้านขวาของเส้นทแยงมุม "หลัก") สิ่งนี้ส่งผลให้เกิดเมทริกซ์ที่มีค่าลักษณะเฉพาะทั้งหมด (ที่มีหลายหลาก) บนเส้นทแยงมุมหลักและบางส่วน1ของเส้นทแยงมุมซุปเปอร์ที่สอดคล้องกับค่าลักษณะซ้ำ สิ่งนี้จะส่งคืนผลคูณของเส้นทแยงมุมของรูปแบบปกติของจอร์แดนซึ่งเป็นผลผลิตของค่าลักษณะเฉพาะ (ที่มีหลายค่า) ดังนั้นนี่จึงเป็นวิธีที่ใช้ในการคำนวณแบบเดียวกันกับวิธีก่อนหน้านี้

เพราะผู้รอบรู้ต้องการให้รูปแบบปกติของจอร์แดนอยู่เหนือวงแหวนเดียวกันกับเมทริกซ์ดั้งเดิมนี่จะใช้งานได้ก็ต่อเมื่อค่าลักษณะเฉพาะทั้งหมดมีเหตุผล ค่าลักษณะเฉพาะที่ซับซ้อนส่งผลให้เกิดข้อผิดพลาด (เว้นแต่ว่าเมทริกซ์ดั้งเดิมอยู่เหนือวงแหวนCDF (คอมเพล็กซ์ลอยคู่) หรือSR) อย่างไรก็ตามนั่นหมายความว่าไม่จำเป็นต้องมีส่วนจริงเมื่อเปรียบเทียบกับวิธีแก้ปัญหาข้างต้น

ผลิตภัณฑ์ของทแยงในสมิ ธ สลายตัว

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

ซึ่งแตกต่างจากรูปแบบปกติของจอร์แดนรูปแบบปกติของสมิ ธ รับประกันว่าจะอยู่เหนือสนามเดียวกันกับเมทริกซ์ดั้งเดิม แทนที่จะคำนวณค่าลักษณะเฉพาะและเป็นตัวแทนของพวกเขาด้วยเมทริกซ์ทแยงมุมบล็อกสมิ ธ สลายตัวคำนวณตัวหารเบื้องต้นของเมทริกซ์ (ซึ่งเป็นหัวข้อที่ซับซ้อนเกินไปสำหรับโพสต์นี้) ทำให้พวกมันกลายเป็นเมทริกซ์ทแยงมุมDและคำนวณเมทริกซ์สองหน่วย ดีเทอร์แนนต์UและVเช่นนั้นD = U*A*V(ซึ่งAเป็นเมทริกซ์ดั้งเดิม) เนื่องจากดีเทอร์มีแนนต์ของผลคูณของเมทริกซ์เท่ากับผลคูณของดีเทอร์มิแนนต์ของเมทริกซ์ ( det(A*B*...) = det(A)*det(B)*...) และUและVถูกกำหนดให้มีตัวกำหนดหน่วยdet(D) = det(A)มีการกำหนดให้มีปัจจัยหน่วยดีเทอร์มิแนนต์ของเมทริกซ์ทแยงมุมนั้นเป็นผลผลิตขององค์ประกอบบนทแยงมุม

Laplace Expansion, 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]

สิ่งนี้จะทำการขยายตัวของ Laplace ไปตามแถวแรกโดยใช้วิธีเรียกซ้ำ det([[a]]) = aจะใช้สำหรับกรณีฐาน มันควรจะสั้นกว่าdet([[]]) = 1สำหรับใช้กับเคสฐาน แต่ความพยายามของฉันในการติดตั้งนั้นมีข้อบกพร่องที่ฉันยังไม่สามารถติดตามได้

สูตรของ Leibniz ขนาด 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(λ)แต่ละค่าลักษณะเฉพาะλของAเท่ากับผลรวมของค่าลักษณะเฉพาะของexp(A)) ดังนั้นหากเราสามารถหาเมทริกซ์Lเช่นนั้นได้exp(L) = Aเราสามารถคำนวณdet(A) = exp(trace(L))ได้

เราสามารถหาเมทริกซ์ดังกล่าวโดยคอมพิวเตอร์L log(A)ลอการิทึมเมทริกซ์สามารถคำนวณได้ในลักษณะเดียวกับเมทริกซ์เอกซ์โปเนนเชียล: สร้างเมทริกซ์ทแยงมุมสแควร์โดยใช้ฟังก์ชันลอการิทึมสเกลาร์กับแต่ละค่าลักษณะเฉพาะของA(นี่คือเหตุผลที่เรา จำกัดAการ reals) เนื่องจากเราสนใจเพียงร่องรอยLเท่านั้นเราสามารถข้ามสิ่งก่อสร้างและสรุปผลรวมของค่าลักษณะเฉพาะโดยตรง ค่าลักษณะเฉพาะอาจมีความซับซ้อนแม้ว่าเมทริกซ์จะไม่อยู่เหนือวงแหวนที่ซับซ้อนดังนั้นเราจึงเอาส่วนที่แท้จริงของผลรวม

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

ดูสิไม่มี build-ins .. _{เพราะ Java ไม่มีเลย .. >.>}

-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

JavaScript (ES6), 91

Laplace แบบเรียกซ้ำ

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)

น้อย golfed

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

งูหลาม 2 + numpy 29 ไบต์

from numpy.linalg import*
det

ลองออนไลน์!

จูเลีย 3 ไบต์

det

ลองออนไลน์!

Pari / GP , 6 ไบต์

matdet

ลองออนไลน์!

Java (OpenJDK 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;}

ลองออนไลน์!

เช่นเดียวกับคำตอบอื่น ๆ อีกมากมายนี่ยังใช้สูตร Laplace รุ่น golfed น้อยกว่าเล็กน้อย:

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

J , 5 ไบต์

-/ .*

ลองออนไลน์!