Migrado desde el chat

Dado número entero dos no vacío no negativo matrices A y B , responder a la cantidad de veces que A se produce como contigua, posiblemente superpuestos, submatriz en B .

Ejemplos / Reglas

0. Puede que no haya submatrices

A :
[[3,1],
[1,4]]

B :
[[1,4],
[3,1]]

Responder:
0

1. Las submatrices deben ser contiguas

A :
[[1,4],
[3,1]]

B :
[[3,1,4,0,5],
[6,3,1,0,4],
[5,6,3,0,1]]

Respuesta:
1(marcado en negrita)

2. Las submatrices pueden superponerse

A :
[[1,4],
[3,1]]

B :
[[3,1,4,5],
[6,3,1,4],
[5,6,3,1]]

Respuesta:
2(marcado en negrita y cursiva respectivamente)

3. Una (sub) matriz puede ser de tamaño 1 por 1 y superior

A :
[[3]]

B :
[[3,1,4,5],
[6,3,1,4],
[5,6,3,1]]

Respuesta:
3(marcado en negrita)

4. Las matrices pueden tener cualquier forma.

A :
[[3,1,3]]

[[3,1,3,1,3,1,3,1,3]]

Respuesta:
4(dos en negrita, dos en cursiva)

Brachylog (v2), 10 bytes

{{s\s\}ᵈ}ᶜ

Pruébalo en línea!

Me gusta lo claro y directo que es este programa en Brachylog; desafortunadamente, no es tan corto en bytes porque la sintaxis metapredicada ocupa tres bytes y debe usarse dos veces en este programa.

Explicación

{{s\s\}ᵈ}ᶜ
  s         Contiguous subset of rows
   \s\      Contiguous subset of columns (i.e. transpose, subset rows, transpose)
 {    }ᵈ    The operation above transforms the first input to the second input
{       }ᶜ  Count the number of ways in which this is possible

Jalea , 7 bytes

ZẆ$⁺€Ẏċ

Pruébalo en línea!

Cómo funciona

ZẆ$⁺€Ẏċ  Main link. Arguments: B, A

  $      Combine the two links to the left into a monadic chain.
Z          Zip; transpose the matrix.
 Ẇ         Window; yield all contiguous subarrays of rows.
   ⁺     Duplicate the previous link chain.
    €    Map it over the result of applying it to B.
         This generates all contiguous submatrices of B, grouped by the selected
         columns of B.
     Ẏ   Tighten; dump all generated submatrices in a single array.
      ċ  Count the occurrences of A.

MATL , 12 bytes

ZyYC2MX:=XAs

Las entradas son A , entonces B .

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Considere insumos [1,4; 3 1], [3,1,4,5; 6,3,1,4; 5,6,3,1]. La pila se muestra con el elemento más reciente a continuación.

Zy    % Implicit input: A. Push size as a vector of two numbers
      % STACK: [2 2]
YC    % Implicit input: B. Arrange sliding blocks of specified size as columns,
      % in column-major order
      % STACK: [3 6 1 3 4 1;
                6 5 3 6 1 3;
                1 3 4 1 5 4;
                3 6 1 3 4 1]
2M    % Push input to second to last function again; that is, A
      % STACK: [3 6 1 3 4 1;
                6 5 3 6 1 3;
                1 3 4 1 5 4;
                3 6 1 3 4 1],
               [1 4;
                3 1]                    
X:    % Linearize to a column vector, in column-major order
      % STACK: [3 6 1 3 4 1;
                6 5 3 6 1 3;
                1 3 4 1 5 4;
                3 6 1 3 4 1],
               [1;
                3;
                4;
                1]  
=     % Test for equality, element-wise with broadcast
      % STACK: [0 0 1 0 0 1
                0 0 1 0 0 1;
                0 0 1 0 0 1;
                0 0 1 0 0 1]
XA    % True for columns containing all true values
      % STACK: [0 0 1 0 0 1]
s     % Sum. Implicit display
      % STACK: 2

05AB1E , 10 bytes

øŒεøŒI.¢}O

Pruébalo en línea!

øŒεøŒI.¢}O     Full program. Takes 2 matrices as input. First B, then A.
øŒ             For each column of B, take all its sublists.
  ε     }      And map a function through all those lists of sublists.
   øŒ          Transpose the list and again generate all its sublists.
               This essentially computes all sub-matrices of B.
     I.¢       In the current collection of sub-matrices, count the occurrences of A.
         O     At the end of the loop sum the results.

