कोडगोल्फ स्थायी

Question

एक मैट्रिक्स के स्थायी के लिए कोडगॉल्फ लिखना चुनौती है ।

nA -by- nमैट्रिक्स A= ( ai,j) के स्थायी रूप में परिभाषित किया गया है

यहाँ S_nसभी क्रमपरिवर्तन के सेट का प्रतिनिधित्व करता है [1, n]।

एक उदाहरण के रूप में (विकी से):

आपका कोड इनपुट ले सकता है, लेकिन यह इच्छानुसार और किसी भी समझदार प्रारूप में आउटपुट देता है, लेकिन कृपया अपने उत्तर में एक पूर्ण काम किए गए उदाहरण को शामिल करें जिसमें आपके कोड को इनपुट की आपूर्ति करने के लिए स्पष्ट निर्देश शामिल हैं। चुनौती को थोड़ा और दिलचस्प बनाने के लिए, मैट्रिक्स में जटिल संख्याएं शामिल हो सकती हैं।

इनपुट मैट्रिक्स हमेशा वर्गाकार होता है और अधिकतम 6 से 6 पर होगा। आपको खाली मैट्रिक्स को संभालने में भी सक्षम होना होगा, जिसकी स्थायी 1 है। खाली मैट्रिक्स को संभालने में सक्षम होने की आवश्यकता नहीं है (यह बहुत अधिक पैदा कर रहा था। समस्या)।

उदाहरण

इनपुट:

[[ 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 ]]

आउटपुट:

-1.7421952844303492+2.2476833142265793j

इनपुट:

[[ 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]]

आउटपुट:

-1.972117936608412+1.6081325306004794j

इनपुट:

 [[ 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]]

आउटपुट:

-22.92354821347135-90.74278997288275j

आप स्थायी की गणना करने के लिए किसी भी पहले से मौजूद कार्यों का उपयोग नहीं कर सकते हैं।

Comments

क्या आप कृपया जटिल आवश्यकता को दूर कर सकते हैं? मुझे लगता है कि यह एक अच्छी चुनौती को बर्बाद कर देता है। हर भाषा, जिसमें बिल्ट-इन कॉम्प्लेक्स अंकगणित नहीं होता, को अब एक बिलकुल अलग कार्य करना पड़ता है।

— xnor

यदि हमें खाली मैट्रिक्स को संभालने की आवश्यकता है, तो आपको इसे एक परीक्षण मामले के रूप में जोड़ना चाहिए। तथ्य यह है कि आप वास्तव में सूची के साथ 0x0 मैट्रिक्स का प्रतिनिधित्व नहीं कर सकते हैं यह थोड़ा मुश्किल बनाता है। व्यक्तिगत रूप से, मैं बस उस आवश्यकता को हटा दूंगा।

— डेनिस

3 घंटे तक सैंडबॉक्स में कुछ डालने का कोई मतलब नहीं है। इसे 3 दिन दें और लोगों के पास प्रतिक्रिया देने का मौका है।

— पीटर टेलर

1. यह सिर्फ पलायन नहीं है। बैश, उदाहरण के लिए, यहां तक ​​कि मूल रूप से झांकियों के साथ सौदा नहीं किया जा सकता है । प्रतियोगिता से एक भाषा को छोड़कर सिर्फ इसलिए कि इसमें एक निश्चित संख्यात्मक प्रकार का अभाव है, भले ही अनायास वांछित एल्गोरिदम को लागू किया जा सकता है, बस बिना किसी अच्छे कारण के लिए उपयुक्त है। 2. मैं अभी भी खाली मैट्रिक्स के बारे में निश्चित नहीं हूं। क्या यह होगा [[]](सूची में एक पंक्ति है, खाली मैट्रिक्स नहीं है) या [](गहराई 2 नहीं है, मैट्रिसेस करते हैं) सूची के रूप में?

— डेनिस

1. मैं यह नहीं सोच रहा हूं कि इस चुनौती को बश में हल करना असंभव है, लेकिन अगर कोड के शेर का हिस्सा जटिल संख्या अंकगणित से निपटने के लिए उपयोग किया जाता है, तो यह स्थायी के बारे में एक चुनौती बन जाता है। 2. अधिकांश यदि सभी वर्तमान उत्तर इनपुट के लिए मैट्रिक्स प्रकार के विराम के बिना भाषा नहीं हैं [[]]।

— डेनिस

Answer 1

जे, 5 बाइट्स

+/ .*

J, स्थायी या निर्धारक के लिए बिल्डरों की पेशकश नहीं करता है, बल्कि एक संयोजन प्रदान करता है u . v yजो yनाबालिगों के साथ पुन: विस्तार u . vकरता है और कोफ़ैक्टर्स और नाबालिगों पर पुनरावर्ती कॉल के आउटपुट के बीच डाइएडिक की गणना करता है। के विकल्पों uऔर vभिन्न हो सकते हैं। उदाहरण के लिए, का उपयोग करते हुए u =: -/और v =: *है -/ .*जो निर्धारक है। विकल्प भी %/ .!जहां u=: %/विभाजन से कम कर सकते हैं , और v =: !जो द्विपद गुणांक है। मुझे यकीन नहीं है कि वह आउटपुट क्या दर्शाता है लेकिन आप अपनी क्रियाओं को चुनने के लिए स्वतंत्र हैं।

