Đầu vào:

Một ma trận chứa các số nguyên trong phạm vi [0 - 9] .

Thử thách:

Xác định xem tất cả các phần tử khác không được kết nối với nhau theo chiều dọc và / hoặc chiều ngang.

Đầu ra:

Một giá trị truthy nếu tất cả được kết nối, và một giá trị falsy nếu có khác không yếu tố / nhóm không được kết nối với các yếu tố / nhóm khác.

Các trường hợp thử nghiệm:

Các trường hợp thử nghiệm được phân tách bằng dòng. Các trường hợp thử nghiệm có thể được tìm thấy ở các định dạng thuận tiện hơn ở đây ( Kudos to Dada ).

Sau đây tất cả được kết nối và sẽ trả về một giá trị trung thực:

0
--- 
0 0
---
1 1 1
0 0 0
---
1 0 0
1 1 1
0 0 1
---
0 0 0 0 0 0
0 0 3 5 1 0
0 1 0 2 0 1
1 1 0 3 1 6
7 2 0 0 3 0
0 8 2 6 2 9
0 0 0 0 0 5

Tất cả các mục sau đây không được kết nối và sẽ trả về giá trị giả:

0 1
1 0
---
1 1 1 0
0 0 0 2
0 0 0 5
---
0 0 5 2
1 2 0 0
5 3 2 1
5 7 3 2
---
1 2 3 0 0 5
1 5 3 0 1 1
9 0 0 4 2 1
9 9 9 0 1 4
0 1 0 1 0 0

Đây là môn đánh gôn , vì vậy bài nộp ngắn nhất trong mỗi ngôn ngữ sẽ thắng. Giải thích được khuyến khích!

Lấy cảm hứng từ thử thách này .

Võng mạc 0.8.2 , 80 77 byte

T`d`@1
1`1
_
+m`^((.)*)(1|_)( |.*¶(?<-2>.)*(?(2)(?!)))(?!\3)[1_]
$1_$4_
^\D+$

Hãy thử trực tuyến! Chỉnh sửa: Đã lưu 1 byte nhờ @FryAmTheEggman. Giải trình:

T`d`@1

Đơn giản hóa thành một mảng @s và 1s.

1`1
_

Thay đổi một 1thành a _.

+m`^((.)*)(1|_)( |.*¶(?<-2>.)*(?(2)(?!)))(?!\3)[1_]
$1_$4_

Lấp đầy từ s _đến liền kề 1.

^\D+$

Kiểm tra xem có 1còn lại s không.

JavaScript (ES6), 136 135 byte

Trả về một boolean.

m=>!/[1-9]/.test((g=(y,x=0)=>1/(n=(m[y]||0)[x])&&!z|n?(m[y++][x]=0,z=n)?g(y,x)&g(--y-1,x)&g(y,x+1)||g(y,x-1):g(m[y]?y:+!++x,x):m)(z=0))

Các trường hợp thử nghiệm

let f =

m=>!/[1-9]/.test((g=(y,x=0)=>1/(n=(m[y]||0)[x])&&!z|n?(m[y++][x]=0,z=n)?g(y,x)&g(--y-1,x)&g(y,x+1)||g(y,x-1):g(m[y]?y:+!++x,x):m)(z=0))

console.log('[Truthy]')

console.log(f([
  [0]
]))
console.log(f([
  [0,0]
]))
console.log(f([
  [1,1,1],
  [0,0,0]
]))
console.log(f([
  [1,0,0],
  [1,1,1],
  [0,0,1]
]))
console.log(f([
  [0,0,0,0,0,0],
  [0,0,3,5,1,0],
  [0,1,0,2,0,1],
  [1,1,0,3,1,6],
  [7,2,0,0,3,0],
  [0,8,2,6,2,9],
  [0,0,0,0,0,5]
]))

console.log('[Falsy]')

console.log(f([
  [0,1],
  [1,0]
]))
console.log(f([
  [1,1,1,0],
  [0,0,0,2],
  [0,0,0,5]
]))
console.log(f([
  [0,0,5,2],
  [1,2,0,0],
  [5,3,2,1],
  [5,7,3,2]
]))
console.log(f([
  [1,2,3,0,0,5],
  [1,5,3,0,1,1],
  [9,0,0,4,2,1],
  [9,9,9,0,1,4],
  [0,1,0,1,0,0]
]))

