मैट्रिक्स आरा पहेलियाँ

24

इनपुट:

  • पूर्णांक n
  • दो समान आकार के वर्ग मैट्रिस (उनकी चौड़ाई / ऊंचाई एक से अधिक होने के साथ n)

आउटपुट:

आपकी अपनी पसंद के दो अलग-अलग मूल्यों में से एक, सत्य परिणामों के लिए और एक गलत परिणामों के लिए (हां, 1/0इसके बजाय true/falseजावा जैसी भाषाओं के लिए वैध आउटपुट हैं, भले ही वे आधिकारिक सत्य / गलत मान नहीं हैं )।

सत्य / फाल्सी आउटपुट यह दर्शाता है कि क्या हम n by nएक मैट्रिक्स में आकार के ब्लॉक को दूसरे मैट्रिक्स के बराबर बनाने के लिए पुनर्व्यवस्थित कर सकते हैं ।

उदाहरण:

इनपुट:

Matrix 1:
1 2 3 4 5 6
7 8 9 0 1 2
3 4 5 6 7 8
9 8 7 6 5 4
3 2 1 0 9 8
1 1 1 1 1 1

Matrix 2:
3 2 9 8 7 8
1 1 1 1 5 4
3 4 5 6 1 0
9 0 7 6 1 1
5 6 1 2 3 4
1 2 7 8 9 8

Integer n:
2

आउटपुट: truthy

क्यूं कर?

यदि हम मैट्रिक को ब्लॉक में विभाजित करते हैं 2 by 2, तो हम देख सकते हैं कि एक मैट्रिक्स पर सभी ब्लॉक दूसरे मैट्रिक्स में भी मिल सकते हैं:

Matrix 1:
1 2 | 3 4 | 5 6
7 8 | 9 0 | 1 2
---------------
3 4 | 5 6 | 7 8
9 8 | 7 6 | 5 4
---------------
3 2 | 1 0 | 9 8
1 1 | 1 1 | 1 1

Matrix 2:
3 2 | 9 8 | 7 8
1 1 | 1 1 | 5 4
---------------
3 4 | 5 6 | 1 0
9 0 | 7 6 | 1 1
---------------
5 6 | 1 2 | 3 4
1 2 | 7 8 | 9 8

चुनौती नियम:

  • आप मान सकते हैं कि मैट्रिसेस में केवल गैर-नकारात्मक अंक (रेंज [0,9]) होंगे
  • आप मान सकते हैं कि मैट्रिसेस की चौड़ाई / ऊंचाई बराबर है, और एक से अधिक है n
  • आप मान सकते हैं nकि रेंज में होगा [1, 50], और मैट्रिसेस की चौड़ाई / ऊंचाई सीमा में है [1,100]।
  • के ब्लॉक में n by nविभाजित होने पर मैट्रिस एक दूसरे के क्रमपरिवर्तन हैं या नहीं यह निर्धारित करने के लिए केवल एक बार उपयोग किया जा सकता है n by n।
  • कई n by nब्लॉक हो सकते हैं जो समान हैं।
  • n by nब्लॉक करता है, तो दो मैट्रिक्स के ब्लॉक में एक दूसरे को जब विभाजन के क्रमचय हैं जब जाँच एक ही ओरिएंटेशन में ही रहेगा n by n।

सामान्य नियम:

  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने की कोशिश करें।
  • डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
  • डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
  • यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
  • साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

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

Input:
Matrix 1:       Matrix 2:       Integer:
1 2 3 4 5 6     3 2 9 8 7 8     2
7 8 9 0 1 2     1 1 1 1 5 4
3 4 5 6 7 8     3 4 5 6 1 0
9 8 7 6 5 4     9 0 7 6 1 1
3 2 1 0 9 8     5 6 1 2 3 4
1 1 1 1 1 1     1 2 7 8 9 8
Output:
truthy

Input:
Matrix 1:       Matrix 2:       Integer:
1 2 3 4 5 6     3 2 9 8 7 8     1
7 8 9 0 1 2     1 1 1 1 5 4
3 4 5 6 7 8     3 4 5 6 1 0
9 8 7 6 5 4     9 0 7 6 1 1
3 2 1 0 9 8     5 6 1 2 3 4
1 1 1 1 1 1     1 2 7 8 9 8
Output:
truthy

