Questa è la generalizzazione bidimensionale di questa sfida .

Per i nostri scopi, una matrice (o matrice 2D) A è considerata una sottomatrice di un'altra matrice B , se A può essere ottenuto rimuovendo completamente un numero di righe e colonne da B . (Nota: alcune fonti hanno definizioni diverse / più restrittive.)

Ecco un esempio:

A = [1 4      B = [1 2 3 4 5 6
     2 1]          6 5 4 3 2 1
                   2 1 2 1 2 1
                   9 1 8 2 7 6]

Possiamo eliminare le colonne 2, 3, 5, 6 e le righe 2, 4 da B per ottenere A :

B = [1 2 3 4 5 6         [1 _ _ 4 _ _         [1 4  = A
     6 5 4 3 2 1   -->    _ _ _ _ _ _   -->    2 1]
     2 1 2 1 2 1          2 _ _ 1 _ _
     9 1 8 2 7 6]         _ _ _ _ _ _]

Si noti che A è ancora una sottotrix di B se vengono mantenute tutte le righe o tutte le colonne di B (o di fatto se A = B ).

La sfida

Hai indovinato. Dato intero due non vuoto matrici A e B , determinare se A è una sottomatrice di B .

È possibile scrivere un programma o una funzione, prendendo l'input tramite STDIN (o l'alternativa più vicina), l'argomento della riga di comando o l'argomento della funzione e producendo il risultato tramite STDOUT (o l'alternativa più vicina), il valore di ritorno della funzione o il parametro della funzione (out).

L'input può essere in qualsiasi formato conveniente. Le matrici possono essere fornite come liste nidificate, stringhe che utilizzano due diversi separatori, liste piatte insieme alle dimensioni della matrice, ecc., Purché l'input non sia preelaborato. Puoi scegliere di prendere B prima e A secondo, purché la tua scelta sia coerente. Puoi presumere che gli elementi delle matrici siano positivi e meno di 256.

L'output dovrebbe essere veritiero se A è una sottostruttura di B e falsare diversamente. Il valore di output specifico non deve essere coerente.

Si applicano le regole standard del code-golf .

Casi test

Ogni test è su una linea separata, A, B.

Casi veri:

[[1]], [[1]]
[[149, 221]], [[177, 149, 44, 221]]
[[1, 1, 2], [1, 2, 2]], [[1, 1, 1, 2, 2, 2], [3, 1, 3, 2, 3, 2], [1, 1, 2, 2, 2, 2]]
[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 2, 3], [4, 7, 6], [7, 8, 9], [1, 2, 3], [4, 5, 6], [7, 8, 9]]
[[228, 66], [58, 228]], [[228, 66], [58, 228]]
[[1, 2], [2, 1]], [[1, 2, 2], [2, 1, 2], [2, 2, 1]]
[[136, 196], [252, 136]], [[136, 252, 210, 196, 79, 222], [222, 79, 196, 210, 252, 136], [252, 136, 252, 136, 252, 136], [180, 136, 56, 252, 158, 222]]

Casi di falsi:

[[1]], [[2]]
[[224, 15]], [[144, 15, 12, 224]]
[[41], [150]], [[20, 41, 197, 150]]
[[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[1, 2, 3], [7, 8, 9], [4, 5, 6]]
[[1, 2, 2], [2, 1, 2], [2, 2, 1]], [[1, 2], [2, 1]]
[[1, 2, 2], [2, 1, 2]], [[1, 2], [2, 1], [2, 2]]
[[1, 2], [3, 4]], [[5, 3, 4, 5], [2, 5, 5, 1], [4, 5, 5, 3], [5, 1, 2, 5]]
[[158, 112], [211, 211]], [[158, 211, 189, 112, 73, 8], [8, 73, 112, 189, 211, 158], [211, 158, 211, 158, 211, 158], [21, 158, 199, 211, 212, 8]]

Pyth, 10 byte

}CQsyMCMyE

Suite di test

Questo è abbastanza semplice. Innanzitutto, consideriamo B come un elenco di righe e utilizziamo tutti i sottoinsiemi yE. Quindi, ognuna di quelle matrici viene trasposta con CM, e tutti i sottoinsiemi vengono presi delle loro file, con yM. Concatenando queste liste secondarie si sottengono tutte le possibili sottomesse trasposte. Quindi trasponiamo A con CQe controlliamo se è presente con }.

Dyalog APL, 53 43 byte

(⊂A)∊⊃∘.{∧/∊2</¨⍺⍵:B[⍺;⍵]⋄⍬}/⍳¨(⍴A←⎕)/¨⍴B←⎕