Đã bình luận

Hàm đệ quy g () trước tiên tìm một ô khác không (miễn là cờ z được xác định toàn cục được đặt thành 0 ) và sau đó bắt đầu lấp đầy lũ từ đó (ngay khi z! = 0 ).

m =>                               // given the input matrix m
  !/[1-9]/.test((                  // test whether there's still a non-zero digit
    g = (y, x = 0) =>              //   after recursive calls to g(), starting at (x=0,y=0):
      1 / (n = (m[y] || 0)[x]) &&  //     n = current cell; if it is defined:
      !z | n ? (                   //       if z is zero or n is non-zero:
          m[y++][x] = 0,           //         we set the current cell to zero
          z = n                    //         we set z to the current cell
        ) ?                        //         if z is non-zero:
          g(y, x) &                //           flood-fill towards bottom
          g(--y - 1, x) &          //           flood-fill towards top
          g(y, x + 1) ||           //           flood-fill towards right
          g(y, x - 1)              //           flood-fill towards left
        :                          //         else:
          g(m[y] ? y : +!++x, x)   //           look for a non-zero cell to start from
      :                            //       else:
        m                          //         return the matrix
    )(z = 0)                       //   initial call to g() + initialization of z
  )                                // end of test()

MATL , 7 byte

4&1ZI2<

Điều này cho phép một ma trận bao gồm tất cả những người như truthy đầu ra, hoặc một ma trận có chứa ít nhất một số không như falsy .Hãy thử trực tuyến!

Bạn cũng có thể xác minh truthiness / falsiness thêm một if- elsechi nhánh tại chân; hãy thử nó

Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

4       % Push 4 (defines neighbourhood)
&       % Alternative input/output specification for next function
1ZI     % bwlabeln with 2 input arguments: first is a matrix (implicit input),
        % second is a number (4). Nonzeros in the matrix are interpreted as
        % "active" pixels. The function gives a matrix of the same size
        % containing positive integer labels for the connected components in 
        % the input, considering 4-connectedness
2<      % Is each entry less than 2? (That would mean there is only one
        % connected component). Implicit display

Ngôn ngữ Wolfram (Mathicala) , 54 byte

Đã lưu 2 byte nhờ user202729.

