पुनरावर्ती 2x2 निर्धारक

Question

2 बाय 2 मैट्रिक्स का निर्धारक

a b
c d

द्वारा दिया गया है ad - bc।

2 ⁿ द्वारा 2 ⁿ , n output 1 के आयामों के साथ अंकों के एक मैट्रिक्स को देखते हुए , प्रत्येक 2 के निर्धारक को पुनरावर्ती कंप्यूटिंग द्वारा प्राप्त परिणाम का उत्पादन करते हैं जब तक कि हम एक एकल संख्या तक नहीं पहुंचते।

उदाहरण के लिए, इनपुट दिया गया

3 1 4 1
5 9 2 6
5 3 5 8
9 7 9 3

एक कदम के बाद, हम प्राप्त करते हैं:

(3*9 - 1*5)    (4*6 - 1*2)    =    22  22
(5*7 - 3*9)    (5*3 - 8*9)         8  -57

और एक बार और पुनरावृति, हम प्राप्त करते हैं:

(22*-57 - 22*8) = -1430

इसलिए, आउटपुट होना चाहिए -1430।

नियम

• मैट्रिक्स के तत्व हमेशा एकल अंक पूर्णांक होंगे, अर्थात 0 से 9।
• आप किसी भी सुविधाजनक सूची या स्ट्रिंग प्रारूप में इनपुट ले सकते हैं, जब तक कि डेटा का कोई प्रीप्रोसेसिंग नहीं किया जाता है। चूंकि मैट्रिक्स हमेशा चौकोर होता है, आप चाहें तो 2 डी सूची के बजाय एकल 1 डी सूची के रूप में इनपुट ले सकते हैं।
• इनपुट फ़ंक्शन इनपुट, एसटीडीआईएन, कमांड-लाइन तर्क या निकटतम विकल्प के माध्यम से हो सकता है।
• आउटपुट, STDOUT या निकटतम विकल्प को कार्य करने के लिए आउटपुट एक पूर्णांक होना चाहिए। आप सूची या मैट्रिक्स में एकल पूर्णांक का उत्पादन नहीं कर सकते हैं।
• यदि आपकी भाषा उनका समर्थन करने के लिए होती है, तो आप बिलिन निर्धारक और मैट्रिक्स हेरफेर विधियों का उपयोग कर सकते हैं।
• आपके एल्गोरिथ्म को किसी भी मान्य इनपुट के लिए सिद्धांत रूप में काम करना चाहिए।
• मानक कोड-गोल्फ नियम लागू होते हैं।

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

निम्नलिखित परीक्षण मामलों को पायथन-शैली सूची के रूप में दिया गया है:

[[1,0],[0,1]] -> 1
[[1,9],[8,4]] -> -68
[[0,1,2,3],[4,5,6,7],[8,9,0,1],[2,3,4,5]] -> 40
[[3,1,4,1],[5,9,2,6],[5,3,5,8],[9,7,9,3]] -> -1430
[[9,0,0,9],[0,9,9,0],[9,0,9,0],[0,9,0,9]] -> 13122
[[1,0,0,0,0,0,0,0],[2,1,0,0,0,0,0,0],[3,2,1,0,0,0,0,0],[4,3,2,1,0,0,0,0],[5,4,3,2,1,0,0,0],[6,5,4,3,2,1,0,0],[7,6,5,4,3,2,1,0],[8,7,6,5,4,3,2,1]] -> 1
[[7,1,0,5,8,0,1,5],[9,9,6,6,1,2,4,8],[4,8,7,3,8,7,4,7],[4,6,1,9,7,0,1,7],[7,6,7,1,9,4,1,6],[8,0,0,8,5,5,9,9],[4,6,4,8,9,4,8,6],[9,0,8,7,6,2,1,5]] -> 2937504
[[1,2,3,4,5,6,7,8],[2,3,4,5,6,7,8,1],[3,4,5,6,7,8,1,2],[4,5,6,7,8,1,2,3],[5,6,7,8,1,2,3,4],[6,7,8,1,2,3,4,5],[7,8,1,2,3,4,5,6],[8,1,2,3,4,5,6,7]] -> -10549504
[[1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0],[0,1,1,1,1,0,0,1,0,1,1,1,1,1,1,0],[1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,0],[0,1,1,1,1,0,0,0,0,1,1,1,1,1,0,1],[1,0,1,0,1,1,1,0,0,1,1,1,1,0,1,0],[0,0,1,1,1,0,1,1,1,1,1,1,1,0,0,0],[1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1],[1,1,0,1,1,1,1,1,1,1,1,1,0,1,0,1],[1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1],[0,1,1,1,1,1,1,1,1,0,0,1,0,1,0,1],[1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[1,1,0,1,1,0,1,1,1,1,1,0,0,1,1,0],[1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,0],[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],[1,0,1,0,0,1,0,1,0,1,1,1,1,1,0,1],[1,1,1,1,1,1,1,1,1,0,0,1,1,1,0,1]] -> -8

(इस चुनौती में मदद के लिए @ MartinBüner को धन्यवाद)

Comments

मजेदार तथ्य: मैंने इस पर कुछ प्रयोग किए और गैर-शून्य पुनरावर्ती निर्धारक के साथ आश्चर्यजनक रूप से बड़ी संख्या में बाइनरी मैट्रिस हैं। 2x2, 4x4, 8x8, 16x16 के लिए, हमें 6, 16488, 2229617029168687104, 3349795881591711818175850326868175555502655555547474307649708494449448832 मैट्रिसेड के साथ संगत मिलेगा।

— मार्टिन एंडर

@ मार्टिनबटनर: मुझे 6, 22560, 10160459763342013440 मिलते हैं, ... जो A055565 से मेल खाते हैं ।

— चार्ल्स

@ अजीब, मैं अपने कोड की जाँच करूँगा

— मार्टिन एंडर

@ मार्टिनबटनर: संभवतः हम केवल दो अलग-अलग चीजों की गणना कर रहे हैं?

— चार्ल्स

@Charles मैट्रिक्स पर विचार करें [1,0,1,0;1,1,1,1;1,1,1,1;0,0,0,1]। इसका पूर्ण निर्धारक शून्य है क्योंकि इसमें दो समान पंक्तियाँ हैं। यह एक इसलिए एक विलक्षण (जिसका अर्थ है गैर-असंगत) 4 × 4 मैट्रिक्स, इसलिए इसे A055165 द्वारा नहीं गिना जाता है। हालांकि, यहां चर्चा की गई "पुनरावर्ती" निर्धारक है 1*1-1*0==1। विपरीत दिशा में, मैट्रिक्स [0,0,0,1;1,0,0,0;0,1,0,0;0,0,1,0]में "पुनरावर्ती" निर्धारक है 0*0-0*0==0। हालाँकि, इसका पूर्ण निर्धारक शून्य नहीं होना चाहिए क्योंकि इसकी पंक्तियाँ सिर्फ एक अन्य क्रम में पहचान मैट्रिक्स की पंक्तियाँ हैं; और यह A055165 द्वारा गिना जाता है।

— जेपी स्टिग नीलसन

Answer 1

जे, 21 25 बाइट्स

0{0{(_2(_2-/ .*\|:)\])^:_

उपयोग:

   ]input=.(3,1,4,1),(5,9,2,6),(5,3,5,8),:(9,7,9,3)
3 1 4 1
5 9 2 6
5 3 5 8
9 7 9 3
   (0{0{(_2(_2-/ .*\|:)\])^:_) input
_1430

प्रत्येक चरण में हम मैट्रिक्स को 2-बाय -2 तक काटते हैं और प्रत्येक व्यक्ति को निर्धारक की गणना करते हैं जिसके परिणामस्वरूप अगले चरण का इनपुट मैट्रिक्स होता है। हम इस प्रक्रिया को तब तक दोहराते हैं जब तक कि परिणाम नहीं बदल जाता (अंतिम तत्व स्वयं निर्धारक होता है)। हम अंतिम परिणाम को एक स्केलर में बदल देते हैं 0{0{।

इसे यहाँ ऑनलाइन आज़माएँ।

Comments

ऐसा करने के लिए कट के टाइलिंग फ़ंक्शन का उपयोग करने की कोशिश की गई, लेकिन इसे आपके संस्करण के रूप में दूर करने में सक्षम नहीं था। 29 बाइट्स: (2 2$2)&(-/ .*;._3^:(2^.#@])) इसे ऑनलाइन आज़माएं!

— योना

Answer 2

गणितज्ञ, 52 40 बाइट्स

मार्टिन बर्टनर को 12 बाइट बचाने के लिए धन्यवाद।

Tr[#//.l:{_,__}:>BlockMap[Det,l,{2,2}]]&

---

व्याख्या

BlockMap[f,expr,n]हर उपनलियों पर exprआकार nऔर नक्शे के उप-कलाकारों में विभाजित f। BlockMap[Det,#,{2,2}]&इनपुट सरणी को 2 * 2 ब्लॉक में विभाजित करें और उनके निर्धारकों की गणना करें।

---

परीक्षण का मामला

%[{{3,1,4,1},{5,9,2,6},{5,3,5,8},{9,7,9,3}}]
(* -1430 *)

Comments

मैंने Sp3000 के साथ चुनौती विचार पर चर्चा करते हुए गणितज्ञ में एक संदर्भ कार्यान्वयन लिखा है और यह 40 बाइट्स है। हालांकि यह आपके लिए बहुत समान है, इसलिए यदि आप चाहें तो मैं आपको इसे खोजने के लिए कुछ समय दूंगा। :)

— मार्टिन एंडर

@ मार्टिनबटनर मैं असफल रहा। :(

— njpipeorgan

आप बच सकते हैं [[1,1]]के साथ Trऔर Nestसाथ //.:Tr[#//.l:{_,__}:>BlockMap[Det,l,{2,2}]]&

— मार्टिन Ender

@ मार्टिनबटनर वास्तव में, मैं // के साथ आया था। J में उत्तर पढ़ते समय विचार करें, लेकिन सरणी से मेल खाने का एक अच्छा तरीका खोजने में अटक गया। : पी

— njpipeorgan 23

अपने जवाब को अपडेट करने के लिए मेरे समाधान का उपयोग करने के लिए स्वतंत्र महसूस करें

— मार्टिन एंडर

Answer 3

जेली, 20 17 बाइट्स

s€2s2U×¥/€ḅ-µL¡SS

इसे ऑनलाइन आज़माएं! या एक ही बार में सभी परीक्षण मामलों को सत्यापित करें ।

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

s€2s2U×¥/€ḅ-µL¡SS  Main link. Input: M (matrix)

s€2                Split each row of M into pairs.
   s2              Split the result into pairs of rows.
        /€         Reduce each pair...
       ¥             by applying the following, dyadic chain:
     U                 Reverse each pair of the left argument (1st row).
      ×                Multiply element-wise with the right argument (2nd row).
          ḅ-       Convert each resulting pair from base -1 to integer.
                   This maps [a, b] -> b - a.
            µ      Turn the previous links into a monadic chain. Begin a new one.
             L     Yield the length of the input.
              ¡    Execute the previous chain L times.
                   log2(L) times would do, but who's counting?
               SS  Sum twice to turn the resulting 1x1 matrix into a scalar.

Answer 4

हास्केल , 93 86 बाइट्स

संपादित करें: यह पूरे 7 बाइट्स को छोटा करने के लिए @ लिकोनी के लिए धन्यवाद!

f[[a,b],[c,d]]=a*d-b*c
f m|let l=[take,drop]<*>[div(length m)2]=f[f.($b<$>m)<$>l|b<-l]

मुझे नहीं पता था कि आप = से पहले एक लेट स्टेटमेंट डाल सकते हैं और मैंने कभी भी उन मोनाड ऑपरेटर्स की आदत नहीं डाली है। धन्यवाद फिर से @Laikoni

पुराना संस्करण:

f[[a,b],[c,d]]=a*d-b*c
f m=f[[f$a$map b m|a<-l]|b<-l]where h=length m`div`2;l=[take h,drop h]

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

यह एक ऐसा फंक्शन है जो खुद को दो अलग-अलग तरीकों से पुन: बनाता है। पहला पैटर्न मिलान बेस केस को पकड़ता है: एक 2x2 मैट्रिक्स और यह गणना करता है। मैं इसका उपयोग पुनरावर्ती मामले में गणना को 2x2 मैट्रिक्स के साथ फ़ंक्शन को कॉल करके करता हूं जो मैं उत्पन्न करता हूं कि इसमें पुनरावर्ती समाधान हैं। उस मैट्रिक्स को दो बार कार्यों की एक सरणी पर पुनरावृत्त करके उत्पन्न किया जाता है जो प्रत्येक सूची को आधे में काटता है। मैं इसे एक साधारण कॉल के साथ पंक्तियों पर लागू करता हूं और इसे कॉलम का उपयोग करके लागू करता हूं map।

Comments

इसके बजाय where h=length m`div`2;l=[take h,drop h], आप उपयोग कर सकते हैं f m|let l=[take,drop]<*>[length m`div`2]=। map b mहो सकता है b<$>m, और [f$a$b<$>m|a<-l]आगे छोटा किया जा सकता है f.($b<$>m)<$>l। कुल मिलाकर 86 बाइट्स: [ tio.run/… इसे ऑनलाइन आज़माएं!]

— लिकोनी

Answer 5

पायथन, 166 बाइट्स

def f(m):l=len(m)/2;g=lambda x,y:[(s[:l],s[l:])[x]for s in(m[:l],m[l:])[y]];return f(g(0,0))*f(g(1,1))-f(g(0,1))*f(g(1,0)) if l>1 else m[0][0]*m[1][1]-m[1][0]*m[0][1]

यह प्रदान किए गए सभी परीक्षण मामलों को पास करता है। मी को एक 2 डी सरणी होना चाहिए (जैसे परीक्षण मामलों में), जी उप मैट्रिक्स का चयन करता है।

Answer 6

अजगर, २६

M-F*VG_HhhumgMCcR2dcG2llQQ

परीक्षण सूट

इसके दो भाग हैं: M-F*VG_Hg दो मैट्रिक्स द्वारा दो के निर्धारक की गणना करने के लिए फ़ंक्शन को फिर से परिभाषित करता है। यह बाइट्स को बचाता है भले ही हम केवल एक बार इसका उपयोग करते हैं क्योंकि यह दो पंक्तियों को अनपैक करता है।

दूसरा हिस्सा एक बड़ी कमी वाला बयान है जिसे हम log_2( len( input() ) )बार कहते हैं। दुर्भाग्य से, 1 बाय 1 मैट्रिक्स में कमी पर एक कदम प्रदर्शन करने से परिणाम एक सूची में लिपटे रहते हैं, इसलिए हमें एक निश्चित बिंदु नहीं मिलता है। कमी ज्यादातर मैट्रिक्स को विभाजित कर रही है 2 से 2 मेट्रिसेस प्राप्त करने और फिर आवेदन करने के लिए g।

Answer 7

MATL , 26 30 बाइट्स

`tnX^teHHhZC2Ih2#Y)pwp-tnq

इनपुट एक 2D सरणी है जिसमें पंक्तियों को अलग किया गया है ;, अर्थात

[3 1 4 1; 5 9 2 6; 5 3 5 8; 9 7 9 3]

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

`             % do...while loop
  tnX^te      %   reshape into square matrix. Implicitly asks for input the first time
  HHhZC       %   transform each 2x2 block into a column
  2Ih2#Y)     %   push matrix with rows 2,3, and also matrix with remaining rows (1,4)
  pwp-        %   multiplications and subtraction to compute the 2x2 determinants
  tnq         %   condition of do...while loop: is number of elements greater than 1?
              % implicitly end loop
              % implicitly display

Answer 8

पर्ल 5 , 120 + 1 (-a ) = 121 बाइट्स

while($#F){@r=();for$i(@o=0..($l=sqrt@F)/2-1){push@r,$F[$k=$i*$l*2+2*$_]*$F[$k+$l+1]-$F[$k+$l]*$F[$k+1]for@o}@F=@r}say@F

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

इनपुट को अंतरिक्ष से अलग किए गए नंबरों की सूची के रूप में लेता है।

Answer 9

ईएस 6, 91 बाइट्स

(a,x=0,y=0,w=a.length)=>(w>>=1)?f(a,x,y,w)*f(a,x+w,y+w,w)-f(a,x,y+w,w)*f(a,x+w,y,w):a[x][y]

सीधा पुनरावर्ती समाधान।

Answer 10

आर , 111 बाइट्स

f=function(m)"if"((n=nrow(m))-2,f(matrix(c(f(m[x<-1:(n/2),x]),f(m[y<-x+n/2,x]),f(m[x,y]),f(m[y,y])),2)),det(m))

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

आर मैट्रिक्स के रूप में इनपुट लेता है (जो हेडर में फ़ंक्शन द्वारा परिवर्तित होता है)।

Answer 11

ग्रूवी, 221 189 बाइट्स (इस बिंदु पर, जावा का उपयोग कर सकते हैं)

f={x->b=x.size();c=b/2-1;a=(0..c).collect{i->(0..c).collect{j->z=x.toList().subList(i*2,i*2+2).collect{it.toList().subList(j*2,j*2+2)};z[0][0]*z[1][1]-z[0][1]*z[1][0];}};a.size()==1?a:f(a)}

---

पुराना भद्दा संस्करण, जो जावा (221 बाइट्स) भी हो सकता है:

f={x->b=x.size();a=new int[b/2][b/2];for(i=0;i<b-1;i+=2){for(j=0;j<b-1;j+=2){z=x.toList().subList(i,i+2).collect{it.toList().subList(j,j+2)};a[(int)(i/2)][(int)(j/2)]=z[0][0]*z[1][1]-z[0][1]*z[1][0];}};a.size()==1?a:f(a)}

अघोषित कोड:

f=
{x->
  b=x.size();
  int[][]a=new int[b/2][b/2];
  for(i=0;i<b-1;i+=2) {
    for(j=0;j<b-1;j+=2) {
      z=x.toList().subList(i,i+2).collect{
        it.toList().subList(j,j+2)
      };
      a[(int)(i/2)][(int)(j/2)]=z[0][0]*z[1][1]-z[0][1]*z[1][0];
    }
  }
  a.size()==1
    ?
      a:f(a)
}