Input:
Matrix 1:       Matrix 2:       Integer:
1 2 3 4 5 6     3 2 9 8 7 8     3
7 8 9 0 1 2     1 1 1 1 5 4
3 4 5 6 7 8     3 4 5 6 1 0
9 8 7 6 5 4     9 0 7 6 1 1
3 2 1 0 9 8     5 6 1 2 3 4
1 1 1 1 1 1     1 2 7 8 9 8
Output:
falsey

Input:
Matrix 1:    Matrix 2:    Integer:
1 2 3 4      1 2 3 4      4
2 3 4 5      2 3 4 5
3 4 5 6      3 4 5 6
4 5 6 7      4 5 6 7
Output:
truthy

Input:
Matrix 1:    Matrix 2:    Integer:
1 2 3 4      3 4 3 4      2
2 3 4 5      4 5 4 5
3 4 5 6      1 2 5 6
4 5 6 7      2 3 6 6
Output:
falsey

Input:
Matrix 1:    Matrix 2:    Integer:
1 2          2 3          1
3 4          1 1
Output:
falsey

Input:
Matrix 1:    Matrix 2:    Integer:
0            8            1
Output:
falsey

Input:
Matrix 1:    Matrix 2:    Integer:
1 2 3 4      1 2 1 2      2
5 6 7 8      5 6 5 6
9 0 0 9      0 9 9 0
4 3 2 1      2 1 4 3
Output:
falsey

Input:
Matrix 1:    Matrix 2:    Integer:
1 2 1 2      9 5 1 2      2
3 4 3 4      7 7 3 4
8 3 9 5      1 2 8 3
6 1 7 7      3 4 6 1
Output:
truthy

Input:
Matrix 1:      Matrix 2:      Integer:
1 0 2 0 0 3    1 1 1 0 0 3    2
1 1 1 1 1 1    2 0 1 1 1 1
2 2 2 2 2 2    2 2 2 2 2 2
3 3 3 3 3 3    3 3 3 3 3 3
4 4 4 4 4 4    4 4 4 4 4 4
5 5 5 5 5 5    5 5 5 5 5 5
Output:
falsey

[[,]]प्रारूप में मेट्रिसेस के साथ पास्टबीन ।

code-golf  number  integer  matrix 
— केविन क्रूज़सेन
स्रोत
क्या हम मैट्रिसेस को मैट्रिसेस की सूची के रूप में ले सकते हैं?
— जो राजा
@JoKing क्या आपका मतलब दो अलग-अलग मैट्रिक्स-इनपुट के बजाय दोनों मैट्रिसेस वाली सूची है? यदि आप पूछ रहे हैं, तो यकीन है, क्यों नहीं।
— केविन क्रूज़सेन
— श्री एक्सकोडर
उदाहरण क्यों [ [ 0 ] ], [ [ 25 ] ], 1मौजूद है? मुझे समझ में आया You can assume the matrices will only contain non-negative digits (range [0,9])कि मैट्रिक्स का मान केवल 0 और 9 के बीच है?
— ओलिवियर ग्रेजायर
2
@ OlivierGrégoire क्षमा करें, उस नियम को [0,9]बाद में सैंडबॉक्स में श्रेणी के बारे में जोड़ा गया । मैंने परीक्षण मामले को बदल दिया है [[0]],[[8]]।
— केविन क्रूज़सेन

जवाबों:

4

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

ż⁹/ẎsṢʋ€E

इसे ऑनलाइन आज़माएं! (यापरीक्षण मामलों से आसान कॉपी और पेस्ट के लिए पूर्व प्रसंस्करण के साथ )

एक dyadic लिंक दो मैट्रिक्स की एक सूची को स्वीकार बाईं तरफ (सूचियों की सूची के रूप में) और पूर्णांक सही जो पैदावार पर 1या 0truthy के लिए या falsey क्रमशः।

कैसे?

