Đầu vào:

• Một số nguyên n
• Hai ma trận vuông có kích thước bằng nhau (với chiều rộng / chiều cao của chúng là bội số của n)

Đầu ra:

Một trong hai giá trị riêng biệt của sự lựa chọn của bạn, một là cho kết quả trung thực và một cho kết quả falsey (vì vậy, 1/0thay vì true/falselà kết quả đầu ra hợp lệ cho các ngôn ngữ như Java, mặc dù chúng không được coi là giá trị trung thực / falsey chính thức ).

Đầu ra trung thực / falsey cho biết liệu chúng ta có thể sắp xếp lại các khối kích thước n by ntrong một ma trận để làm cho nó bằng với ma trận khác hay không.

Thí dụ:

Đầu vào:

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

Đầu ra: truthy

Tại sao?

Nếu chúng ta chia ma trận thành các khối 2 by 2, chúng ta có thể thấy rằng tất cả các khối trên một ma trận cũng có thể được tìm thấy trong ma trận khác:

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

Quy tắc thử thách:

• Bạn có thể giả sử ma trận sẽ chỉ chứa các chữ số không âm (phạm vi [0,9])
• Bạn có thể giả sử chiều rộng / chiều cao của ma trận bằng nhau và bội số của n
• Bạn có thể giả sử nsẽ nằm trong phạm vi [1, 50]và chiều rộng / chiều cao của ma trận nằm trong phạm vi [1,100].
• Các khối riêng lẻ n by nchỉ có thể được sử dụng một lần để xác định xem các ma trận có hoán vị lẫn nhau khi chia thành các khối không n by n.
• Có thể có nhiều n by nkhối giống nhau.
• Các n by nkhối sẽ vẫn giữ nguyên hướng khi kiểm tra xem hai ma trận có hoán vị lẫn nhau khi chia thành các khối không n by n.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm:

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

Pastebin với ma trận ở [[,]]định dạng.

Thạch ,  10  9 byte

ż⁹/ẎsṢʋ€E

Hãy thử trực tuyến! (hoặc với tiền xử lý để sao chép và dán dễ dàng hơn từ các trường hợp thử nghiệm)

Một liên kết dyadic chấp nhận một danh sách hai ma trận (như danh sách các danh sách) ở bên trái và số nguyên ở bên phải mang lại 1hoặc 0cho sự thật hoặc falsey tương ứng.

Làm sao?

ż⁹/Ẏ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?

APL (Dyalog mở rộng) , 19 18 17 byte

-2 nhờ ngn.

Chức năng ẩn danh ẩn danh. Lấy nlàm đối số bên trái và danh sách hai ma trận làm đối số bên phải. Yêu cầu lập chỉ mục bằng không ( ⎕IO←0). Ngẫu nhiên, chức năng này hoạt động trên các mảng của bất kỳ số lượng kích thước.

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

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

≡.{... } kết quả giống hệt nhau của các chức năng sau đây áp dụng cho từng ma trận ⍵với nnhư ⍺?

 ≢⍵ kích thước của ma trận

 ⍳ chỉ số 0

 ⍺| phần còn lại khi chia n

 ⊂ kèm theo để sử dụng dọc theo tất cả các kích thước

 ⍵⊂⍨ sử dụng điều đó để phân vùng * ma trận thành một ma trận các ma trận con
  ^{* bắt đầu phân vùng mới khi phần tử tương ứng nhỏ hơn phần tử trước; loại bỏ các yếu tố được đánh dấu bằng không}

 , đưa ma trận vào một danh sách các mô hình con

 ∧ sắp xếp tăng dần

Python 2 , 108 103 byte

lambda s,*a:len(set(`sorted(sum([zip(*[iter(zip(*l))]*s)for l in zip(*[iter(m)]*s)],[]))`for m in a))<2

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

Perl 6 , 94 68 63 byte

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

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

Khối mã ẩn danh nhận đầu vào là size, [matrix1, matrix2]và trả về một boolean True/False. Có thể có một cách hiệu quả hơn để chia ma trận thành nhiều phần hơn rotor.

Giải trình:

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

05AB1E , 14 byte

εε²ô}ø˜²ô²ô{]Ë

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

Java (JDK) , 221 byte

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

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

Giải trình

Ý tưởng là chọn mỗi ô nhỏ dưới dạng một chuỗi, có thể so sánh được, sau đó sắp xếp các chuỗi đó và so sánh chúng theo thứ tự.

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

Tín dụng

• -12 byte nhờ Kevin Cruijssen!

