मैट्रिक्स में 1 और 0 के द्वीपों को खोजने के लिए

Question

0 और 1s के दो आयामी मैट्रिक्स को देखते हुए। 1s और 0s के लिए द्वीप की संख्या ज्ञात करें जहां पड़ोसी केवल क्षैतिज और ऊर्ध्वाधर में हैं।

Given input:

1 1 1 0
1 1 1 0

output = 1 1
Number of 1s island = 1

xxx-
xxx-

Number of 0s island = 1 

---x
---x

------------------------------

Given input:

0 0 0 0
1 1 1 1
0 0 0 0
1 1 1 1

output = 2 2
Number of 1s island = 2

----
xxxx  <-- an island of 1s
----
xxxx  <-- another island of 1s

Number of 0s island = 2

xxxx  <-- an island
----
xxxx  <-- another island
----

------------------------------

Given input:

1 0 0
0 0 0
0 0 1
output = 2 1
Number for 1's island = 2:

x--  <-- an island of 1s
---
--x  <-- an island of 1s

Number of 0's island = 1:

-xx  \
xxx   > 1 big island of 0s
xx-  / 


------------------------------

Given input:

1 1 0
1 0 0
output = 1 1
Number for 1's island =1 and number of 0's island = 1

------------------------------

Given input:

1 1
1 1
output = 1 0
Number for 1's island =1 and number of 0's island = 0

Comments

आपको [[1,0];[0,1]]यह सुनिश्चित करने के लिए एक

— टेस्टकेस

मेरा सुझाव है कि जब तक आदेश निर्दिष्ट किया जाता है तब तक आउटपुट किसी भी क्रम में हो सकता है - यह किसी आदेश को लागू करने के लिए कोई मूल्य नहीं जोड़ता है

— स्ट्रीट

साइट पर आपका स्वागत है!

— अरनुलद

टिप्पणियों में जो जवाब दिया गया था, उसे चुनौती के शरीर में स्पष्ट किया जाना चाहिए। और अधिक विशेष रूप से, यदि आप वास्तव में चाहते हैं कि हम 0 से पहले 1 लौटा दें, तो यह स्पष्ट रूप से कहा जाना चाहिए।

— अरनुलद

सुझाया गया परीक्षण मामला: 11111 / 10001 / 10101 / 10001 / 11111→2 1

— केविन क्रूज़सेन

Answer 1

एपीएल (डायलॉग यूनिकोड) , 29 28 बाइट्स ^{एसबीसीएस}

-1 @ Adám को धन्यवाद

{≢∪∨.∧⍨⍣≡2>+/↑|∘.-⍨⍸⍵}¨⊂,~∘⊂

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

⊂,~∘⊂ मैट्रिक्स और इसकी उपेक्षा

{ }¨ उनमें से प्रत्येक के लिए करते हैं

⍸⍵ 1s के कोर्ड्स के जोड़े की सूची

+/↑|∘.-⍨ मैनहट्टन दूरियों का मैट्रिक्स

2> पड़ोसी मैट्रिक्स

∨.∧⍨⍣≡ सकर्मक बंद

≢∪ अद्वितीय पंक्तियों की संख्या

Comments

यह वास्तव में चालाक है। क्या आप इस बारे में विस्तार से बता सकते हैं कि अंतिम पंक्ति को काम करने की गारंटी क्यों दी गई है - अर्थात, अद्वितीय पंक्तियाँ उत्तर के बराबर क्यों हैं। भी, "सकर्मक बंद" जे की तरह है ^:_?

— योना

@ जोना चैट

— ngn

Answer 2

जे , 57 बाइट्स