ż⁹/ẎsṢʋ€E - Link: [M1, M2]; N
       €  - for each of [M1, M2]:
      ʋ   -   last four links as a dyad (i.e. f(M, N)):
 ⁹        -     (chain's right argument, N)
 ⁹/       -     N-wise-reduce with:
ż         -       zip together
   Ẏ      -     tighten
    s     -     split into chunks of length N
     Ṣ    -     sort
        E - equal?
— जोनाथन एलन
स्रोत
8

APL (Dyalog Extended) , 19 18 17 बाइट्स

-2 ngn के लिए धन्यवाद।

अनाम टैसिट इन्फिक्स फ़ंक्शन। nबाएं तर्क के रूप में और दो तर्क की सूची को सही तर्क के रूप में लेता है। शून्य-अनुक्रमण ( ⎕IO←0) की आवश्यकता है। संयोग से, यह फ़ंक्शन किसी भी संख्या के आयामों के सरणियों पर काम करता है।

≡.{∧,⍵⊂⍨⊂0=⍺|⍳≢⍵}

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

≡.{... } निम्नलिखित समारोह के समान परिणाम प्रत्येक मैट्रिक्स के लिए लागू ⍵के साथ nके रूप में ⍺?

 ≢⍵ मैट्रिक्स का आकार

 ⍳ सूचकांक 0… आकार -1

 ⍺| विभाजित होने पर विभाजन शेष रहता है n

 ⊂ सभी आयामों का उपयोग करने के लिए संलग्न करें

 ⍵⊂⍨ उस विभाजन का उपयोग करें * मैट्रिक्स को सबमेट्रिसेस के मैट्रिक्स में
  * नए विभाजन को शुरू करता है जब संबंधित तत्व पिछले से कम होता है; शून्य द्वारा चिह्नित तत्वों को निकालता है

 , मैट्रिक्स को सबमेट्रिसेस की सूची में ले जाएं

 ∧ छोटे से बड़े क्रम में क्रमबद्ध करें

— एडम
स्रोत
(≢⍵)⍴⍺↑1-> 0=⍺|⍳≢⍵(साथ ⎕io←0)
— ngn
@ धन्यवाद धन्यवाद। किया हुआ।
— एडम
≡/{}¨->≡.{}
— ngn
@ngn किया। धन्यवाद।
— एडम
6

पर्ल 6 , 94 68 63 बाइट्स

{[eqv] map *.rotor($^a).map({[Z] $_}).flat.rotor($a²).sort,@_}

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

अनाम कोड ब्लॉक जो इनपुट लेता है size, [matrix1, matrix2]और एक बूलियन देता है True/False। मैट्रिक्स को विखंडू में विभाजित करने का एक अधिक कुशल तरीका हो सकता है rotor।

स्पष्टीकरण:

{                                                            }  # Anonymous code block
       map                                                ,@_   # For both matrices 
           *.rotor($^a)   # Split the matrix into N sized chunks
                       .map({[Z] $_})  # Then zip each of those chunks together
                                     .flat  # Flatten the resulting list
                                          .rotor($a²)  # Then split into the NxN lists
                                                     .sort   # And sort them
 [eqv]    # And then check if the lists are equivalent
— मजाक कर रहा है
स्रोत
4

जावा (JDK) , 221 बाइट्स

(n,a,b)->{java.util.Arrays A=null;int l=a.length,x=l/n,i=0,j,z;var c=new String[x*x];A.fill(c,"");var d=c.clone();for(;i<l;i++)for(j=0;j<l;d[z]+=b[i][j++])c[z=i/n+j/n*x]+=a[i][j];A.sort(c);A.sort(d);return A.equals(c,d);}

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

व्याख्या

विचार प्रत्येक छोटे सेल को एक स्ट्रिंग के रूप में चुनना है, जो तुलनीय है, और फिर उन तारों को क्रमबद्ध करने और क्रम में उनकी तुलना करने के लिए है।

(n,a,b)->{
 java.util.Arrays A=null;             // Shortcut A for the several java.util.Arrays that'll come
 int l=a.length,x=l/n,i=0,j,z;        // Variable declarations
 var c=new String[x*x];               // Declare the small squares list
 A.fill(c,"");                        // Fill the lists of small squares with the empty string.
 var d=c.clone();                     // Make a copy of the list, for the second matrix
 for(;i<l;i++)
  for(j=0;j<l;d[z]+=b[i][j++])        // For each matrix cell
   c[z=i/n+j/n*x]+=a[i][j];           // Fill the small square with the value, string-wise
 A.sort(c);A.sort(d);                 // Sort both small squares list
 return A.equals(c,d);                // Return true if they're equal, false otherwise.
}

क्रेडिट

  • -12 बाइट्स केविन क्रूज़सेन को धन्यवाद!
— ओलिवियर ग्रेजायर
स्रोत
क्या आप गोल्फ को भूल गए for(j=0;j<l;){c[z=i/n+j/n*x]+=a[i][j];d[z]+=b[i][j++];}? .. आप सभी चीजों को लूप के अंदर रखकर ब्रैकेट्स को हटा सकते हैं। इसके अलावा, i=0लूप में हटाया जा सकता है, क्योंकि आपके iपहले से ही घोषणा में 0 है।
— केविन क्रूज़सेन
और वास्तव में गोल्फ के लिए एक चीज: इसके बजाय var d=new String[x*x];हो सकता है var d=c.clone();। 234 बाइट्स
— केविन क्रूज़सेन
पुनश्च: आपके TIO में स्ट्रिंग क्यों है जिसे आप 2D-पूर्णांक सरणियों में परिवर्तित करते हैं? मैं तल पर परीक्षण मामलों, जिसके लिए आप की जगह ले सकता के साथ एक पेस्ट-बिन जोड़ दिया है [और ]साथ {और }और एक अग्रणी जोड़ने new int[][], और यह पर्याप्त हो गया होता। ;)
— केविन क्रूज़सेन
दमिति, मैंने पेस्ट-बिन नहीं देखा था :( और बाकी के लिए, मैं अभी भी गोल्फ खेल रहा हूं। मैंने एक मोटा रास्ता तय किया, लेकिन धन्यवाद :-)
— ओलिवियर ग्राएगोइरे
i=0जब मैं नहीं बल्कि का उपयोग करने से अपने आप से सरणियों भरा एक अवशेष था Arrays.fill। धन्यवाद :-) और cloneमैं इसे इस्तेमाल करने के बारे में सोचता था, लेकिन मैंने अभी भी सोचा था कि यह Objectवास्तविक प्रकार नहीं है। मुझे उस बिंदु पर देर से कई संस्करण होने चाहिए;)
— ओलिवियर ग्रेजायर
4

