กำหนดเมทริกซ์สองมิติเป็น 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

APL (Dyalog Unicode) , 29 28 ไบต์^SBCS

-1 ต้องขอบคุณ @ Adám

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

ลองออนไลน์!

⊂,~∘⊂ เมทริกซ์และการปฏิเสธ

{ }¨ สำหรับแต่ละคนทำ

⍸⍵ รายการคู่ของคอร์ด 1s

+/↑|∘.-⍨ เมทริกซ์ของระยะทางแมนฮัตตัน

2> เมทริกซ์เพื่อนบ้าน

∨.∧⍨⍣≡ ปิดสกรรมกริยา

≢∪ จำนวนแถวที่ไม่ซ้ำกัน

J , 57 ไบต์

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

ลองออนไลน์!

นี่คือหนึ่งในสิ่งที่ความคิดนั้นเรียบง่ายอย่างเหลือเชื่อ (และฉันคิดว่าสนุก) แต่การดำเนินการมันมีความยาวเชิงกลซึ่งปกปิดความเรียบง่าย ... เช่นการเปลี่ยนเมทริกซ์ดั้งเดิมในทุกทิศทางด้วย 0 เติมคือ verbose ((,-)#:i.3) |.!.0verbose

อาจเป็นไปได้ที่ความยาวเชิงกลนี้จะสามารถเล่นกอล์ฟต่อไปได้และฉันอาจลองตอนเย็นวันพรุ่งนี้ แต่ฉันจะโพสต์ปมของมันตอนนี้

พูดว่าอินพุตของเราคือ:

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 เกาะ

เราใช้กระบวนการเดียวกันกับ "1 ลบอินพุต" เพื่อรับจำนวน 0 เกาะ

JavaScript (ES7),  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$ 's

เพื่อบันทึกไบต์ใช้รหัสเดียวกันที่แน่นอนสำหรับทั้งการทำซ้ำรูทและการทำซ้ำซ้ำ แต่มันทำงานแตกต่างกันเล็กน้อย

ในช่วงการทำซ้ำครั้งแรก:

• $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

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)

K (ngn / k) , 60 55 51 50 46 ไบต์

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

ลองออนไลน์!

~:\ คู่ของอินพุตและการปฏิเสธ (แท้จริง: negate iterate-converge)

{ }' แต่ละ

,/x เรียบ ARG

&1s อยู่ที่ไหน - รายการดัชนี

