Migration depuis le chat

Étant donné deux matrices entières non négatives non vides A et B , répondez au nombre de fois où A se présente comme une sous-matrice contiguë, éventuellement se chevauchant, dans B .

Exemples / règles

0. Il ne peut y avoir de sous-matrices

Un :
[[3,1],
[1,4]]

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

Répondre:
0

1. Les sous-matrices doivent être contiguës

Un :
[[1,4],
[3,1]]

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

Répondre:
1 (marqué en gras)

2. Les sous-matrices peuvent se chevaucher

Un :
[[1,4],
[3,1]]

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

Répondre:
2 (marqués respectivement en gras et en italique)

3. Une (sous) matrice peut être de taille 1 par 1 et plus

Un :
[[3]]

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

Répondre:
3 (marqué en gras)

4. Les matrices peuvent avoir n'importe quelle forme

Un :
[[3,1,3]]

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

Réponse:
4(deux gras, deux italiques)

Brachylog (v2), 10 octets

{{s\s\}ᵈ}ᶜ

Essayez-le en ligne!

J'aime la clarté et la simplicité de ce programme dans Brachylog; malheureusement, ce n'est pas si court octet parce que la syntaxe de métaprédicat prend trois octets et doit être utilisée deux fois dans ce programme.

Explication

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

Gelée , 7 octets

ZẆ$⁺€Ẏċ

Essayez-le en ligne!

Comment ça fonctionne

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 octets

ZyYC2MX:=XAs

Les entrées sont A , puis B .

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Tenez compte des entrées [1,4; 3 1], [3,1,4,5; 6,3,1,4; 5,6,3,1]. La pile est affichée avec l'élément le plus récent ci-dessous.

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 octets

øŒεøŒI.¢}O

Essayez-le en ligne!

øŒεøŒ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 octets

≢∘⍸⍷

C'est presque une fonction intégrée (merci H.PWiz et ngn ).

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

Alternative non intégrée:

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

Fonction dyadique qui prend le grand tableau à droite et le sous-tableau à gauche.

                  *⍵       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.

Essayez-le ici .

JavaScript (ES6), 93 octets

Prend l'entrée comme (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

Essayez-le en ligne!

R , 95 octets

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}

Essayez-le en ligne!

Nettoyer , 118 97 95 octets

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

Essayez-le en ligne!

Python 2 , 101 octets

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

Essayez-le en ligne!

Fusain , 36 27 octets

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

Essayez-le en ligne! Beaucoup plus court maintenant que Equals fonctionne à nouveau pour les tableaux. Explication:

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

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 

Essayez-le en ligne!

Assez simple. Parcourez la plus grande matrice et vérifiez si la plus petite matrice peut tenir.

La seule étape, même légèrement délicate, est la compréhension de la liste dans la 6ème ligne, qui s'appuie sur les conventions de Python pour mélanger l'arithmétique booléenne et entière.

Groovy , 109 octets

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

Essayez-le en ligne!

Scala , 151 octets

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

Essayez-le en ligne!