जाप , 18 बाइट्स

®mòV yòV rc n qÃr¥

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

स्पष्टीकरण:

®              Ã      #Apply this to each of the input matrices:
 mòV                  # Split each row into groups of n
     yòV              # Split each column into groups of n
         rc           # Flatten into a list of nxn submatrices
            n         # Sort that list
              q       # Turn it into a string
                r¥    #Return true if both matrices had identical results

"इसे स्ट्रिंग में बदल दें" चरण आवश्यक है क्योंकि जाप मान द्वारा सरणियों की तुलना नहीं करता है और बिल्टिन के चारों ओर काम करने के लिए जो बहुआयामी सरणियों के लिए काम नहीं करता है ।

— कामिल दकरी
स्रोत
2
मैं देखूंगा कि क्या मैं कल A.e()बहुआयामी सरणियों के लिए काम करने और पाने के लिए बैठकों के बीच कुछ समय बना सकता हूं ; हमेशा वापस आने का मतलब था। इस बीच ÕmòV-> yòVआपको एक बाइट बचाएगा।
— झबरा
वैसे, समानता के लिए सरणियों की तुलना करने पर सीमा जावास्क्रिप्ट के बजाय जाप के लिए विशेष है;)
— झबरा
4

TSQL, 164 बाइट्स

इनपुट करने के लिए एक टेबल चर को पॉप्युलेट करना, यह इनपुट बनाना और डेटा सम्मिलित करना बाइट काउंट में शामिल नहीं किया गया है। डेटा निकालने के लिए केवल वास्तविक क्वेरी।

गोल्फ (टेस्ट टेबल सहित नहीं - यह अन-गोल्ड संस्करण में पाया जा सकता है):

SELECT iif(exists(SELECT*FROM(SELECT string_agg(v,'')within
group(order by x,y)s,m FROM @t GROUP BY x/@,y/@,m)x
GROUP BY s HAVING max(m)=min(m)or sum(m-.5)<>0),0,1)

Ungolfed:

-- test data
DECLARE @ INT = 2
-- x = x-position of the input
-- y = y-position of the input
-- v = value
-- m = matrix(0 or 1)
DECLARE @t table(x int, y int, v int, m int)
--insert first matrix values
INSERT @t values
(0,0,1,0),(0,1,2,0),(0,2,1,0),(0,3,2,0),
(1,0,3,0),(1,1,4,0),(1,2,3,0),(1,3,4,0),
(2,0,8,0),(2,1,3,0),(2,2,9,0),(2,3,5,0),
(3,0,6,0),(3,1,1,0),(3,2,7,0),(3,3,7,0)
INSERT @t values
(0,0,9,1),(0,1,5,1),(0,2,1,1),(0,3,2,1),
(1,0,7,1),(1,1,7,1),(1,2,3,1),(1,3,4,1),
(2,0,1,1),(2,1,2,1),(2,2,8,1),(2,3,3,1),
(3,0,3,1),(3,1,4,1),(3,2,6,1),(3,3,1,1)

