입력:

• 정수 n
• 두 개의 동일한 크기의 정사각 행렬 (너비 / 높이는 배수 임 n)

산출:

자신의 선택의 두 가지 값, 하나 개 truthy 결과에 대한 존재 등 네 falsey 결과에 대해 하나 (하나 1/0대신 true/false자바와 같은 언어에 대한 올바른 출력에도 불구하고 있습니다 그들은 공식 truthy / falsey 값을 고려하지 않는 ).

진실 / 거짓 출력은 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

도전 규칙 :

• 행렬에 음이 아닌 숫자 만 포함한다고 가정 할 수 있습니다 (range [0,9])
• 행렬의 너비 / 높이가 같고 n
• n범위 안에 [1, 50]있고 행렬의 너비 / 높이는 범위 안에 있다고 가정 할 수 있습니다.[1,100] .
• 의 개별 블록은 블록으로 n by n분할 될 때 행렬이 서로의 순열인지를 결정하기 위해 한 번만 사용할 수 있습니다 n by n.
• n by n동일한 블록이 여러 개있을 수 있습니다 .
• 의 n by n블록으로 분할 될 때 두 행렬이 서로 순열인지 검사 할 때 블록은 동일한 방향으로 유지됩니다 n by n.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙 은 기본 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

[[,]]형식의 행렬이있는 Pastebin .

젤리 ,  10  9 바이트

ż⁹/ẎsṢʋ€E

온라인으로 사용해보십시오! (또는 전처리로 테스트 케이스에서보다 쉽게 ​​복사 및 붙여 넣기를위한 )

왼쪽의 두 행렬 (목록의 목록)과 오른쪽의 정수를 허용하는 2 차원 링크 1또는0 truthy 또는 각각 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?

APL (Dyalog Extended) , 19 18 17 바이트

ngn 덕분에 -2입니다.

익명의 암묵적 삽입 기능. 소요 n왼쪽 인자과 오른쪽 인수로 두 행렬의 목록으로. 제로 인덱싱 ( ⎕IO←0)이 필요합니다 . 또한이 함수는 여러 차원의 배열에서 작동합니다.

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

온라인으로 사용해보십시오!

≡.{… } 다음 함수의 동일한 결과는 ? ⍵와 함께 각 행렬에 적용 n됩니다 ⍺.

 ≢⍵ 매트릭스의 크기

 ⍳ 지수 0… 크기 –1

 ⍺| 나눈 나머지 나눗셈 n

 ⊂ 모든 치수와 함께 사용하도록 동봉

 ⍵⊂⍨ 이를 사용하여 행렬을 서브 행렬의 행렬로 분할 *하십시오.
  ^{해당하는 요소가 이전보다 작을 때 새 분할을 시작합니다. 0으로 표시된 요소를 제거합니다}

 , 행렬을 하위 행렬 목록으로 분류

 ∧ 오름차순으로 정렬

파이썬 2 , 108103 바이트

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

온라인으로 사용해보십시오!

펄 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 

05AB1E , 14 바이트

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

온라인으로 사용해보십시오!

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

크레딧

• Kevin Cruijssen 덕분에 -12 바이트!

apt , 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

"문자열로 변환"단계는 Japt 가 배열을 값으로 비교하지 않으며 ,이를 해결하기 위해 기본 제공되는 다차원 배열에서는 작동하지 않기 때문에 필요합니다 .

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)

언 골프 드 :

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

사용해보십시오

자바 스크립트 (ES6), 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=\left\lfloor\frac{y}{n}\right\rfloor\times128+\left\lfloor\frac{x}{n}\right\rfloor$$

  또는 JS 코드로 : 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)

숯 , 54 49 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 동일한 크기의 2 차원 배열로 입력을받습니다. 성공하면 1을 출력하고 실패하면 아무것도 출력하지 않습니다. 설명:

1

성공을 가정하십시오.

Ｆθ

배열을 반복합니다.

Ｆ⪪ιη

배열을 n크기가 지정된 행 청크 로 나눕니다 .

Ｆ÷Ｌ§κ⁰η

각 열 청크를 반복합니다.

⊞υＥκ§⪪μηλ

행 청크의 각 행에 대한 열 청크를 추출하고 결과 하위 행렬을 목록에 저장하십시오.

Ｗ∧υ⊟υ

목록이 비어 있지 않은 경우, 정상적인 상황에서는 두 번째 배열에서 오는 목록의 마지막 청크를 제거하십시오.

¿№✂υ⁰⊘⊕Ｌυ¹ι

목록의 전반부에서 해당 청크의 발생 횟수를 계산하십시오. 정상적인 상황에서는 첫 번째 배열의 나머지 청크가 포함됩니다.

≔Φυ⁻⌕υιλυ

0이 아닌 경우 해당 청크의 첫 번째 항목을 목록에서 제거하십시오.

⎚

0이면 출력을 지우고 허위로 만듭니다.

J , 55 바이트

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

온라인으로 사용해보십시오!

끔찍한 해결책으로 방금 작동했습니다. 골프를 칠 힘이 없습니다 ...

하스켈, 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  

C # (Visual C # 대화식 컴파일러) 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));}

온라인으로 사용해보십시오!

@KevinCruijssen에게 -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));
}

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

온라인으로 사용해보십시오!

모든 좋은 도전과 마찬가지로, 나는 이것이 매우 쉽다고 생각하고 커브를 던졌습니다. @Kevin Cruijssen 님 감사합니다!

행렬을 각 블록의 값을 포함하는 문자열로 청크합니다. 그런 다음 배열을 정렬하고 동일한 지 비교합니다.

언 골프 드 :

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)

레드 , 148 147 142 바이트

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]

온라인으로 사용해보십시오!