,&([:(0#@-.~~.@,)](*@[*[:>./((,-)#:i.3)|.!.0])^:_ i.@$)-.

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

यह उन लोगों में से एक है, जहां विचार अविश्वसनीय रूप से सरल है (और मुझे लगता है कि मज़ेदार है), लेकिन इसे निष्पादित करने में कुछ यांत्रिक लंबाई थी, जो सादगी को मुखौटा बनाती है ... उदाहरण के लिए, मूल मैट्रिक्स को सभी दिशाओं में 0 भरने के साथ स्थानांतरित करना क्रिया है ((,-)#:i.3) |.!.0।

यह संभावना है कि इस यांत्रिक लंबाई को और आगे बढ़ाया जा सकता है, और मैं कल शाम की कोशिश कर सकता हूं, लेकिन मैं अब इसके क्रू को पोस्ट करूंगा।

कहें हमारा इनपुट है:

0 0 0 0
1 1 1 1
0 0 0 0
1 1 1 1

हम एक ही आकार के अनूठे पूर्णांक के मैट्रिक्स से शुरू करते हैं:

 0  1  2  3
 4  5  6  7
 8  9 10 11
12 13 14 15

फिर प्रत्येक कोशिका के लिए हम उसके सभी पड़ोसियों की अधिकतम खोज करते हैं, और इनपुट मास्क द्वारा गुणा करते हैं:

 0  0  0  0
 8  9 10 11
 0  0  0  0
13 14 15 15

हम इस प्रक्रिया को तब तक दोहराते हैं जब तक कि मैट्रिक्स बदलना बंद न हो जाए:

 0  0  0  0
11 11 11 11
 0  0  0  0
15 15 15 15

और फिर अद्वितीय, गैर-शून्य तत्वों की संख्या की गणना करें। यह हमें 1-द्वीपों की संख्या बताता है।

हम 0-द्वीपों की संख्या प्राप्त करने के लिए "1 ऋण इनपुट" के समान प्रक्रिया लागू करते हैं।

Comments

यह एक "बाढ़-भरण" तंत्र की तरह दिखता है, वास्तव में साफ-सुथरा।

— मैथ्यू एम।

Answer 3

जावास्क्रिप्ट (ईएस 7),  138 ... 107  106 बाइट्स

एक सरणी देता है [ones, zeros]।

f=(m,X,Y,V=.5,c=[0,0])=>m.map((r,y)=>r.map((v,x)=>V-v|(x-X)**2+(y-Y)**2>1||f(m,x,y,v,r[c[v^1]++,x]=2)))&&c

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

कैसे?

$0$$1$$c[0]$$c[1]$$2$

बाइट्स को बचाने के लिए, रूट पुनरावृत्ति और पुनरावर्ती पुनरावृत्तियों दोनों के लिए सटीक समान कोड का उपयोग किया जाता है, लेकिन यह थोड़ा अलग व्यवहार करता है।

पहली यात्रा के दौरान:

• $V=0.5$$V-v$$0$$v=0$$v=1$
• $X$$Y$$(x-X)^2+(y-Y)^2$$(x,y)$

पुनरावर्ती पुनरावृत्तियों के दौरान:

• $c$$2$c[v ^ 1]++$c$

टिप्पणी की गई

f = (                 // f is a recursive function taking:
  m,                  //   m[]  = input binary matrix
  X, Y,               //   X, Y = coordinates of the previous cell, initially undefined
  V = .5,             //   V    = value of the previous cell, initially set to 0.5
                      //          so that the integer part of V - v is 0 for v = 0 or 1
  c = [0, 0]          //   c[]  = array of counters of 1's and 0's islands
) =>                  //          (or an integer when called recursively)
  m.map((r, y) =>     // for each row r[] at position y in m[]:
    r.map((v, x) =>   //   for each value v at position x in r[]:
      V - v |         //     abort if |V - v| ≥ 1
      (x - X) ** 2 +  //     or X and Y are defined and the quadrance between
      (y - Y) ** 2    //     (X, Y) and (x, y)
      > 1 ||          //     is greater than 1
      f(              //     otherwise, do a recursive call to f:
        m,            //       leave m[] unchanged
        x, y,         //       pass the new coordinates
        v,            //       pass the new reference value
        r[c[v ^ 1]++, //       increment c[v ^ 1] (ineffective if c is an integer)
          x           //       and set the current cell ...
        ] = 2         //       ... to 2
      )               //     end of recursive call
    )                 //   end of inner map()
  ) && c              // end of outer map(); return c

Comments

स्टैक ओवरफ्लो के कारण सिर्फ 1s या 0s के साथ यह कोड 100 * 100 जैसे बड़े मैट्रीक के लिए काम नहीं करता है।

— केबी आनंद

@KBjoy जब तक स्पष्ट रूप से चुनौती में अन्यथा स्पष्ट रूप से निर्दिष्ट नहीं किया गया है, हमारा डिफ़ॉल्ट नियम यह है कि हम कार्यान्वयन सीमाओं के बारे में परवाह नहीं करते हैं जब तक कि किसी भी इनपुट के लिए सिद्धांत में अंतर्निहित एल्गोरिथ्म काम नहीं करता है। ( यहां एक मेटा पोस्ट के बारे में बताया गया है, लेकिन शायद कहीं अधिक प्रासंगिक है।)

— अरनौल

Answer 4

MATL , 14 12 बाइट्स

,G@-K&1ZIugs

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

व्याख्या

,        % Do twice
  G      %   Push input
  @      %   Push iteration index: first 0, then 1
  -      %   Subtract. This converts 0 and 1 into -1 and 0 in the second iteration 
  K      %   Push 4
  &1ZI   %   Label connected components of matrix using 4-connectedness. Zeros in the
         %   matrix are background. This replaces the nonzeros by 1, 2, 3, ..., where 
         %   each number defines a connected component
  u      %   Unique values. This gives [0; 1; 2; ..., L], where L is the number of
         %   connected components.
  g      %   Convert nonzeros to 1
  s      %   Sum. This gives L, to be output
         % End (implicit).
         % Display stack (implicit)

Answer 5

K (ngn / k) , 60 55 51 50 46 बाइट्स

{#?{|/'x*\:x}/2>+/x*x:x-\:'x:(0,#*x)\&,/x}'~:\

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

~:\ इनपुट और उसकी उपेक्षा की एक जोड़ी (शाब्दिक: नकारात्मक पुनरावृति-अभिसरण)

{ }' प्रत्येक के लिए

,/x आर्गन को समतल करें

&1s कहाँ हैं? - सूचकांकों की सूची

(0,#*x)\ ym और xs के लिए दो अलग-अलग सूचियाँ प्राप्त करने के लिए divmod चौड़ाई (इनपुट)

x-\:'x: प्रति-अक्ष दूरी andx और ∆y

x*x: उन्हें चौकोर करें

+/ x∆ और ²y² जोड़ें

2> पड़ोसी मैट्रिक्स

{|/'x*\:x}/ सकर्मक बंद

#? अद्वितीय पंक्तियों को गिनें

Comments

आपके जवाब को देखने के बाद मुझे खुशी है कि मैंने के :) में इस से निपटने की कोशिश नहीं की

— स्ट्रीटस्टर

@streetster हाहा, धन्यवाद! यह वह प्रभाव नहीं है जिसका मैं इरादा करता हूं :) मैं वास्तव में लोगों को (k की और किसी भी बोली) को जानने के लिए प्रोत्साहित करना चाहूंगा

— ngn

Answer 6

वोल्फ्राम भाषा (गणितज्ञ) , 64 62 बाइट्स

Max@MorphologicalComponents[#,CornerNeighbors->1<0]&/@{#,1-#}&

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

एटीनट के लिए धन्यवाद : हम दो बाइट के 1<0बजाय लिख सकते हैं Falseऔर बचा सकते हैं ।

बिना गोल्फ वाला संस्करण:

F[M_] := {Max[MorphologicalComponents[M,   CornerNeighbors -> False]], 
          Max[MorphologicalComponents[1-M, CornerNeighbors -> False]]}

बेशक, एक मैथेमेटिका बिल्डिन है MorphologicalComponentsजो एक सरणी (या एक छवि) लेता है और द्वीप सूचकांक द्वारा प्रतिस्थापित प्रत्येक रूपात्मक रूप से जुड़े द्वीप के पिक्सल के साथ समान देता है। Maxइस परिणाम को लेने से द्वीपों की संख्या मिलती है (पृष्ठभूमि शून्य शून्य पर छोड़ दी जाती है, और द्वीप सूचकांक 1 से शुरू होता है)। हमें इसे सरणी के लिए अलग से करने की आवश्यकता है (1-द्वीपों की संख्या देते हुए) और एक शून्य से सरणी (0-द्वीपों की संख्या देते हुए)। यह सुनिश्चित करने के लिए कि विकर्ण पड़ोसी पड़ोसी के रूप में गिनती नहीं करते हैं, विकल्प देने की CornerNeighbors->Falseआवश्यकता है।

Comments

-2 बाइट्स के बाद से असमानताओं की तुलना में अधिक पूर्वता हैRule

— एटीनैट

Answer 7

पायथन 3, 144 127 बाइट्स

इस समाधान में cv2भयानक छवि प्रसंस्करण शक्ति का उपयोग किया गया है। सीवी के कम भयानक, सुपर लंबे और पठनीय विधि के नामों के बावजूद, यह दोनों पायथन के जवाबों को हरा देता है!

golfed:

import cv2,numpy as n
f=lambda b:n.amax(cv2.connectedComponents(b*255,0,4)[1])
def g(a):b=n.array(a,n.uint8);print(f(1-b),f(b))

विस्तारित:

import cv2
import numpy as np

# Finds the number of connected 1 regions 
def get_components(binary_map):
    _, labels = cv2.connectedComponents(binary_map*255, connectivity=4) # default connectivity is 8
    # labels is a 2d array of the binary map but with 0, 1, 2, etc. marking the connected regions
    components = np.amax(labels)
    return components

# Takes a 2d array of 0s and 1s and returns the number of connected regions
def solve(array): 
    binary_map = np.array(input_map, dtype=np.uint8)
    black_regions = get_components(1 - binary_map) # 0s
    white_regions = get_components(binary_map) # 1s
    return (black_regions, white_regions)

Comments

मैं पायथन से बहुत परिचित नहीं हूं, लेकिन आपको स्पष्ट तर्क नामों की आवश्यकता क्यों है? बस नहीं है 4के बजाय connectivity=4और n.uint8के बजाय dtype=n.uint8संभव?

— केविन क्रूजेसेन

यदि आप वैकल्पिक तर्क छोड़ते हैं तो @KevinCruijssen, आपको तर्क नामों की आवश्यकता है। डॉक्स पर एक नज़र डालते हुए, मुझे वास्तव में स्किप करने की ज़रूरत नहीं है, जो मुझे बहुत सारे बाइट्स बचाता है। धन्यवाद!

— डैनियल

आह ठीक है, मैंने सोचा कि यह कुछ ऐसा ही था, लेकिन जब मैंने केवल डॉक्स को देखा तो मैं केवल एक ही cv2.connectedComponentsतरीका खोज सकता था, इसलिए मैं उलझन में था और सोचा कि तर्क नामों की आवश्यकता के लिए एक अलग कारण हो सकता है। जैसा कि मैंने कहा, मैं पायथन से बहुत परिचित नहीं हूँ। मैंने इससे जो कुछ सीखा है, वह यहां से CCGC पर है। ;) लेकिन यह अन्य वैकल्पिक तर्कों को छोड़ने के लिए चर नामों का उपयोग करने के लिए समझ में आता है।

— केविन क्रूज़सेन

बहुत अच्छा! मुझे एक ऑनलाइन कंपाइलर मिला जिसमें यहाँ cv2 मॉड्यूल शामिल है ।

— १२:४५ पर जितसे

Answer 8

जे , ४६ ४४ ४३ बाइट्स

-1 बाइट के लिए @ मीलों धन्यवाद

,&#&~.&([:+./ .*~^:_:2>1#.[:|@-"1/~4$.$.)-.

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

परीक्षण और ,& -.रैपर @ जोनाह के जवाब से चुराया गया

,& -. इनपुट और इसकी उपेक्षा के लिए:

4$.$. (y, x) 1s का निर्देशांक n × 2 मैट्रिक्स के रूप में है

1#.[:|@-"1/~ मैनहट्टन दूरी: abs (∆x) + abs (absy)

2> पड़ोसी मैट्रिक्स

[:+./ .*~^:_: सकर्मक बंद

#&~.&( ) अद्वितीय पंक्तियों की संख्या

Comments

आप एक और बाइट को बचाने के लिए लंबाई और अद्वितीय की रचना कर सकते हैं, यानी ,&#&~.टोपी से बचने के लिए[:

— मील

@ मीलों शुक्रिया

— ngn

Answer 9

रेटिना 0.8.2 , 155 बाइट्स

s`1(.*)
;$1a
}+`(?<=(.)*)(1|;)(.*¶(?<-1>.)*(?(1)$))?(?!\2)[1;]
;$3;
s`0(.*)
:$1b
}+`(?<=(.)*)(0|:)(.*¶(?<-1>.)*(?(1)$))?(?!\2)[0:]
:$3:
\W+(a*)(b*)
$.1 $.2

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण का मामला भी शामिल है। स्पष्टीकरण:

s`1(.*)
;$1a

यदि कोई है 1, तो इसे इनपुट के अंत में बदल दें ;और एपेंड करें aताकि यह रास्ते से बाहर हो जाए।

}+`(?<=(.)*)(1|;)(.*¶(?<-1>.)*(?(1)$))?(?!\2)[1;]
;$3;

बाढ़ 1एस के साथ किसी भी अधिक आसन्न भरें ;।

}

तब तक दोहराएं जब तक कि सभी द्वीपों को 1एस में बदल नहीं दिया जाता ;।

s`0(.*)
:$1b

यदि कोई है 0, तो इसे इनपुट के अंत में बदल दें :और एपेंड करें bताकि यह रास्ते से बाहर हो जाए।

+`(?<=(.)*)(0|:)(.*¶(?<-1>.)*(?(1)$))?(?!\2)[0:]
:$3:

बाढ़ 0एस के साथ किसी भी अधिक आसन्न भरें :।

}

तब तक दोहराएं जब तक कि सभी द्वीपों को 0एस में बदल नहीं दिया जाता :।

\W+(a*)(b*)
$.1 $.2

अलग-अलग 1s और 0s के द्वीपों की संख्या की गणना करें ।

Answer 10

हास्केल , 228 227 225 224 बाइट्स

import Data.List
z=zipWith
a!b=div(max(a*a)(a*b))a
l x=z(!)(z(!)x(0:x))$tail x++[0]
s=(\x->length.($x).filter<$>[(>0),(<0)]).nub.(>>=id).(until=<<((==)=<<))((.)>>=id$transpose.map l).z(\i->z(\j x->2^i*j*(2*x-1))[1,3..])[1..]

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

स्पष्टीकरण:

इस समाधान के लिए विचार निम्नानुसार है: प्रत्येक सेल में अद्वितीय मूल्यों के साथ मैट्रिक्स को आरम्भ करें, के लिए सकारात्मक 1और नकारात्मक 0। फिर बार-बार प्रत्येक सेल की अपने पड़ोसियों से तुलना करें और, यदि पड़ोसी के पास एक ही चिन्ह है लेकिन एक बड़ा निरपेक्ष मान वाला नंबर है, तो सेल के नंबर को पड़ोसी के नंबर से बदल दें। एक बार जब यह निश्चित बिंदु पर आ जाता है, तो 1क्षेत्रों की संख्या के लिए अलग-अलग सकारात्मक संख्याओं की संख्या और क्षेत्रों की संख्या के लिए अलग-अलग ऋणात्मक संख्याओं की गणना करें 0।

कोड में:

s=(\x->length.($x).filter<$>[(>0),(<0)]).nub.(>>=id).(until=<<((==)=<<))((.)>>=id$transpose.map l).z(\i->z(\j x->2^i*j*(2*x-1))[1,3..])[1..]

प्रीप्रोसेसिंग (कोशिकाओं को संख्या निर्दिष्ट करना), पुनरावृत्ति और पोस्टप्रोसेसिंग (कोशिकाओं की गिनती) में विभाजित किया जा सकता है

preprocessing

प्रीप्रोसेसिंग हिस्सा फ़ंक्शन है

z(\i->z(\j x->2^i*j*(2*x-1))[1,3..])[1..]

जो कुछ बाइट्स को शेव करने के zलिए संक्षिप्त नाम के रूप में उपयोग करता है zipWith। हम यहाँ क्या करते हैं पंक्तियों में पूर्णांक सूचकांकों और स्तंभों में विषम पूर्णांक सूचक के साथ दो आयामी सरणी को ज़िप करें। हम ऐसा करते हैं क्योंकि हम (i,j)सूत्र का उपयोग करके पूर्णांक की एक जोड़ी से एक अद्वितीय पूर्णांक बना सकते हैं (2^i)*(2j+1)। यदि हम केवल विषम पूर्णांक उत्पन्न करते हैं j, तो हम 2*j+1तीन बाइट्स की बचत करते हुए , गणना करना छोड़ सकते हैं ।

अद्वितीय संख्या के साथ, अब हमें केवल मैट्रिक्स में मूल्य के आधार पर एक संकेत में गुणा करना होगा, जो कि प्राप्त होता है 2*x-1

यात्रा

द्वारा पुनरावृति किया जाता है

(until=<<((==)=<<))((.)>>=id$transpose.map l)

चूंकि इनपुट सूची की एक सूची के रूप में है, इसलिए हम प्रत्येक पंक्ति पर पड़ोसी की तुलना करते हैं, मैट्रिक्स को स्थानांतरित करते हैं, प्रत्येक पंक्ति पर फिर से तुलना करते हैं (जो कि संक्रमण के कारण कॉलम पहले था) और फिर से प्रस्ताव करते हैं। इन चरणों में से एक को पूरा करने वाला कोड है

((.)>>=id$transpose.map l)

जहां lतुलना समारोह (नीचे विवरण) और है transpose.map lप्रदर्शन तुलना और स्थानांतरण चरणों में से एक आधा। ऑपरेटर पूर्ववर्ती नियमों के कारण इस मामले में (.)>>=idदो बार अपना तर्क प्रस्तुत करता है, \f -> f.fऔर इस मामले में एक बाइट से छोटा होता है।

lके रूप में ऊपर पंक्ति में परिभाषित किया गया है l x=z(!)(z(!)x(0:x))$tail x++[0]। यह कोड (!)प्रत्येक सेल पर पहले बाएं पड़ोसी के साथ तुलना ऑपरेटर (नीचे देखें) करता है, और फिर अपने दाएं पड़ोसी के साथ, सूची xको दाईं ओर स्थानांतरित सूची 0:xऔर बाएं स्थानांतरित सूची के साथ ज़िप करके tail x++[0]। शिफ्ट की गई सूचियों को पैड करने के लिए हम शून्य का उपयोग करते हैं, क्योंकि वे प्रीप्रोसेस मैट्रिक्स में कभी नहीं हो सकते हैं।

a!bइस के रूप में ऊपर पंक्ति में परिभाषित किया गया है a!b=div(max(a*a)(a*b))a। हम यहाँ क्या करना चाहते हैं निम्नलिखित मामले भेद है:

• यदि sgn(a) = -sgn(b), हमारे पास मैट्रिक्स में दो विरोधी क्षेत्र हैं और उन्हें एकजुट करने की इच्छा नहीं है, तो aअपरिवर्तित रहता है
• यदि sgn(b) = 0, हमारे पास कोने का मामला है जहां bपेडिंग है और इसलिए aअपरिवर्तित रहता है
• यदि sgn(a) = sgn(b), हम दो क्षेत्रों को एकजुट करना चाहते हैं और एक को बड़े निरपेक्ष मूल्य (सुविधा के लिए) के साथ लेना चाहते हैं।

ध्यान दें कि sgn(a)कभी नहीं हो सकता 0। हम इसे दिए गए सूत्र के साथ पूरा करते हैं। यदि संकेत aऔर bभिन्न होते हैं, a*bतो शून्य से कम या बराबर होता है, जबकि a*aहमेशा शून्य से अधिक होता है, इसलिए हम इसे अधिकतम के रूप में चुनते हैं और aवापस पाने के लिए विभाजित करते हैं a। अन्यथा, max(a*a)(a*b)है abs(a)*max(abs(a),(abs(b)), और इसके द्वारा विभाजित करके a, हम प्राप्त करते हैं sgn(a)*max(abs(a),abs(b)), जो कि बड़े निरपेक्ष मान के साथ संख्या है।

फ़ंक्शन को पुनरावृत्त करने के लिए ((.)>>=id$transpose.map l)जब तक यह एक निश्चित बिंदु तक नहीं पहुंचता, हम उपयोग करते हैं (until=<<((==)=<<)), जो इस स्टैकओवरफ़्लो उत्तर से लिया जाता है ।

प्रोसेसिंग के बाद

पोस्टप्रोसेसिंग के लिए, हम भाग का उपयोग करते हैं

(\x->length.($x).filter<$>[(>0),(<0)]).nub.(>>=id)

जो सिर्फ चरणों का एक संग्रह है।

(>>=id)सूचियों की सूची को एकल सूची में विभाजित करता है nub, युगल से छुटकारा दिलाता है, (\x->length.($x).filter<$>[(>0),(<0)])सूची को सूची में जोड़े में रखता है, सकारात्मक के लिए एक और नकारात्मक संख्या के लिए एक, और उनकी लंबाई की गणना करता है।

Answer 11

जावा 10, 359 355 281 280 261 246 बाइट्स

int[][]M;m->{int c[]={0,0},i=m.length,j,t;for(M=m;i-->0;)for(j=m[i].length;j-->0;)if((t=M[i][j])<2)c[t^1]+=f(t,i,j);return c;}int f(int v,int x,int y){try{if(M[x][y]==v){M[x][y]|=2;f(v,x+1,y);f(v,x,y+1);f(v,x-1,y);f(v,x,y-1);}}finally{return 1;}}

-74 बाइट्स के लिए @NahuelFouilleul को धन्यवाद ।

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

स्पष्टीकरण:

int[][]M;              // Integer-matrix on class-level, uninitialized

m->{                   // Method with integer-matrix parameter and integer-array return-type
  int c[]={0,0}        //  Counters for the islands of 1s/0s, starting both at 0
      i=m.length,      //  Index of the rows
      j,               //  Index of the columns
      t;               //  Temp-value to decrease the byte-count
  for(M=m;             //  Set the class-level matrix to the input-matrix
      i-->0;)          //  Loop over the rows
    for(j=m[i].length;j-->0)
                       //   Inner loop over the columns
      if((t=M[i][j])   //    Set the temp value `t` to the value of the current cell
         <2)           //    And if this value is a 0 or 1:
        c[t^1]+=       //     Increase the corresponding counter by:
          f(t,i,j);    //      Call the recursive flood-fill method with value `t`
                       //      Which always returns 1 to increase the counter
  return c;}           //  After the nested loops: return the counters-array as result

// Recursive method with value and cell-coordinate as parameters,
// This method will flood-fill the matrix, where 0 becomes 2 and 1 becomes 3
int f(int v,int x,int y){
  try{if(M[x][y]==v){  //   If the cell contains the given value:
    M[x][y]|=2;        //    Fill the cell with 0→2 or 1→3 depending on the value
    f(v,x+1,y);        //    Do a recursive call downwards
    f(v,x,y+1);        //    Do a recursive call towards the right
    f(v,x-1,y);        //    Do a recursive call upwards
    f(v,x,y-1);}       //    Do a recursive call towards the left
  }finally{return 1;}} //  Ignore any ArrayIndexOutOfBoundsExceptions with a finally-return,
                       //  which is shorter than manual checks
                       //  And return 1 to increase the counter

Comments

-74 बाइट्स , क्लोन को हटाना और उपयोग करना |=2: 0 -> 2 और 1 -> 3, हालाँकि, >0को बदल दिया गया था==1

— नहुएल फौइउल

क्षमा करें, मुझे परीक्षण हटाना पड़ा ताकि tio लिंक टिप्पणियों में फिट हो जाए

— नाहुएल फौइउल

@NahuelFouilleul धन्यवाद, स्मार्ट का उपयोग कर |=2! और मैं अभी भी पहली बाइट <2के ==1लिए -1 बाइट के बदले उपयोग कर सकता था 0(और इस तरह उन्हें बदल दिया जाता है 2, और फिर <2चेक करने के लिए उपयोग किया जाता है 1(जो बदल जाते हैं 3)।

— केविन क्रूज़सेन

Answer 12

पायथन 3 , 167 बाइट्स

def f(m):
 n=[0,0];i=-2
 for r in m:
  j=0;i+=1
  for c in r:n[c^1]+=1-((i>=0)*(m[i][j]==c)*(1+({*r[:j]}=={c})*({*m[i][:j]}=={c^1}))or(j>0)*(r[j-1]==c));j+=1
 print(n)

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

---

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

def f(m):
 n=[0,0];i=-2
 for r in m:
	j=0;i+=1
	for c in r:n[c^1]+=1-((i>=0)*(m[i][j]==c)*(1+(set(r[:j])=={c})*(set(m[i][:j])=={c^1}))or(j>0)*(r[j-1]==c));j+=1
 print n

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

-2 बाइट्स केविन क्रूज़सेन की बदौलत

+2 बाइट्स स्वरूपण फिक्स

व्याख्या

0 और 1 एस के लिए एक काउंटर रखा गया है। मैट्रिक्स में प्रत्येक प्रविष्टि के लिए, निम्नलिखित क्रियाएं की जाती हैं:

• 1 से वर्तमान मूल्य के लिए काउंटर को बढ़ाएं
• यदि समान मान सीधे ऊपर या बाईं ओर मौजूद है, तो 1 से घटाएं

इसके परिणामस्वरूप बाएं-संरेखित मामलों के लिए एक गलत सकारात्मक परिणाम होता है

0 0 1
1 1 1

या

0 1
1 1

यदि ऐसी स्थिति उत्पन्न होती है, तो काउंटर 1 से कम हो जाता है।

रिटर्न वैल्यू है [#1, #0]

Comments

मुझे डर है कि दूसरी टिप्पणी में उल्लिखित ओपी का आदेश होना चाहिए [#1, #0]। इसे लागू करने के लिए बिट व्यर्थ imo, लेकिन यह अभी के लिए है। वैसे भी, आप गोल्फ कर सकते हैं {not c}करने के लिए {c^1}, और इस मुद्दे को मैं बदलकर उल्लेख किया ठीक n[c]+=करने के लिए n[c^1]+=इसी तरह की एक मामले में। हालांकि अच्छा जवाब, मेरी ओर से +1। :)

— केविन क्रूज़सेन

आह, तुम सही हो। धन्यवाद!

— जितसे

Answer 13

पर्ल 5 ( -0777p), 110 बाइट्स

बेहतर हो सकता है, एक regex को बदलने के लिए उपयोग करता है 1के साथ 3तो, 0के साथ 2।

/
/;$m="(.{@-})?";sub f{($a,$b,$c)=@_;1while s/$b$m\K$a|$a(?=$m$b)/$b/s||s/$a/$b/&&++$c;$c}$_=f(1,3).$".f(0,2)

TIO

Answer 14

जेली , 44 36 बाइट्स

ŒJfⱮ+€¥Ø.,UŻ¤œịƇþ,¬$¹ƇfƇⱮ`ẎQ$€QƲÐL€Ẉ

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

एक मोनडिक लिंक पूर्णांक की सूचियों की एक सूची को अपने तर्क के रूप में स्वीकार करता है और उस क्रम में 1 और 0 द्वीपों की संख्या की सूची वापस करता है।

व्याख्या

चरण 1

अपने पड़ोसी के सूचकांकों के साथ दाईं ओर (जब तक दाईं ओर) और नीचे (जब तक नीचे) सभी मैट्रिक्स सूचकांकों की सूची बनाएं

ŒJ            | Multi-dimensional indices (e.g. [1,1],[1,2],[1,3],[2,1],[2,2],[2,3])
      ¥       | Following as as a dyad:
  fⱮ          | - Filter the indices by each of:
    +€      ¤ |   - The indices added to the following
       Ø.     |     - 0,1
         ,U   |     - Paired with itself reversed [0,1],[1,0]
           Ż  |     - Prepended with zero 0,[0,1],[1,0]

चरण 2

इन सूचकांकों को विभाजित करें कि क्या इनपुट में 1 या 0 था। 1s के लिए पड़ोसियों के साथ सूचकांकों की एक सूची देता है और 0 के लिए दूसरा।

  Ƈþ   | Filter each member of the output of stage 1 using the following criteria:
œị   $ | - Corresponding value for the multi-dimensional indices in each of the following as a monad:
   ,¬  |   - The input paired with its inverse

चरण 3

सामान्य और आउटपुट काउंट में सदस्यों के साथ मर्ज की सूची

           ƲÐL€  | For each of the outputs from stage 2, do the following as a monad and repeat until no changes
¹Ƈ               | - Filter out empty lists (only needed on first pass through but included here to save a byte)         
  fƇⱮ`           | - Take each list of indices and filter the list of indices for those containing a match for any of them
        $€       | - For each resulting list of lists:
      Ẏ          |   - Tighten (concatenate top level of lists)
       Q         |   - Uniquify
          Q      | - Uniquify
               Ẉ | Finally output the lengths of the final lists

Answer 15

टी-एसक्यूएल 2008, 178 बाइट्स

इनपुट एक तालिका चर है।

x और y निर्देशांक हैं

v मान 0 और 1 है (अन्य संख्यात्मक मानों को भी संभाल सकता है)

इस उदाहरण में उपयोग किया गया परीक्षण डेटा:

100
000
001

DECLARE @ table(x int, y int, v int)

INSERT @ values
(1,1,1),(1,2,0),(1,3,0),
(2,1,0),(2,2,0),(2,3,0),
(3,1,0),(3,2,0),(3,3,1)
SELECT*,y-x*99r INTO # FROM @
WHILE @@rowcount>0UPDATE #
SET r=b.r
FROM #,# b
WHERE abs(#.x-b.x)+abs(#.y-b.y)=1and #.v=b.v and #.r>b.r
SELECT v,count(distinct r)FROM #
GROUP BY v

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

Answer 16

आर , 194 172 बाइट्स

function(m,u=!1:2){for(i in 1:2){w=which(m==i-1,T)
N=1:nrow(w)
A=!!N
for(s in N){u[i]=u[i]+A[s]
while(any(s)){A[s]=F
s=c(N[as.matrix(dist(w))[s[1],]==1&A],s[-1])}}}
rev(u)}

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

मैट्रिक्स के प्रत्येक सेल में शुरू होने वाली गहराई-पहली खोज करें जो 1 (या शून्य) के बराबर हो।

• -2 बाइट्स @Giuseppe की बदौलत