Max@MorphologicalComponents[#,CornerNeighbors->1<0]<2&

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

C, 163 byte

Cảm ơn @ user202729 vì đã lưu hai byte!

*A,N,M;g(j){j>=0&j<N*M&&A[j]?A[j]=0,g(j+N),g(j%N?j-1:0),g(j-N),g(++j%N?j:0):0;}f(a,r,c)int*a;{A=a;N=c;M=r;for(c=r=a=0;c<N*M;A[c++]&&++r)A[c]&&!a++&&g(c);return!r;}

Vòng lặp thông qua ma trận cho đến khi tìm thấy phần tử khác không đầu tiên. Sau đó dừng lặp lại một lúc và đặt đệ quy mọi phần tử khác không được kết nối với phần tử tìm thấy thành 0. Sau đó lặp qua phần còn lại của ma trận kiểm tra xem mọi phần tử bây giờ có bằng không.

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

Chưa được kiểm soát:

*A, N, M;

g(j)
{
    j>=0 & j<N*M && A[j] ? A[j]=0, g(j+N), g(j%N ? j-1 : 0), g(j-N), g(++j%N ? j : 0) : 0;
}

f(a, r, c) int*a;
{
    A = a;
    N = c;
    M = r;

    for (c=r=a=0; c<N*M; A[c++] && ++r)
        A[c] && !a++ && g(c);

    return !r;
}

Perl, 80 79 78 73 70 byte

Bao gồm +2cho0a

Đưa ra ma trận đầu vào không có khoảng trắng trên STDIN (hoặc trên thực tế là các hàng được phân tách bằng bất kỳ loại khoảng trắng nào)

perl -0aE 's%.%$".join"",map chop,@F%seg;s%\b}|/%z%;y%w-z,-9%v-~/%?redo:say!/}/'
000000
003510
010201
110316
720030
082629
000005
^D

Dễ đọc hơn nếu đặt trong tệp:

#!/usr/bin/perl -0a
use 5.10.0;
s%.%$".join"",map chop,@F%seg;s%\b}|/%z%;y%w-z,-9%v-~/%?redo:say!/}/

Java 8, 226 byte

m->{int c=0,i=m.length,j;for(;i-->0;)for(j=m[i].length;j-->0;)if(m[i][j]>0){c++;f(m,i,j);}return c<2;}void f(int[][]m,int x,int y){try{if(m[x][y]>0){m[x][y]=0;f(m,x+1,y);f(m,x,y+1);f(m,x-1,y);f(m,x,y-1);}}catch(Exception e){}}

Điều này mất khá nhiều thời gian, vì vậy tôi rất vui vì giờ nó đã hoạt động ..

Giải trình:

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

m->{                   // Method with integer-matrix parameter and boolean return-type
  int c=0,             //  Amount of non-zero islands, starting at 0
      i=m.length,j;    //  Index integers
  for(;i-->0;)         //  Loop over the rows
    for(j=m[i].length;j-->0;)
                       //   Inner loop over the columns
      if(m[i][j]>0){   //    If the current cell is not 0:
        c++;           //     Increase the non-zero island counter by 1
        f(m,i,j);}     //     Separate method call to flood-fill the matrix
  return c<2;}         //  Return true if 0 or 1 islands are found, false otherwise

void f(int[][]m,int x,int y){
                        // Separated method with matrix and cell input and no return-type
  try{if(m[x][y]>0){    //  If the current cell is not 0:
    m[x][y]=0;          //   Set it to 0
    f(m,x+1,y);         //   Recursive call south
    f(m,x,y+1);         //   Recursive call east
    f(m,x-1,y);         //   Recursive call north
    f(m,x,y-1);}        //   Recursive call west
  }catch(Exception e){}}//  Catch and swallow any ArrayIndexOutOfBoundsExceptions
                        //  (shorter than manual if-checks)

APL (Dyalog Unicode) , 36 byte ^SBCS

{2≥≢∪0,,(⍉××3⌈/0,,∘0)⍣2⍣≡⍵}××⍴⍴⍳∘≢∘,

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

Thạch , 23 byte

FJṁa@µ«Ḋoµ€ZUµ4¡ÐLFQL<3

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

Giải trình.

Chương trình ghi nhãn mỗi thành phần hình thái với một số khác nhau, sau đó kiểm tra xem có ít hơn 3 số không. (bao gồm 0).

Hãy xem xét một hàng trong ma trận.

«Ḋo   Given [1,2,3,0,3,2,1], return [1,2,3,0,2,1,1].
«     Minimize this list (element-wise) and...
 Ḋ      its dequeue. (remove the first element)
      So min([1,2,3,0,3,2,1],
             [2,3,0,3,2,1]    (deque)
      ) =    [1,2,0,0,2,1,1].
  o   Logical or - if the current value is 0, get the value in the input.
         [1,2,0,0,2,1,1] (value)
      or [1,2,3,0,3,2,1] (input)
      =  [1,2,3,0,2,1,1]

Liên tục áp dụng chức năng này cho tất cả các hàng và cột trong ma trận, trong tất cả các đơn hàng, cuối cùng tất cả các thành phần hình thái sẽ có cùng nhãn.

µ«Ḋoµ€ZUµ4¡ÐL  Given a matrix with all distinct elements (except 0),
               label two nonzero numbers the same if and only if they are in
               the same morphological component.
µ«Ḋoµ          Apply the function above...
     €           for €ach row in the matrix.

      Z        Zip, transpose the matrix.
       U       Upend, reverse all rows in the matrix.
               Together, ZU rotates the matrix 90° clockwise.
         4¡    Repeat 4 times. (after rotating 90° 4 times the matrix is in the
               original orientation)
           ÐL  Repeat until fixed.

Và cuối cùng...

FJṁa@ ... FQL<3   Main link.
F                 Flatten.
 J                Indices. Get `[1,2,3,4,...]`
  ṁ               ṁold (reshape) the array of indices to have the same
                  shape as the input.
   a@             Logical AND, with the order swapped. The zeroes in the input
                  mask out the array of indices.
      ...         Do whatever I described above.
          F       Flatten again.
           Q      uniQue the list.
            L     the list of unique elements have Length...
             <3   less than 3.

Haskell , 132 byte

 \m->null.snd.until(null.fst)(\(f,e)->partition(\(b,p)->any(==1)[(b-d)^2+(p-q)^2|(d,q)<-f])e).splitAt 1.filter((/=0).(m!)).indices$m

trích từ câu đố Solve Hitori

indices mliệt kê các (line,cell)vị trí của lưới đầu vào.

filter((/=0).(m!)) lọc ra tất cả các vị trí có giá trị khác không.

splitAt 1 phân vùng thành viên đầu tiên vào danh sách đơn bên cạnh danh sách còn lại.

any(==1)[(b-d)^2+(p-q)^2|(d,q)<-f]cho biết nếu (b,p)chạm vào biên giới f.

\(f,e)->partition(\(b,p)->touches(b,p)f)e tách ra khỏi cảm ứng từ không [chưa] cảm ứng.

until(null.fst)advanceFrontier lặp lại điều này cho đến khi biên giới không thể tiến xa hơn.

null.snd nhìn vào kết quả liệu tất cả các địa điểm cần đạt được có thực sự đạt được hay không.

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

Vết bẩn , 37 byte

C=[,0]&<e/\0{/e\0*0$e|CoF^0oX
e`C|:\0

In 1cho khớp và 0không khớp. Hãy thử trực tuyến!

Giải trình

Nonterminal Ckhớp với bất kỳ ký tự khác nào được kết nối với ký tự khác không đầu tiên của ma trận theo thứ tự đọc tiếng Anh.

C=[,0]&<e/\0{/e\0*0$e|CoF^0oX
C=                             A rectangle R matches C if
  [,0]                         it is a single character other than 0
      &                        and
       <                       it is contained in a rectangle S which matches this pattern:
        e/\0{/e\0*0$e           R is the first nonzero character in the matrix:
        e                        S has an edge of the matrix over its top row,
         /0{/                    below that a rectangle of 0s, below that
             e\0*0$e             a row containing an edge, then any number of 0s,
                                 then R (the unescaped 0), then anything, then an edge.
                    |CoF^0oX    or R is next to another match of C:
                     CoF         S is a match of C (with fixed orientation)
                        ^0       followed by R,
                          oX     possibly rotated by any multiple of 90 dergees.

Một số giải thích: ekhớp với hình chữ nhật có chiều rộng hoặc chiều cao bằng 0, là một phần của cạnh của ma trận đầu vào và $là "ký tự đại diện" khớp với mọi thứ. Biểu thức e/\0{/e\0*0$ecó thể được hình dung như sau:

+-e-e-e-e-e-e-e-+
|               |
|      \0{      |
|               |
+-----+-+-------+
e \0* |0|   $   e
+-----+-+-------+

Biểu thức CoX^0oXthực sự được phân tích cú pháp như ((CoF)0)oX; các oFvà oXlà nhà khai thác postfix và nối các thẻ phương tiện nối ngang. Việc ^cung cấp vị trí kề nhau được ưu tiên cao hơn sau đó oX, do đó phép quay được áp dụng cho toàn bộ biểu thức con. Các oFsửa chữa hướng của Csau khi nó được xoay bởi oX; mặt khác, nó có thể khớp với tọa độ khác không đầu tiên theo thứ tự đọc tiếng Anh xoay.

e`C|:\0
e`       Match entire input against pattern:
    :    a grid whose cells match
  C      C
   |     or
     \0  literal 0.

Điều này có nghĩa là tất cả các ký tự khác phải được kết nối với ký tự đầu tiên. Công cụ xác định lưới :về mặt kỹ thuật là một toán tử postfix, nhưng C|:\0là đường cú pháp cho (C|\0):.

Perl 5 , 131 129 + 2 ( -ap) = 133 byte

push@a,[@F,0]}{push@a,[(0)x@F];$\=1;map{//;for$j(0..$#F){$b+=$a[$'][$j+$_]+$a[$'+$_][$j]for-1,1;$\*=$b||!$a[$'][$j];$b=0}}0..@a-2

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

Python 2 , 211 163 150 byte

m,w=input()
def f(i):a=m[i];m[i]=0;[f(x)for x in(i+1,i-1,i+w,i-w)if(x>=0==(i/w-x/w)*(i%w-x%w))*a*m[x:]]
f(m.index((filter(abs,m)or[0])[0]))<any(m)<1>q

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

Đầu ra là thông qua mã thoát. Đầu vào là một danh sách 1d và chiều rộng của ma trận.