(0,#*x)\ ความกว้าง divmod (อินพุต) เพื่อรับสองรายการแยกกันสำหรับ ys และ xs

x-\:'x: ระยะต่อแกน ∆x และ ∆y

x*x: ยกกำลังสอง

+/ เพิ่ม ∆x² และ ∆y²

2> เมทริกซ์เพื่อนบ้าน

{|/'x*\:x}/ ปิดสกรรมกริยา

#? นับแถวที่ไม่ซ้ำกัน

ภาษา Wolfram (Mathematica) , 64 62 ไบต์

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

ลองออนไลน์!

ขอบคุณattinat : เราสามารถเขียน1<0แทนFalseและบันทึกสองไบต์

รุ่นที่ไม่ตีกอล์ฟ:

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

แน่นอนว่ามีMathematica builtinMorphologicalComponentsที่ใช้อาเรย์ (หรือรูปภาพ) และส่งกลับค่าเดียวกันด้วยพิกเซลของแต่ละเกาะที่เชื่อมต่อทางสัณฐานวิทยาซึ่งถูกแทนที่ด้วยดัชนีเกาะ การบันทึกMaxผลลัพธ์นี้จะทำให้จำนวนเกาะ (ศูนย์หลังเหลือศูนย์และดัชนีเกาะเริ่มที่ 1) เราต้องทำสิ่งนี้แยกต่างหากสำหรับอาเรย์ (ให้หมายเลข 1 เกาะ) และอีกหนึ่งลบอาเรย์ (ให้จำนวน 0 เกาะ) เพื่อให้แน่ใจว่าเพื่อนบ้านเส้นทแยงมุมไม่นับเป็นเพื่อนบ้านตัวเลือกในการCornerNeighbors->Falseตอบสนองความต้องการที่จะได้รับ

Python 3 144 127 ไบต์

วิธีนี้ใช้cv2พลังการประมวลผลภาพที่ยอดเยี่ยม แม้จะมีชื่อวิธีการที่น่ากลัวน้อยกว่ายาวมากและอ่านง่าย แต่มันก็เต้นได้ทั้งคำตอบของ Python อื่น ๆ !

แข็งแรงเล่นกอล์ฟ:

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)

J , 46 44 43 ไบต์

-1 ไบต์ขอบคุณ @miles

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

ลองออนไลน์!

การทดสอบและ,& -.เสื้อคลุมที่ขโมยมาจากคำตอบของ @ jonah

,& -. สำหรับอินพุตและการปฏิเสธทำ:

4$.$. (y, x) พิกัดของ 1s เป็นเมทริกซ์ n × 2

1#.[:|@-"1/~ แมนฮัตตันระยะทาง: abs (∆x) + abs (∆y)

2> เมทริกซ์เพื่อนบ้าน

[:+./ .*~^:_: ปิดสกรรมกริยา

#&~.&( ) จำนวนแถวที่ไม่ซ้ำกัน

เรติน่า 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;

น้ำท่วมเติม1s ที่อยู่ติดกันด้วย;s

}

ทำซ้ำจนกว่าทั้งหมดของหมู่เกาะใน1s ได้รับกลายเป็น;s

s`0(.*)
:$1b

หากมีให้0เปลี่ยนเป็น:และผนวก a bถึงจุดสิ้นสุดของอินพุตเพื่อให้ไม่สามารถแก้ไขได้

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

น้ำท่วมเติม0s ที่อยู่ติดกันด้วย:s

}

ทำซ้ำจนกว่าทั้งหมดของหมู่เกาะใน0s ได้รับกลายเป็น:s

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

แยกนับตัวเลขของเกาะ1และ0s

Haskell , 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..]

ลองออนไลน์!

คำอธิบาย:

ความคิดสำหรับการแก้ปัญหานี้จะเป็นดังนี้: initialise เมทริกซ์ที่มีค่าที่ไม่ซ้ำกันในแต่ละเซลล์ในเชิงบวกสำหรับและเชิงลบสำหรับ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..]

สามารถแยกออกเป็นการประมวลผลล่วงหน้า (การกำหนดหมายเลขให้กับเซลล์) การวนซ้ำและการประมวลผลภายหลัง (การนับเซลล์)

กระบวนการเตรียมการผลิต

ส่วนการประมวลผลล่วงหน้าคือฟังก์ชั่น

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ดำเนินการโต้แย้งสองครั้งเป็นรูปแบบ pointfree \f -> f.fและสั้นลงหนึ่งไบต์ในกรณีนี้เนื่องจากกฎที่มีความสำคัญกว่าผู้ประกอบการ

ll x=z(!)(z(!)x(0:x))$tail x++[0]ถูกกำหนดไว้ในแถวด้านบนเป็น รหัสนี้ดำเนินการตัวดำเนินการเปรียบเทียบ(!)(ดูด้านล่าง) ในทุกเซลล์ที่มีเพื่อนบ้านด้านซ้ายก่อนแล้วจึงมีเพื่อนบ้านที่เหมาะสมโดยการซิปรายการที่xมีรายการที่เลื่อนด้านขวา0:xและรายการที่เลื่อนด้านซ้ายtail x++[0]ในทางกลับกัน เราใช้ศูนย์เพื่อรองรายการที่ถูกเลื่อนเนื่องจากมันไม่สามารถเกิดขึ้นได้ในเมทริกซ์ที่ประมวลผลล่วงหน้า

a!ba!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=<<((==)=<<))ซึ่งนำมาจากคำตอบสแต็คโอเวอร์โฟลว์นี้นี้

postprocessing

สำหรับการประมวลผลภายหลังเราใช้ชิ้นส่วน

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

ซึ่งเป็นเพียงชุดของขั้นตอน

(>>=id)สควอชรายการของรายการลงในรายการเดียว nubกำจัดคู่ผสม (\x->length.($x).filter<$>[(>0),(<0)])พาร์ทิชันรายการเป็นคู่ของรายการหนึ่งรายการสำหรับบวกและอีกหนึ่งสำหรับตัวเลขลบและคำนวณความยาวของพวกเขา

Java 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 @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

Python 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)

ลองออนไลน์!

Python 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 ไบต์ขอบคุณ Kevin Cruijssen

การแก้ไขการจัดรูปแบบ +2 ไบต์

คำอธิบาย

ตัวนับจะถูกเก็บไว้เป็น 0 วินาทีและ 1 วินาที สำหรับแต่ละรายการในเมทริกซ์จะดำเนินการต่อไปนี้:

• เพิ่มตัวนับสำหรับค่าปัจจุบัน 1
• หากค่าเดียวกันมีอยู่ด้านบนโดยตรงหรือทางซ้ายให้ลดลง 1

ซึ่งจะส่งผลในเชิงบวกที่ผิดพลาดสำหรับกรณีที่ชิดซ้ายเช่น

0 0 1
1 1 1

หรือ

0 1
1 1

หากสถานการณ์ดังกล่าวเกิดขึ้นตัวนับจะลดลง 1

ค่าส่งคืนคือ [#1, #0]

Perl 5 ( -0777p), 110 ไบต์

อาจจะดีขึ้น, ใช้ regex เพื่อแทนที่1ด้วย3แล้วด้วย02

/
/;$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

เจลลี่ , 44 36 ไบต์

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

ลองออนไลน์!

ลิงก์ monadic ยอมรับรายการของจำนวนเต็มเป็นอาร์กิวเมนต์และส่งคืนรายการจำนวน 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 ในอินพุต ส่งคืนหนึ่งรายการดัชนีที่มีเพื่อนบ้านเป็นเวลา 1 วินาทีและอีกดัชนีหนึ่งเป็น 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

T-SQL 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

ลองออนไลน์

R , 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