Di chuyển từ trò chuyện

Với số nguyên hai không trống không âm ma trận A và B , trả lời số lần Một xảy ra như một tiếp giáp, có thể chồng chéo, submatrix trong B .

Ví dụ / Quy tắc

0. Có thể không có bất kỳ mô hình con

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

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

Câu trả lời:
0

1. Submatrices phải được tiếp giáp

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

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

Trả lời:
1(đánh dấu đậm)

2. Submatrices có thể chồng lấp

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

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

Trả lời:
2(được đánh dấu in đậm và in nghiêng tương ứng)

3. Ma trận (phụ) có thể có kích thước 1-by-1 trở lên

A :
[[3]]

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

Trả lời:
3(đánh dấu đậm)

4. Ma trận có thể là bất kỳ hình dạng

A :
[[3,1,3]]

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

Trả lời:
4(hai chữ đậm, hai chữ nghiêng)

Brachylog (v2), 10 byte

{{s\s\}ᵈ}ᶜ

Hãy thử trực tuyến!

Tôi thích cách rõ ràng và đơn giản chương trình này trong Brachylog; thật không may, nó không phải là byte khôn ngoan vì cú pháp siêu hình chiếm ba byte và phải được sử dụng hai lần trong chương trình này.

Giải trình

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

Thạch , 7 byte

ZẆ$⁺€Ẏċ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

ZyYC2MX:=XAs

Đầu vào là A , sau đó B .

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Xem xét đầu vào [1,4; 3 1], [3,1,4,5; 6,3,1,4; 5,6,3,1]. Ngăn xếp được hiển thị với các yếu tố gần đây nhất dưới đây.

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 byte

øŒεøŒI.¢}O

Hãy thử trực tuyến!

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

APL Dyalog, 6 4 byte

≢∘⍸⍷

Đây là gần một nội dung (cảm ơn H.PWiz và ngn ).

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

Thay thế không xây dựng:

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

Hàm Dyadic lấy mảng lớn ở bên phải và subarray bên trái.

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

Hãy thử nó ở đây .

JavaScript (ES6), 93 byte

Đưa đầu vào là (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

Hãy thử trực tuyến!

R , 95 byte

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}

Hãy thử trực tuyến!

Sạch , 118 97 95 byte

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

Hãy thử trực tuyến!

Python 2 , 101 byte

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

Hãy thử trực tuyến!

Than , 36 27 byte

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

Hãy thử trực tuyến! Bây giờ ngắn hơn nhiều mà Equals hoạt động cho mảng một lần nữa. Giải trình:

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

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 

Hãy thử trực tuyến!

Khá đơn giản. Bước qua ma trận lớn hơn và kiểm tra xem ma trận nhỏ hơn có phù hợp không.

Bước duy nhất thậm chí hơi khó khăn là việc hiểu danh sách trong dòng thứ 6, dựa trên các quy ước của Python để trộn số học Boolean và số nguyên.

Groovy , 109 byte

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

Hãy thử trực tuyến!

Scala , 151 byte

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

Hãy thử trực tuyến!