मेरे गणितज्ञ उत्तर में एक ही विधि का उपयोग करके 47 बाइट्स के लिए एक वैकल्पिक कार्यान्वयन ।

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

यह 2 की शक्तियों के लिए उठाए गए एक चर के साथ एक बहुपद बनाकर एन चर के साथ एक बहुपद का अनुकरण करता है। यह गुणांक सूची के रूप में आयोजित किया जाता है और पुल्लिंग का उपयोग करके बहुपद गुणन किया जाता है, और 2 ⁿ पर सूचकांक में परिणाम होगा।

31 बाइट्स के लिए एक और कार्यान्वयन है

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

जो एक से थोड़ा golfed लाप्लास विस्तार पर जम्मू निबंध से लिया पर आधारित संस्करण है निर्धारकों ।

प्रयोग

   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

Comments

वाह, बस मैं यही कह सकता हूं।

Answer 2

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

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

यह पहले कॉलम के साथ लाप्लास-जैसा विकास करता है, और इसका उपयोग करता है कि पंक्तियों का क्रम मायने नहीं रखता है। यह किसी भी संख्यात्मक प्रकार के लिए काम करता है।

इनपुट सूची की सूची के रूप में है:

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

Comments

हमेशा एक हास्केल समाधान का स्वागत करें!

Answer 3

जेली , 10 9 बाइट्स

Œ!ŒDḢ€P€S

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

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

Œ!Œ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.

Comments

यह बहुत अच्छा है!

Answer 4

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

भद्दा लगता है ... हरा देना चाहिए।

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

Answer 5

05AB1E , 19 14 13 बाइट्स

œvyvyNè}Pˆ}¯O

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

व्याख्या

œ              # 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

Comments

थोड़ा चौंकाने वाला जवाब! क्या आप कुछ स्पष्टीकरण दे सकते हैं?

@ लेम्बिक: ऐसा लगता है कि यह अभी भी कम हो सकता है। मेरे पास अब तक एक ही आकार का दूसरा समाधान है।

— एमिग्ना

खाली मैट्रिस को संभालने की अब आवश्यकता नहीं है।

— डेनिस

नक्शे का उपयोग करके 8 बाइट्स । बहुत बुरा नया 05AB1E काल्पनिक संख्याओं का समर्थन नहीं करता है (या मुझे आसानी से पता नहीं है), क्योंकि अब हमारे पास एक मुख्य विकर्ण बिलिन है और यह 6 बाइट्स हो सकता है œ€Å\PO:।

— केविन क्रूज़सेन

Answer 6

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

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

repl.it

भोले एल्गोरिथ्म को लागू करता है जो परिभाषा का आँख बंद करके अनुसरण करता है।

Answer 7

MATL, 17 14 बाइट्स

tZyt:tY@X])!ps

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

व्याख्या

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

Comments

बहुत प्रभावशाली।

Answer 8

माणिक, 74 63 बाइट्स

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

सूत्र का सीधा अनुवाद। कई बाइट्स ने एज़रास्ट के लिए धन्यवाद बचाया।

व्याख्या

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

Comments

reduceवास्तव में मैन्युअल रूप से एकत्र करने की तुलना में आपकी बाइट की गिनती को ->a{m=0;a.permutation{|b|n=1;a.size.times{|i|n*=b[i][i]};m+=n};m}

— नुकसान पहुंचाता है

@ तेज धन्यवाद! के timesरूप में अच्छी तरह से उस पाश नीचे गोल्फ के लिए प्रबंधित ।

— m-chrzan

Answer 9

रूबी 2.4.0, 59 61 बाइट्स

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

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

कम गोल्फ वाला:

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
}

रूबी 2.4 आधिकारिक रूप से जारी नहीं किया गया है। पहले के संस्करणों पर, 7 बाइट्स जोड़ने के .sumसाथ बदलने की आवश्यकता होगी .reduce(:+)।

Answer 10

मैथेमेटिका, 54 बाइट्स

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

अब चूंकि खाली मेट्रिक्स पर विचार नहीं किया जाता है, इसलिए यह समाधान मान्य है। यह मैथवर्ल्ड पेज से परमानेंट होता है ।

Comments

@alephalpha गुणांक की पहचान करने के लिए पंक्तियों का उपयोग करने के लिए एक अच्छा विचार है, लेकिन क्या यह अद्वितीय नहीं होगा यदि पंक्तियाँ अद्वितीय नहीं थीं?

— मील

Answer 11

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

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

खाली मैट्रिक्स के साथ भी काम करता है, बिल्कुल।

Comments

@ETHproductions मैं कभी नहीं सीखता ...

— नील

मेरे कोड के ठीक 14 घंटे पहले प्रकाशित, मैं जटिल संख्याएँ जोड़ने की कोशिश करूँगा

— edc65

Answer 12

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

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

जूलिया के नए संस्करण में आप छोड़ सकते हैं []comprehensions के आसपास है, लेकिन जरूरत using Combinatoricsके लिए permutationsकार्य करते हैं। जूलिया में सभी प्रकार की संख्या के साथ काम करता है Complex। rएक है UnitRangeवस्तु एक डिफ़ॉल्ट समारोह तर्क है, जो पिछले समारोह तर्क पर निर्भर कर सकता के रूप में परिभाषित।

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