Cho ma trận hai chiều là 0 và 1s. Tìm số lượng đảo trong 1 và 0 trong đó hàng xóm chỉ nằm ngang và dọc.

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 byte ^SBCS

-1 cảm ơn @ Adám

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

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

⊂,~∘⊂ ma trận và phủ định của nó

{ }¨ cho mỗi người trong số họ làm

⍸⍵ danh sách các cặp hợp âm 1s

+/↑|∘.-⍨ ma trận khoảng cách manhattan

2> ma trận hàng xóm

∨.∧⍨⍣≡ Sự đóng kín

≢∪ số lượng hàng duy nhất

J , 57 byte

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

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

Đây là một trong những ý tưởng cực kỳ đơn giản (và tôi nghĩ là vui), nhưng thực hiện nó có một số độ dài cơ học che giấu sự đơn giản ... ví dụ, thay đổi ma trận gốc theo mọi hướng với 0 fill là dài dòng ((,-)#:i.3) |.!.0.

Có vẻ như độ dài cơ học này có thể được chơi gôn hơn nữa và tôi có thể thử vào tối mai, nhưng tôi sẽ đăng tải mấu chốt của nó ngay bây giờ.

Nói đầu vào của chúng tôi là:

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

Chúng tôi bắt đầu với một ma trận các số nguyên duy nhất có cùng kích thước:

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

Sau đó, với mỗi ô, chúng ta tìm tối đa của tất cả các ô lân cận và nhân với mặt nạ đầu vào:

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

Chúng tôi lặp lại quá trình này cho đến khi ma trận ngừng thay đổi:

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

Và sau đó đếm số phần tử duy nhất, khác không. Điều đó cho chúng ta biết số lượng 1 đảo.

Chúng tôi áp dụng quy trình tương tự cho "1 trừ đi đầu vào" để có được số lượng 0 đảo.

JavaScript (ES7),  138 ... 107  106 byte

Trả về một mảng [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

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

Làm sao?

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

Để lưu byte, cùng một mã chính xác được sử dụng cho cả lần lặp gốc và lần lặp đệ quy, nhưng nó hoạt động hơi khác một chút.

Trong lần lặp đầu tiên:

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

Trong các lần lặp đệ quy:

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

Đã bình luận

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 byte

,G@-K&1ZIugs

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

,        % 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 byte

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

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

~:\ một cặp đầu vào và phủ định của nó (nghĩa đen: phủ định iterate-converge)

{ }' cho mỗi

,/x làm phẳng các arg

&1s ở đâu? - danh sách các chỉ số

(0,#*x)\ chiều rộng divmod (đầu vào) để có hai danh sách riêng cho ys và xs

x-\:'x: khoảng cách mỗi trục x và y

x*x: vuông chúng

+/ thêm ∆x² và ∆y²

2> ma trận hàng xóm

{|/'x*\:x}/ Sự đóng kín

#? đếm hàng độc đáo

Ngôn ngữ Wolfram (Mathicala) , 64 62 byte

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

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

Nhờ attinat : chúng ta có thể viết 1<0thay vì Falsevà lưu hai byte.

phiên bản không chơi gôn:

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

Có, tất nhiên, một Mathematica dựng sẵn MorphologicalComponentsmà phải mất một mảng (hoặc hình ảnh) và lợi nhuận cùng với các điểm ảnh của mỗi hòn đảo có hình thái kết nối thay thế bằng các chỉ số đảo. Lấy Maxkết quả này sẽ cho số lượng đảo (các số 0 nền được giữ ở mức 0 và chỉ số đảo bắt đầu từ 1). Chúng ta cần thực hiện điều này một cách riêng biệt cho mảng (đưa ra số lượng 1 đảo) và trừ đi một mảng (cho số lượng 0 đảo). Để đảm bảo hàng xóm chéo không được tính là hàng xóm, tùy chọn CornerNeighbors->Falsecần phải được đưa ra.

Python 3, 144 127 byte

Giải pháp này sử dụng cv2sức mạnh xử lý hình ảnh tuyệt vời của. Mặc dù tên phương thức ít tuyệt vời, siêu dài và dễ đọc của cv, nó đánh bại cả hai câu trả lời Python khác!

Chơi gôn

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

Mở rộng:

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 byte

-1 byte nhờ @miles

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

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

các bài kiểm tra và ,& -.trình bao bọc bị đánh cắp từ câu trả lời của @ jonah

,& -. cho đầu vào và phủ định của nó làm:

4$.$. (y, x) tọa độ của 1s dưới dạng ma trận n × 2

1#.[:|@-"1/~ khoảng cách manhattan: abs (x) + abs (y)

2> ma trận hàng xóm

[:+./ .*~^:_: Sự đóng kín

#&~.&( ) số lượng hàng duy nhất

Võng mạc 0.8.2 , 155 byte

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

Hãy thử trực tuyến!Liên kết bao gồm trường hợp thử nghiệm. Giải trình:

s`1(.*)
;$1a

Nếu có 1, thay đổi nó ;và nối thêma vào cuối của đầu vào để nó không xảy ra.

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

Lũ lấp đầy bất kỳ 1s liền kề nào với; s.

}

Lặp lại cho đến khi tất cả các đảo của 1s đã được biến thành ;s.

s`0(.*)
:$1b

Nếu có 0, thay đổi nó thành :và nối thêm bvào cuối của đầu vào để nó không xảy ra.

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

Lũ lấp đầy bất kỳ 0s liền kề với: s.

}

Lặp lại cho đến khi tất cả các đảo của 0s đã được biến thành :s.

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

Đếm riêng số lượng đảo của 1s và 0s.

Haskell , 228 227 225 224 byte

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

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

Giải trình:

Ý tưởng cho giải pháp này như sau: Khởi tạo ma trận với các giá trị duy nhất trong mỗi ô, dương cho 1và âm cho 0. Sau đó liên tục so sánh từng ô với các ô lân cận và, nếu hàng xóm có cùng dấu nhưng một số có giá trị tuyệt đối lớn hơn, hãy thay thế số của ô bằng số của neighbour. Khi điểm này đạt một điểm cố định, hãy đếm số lượng số dương khác biệt cho số 1vùng và số âm khác biệt cho số 0vùng.

Trong mã:

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

có thể được tách thành tiền xử lý (gán số cho các ô), lặp và xử lý sau (đếm ô)

Sơ chế

Phần tiền xử lý là chức năng

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

Mà sử dụng znhư viết tắt zipWithđể cạo một vài byte. Những gì chúng ta làm ở đây là nén mảng hai chiều với các chỉ số nguyên ở các hàng và các chỉ số nguyên lẻ ở các cột. Chúng tôi làm điều này vì chúng tôi có thể xây dựng một số nguyên duy nhất từ ​​một cặp số nguyên(i,j) bằng công thức (2^i)*(2j+1). Nếu chúng ta chỉ tạo các số nguyên lẻ cho j, chúng ta có thể bỏ qua việc tính toán 2*j+1, tiết kiệm ba byte.

Với số duy nhất, giờ đây chúng ta chỉ phải nhân một dấu dựa trên giá trị trong ma trận, được lấy là 2*x-1

Lặp lại

Lặp lại được thực hiện bởi

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

Do đầu vào ở dạng danh sách các danh sách, chúng tôi thực hiện so sánh hàng xóm trên mỗi hàng, hoán đổi ma trận, thực hiện so sánh trên mỗi hàng một lần nữa (do chuyển vị là các cột trước đó) và hoán vị lại. Mã thực hiện một trong các bước này là

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

trong đó lchức năng so sánh (chi tiết bên dưới) và transpose.map lthực hiện một nửa các bước so sánh và chuyển vị. (.)>>=idthực hiện đối số của nó hai lần, là dạng không có điểm \f -> f.fvà ngắn hơn một byte trong trường hợp này do các quy tắc ưu tiên toán tử.

lđược định nghĩa trong hàng trên như l x=z(!)(z(!)x(0:x))$tail x++[0]. Mã này thực hiện một toán tử so sánh (!)(xem bên dưới) trên mỗi ô với hàng xóm bên trái đầu tiên và sau đó với hàng xóm bên phải của nó, bằng cách nén danh sách xvới danh sách dịch chuyển bên phải 0:xvà danh sách dịch chuyển tráitail x++[0] lần lượt. Chúng tôi sử dụng các số 0 để đệm các danh sách đã thay đổi, vì chúng không bao giờ có thể xảy ra trong ma trận được xử lý trước.

a!bđược định nghĩa trong hàng trên này như a!b=div(max(a*a)(a*b))a. Những gì chúng tôi muốn làm ở đây là phân biệt trường hợp sau đây:

• Nếu sgn(a) = -sgn(b), chúng ta có hai khu vực đối lập trong ma trận và không muốn thống nhất chúng, vì vậy avẫn không thay đổi
• Nếu sgn(b) = 0, chúng ta có trường hợp góc blà phần đệm và do đó akhông thay đổi
• Nếu sgn(a) = sgn(b), chúng tôi muốn thống nhất hai khu vực và lấy một khu vực có giá trị tuyệt đối lớn hơn (vì sự thuận tiện).

Lưu ý rằng sgn(a)không bao giờ có thể được 0. Chúng tôi thực hiện điều này với công thức được đưa ra. Nếu các dấu hiệu của avà bkhác nhau, a*bnhỏ hơn hoặc bằng 0, trong khi a*aluôn lớn hơn 0, vì vậy chúng tôi chọn nó là mức tối đa và chia acho để lấy lại a. Nếu không, max(a*a)(a*b)là abs(a)*max(abs(a),(abs(b)), và bằng cách chia này bằng cách a, chúng tôi nhận sgn(a)*max(abs(a),abs(b)), đó là số có giá trị tuyệt đối lớn hơn.

Để lặp lại hàm ((.)>>=id$transpose.map l)cho đến khi nó đạt đến một điểm cố định, chúng tôi sử dụng (until=<<((==)=<<)), được lấy từ câu trả lời stackoverflow này .

Hậu xử lý

Để xử lý hậu kỳ, chúng tôi sử dụng phần

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

mà chỉ là một tập hợp các bước.

(>>=id)xóa danh sách các danh sách thành một danh sách, nubloại bỏ gấp đôi, (\x->length.($x).filter<$>[(>0),(<0)])phân chia danh sách thành một cặp danh sách, một cho danh sách dương và một cho số âm và tính độ dài của chúng.

Java 10, 359 355 281 280 261 246 byte

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 byte nhờ @NahuelFouilleul .

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

Giải trình:

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 byte

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)

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

Python 2 , 168 byte

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

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

-2 byte nhờ Kevin Cruijssen

Sửa lỗi định dạng +2 byte

Giải trình

Một bộ đếm được giữ trong 0 giây và 1 giây. Đối với mỗi mục trong ma trận, các hành động sau được thực hiện:

• Truy cập cụm từ cho giá trị hiện tại bằng 1
• Nếu cùng một giá trị tồn tại trực tiếp ở trên hoặc bên trái, giảm 1

Điều này dẫn đến kết quả dương tính giả đối với các trường hợp căn lề trái như

0 0 1
1 1 1

hoặc là

0 1
1 1

Nếu một tình huống như vậy phát sinh, bộ đếm giảm 1.

Giá trị trả về là [#1, #0]

Perl 5 ( -0777p), 110 byte

Có thể được cải thiện, sử dụng một regex để thay thế 1với 3, sau đó0 với 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

Thạch , 44 36 byte

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

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

Một liên kết đơn âm chấp nhận một danh sách các danh sách số nguyên làm đối số của nó và trả về một danh sách số lượng 1 và 0 đảo theo thứ tự đó.

Giải trình

Bước 1

Tạo danh sách tất cả các chỉ số ma trận, mỗi chỉ số của các chỉ số lân cận ở bên phải (trừ khi ở bên phải) và xuống (trừ khi ở dưới cùng)

Œ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]

Bước 2

Tách các chỉ số này bằng cách có 1 hoặc 0 trong đầu vào. Trả về một danh sách các chỉ số với hàng xóm trong 1 giây và một danh sách khác cho 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

Bước 3

Hợp nhất danh sách với các thành viên trong số lượng chung và đầu ra

           ƲÐ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 byte

Đầu vào là một biến bảng.

x và y là tọa độ

v là các giá trị 0 và 1 (cũng có thể xử lý các giá trị số khác)

Dữ liệu thử nghiệm được sử dụng trong ví dụ này:

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

Dùng thử trực tuyến

R , 194 172 byte

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

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

Thực hiện tìm kiếm theo chiều sâu bắt đầu trong mỗi ô của ma trận bằng 1 (hoặc bằng 0).

• -2 byte nhờ @Giuseppe