-- query
SELECT iif(exists
  (
    SELECT *
    FROM
    (
      SELECT string_agg(v,'')within group(order by x,y)s,m
      FROM @t
      GROUP BY x/@,y/@,m
    ) x
    GROUP BY s
    HAVING max(m)=min(m)or sum(m-.5)<>0
  ),0,1)

कोशिश करके देखो

— t-clausen.dk
स्रोत
4

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

(n,a,b)=>(g=a=>a.map((r,y)=>r.map((v,x)=>o[y/n<<7|x/n]+=[v]),o=[])&&o.sort()+o)(a)==g(b)

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

कैसे?

यह कोड है:

  • प्रत्येक इनपुट मैट्रिक्स में सभी उप-मेट्रिक्स को कोशिकाओं के संघनन के रूप में निकालना
  • उप-गणित को क्रमबद्ध क्रम में क्रमबद्ध करना
  • परीक्षण कि क्या परिणाम दोनों इनपुट मैट्रिस के लिए समान है

यह चुनौती में वर्णित सीमाओं का लाभ उठा रहा है:

  • एक मैट्रिक्स में एकल अंक होते हैं, इसलिए हम बिना किसी विभाजक के उप-मैट्रिक्स की सभी कोशिकाओं को बस समेट सकते हैं और फिर भी इसका एक अनूठा प्रतिनिधित्व प्राप्त [[1,2],[3,4]]कर सकते हैं (जैसे कि संग्रहीत किया जा सकता है "1234")।

  • 100(x,y)I

    I=⌊yn⌋×128+⌊xn⌋

    या जेएस कोड के रूप में: y / n << 7 | x << n

टिप्पणी की गई

(n, a, b) =>           // n, a, b = input variables (integer, matrix 1, matrix 2)
  (g = a =>            // g = helper function taking one of the two matrices
    a.map((r, y) =>    // for each row r[] at position y in a[]:
      r.map((v, x) =>  //   for each value v at position x in r[]:
        o[             //     update o[]:
          y / n << 7 | //       the position of the slot is computed by taking advantage
          x / n        //       of the limit on the matrix width (see above)
        ] += [v]       //     coerce v to a string and append it to o[slot]
                       //     all slots are initially undefined, so all resulting strings
                       //     are going to start with "undefined", which is harmless
      ),               //   end of inner map()
      o = []           //   start with o = empty array
    ) &&               // end of outer map()
    o.sort() + o       // sort o[] and coerce it to a string by concatenating it with itself
  )(a) == g(b)         // test whether g(a) is equal to g(b)
— Arnauld
स्रोत
3

चारकोल , 54 49 बाइट्स

1ＦθＦ⪪ιηＦ÷Ｌ§κ⁰η⊞υＥκ§⪪μηλＷ∧υ⊟υ¿№✂υ⁰⊘⊕Ｌυ¹ι≔Φυ⁻⌕υιλυ⎚

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। समान आकार के द्वि-आयामी सरणियों के एक सरणी के रूप में इनपुट लेता है। सफलता पर आउटपुट 1, असफलता पर कुछ भी नहीं। स्पष्टीकरण:

1

सफलता मान लो।

Ｆθ

सरणियों पर लूप।

Ｆ⪪ιη

सरणी को n-sized पंक्ति विखंडू में विभाजित करें ।

Ｆ÷Ｌ§κ⁰η

प्रत्येक कॉलम चंक पर लूप करें।

⊞υＥκ§⪪μηλ

पंक्ति के प्रत्येक भाग के लिए कॉलम चंक निकालें और एक सूची में परिणामी सबमेट्रिक्स को सहेजें।

Ｗ∧υ⊟υ

जबकि सूची गैर-रिक्त है, सूची के अंतिम भाग को हटा दें, जो सामान्य परिस्थितियों में दूसरे सरणी से आता है।

¿№✂υ⁰⊘⊕Ｌυ¹ι

सूची के पहले भाग में उस चंक के होने की संख्या की गणना करें, जिसमें सामान्य परिस्थितियों में पहली सरणी से शेष भाग होते हैं।

≔Φυ⁻⌕υιλυ