Dyalog APL, 6 4 bytes

≢∘⍸⍷

Esto es casi una construcción (gracias H.PWiz y ngn ).

  ⍷       Binary matrix containing locations of left argument in right argument
≢∘⍸       Size of the array of indices of 1s

Alternativa no incorporada:

{+/,((*⍺)≡⊢)⌺(⍴⍺)*⍵}

Función diádica que toma la gran matriz a la derecha y la submatriz a la izquierda.

                  *⍵       exp(⍵), to make ⍵ positive.
    ((*⍺)≡⊢)⌺(⍴⍺)        Stencil;
                            all subarrays of ⍵ (plus some partial subarrays
                            containing 0, which we can ignore)
               ⍴⍺             of same shape as ⍺
     (*⍺)≡⊢                   processed by checking whether they're equal to exp(⍺).
                           Result is a matrix of 0/1.
   ,                     Flatten
 +/                      Sum.

Pruébalo aquí .

JavaScript (ES6), 93 bytes

Toma entrada como (A)(B).

a=>b=>b.map((r,y)=>r.map((_,x)=>s+=!a.some((R,Y)=>R.some((v,X)=>v!=(b[y+Y]||0)[x+X]))),s=0)|s

Pruébalo en línea!

R , 95 bytes

function(A,B,x=dim(A),D=dim(B)-x){for(i in 0:D)for(j in 0:D[2])F=F+all(B[1:x+i,1:x[2]+j]==A);F}

Pruébalo en línea!

Limpio , 118 97 95 bytes

import StdEnv,Data.List
?x=[transpose y\\z<-tails x,y<-inits z]
$a b=sum[1\\x<- ?b,y<- ?x|y==a]

Pruébalo en línea!

Python 2 , 101 bytes

lambda a,b:sum(a==[l[j:j+len(a[0])]for l in b[i:i+len(a)]]for i,L in e(b)for j,_ in e(L))
e=enumerate

Pruébalo en línea!

Carbón , 36 27 bytes

ＩΣ⭆η⭆ι⁼θＥ✂ηκ⁺Ｌθκ¹✂νμ⁺Ｌ§θ⁰μ¹

Pruébalo en línea! Mucho más corto ahora que Equals funciona para matrices nuevamente. Explicación:

   η                        Input array B
  ⭆                         Mapped over rows and joined
     ι                      Current row
    ⭆                       Mapped over columns and joined
       θ                    Input array A
      ⁼                     Is equal to
          η                 Input array B
         ✂                  Sliced
                ¹           All elements from
           κ                Current row index to
             Ｌ              Length of
              θ             Input array A
            ⁺               Plus
               κ            Current row index
        Ｅ                   Mapped over rows
                  ν         Current inner row
                 ✂          Sliced
                          ¹ All elements from
                   μ        Current column index to
                     Ｌ      Length of
                       θ    Input array A
                      §     Indexed by
                        ⁰   Literal 0
                    ⁺       Plus
                         μ  Current column index
 Σ                          Digital sum
Ｉ                           Cast to string
                            Implicitly printed

Python 2 , 211 bytes

a,b=input()
l,w,L,W,c=len(a),len(a[0]),len(b),len(b[0]),0
for i in range(L):
 for j in range(W):
  if j<=W-w and i<=L-l:
   if not sum([a[x][y]!=b[i+x][j+y]for x in range(l)for y in range(w)]):
    c+=1
print c 

Pruébalo en línea!

Bastante sencillo. Pase a través de la matriz más grande y verifique si la matriz más pequeña puede caber.

El único paso, incluso un poco complicado, es la comprensión de la lista en la sexta línea, que se basa en las convenciones de Python para mezclar aritmética booleana y entera.

Groovy , 109 bytes

{a,b->(0..<b.size()).sum{i->(0..<b[i].size()).count{j->k=i-1
a.every{l=j;k++
it.every{(b[k]?:b)[l++]==it}}}}}

Pruébalo en línea!

Scala , 151 bytes

(a,b)=>{(0 to b.size-a.size).map(i=>(0 to b(0).size-a(0).size).count(j=>{var k=i-1
a.forall(c=>{var l=j-1;k+=1
c.forall(d=>{l+=1
b(k)(l)==d})})})).sum}

Pruébalo en línea!