B←⎕, A←⎕richiedere Be A
⍴B, ⍴Adimensioni Be A
/¨replicare ciascuno, ad es. 2 3/¨4 5→ (4 4) (5 5 5)
⍳¨tutti gli indici in ciascuno dei sistemi di coordinate con quelle dimensioni
∘.{... }/tabella delle possibili matrici secondarie, in cui ogni matrici è definita come il risultato della funzione anonima {... }applicata tra una coppia di coordinate ⍺e ⍵
∧/∊2</¨:se entrambi ⍺e ⍵sono ( ∧/∊) entrambi ( ¨) crescente ( 2</), quindi ...
B[⍺;⍵]restituisce la matrice secondaria Bcreata dalle intersezioni di righe ⍺e colonne ⍵
⋄⍬, restituisce un vettore vuoto (qualcosa a cui A non è identico)
(⊂A)∊⊃controlla se l'intero di A(⊂A) è membro di ∊una delle matrici ( ⊃)

Vecchia soluzione a 53 byte:

{(⊂⍺)∊v∘.⌿h/¨⊂⍵⊣v h←(⍴⍺){↓⍉⍺{⍵/⍨⍺=+⌿⍵}(⍵/2)⊤⍳⍵*2}¨⍴⍵}

{... }una funzione in linea anonima, dove ⍺è l'argomento sinistro ed ⍵è la
⍴forma dell'argomento giusto , ad es. 2 3 per una matrice 2 per 3
(⍴⍺){... }¨⍴⍵per ogni coppia di corrispondenti lunghezze di dimensione, applica questo
⍳⍵*2indice di funzione anonima del quadrato di, cioè 2 → 1 2 3 4
(⍵/2)⊤convertire in binario (numero di bit è dimensione di lunghezza al quadrato)
{⍵/⍨⍺=+⌿⍵}della tabella binario, selezionare le colonne ( ⍵/⍨) in cui il numero di 1s ( +⌿⍵) è uguale alla lunghezza di tale dimensione nel potenziale sottomatrice ( ⍺=)
↓⍉make la tabella nell'elenco delle colonne viene
v h←archiviata come v(maschere ertiche) e h(maschere orizzontali)
⊣quindi
h/¨⊂⍵applica ciascuna maschera orizzontale alla matrice argomento corretta
v∘.⌿applica ciascuna maschera verticale ciascuna delle versioni mascherate orizzontalmente della matrice grande
(⊂⍺)∊controlla se la matrice argomento sinistra è membro di essa

Gelatina, 12 10 byte

Grazie @Dennis per -2 byte

ZŒP
ÇÇ€;/i

Quasi lo stesso algoritmo di @isaacg, tranne per il fatto che trasponiamo la matrice prima di prendere sottoinsiemi.

ZŒP      Helper link. Input: z
Z          Transpose z
ZŒP        All subsets of columns of z.

ÇÇ€;/i   Main link. Input: B, A. B is a list of rows.
Ç          Call the helper link on B. This is the subsequences of columns of A.
 ǀ        Call the helper link on each column-subsequence.
           Now we have a list of lists of submatrices of B.
   ;/      Flatten that once. The list of submatrices of B.
     i     then get the 1-based index of A in that list.
           If A is not in the list, returns 0.

Provalo qui .

Mathematica, 40 65 byte

!FreeQ[s[# ]&/@(s=Subsets)@#2,# ]&

Spiegazione: vedi una delle altre risposte - sembra che abbiano fatto tutti la stessa cosa.

Brachylog , 4 byte

⊇z⊇z

Provalo online!

Porta la matrice B attraverso la variabile di input e la matrice A attraverso la variabile di output e genera in caso di esito positivo o negativo. Questa è praticamente solo la soluzione Pyth, tranne che l'input è più implicito e non c'è generazione esplicita o controllo dell'appartenenza per i powerset.

        B
⊇       has a sublist
 z      which transposed
  ⊇     has a sublist
   z    which transposed
        is A.

Haskell, 66 byte

import Data.List
t=transpose
s=subsequences
(.((s.t=<<).s)).elem.t

Esempio di utilizzo: ( (.((s.t=<<).s)).elem.t ) [[149, 221]] [[177, 149, 44, 221]]-> True.

Una versione non pointfree è

f a b = elem(transpose a) $ (subsequences.transpose=<<) $ subsequences b

                      subsequences b     -- make all subsequences of b, i.e. all 
                                         -- all combinations of rows removed
     (subsequences.transpose=<<)         -- transpose each such sub-matrix and
                                         -- remove rows again. Concatenate into a
                                         -- single list
elem(transpose a)                        -- check if the transposition of a is in
                                         -- the list

Python + NumPy, 176 173 byte

from itertools import*
from numpy import*
def f(A,B):
 r,c=A.shape
 R,C=B.shape
 S=combinations
 print any([all(B[ix_(i,j)]==A)for i in S(range(R),r)for j in S(range(C),c)])