Japt , 18 byte

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

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

Giải trình:

®              Ã      #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

Bước "Biến nó thành một chuỗi" là cần thiết vì Japt không so sánh các mảng theo giá trị và tích hợp để hoạt động xung quanh mà không hoạt động cho các mảng nhiều chiều .

TSQL, 164 byte

Nhập một biến bảng để có đầu vào, việc tạo dữ liệu đầu vào và chèn này không được bao gồm trong số byte. Chỉ truy vấn thực tế để trích xuất dữ liệu.

Golfed (không bao gồm bảng thử nghiệm - có thể được tìm thấy trong phiên bản không được chỉnh sửa):

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)

Ung dung:

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

Dùng thử

JavaScript (ES6), 88 byte

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

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

Làm sao?

Mã này là:

• trích xuất tất cả các ma trận phụ trong mỗi ma trận đầu vào dưới dạng ghép các ô
• sắp xếp các ma trận phụ theo thứ tự từ điển
• kiểm tra xem kết quả có giống nhau cho cả hai ma trận đầu vào không

Đó là tận dụng các giới hạn được mô tả trong thử thách:

• Một ma trận bao gồm các chữ số đơn, vì vậy chúng ta chỉ có thể ghép tất cả các ô của một ma trận phụ mà không có bất kỳ dấu tách nào và vẫn có được một đại diện duy nhất của nó (ví dụ [[1,2],[3,4]]có thể được lưu trữ dưới dạng "1234").

• $100$$(x,y)$$I$

  $$I=\left\lfloor\frac{y}{n}\right\rfloor\times128+\left\lfloor\frac{x}{n}\right\rfloor$$

  hoặc dưới dạng mã JS: y / n << 7 | x << n

Đã bình luậ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)

Than , 54 49 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lấy đầu vào là một mảng của các mảng hai chiều có kích thước bằng nhau. Kết quả 1 thành công, không có gì thất bại. Giải trình:

1

Giả sử thành công.

Ｆθ

Vòng qua các mảng.

Ｆ⪪ιη

Chia mảng thành các nhàng có kích thước lớn.

Ｆ÷Ｌ§κ⁰η

Vòng qua từng khúc cột.

⊞υＥκ§⪪μηλ

Trích xuất đoạn mã cột cho mỗi hàng của đoạn mã hàng và lưu tệp con kết quả trong danh sách.

Ｗ∧υ⊟υ

Trong khi danh sách không trống, hãy xóa đoạn cuối của danh sách, trong trường hợp thông thường xuất phát từ mảng thứ hai.

¿№✂υ⁰⊘⊕Ｌυ¹ι

Đếm số lần xuất hiện của đoạn đó trong nửa đầu của danh sách, trong trường hợp bình thường có chứa các đoạn còn lại từ mảng đầu tiên.

≔Φυ⁻⌕υιλυ

Nếu khác không thì loại bỏ sự xuất hiện đầu tiên của đoạn đó khỏi danh sách.

⎚

Nếu bằng 0 thì xóa đầu ra, làm cho nó sai lệch.

J , 55 byte

[:-:/[([:/:~([*-@[)]\,@])"3(((;])@(#@]$1{.~[),;.1])&>])

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

Một giải pháp khủng khiếp, chỉ cần làm cho nó hoạt động - Tôi không có sức mạnh để chơi nó ...

Haskell, 74 73 byte

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

Lưu ý: TIO chưa được cài đặt Data.Lists , vì vậy tôi đang sử dụng Data.Listthay vào đó là thêm chức năng bị thiếu chunksOf: Dùng thử trực tuyến!

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  

C # (Trình biên dịch tương tác Visual C #) , 186 byte

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

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

-1 cảm ơn @KevinCruijssen!

Mã golf ít hơn:

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

PHP ,186 163 162 byte

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

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

Giống như tất cả các thử thách tốt, tôi bắt đầu nghĩ rằng điều này khá dễ dàng và nó đã ném cho tôi một số đường cong. Làm tốt lắm @Kevin Cruijssen!

Chuyển đổi ma trận thành các chuỗi chứa các giá trị cho mỗi khối. Mảng sau đó được sắp xếp và so sánh cho bình đẳng.

Ung dung:

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

Đầu ra

bool(false)

Màu đỏ , 148 147 142 byte

func[a b n][g: func[m][
sort collect[loop k:(length? m)/ n[i: 0
loop k[keep/only
collect[loop n[keep
take/part m/(i: i + 1) n]]]]]](g a)= g b]

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