बताओ, कितने वर्ग हैं?

Question

गैर-रिक्त 2D सरणी को देखते हुए 0और 1, उन वर्गों की संख्या ज्ञात करें जिनके 4 कोने सभी हैं 1। वर्गों को "ईमानदार" होने की आवश्यकता नहीं है। सभी पंक्तियों की लंबाई समान होने की गारंटी है।

उचित इनपुट / आउटपुट विधियों की अनुमति है।

परीक्षण के मामलों:

0001000
1000000
0000000
0000100
0100000

यह लौटाता है 1।

10101
00000
10100
00000
10001

यह लौटाता है 2।

1111
1111
1111
1111

यह लौटाता है 20।

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब। मानक खामियां लागू होती हैं।

Comments

एक और व्याख्या, अगर मैं इरादे को समझ रहा हूं: 1एक वर्ग पर 4 एस, जैसे कि प्रत्येक 1अपने दो पड़ोसियों से परिधि के बराबर है।

— फर्सम'

@ Faersum हर वर्ग के लिए बाद की स्थिति सही है, है ना?

— वोजू

Answer 1

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

3 बाइट्स को अंडरस्कोर करने के लिए धन्यवाद

m=>(F=(x,y)=>m.map((r,Y)=>r.map((i,X)=>i?1/y?n+=x<X&y<=Y&(g=(a,b)=>(m[b+X-x]||0)[a-Y+y])(x,y)&g(X,Y):F(X,Y):0)))(n=0)|n

कैसे?

यह फ़ंक्शन इनपुट मैट्रिक्स m के सभी जोड़े कोशिकाओं (x, y) , (X, Y) पर पुन: प्रसारित करता है:

• एम [एक्स, वाई] = एम [एक्स, वाई] = १
• एक्स <एक्स
• य ≤ य

प्रत्येक मिलान जोड़ी एक वर्ग के संभावित किनारे के निर्देशांक का वर्णन करती है। असमानताओं की गारंटी है कि प्रत्येक किनारे का परीक्षण केवल एक बार किया जाता है।

हम वेक्टर का उपयोग करते हैं [dx, dy] = [X - x, Y - y] 90 ° दक्षिणावर्त घुमाएँ [x - डाई, y + dx] और [X-dy, Y + dx] पर स्थित कोशिकाओं का परीक्षण करने के लिए । यदि वे दोनों में 1 है , तो हमें एक वैध वर्ग मिला है।

परीक्षण के मामलों

let f =

m=>(F=(x,y)=>m.map((r,Y)=>r.map((i,X)=>i?1/y?n+=x<X&y<=Y&(g=(a,b)=>(m[b+X-x]||0)[a-Y+y])(x,y)&g(X,Y):F(X,Y):0)))(n=0)|n

console.log(f([
  [0,0,0,1,0,0,0],
  [1,0,0,0,0,0,0],
  [0,0,0,0,0,0,0],
  [0,0,0,0,1,0,0],
  [0,1,0,0,0,0,0]
]));

console.log(f([
  [1,0,1,0,1],
  [0,0,0,0,0],
  [1,0,1,0,0],
  [0,0,0,0,0],
  [1,0,0,0,1]
]));

console.log(f([
  [1,1,1,1],
  [1,1,1,1],
  [1,1,1,1],
  [1,1,1,1]
]));

Comments

-2 बाइट्स: g=(a,b)=>(m[b+X-x]||0)[a-Y+y]-1 बाइट: |n&&n

— अंडरस्कोर

Answer 2

MATL , 20 बाइट्स

&fJ*+4XN!"@&-|un3=vs

इनपुट एक मैट्रिक्स है।

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

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

यह इनपुट ग्रिड में नॉनज़ेरो प्रविष्टियों के सभी निर्देशांक पाता है, और उन्हें जटिल संख्याओं के रूप में दर्शाता है, जैसे कि पंक्ति और स्तंभ सूचकांक क्रमशः वास्तविक और काल्पनिक भागों के अनुरूप हैं।

कोड एक बार में 4 ले लिए गए इन नंबरों के सभी संयोजनों (ऑर्डर से कोई फर्क नहीं पड़ता) की एक सरणी उत्पन्न करता है। प्रत्येक संयोजन एक उम्मीदवार वर्ग का प्रतिनिधित्व करता है। प्रत्येक संयोजन के लिए, जोड़ी-वार पूर्ण अंतर के 4 × 4 मैट्रिक्स (जटिल विमान में दूरी) की गणना की जाती है। यह अपने मुख्य विकर्ण के साथ शून्य के साथ एक सममित मैट्रिक्स है। वर्तमान संयोजन एक वर्ग बनाता है यदि और केवल अगर मैट्रिक्स में 3 अलग-अलग मान हैं (ये वर्ग पक्ष, वर्ग विकर्ण और शून्य होगा):

दूसरी ओर, उदाहरण के लिए, एक गैर-वर्ग आयत 4 अलग-अलग मूल्यों (दो पक्षों, एक विकर्ण मान और शून्य) को जन्म देगा;

और एक सामान्य चतुर्भुज में 7 मान (चार पक्ष, दो विकर्ण और शून्य) हो सकते हैं:

&f      % Input (implicit). Push vectors of row and column indices of nonzero entries
J*      % Multiply by imaginary unit
+       % Add the two vectors. Gives a vector of complex coordinates
4XN     % Matrix of combinations of these complex numbers, taken 4 at a time. Each
        % row is a combination
!       % Transpose
"       % For each column
  @     %   Push current column: candidate set of four points
  &-    %   All pair-wise differences
  |     %   Absolute value
  u     %   Unique entries
  n3=   %   Does the number of elements equal 3? Gives true (1) or false (0)
  vs    %   Concatenate vertically with previous accumulated result, and sum
        % End (implicit). Display (implicit)

Comments

यह कैसे काम करता है?

— लीक नन

@LeakyNun स्पष्टीकरण में कहा गया है

— लुइस