Thách thức là viết codegolf cho vĩnh viễn của một ma trận .

Vĩnh viễn của một n-by- nmatrix A= ( ai,j) được định nghĩa là

Ở đây S_nđại diện cho tập hợp tất cả các hoán vị của [1, n].

Ví dụ (từ wiki):

Mã của bạn có thể nhận đầu vào theo ý muốn và cung cấp đầu ra ở bất kỳ định dạng hợp lý nào, nhưng vui lòng bao gồm trong câu trả lời của bạn một ví dụ hoạt động đầy đủ bao gồm các hướng dẫn rõ ràng về cách cung cấp đầu vào cho mã của bạn. Để làm cho thử thách thú vị hơn một chút, ma trận có thể bao gồm các số phức.

Ma trận đầu vào luôn luôn vuông và sẽ nhiều nhất là 6 x 6. Bạn cũng cần có khả năng xử lý ma trận trống có vĩnh viễn 1. Không cần phải xử lý ma trận trống (nó gây ra quá nhiều các vấn đề).

Ví dụ

Đầu vào:

[[ 0.36697048+0.02459455j,  0.81148991+0.75269667j,  0.62568185+0.95950937j],
 [ 0.67985923+0.11419187j,  0.50131790+0.13067928j,  0.10330161+0.83532727j],
 [ 0.71085747+0.86199765j,  0.68902048+0.50886302j,  0.52729463+0.5974208j ]]

Đầu ra:

-1.7421952844303492+2.2476833142265793j

Đầu vào:

[[ 0.83702504+0.05801749j,  0.03912260+0.25027115j,  0.95507961+0.59109069j],
 [ 0.07330546+0.8569899j ,  0.47845015+0.45077079j,  0.80317410+0.5820795j ],
 [ 0.38306447+0.76444045j,  0.54067092+0.90206306j,  0.40001631+0.43832931j]]

Đầu ra:

-1.972117936608412+1.6081325306004794j

Đầu vào:

 [[ 0.61164611+0.42958732j,  0.69306292+0.94856925j,
     0.43860930+0.04104116j,  0.92232338+0.32857505j,
     0.40964318+0.59225476j,  0.69109847+0.32620144j],
   [ 0.57851263+0.69458731j,  0.21746623+0.38778693j,
     0.83334638+0.25805241j,  0.64855830+0.36137045j,
     0.65890840+0.06557287j,  0.25411493+0.37812483j],
   [ 0.11114704+0.44631335j,  0.32068031+0.52023283j,
     0.43360984+0.87037973j,  0.42752697+0.75343656j,
     0.23848512+0.96334466j,  0.28165516+0.13257001j],
   [ 0.66386467+0.21002292j,  0.11781236+0.00967473j,
     0.75491373+0.44880959j,  0.66749636+0.90076845j,
     0.00939420+0.06484633j,  0.21316223+0.4538433j ],
   [ 0.40175631+0.89340763j,  0.26849809+0.82500173j,
     0.84124107+0.23030393j,  0.62689175+0.61870543j,
     0.92430209+0.11914288j,  0.90655023+0.63096257j],
   [ 0.85830178+0.16441943j,  0.91144755+0.49943801j,
     0.51010550+0.60590678j,  0.51439995+0.37354955j,
     0.79986742+0.87723514j,  0.43231194+0.54571625j]]

Đầu ra:

-22.92354821347135-90.74278997288275j

Bạn không được sử dụng bất kỳ hàm có sẵn nào để tính toán vĩnh viễn.

J, 5 byte

+/ .*

J không cung cấp các nội trang cho vĩnh viễn hoặc xác định mà thay vào đó cung cấp một kết hợp u . v ymở rộng đệ quy ydọc theo vị thành niên và tính toán dyadic u . vgiữa các cofactors và đầu ra của lệnh gọi đệ quy trên vị thành niên. Các lựa chọn uvà vcó thể khác nhau. Ví dụ, sử dụng u =: -/và v =: *là -/ .*yếu tố quyết định. Lựa chọn có thể thậm chí bởi %/ .!nơi u=: %/, giảm phân chia, và v =: !đó là hệ số nhị thức. Tôi không chắc đầu ra đó biểu thị điều gì nhưng bạn có thể tự do chọn động từ của mình.