यदि नॉनजरो फिर सूची से उस चंक की पहली घटना को हटा दें।

⎚

यदि शून्य है तो आउटपुट को साफ़ करें, जिससे यह गलत हो सकता है।

— नील
स्रोत
2

हास्केल, 74 73 बाइट्स

import Data.Lists
i#m|c<-chunksOf i=c.transpose=<<c m
(m!n)i=i#m\\i#n==[]

नोट: TIO स्थापित नहीं है Data.Lists, इसलिए मैं Data.Listएक अनुपलब्ध फ़ंक्शन को जोड़ने के बजाय उपयोग कर रहा हूं chunksOf: इसे ऑनलाइन आज़माएं!

i#m=           -- function '#' makes a list of all transposed jigsaw blocks of matrix 'm'
               -- of size 'i'
 c<-chunksOf i -- define helper function 'c' that splits it's argument into
               -- chunks of site 'i'
         c m   -- split the matrix into chunks of size 'i'
      =<<      -- for each chunk
   transpose   --   transpose
 c.            --   and split into chunks of size 'i', again
               -- flatten one level of nesting ('=<<' is concatMap)

(m!n)i=        -- main function
    i#m\\i#n   -- remove every element of i#n from i#m
      ==[]     -- and check if it results in an empty list
— nimi
स्रोत
2

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 186 बाइट्स

(a,b,n)=>{string[]s(int[][]c){int i=0,j,l=a.Length,m=l/n;var r=new string[m*m];for(;i<l;i++)for(j=0;j<l;)r[i/n*m+j/n]+=c[i][j++];Array.Sort(r);return r;}return s(a).SequenceEqual(s(b));}

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

-1 @ केविनक्रूजसेन को धन्यवाद!

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

// anonymous function
// a and b are 2d jagged arrays
// n is the size of the sub matrix
(a,b,n)=>{
  // helper function that translates
  // the sub matrices into strings
  // of digits.
  string[]s(int[][]c){
    // i and j are loop counters
    int i=0,j,
      // l is the size of a side of a matrix
      l=a.Length,
      // m is the number of sub matrices
      // per side of a matrix
      m=l/n;
    // the concatenated digits are
    // stored in a single dimension
    // array
    var r=new string[m*m];
    // nested loops build up
    // the digit strings
    for(;i<l;i++)
      for(j=0;j<l;)
        r[i/n*m+j/n]+=c[i][j++];
    // The resulting array is
    // sorted before it is returned for
    // ease of comparison.
    Array.Sort(r);
    return r;
  }
  return s(a).SequenceEqual(s(b));
}
— दाना
स्रोत
गोल्फ के लिए एक छोटी सी बात, एक बाइट को बचाने के लिए j++इसे हटाया जा सकता है और रखा जा सकता है +=c[i][j++]+" ";।
— केविन क्रूज़सेन
टिप के लिए धन्यवाद :) दिलचस्प रूप से पर्याप्त है, मैं जावा के रूप में लगभग एक ही समाधान के साथ आया था।
— दाना
1

PHP ,186 163 162 बाइट्स

function($a,$b,$n){$f=function($j,$n){foreach($j as$x=>$r)foreach($r as$y=>$v)$o[count($j)*($x/$n|0)+$y/$n|0].=$v;sort($o);return$o;};return$f($a,$n)==$f($b,$n);}

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

सभी अच्छी चुनौतियों की तरह, मैंने सोचना शुरू कर दिया कि यह काफी आसान था और इसने मुझे कुछ घटता फेंक दिया। अच्छी तरह से @ केविन क्रूज़सेन किया!

मैट्रिक्स को प्रत्येक ब्लॉक के मानों वाले स्ट्रिंग्स में शामिल करें। Arrays तो क्रमबद्ध हैं और समानता के लिए तुलना की जाती है।

Ungolfed:

function jigsaw_chunk( $j, $n ) {
    foreach( $j as $x => $r ) {
        foreach( $r as $y => $v ) {
            $o[ count( $j ) * floor( $x/$n ) + floor( $y/$n )] .= $v;
        }
    }
    sort( $o );
    return $o;
}

function jigsaw_test( $a, $b, $n ) {
    return jigsaw_chunk( $a, $n ) == jigsaw_chunk( $b, $n );
}

// Test 6
var_dump( jigsaw_test( [[1,2],[3,4]], [[2,3],[1,1]], 1 ) );

उत्पादन

bool(false)
— 640KB
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.