सन्निहित उपमाओं की गणना करें

Question

चैट से चले गए

दो गैर खाली गैर नकारात्मक पूर्णांक matrices को देखते हुए एक और बी , समय की संख्या का जवाब एक एक के रूप में होता सन्निहित है, संभवतः ओवरलैपिंग, submatrix में बी ।

उदाहरण / नियम

0. कोई उपमा नहीं हो सकती है

ए :
[[3,1],
[1,4]]

बी :
[[1,4],
[3,1]]

उत्तर:
0

1. उपमाएँ सन्निहित होनी चाहिए

ए :
[[1,4],
[3,1]]

बी :
[[3,1,4,0,5],
[6,3,1,0,4],
[5,6,3,0,1]]

उत्तर:
1(बोल्ड में चिह्नित)

2. उपमाएँ ओवरलैप हो सकती हैं

ए :
[[1,4],
[3,1]]

बी :
[[3,1,4,5],
[6,3,1,4],
[5,6,3,1]]

उत्तर:
2(क्रमशः बोल्ड और इटैलिक में चिह्नित)

3. A (सब) मैट्रिक्स का आकार 1-बाय -1 और ऊपर हो सकता है

ए :
[[3]]

बी :
[[3,1,4,5],
[6,3,1,4],
[5,6,3,1]]

उत्तर:
3(बोल्ड में चिह्नित)

4. मैट्रिस किसी भी आकार का हो सकता है

ए :
[[3,1,3]]

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

उत्तर:
4(दो बोल्ड, दो इटैलिक)

Answer 1

ब्रेकीलॉग (v2), 10 बाइट्स

{{s\s\}ᵈ}ᶜ

इसे ऑनलाइन आज़माएं!

मुझे यह पसंद है कि यह कार्यक्रम ब्रेजलॉग में कितना स्पष्ट और सीधा है; दुर्भाग्य से, यह छोटा बाइट-वार नहीं है क्योंकि मेटाट्रेडिकेट सिंटैक्स में तीन बाइट्स होते हैं और इस कार्यक्रम में दो बार उपयोग किया जाना है।

व्याख्या

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

Answer 2

जेली , 7 बाइट्स

ZẆ$⁺€Ẏċ

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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.

Answer 3

MATL , 12 बाइट्स

ZyYC2MX:=XAs

इनपुट्स ए हैं , फिर बी ।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

आदानों पर विचार करें [1,4; 3 1], [3,1,4,5; 6,3,1,4; 5,6,3,1]। ढेर को सबसे हाल के तत्व के साथ दिखाया गया है।

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

Answer 4

05AB1E , 10 बाइट्स

øŒεøŒI.¢}O

इसे ऑनलाइन आज़माएं!

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

Answer 5

Dyalog एपीएल, 6 4 बाइट्स

≢∘⍸⍷

यह लगभग एक बिलियन है (धन्यवाद H.PWiz और ngn )।

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

वैकल्पिक गैर-बिलिन:

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

डायैडिक फ़ंक्शन जो दाईं ओर बड़ा सरणी लेता है और बाईं ओर सबर्रे।

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

इसे यहाँ आज़माएँ ।

Comments

आपको चेकआउट करना चाहिए⍷

— H.PWiz

आप ∘ट्रेन को छोटा करने के लिए +/∘∊⍷≢∘⍸⍷

— कंपोज़

Answer 6

जावास्क्रिप्ट (ईएस 6), 93 बाइट्स

के रूप में इनपुट लेता है (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

इसे ऑनलाइन आज़माएं!

Answer 7

आर , 95 बाइट्स

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}

इसे ऑनलाइन आज़माएं!

Answer 8

क्लीन , 118 97 95 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 9

पायथन 2 , 101 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 10

चारकोल , 36 27 बाइट्स

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

इसे ऑनलाइन आज़माएं! अभी बहुत कम है कि समान फिर से सरणियों के लिए काम करता है। स्पष्टीकरण:

   η                        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

Answer 11

पायथन 2 , 211 बाइट्स

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 

इसे ऑनलाइन आज़माएं!

काफी सरल। बड़े मैट्रिक्स के माध्यम से कदम रखें, और जांच करें कि क्या छोटा मैट्रिक्स फिट हो सकता है।

केवल थोड़ा मुश्किल कदम भी 6 वीं पंक्ति में सूची की समझ है, जो बूलियन और पूर्णांक अंकगणित को मिलाने के लिए पायथन के सम्मेलनों पर निर्भर करता है।

Answer 12

ग्रूवी , 109 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 13

स्काला , 151 बाइट्स

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

इसे ऑनलाइन आज़माएं!