Một triển khai thay thế cho 47 byte bằng cách sử dụng cùng một phương thức trong câu trả lời Mathicala của tôi .

_1{[:($@]$[:+//.*/)/0,.;@(<@(,0#~<:)"+2^i.@#)"{

Điều này mô phỏng đa thức với n biến bằng cách tạo đa thức với một biến được tăng lên lũy thừa bằng 2. Điều này được tổ chức dưới dạng danh sách hệ số và phép nhân đa thức được thực hiện bằng cách sử dụng tích chập và chỉ số tại 2 ⁿ sẽ chứa kết quả.

Một cách thực hiện khác cho 31 byte là

+/@({.*1$:\.|:@}.)`(0{,)@.(1=#)

đó là một phiên bản chơi golf hơi dựa trên bản mở rộng Laplace được lấy từ bài tiểu luận J về các yếu tố quyết định .

Sử dụng

   f =: +/ .*
   f 0 0 $ 0 NB. the empty matrix, create a shape with dimensions 0 x 0
1
   f 0.36697048j0.02459455 0.81148991j0.75269667 0.62568185j0.95950937 , 0.67985923j0.11419187  0.50131790j0.13067928 0.10330161j0.83532727 ,: 0.71085747j0.86199765 0.68902048j0.50886302 0.52729463j0.5974208
_1.7422j2.24768
   f 0.83702504j0.05801749 0.03912260j0.25027115 0.95507961j0.59109069 , 0.07330546j0.8569899 0.47845015j0.45077079 0.80317410j0.5820795 ,: 0.38306447j0.76444045 0.54067092j0.90206306 0.40001631j0.43832931
_1.97212j1.60813
   f 0.61164611j0.42958732 0.69306292j0.94856925 0.4386093j0.04104116 0.92232338j0.32857505 0.40964318j0.59225476 0.69109847j0.32620144 , 0.57851263j0.69458731 0.21746623j0.38778693 0.83334638j0.25805241 0.6485583j0.36137045 0.6589084j0.06557287 0.25411493j0.37812483 , 0.11114704j0.44631335 0.32068031j0.52023283 0.43360984j0.87037973 0.42752697j0.75343656 0.23848512j0.96334466 0.28165516j0.13257001 , 0.66386467j0.21002292 0.11781236j0.00967473 0.75491373j0.44880959 0.66749636j0.90076845 0.0093942j0.06484633 0.21316223j0.4538433 , 0.40175631j0.89340763 0.26849809j0.82500173 0.84124107j0.23030393 0.62689175j0.61870543 0.92430209j0.11914288 0.90655023j0.63096257 ,: 0.85830178j0.16441943 0.91144755j0.49943801 0.5101055j0.60590678 0.51439995j0.37354955 0.79986742j0.87723514 0.43231194j0.54571625
_22.9235j_90.7428

Haskell, 59 byte

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

Điều này thực hiện một sự phát triển giống như Laplace dọc theo cột đầu tiên và sử dụng thứ tự của các hàng không thành vấn đề. Nó hoạt động cho bất kỳ loại số.

Đầu vào là danh sách các danh sách:

Prelude> p [[1,2],[3,4]]
10

Thạch , 10 9 byte

Œ!ŒDḢ€P€S

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

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

Œ!ŒDḢ€P€S  Main link. Argument: M (matrix / 2D array)

Œ!         Generate all permutations of M's rows.
  ŒD       Compute the permutations' diagonals, starting with the main diagonal.
    Ḣ€     Head each; extract the main diagonal of each permutation.
      P€   Product each; compute the products of the main diagonals.
        S  Compute the sum of the products.

Python 2, 75 byte

Có vẻ vụng về ... nên có thể đánh bại.

P=lambda m,i=0:sum([r[i]*P(m[:j]+m[j+1:],i+1)for j,r in enumerate(m)]or[1])

05AB1E , 19 14 13 byte

œvyvyNè}Pˆ}¯O

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

Giải trình

œ              # get all permutations of rows
 v        }    # for each permutation
  yv   }       # for each row in the permutation
    yNè        # get the element at index row-index
        P      # product of elements
         ˆ     # add product to global array
           ¯O  # sum the products from the global array

Python 2, 139 byte

from itertools import*
def p(a):c=complex;r=range(len(a));return sum(reduce(c.__mul__,[a[j][p[j]]for j in r],c(1))for p in permutations(r))

thay thế

Thực hiện thuật toán ngây thơ mà mù quáng theo định nghĩa.

MATL, 17 14 byte

tZyt:tY@X])!ps

Dùng thử trực tuyến

Giải trình

t       % Implicitly grab input and duplicate
Zy      % Compute the size of the input. Yields [rows, columns]
t:      % Compute an array from [1...rows]
tY@     % Duplicate this array and compute all permutations (these are the columns)
X]      % Convert row/column to linear indices into the input matrix
)       % Index into the input matrix where each combination is a row
!p      % Take the product of each row
s       % Sum the result and implicitly display

Hồng ngọc 74 63 byte

->a{p=0;a.permutation{|b|n=1;i=-1;a.map{n*=b[i+=1][i]};p+=n};p}

Một bản dịch đơn giản của công thức. Một số byte được lưu nhờ vào ezrast.

Giải trình

->a{
    # Initialize the permanent to 0
    p=0
    # For each permutation of a's rows...
    a.permutation{|b|
        # ... initialize the product to 1,
        n=1
        # initialize the index to -1; we'll use this to go down the main diagonal
        # (i starts at -1 because at each step, the first thing we do is increment i),
        i=-1
        # iteratively calculate the product,
        a.map{
            n*=b[i+=1][i]
        }
        # increase p by the main diagonal's product.
        p+=n
    }
    p
}

Toán học, 54 byte

Coefficient[Times@@(#.(v=x~Array~Length@#)),Times@@v]&

Bây giờ các ma trận trống không còn được xem xét, giải pháp này là hợp lệ. Nó bắt nguồn từ trang MathWorld về những người thường trực .

Ruby 2.4.0, 59 61 byte

Mở rộng đệ quy Laplace:

f=->a{a.pop&.map{|n|n*f[a.map{|r|r.rotate![0..-2]}]}&.sum||1}

Ít chơi gôn hơn:

f=->a{
  # Pop a row off of a
  a.pop&.map{ |n|
    # For each element of that row, multiply by the permanent of the minor
    n * f[a.map{ |r| r.rotate![0..-2]}]
  # Add all the results together
  }&.sum ||
  # Short circuit to 1 if we got passed an empty matrix
  1
}

Ruby 2.4 không được phát hành chính thức. Trên các phiên bản trước, .sumsẽ cần phải được thay thế bằng .reduce(:+), thêm 7 byte.

JavaScript (ES6), 82 byte

f=a=>a[0]?a.reduce((t,b,i)=>t+b[0]*f(a.filter((_,j)=>i-j).map(c=>c.slice(1))),0):1

Tất nhiên, cũng hoạt động với ma trận trống.

Julia 0,4 , 73 byte

f(a,r=1:size(a,1))=sum([prod([a[i,p[i]] for i=r]) for p=permutations(r)])

Trong các phiên bản mới hơn của julia bạn có thể thả []quanh comprehensions, nhưng nhu cầu using Combinatoricscho các permutationschức năng. Hoạt động với tất cả các loại Số trong Julia, bao gồm Complex. rlà một UnitRangeđối tượng được định nghĩa là một đối số chức năng mặc định, có thể phụ thuộc vào các đối số chức năng trước đó.

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