Contribution:

• Un nombre entier n
• Deux matrices carrées de taille égale (avec leur largeur / hauteur étant un multiple de n)

Sortie:

L'une des deux valeurs distinctes de votre choix, l'une étant pour les résultats véridiques et l'autre pour les résultats falsey (donc oui, 1/0au lieu de des true/falsesorties valides pour des langages comme Java, même si elles ne sont pas considérées comme des valeurs véridiques / falsey officielles ).

La sortie truey / falsey indique si nous pouvons réorganiser les blocs de taille n by ndans une matrice pour la rendre égale à l'autre matrice.

Exemple:

Contribution:

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

Sortie: truthy

Pourquoi?

Si nous divisons les matrices en blocs de 2 by 2, nous pouvons voir que tous les blocs sur une matrice peuvent également être trouvés dans l'autre matrice:

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

Règles du défi:

• Vous pouvez supposer que les matrices ne contiendront que des chiffres non négatifs (plage [0,9])
• Vous pouvez supposer que la largeur / hauteur des matrices sont égales, et un multiple de n
• Vous pouvez supposer nqu'il sera dans la plage [1, 50]et que la largeur / hauteur des matrices sont dans la plage [1,100].
• Les blocs individuels de n by nne peuvent être utilisés qu'une seule fois pour déterminer si les matrices sont des permutations les unes des autres lorsqu'elles sont divisées en blocs de n by n.
• Il peut y avoir plusieurs n by nblocs identiques.
• Les n by nblocs resteront dans la même orientation lors de la vérification si les deux matrices sont permutations l'une de l'autre lorsqu'elles sont divisées en blocs de n by n.

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse avec des règles d'E / S par défaut , vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code (par exemple TIO ).
• De plus, l'ajout d'une explication à votre réponse est fortement recommandé.

Cas de test:

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 avec des matrices au [[,]]format.

Gelée ,  10  9 octets

ż⁹/ẎsṢʋ€E

Essayez-le en ligne! (ou avec prétraitement pour un copier-coller plus facile à partir des cas de test)

Un lien dyadique acceptant une liste de deux matrices (comme des listes de listes) sur la gauche et le nombre entier situé sur la droite qui produit 1ou 0pour truthy ou Falsey respectivement.

Comment?

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

-2 grâce à ngn.

Fonction infixe tacite anonyme. Prend ncomme argument de gauche et liste de deux matrices comme argument de droite. Nécessite une indexation nulle ( ⎕IO←0). Par ailleurs, cette fonction fonctionne sur des tableaux de n'importe quel nombre de dimensions.

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

Essayez-le en ligne!

≡.{… } Résultats identiques de la fonction suivante appliquée à chaque matrice ⍵avec nas ⍺?

 ≢⍵ taille de la matrice

 ⍳ indices 0… taille – 1

 ⍺| reste de la division lorsqu'il est divisé par n

 ⊂ enfermer pour utiliser dans toutes les dimensions

 ⍵⊂⍨ utiliser cela pour partitionner * la matrice en une matrice de sous-matrices
  ^{* commence une nouvelle partition lorsque l'élément correspondant est inférieur au précédent; supprime les éléments marqués par zéro}

 , défiler la matrice dans une liste de sous-matrices

 ∧ Trier par ordre croissant

Python 2 , 108 103 octets

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

Essayez-le en ligne!

Perl 6 , 94 68 63 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui accepte l'entrée size, [matrix1, matrix2]et renvoie un booléen True/False. Il pourrait y avoir un moyen plus efficace de diviser la matrice en morceaux que rotor.

Explication:

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

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

Essayez-le en ligne!

Java (JDK) , 221 octets

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

Essayez-le en ligne!

Explication

L'idée est de choisir chaque petite cellule sous forme de chaîne, ce qui est comparable, puis de trier ces chaînes et de les comparer dans l'ordre.

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

Crédits

• -12 octets grâce à Kevin Cruijssen!

Japt , 18 octets

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

Essayez-le en ligne!

Explication:

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

L'étape "Transformez-la en chaîne" est nécessaire car Japt ne compare pas les tableaux par valeur et la fonction intégrée à contourner ne fonctionne pas pour les tableaux multidimensionnels .

TSQL, 164 octets

Remplir une variable de table afin d'avoir une entrée, cette création d'entrée et l'insertion de données n'a pas été incluse dans le nombre d'octets. Seule la requête réelle pour extraire les données.

Golfé (hors table de test - on peut le trouver dans la version non golfée):

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)

Non golfé:

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

Essaye le

JavaScript (ES6), 88 octets

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

Essayez-le en ligne!

Comment?

Ce code est:

• extraire toutes les sous-matrices dans chaque matrice d'entrée comme une concaténation de cellules
• tri des sous-matrices par ordre lexicographique
• tester si le résultat est le même pour les deux matrices d'entrée

Il profite des limites décrites dans le challenge:

• Une matrice se compose de chiffres uniques, nous pouvons donc simplement concaténer toutes les cellules d'une sous-matrice sans séparateur et en obtenir une représentation unique (par exemple, elles [[1,2],[3,4]]peuvent être stockées sous "1234").

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

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

  ou comme code JS: y / n << 7 | x << n

Commenté

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

Fusain , 54 49 octets

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

Essayez-le en ligne!Le lien est vers la version détaillée du code. Prend l'entrée comme un tableau de tableaux bidimensionnels de taille égale. Sorties 1 en cas de succès, rien en cas d'échec. Explication:

1

Supposez le succès.

Ｆθ

Boucle sur les tableaux.

Ｆ⪪ιη

Divisez le tableau en n morceaux de ligne de taille.

Ｆ÷Ｌ§κ⁰η

Faites une boucle sur chaque bloc de colonne.

⊞υＥκ§⪪μηλ

Extrayez le bloc de colonne pour chaque ligne du bloc de ligne et enregistrez la sous-matrice résultante dans une liste.

Ｗ∧υ⊟υ

Bien que la liste ne soit pas vide, supprimez le dernier morceau de la liste, qui provient normalement du deuxième tableau.

¿№✂υ⁰⊘⊕Ｌυ¹ι

Comptez le nombre d'occurrences de ce bloc dans la première moitié de la liste, qui dans des circonstances normales contient les morceaux restants du premier tableau.

≔Φυ⁻⌕υιλυ

Si différent de zéro, supprimez la première occurrence de ce morceau de la liste.

⎚

Si zéro, effacez la sortie, ce qui la rend fausse.

J , 55 octets

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

Essayez-le en ligne!

Une solution horrible, je l'ai juste fait fonctionner - je n'ai pas le pouvoir de jouer au golf ...

Haskell, 74 73 octets

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

Remarque: TIO n'a pas été installé Data.Lists, j'utilise donc à la Data.Listplace une fonction manquante chunksOf: essayez-la en ligne!

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 # Interactive Compiler) , 186 octets

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

Essayez-le en ligne!

-1 merci à @KevinCruijssen!

Code moins golfé:

// 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 octets

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

Essayez-le en ligne!

Comme tous les bons défis, j'ai commencé par penser que c'était assez facile et cela m'a lancé quelques courbes. Bien joué @Kevin Cruijssen!

Coupe la matrice en chaînes contenant les valeurs de chaque bloc. Les tableaux sont ensuite triés et comparés pour l'égalité.

Non golfé:

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

Sortie

bool(false)

Rouge , 148 147 142 octets

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]

Essayez-le en ligne!