Con tôi có một tấm thảm bảng chữ cái để chơi, một cái gì đó như thế này:

Sau nhiều tháng với các ô của thảm được đặt ngẫu nhiên, tôi cảm thấy mệt mỏi và đặt tất cả các ô của chiếu được nhóm theo các phần theo màu nền của chúng. Vì vậy, nếu các chữ cái đại diện cho màu nền, tôi có một tấm thảm như thế này:

AABBCDDDE
ABBCCCDEE
ABCCCCDDE
AACCCDDEE
AAAACCCCE
AAAAAACCC

Vì vậy, đối với các màu A, B, C, D và E luôn có cách kết nối tất cả các ô có cùng màu nền theo chiều ngang hoặc chiều dọc trong chiếu. Đó là những gì tôi gọi là một tấm thảm được nhóm đúng màu . Bạn có thể xem các nhóm cho ví dụ trước trong các bảng sau:

AA
A
A
AA
AAAA
AAAAAA

  BB
 BB
 B

    C
   CCC
  CCCC
  CCC
    CCCC
      CCC

     DDD
      D
      DD
     DD

        E
       EE
        E
       EE
        E

Ngoài ra, chỉ có một nhóm cho mỗi màu, vì vậy điều này sẽ không hợp lệ:

ABA
ABA

Bởi vì màu A gạch không được nhóm trong một nhóm duy nhất. Điều này cũng sẽ không hợp lệ vì các ô không kết nối theo chiều ngang hoặc chiều dọc:

AB
BA

Các thách thức

Đưa ra một mảng các ký tự 2 chiều trong phạm vi ASCII có thể in được (không cần phải là một hình vuông miễn là kích thước của cả hai chiều bằng hoặc lớn hơn 1), kiểm tra xem mảng có đại diện cho một tấm thảm được nhóm đúng màu không (mỗi ký tự khác nhau trong mảng đại diện cho một màu khác nhau). Đầu vào có thể ở bất kỳ định dạng hợp lý nào miễn là nó đại diện cho một mảng các ký tự 2 chiều (mảng char 2D, mảng các chuỗi có cùng độ dài, v.v.) và đầu ra phải là một cặp giá trị trung thực và falsey (0 / 1, 't' / 'f', đúng / sai, bất cứ điều gì miễn là một cái gì đó được trả về và các giá trị trả về là nhất quán giữa các đầu vào).

Đây là môn đánh gôn, vì vậy có thể chương trình / chức năng / phương pháp / lambda ngắn nhất cho mỗi ngôn ngữ sẽ giành chiến thắng!

Ví dụ

A    truthy

AB
AB   truthy

AB
BA   falsey

ABCDE    truthy

ABCDC    falsey

**::dd22
***:d222
*:::::22    truthy

$$$%%%&&
$$%%&&&&
&&$$$%&&    falsey

AABBCDDDE
ABBCCCDEE
ABCCCCDDE
AACCCDDEE
AAAACCCCE
AAAAAACCC   truthy

AABB
ABBA
AAAA    truthy

AAAB
AAAA
AAAA    truthy

Thảm của tôi được nhóm đúng theo màu sắc

(Tôi vẫn phải sửa các đường viền đó ...)

MATL , 16 15 byte

1e"G@=4&1ZI1>vzg

Đầu vào là một mảng char 2D (với các hàng cách nhau ;). Đầu ra là 0nếu đầu vào đủ điều kiện, hoặc 1nếu không.

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

Mã cần thiết kiểm tra xem mỗi char trong đầu vào chỉ có một thành phần được kết nối, xem xét kết nối 4 (nghĩa là không có đường chéo).

Chars lặp đi lặp lại được xử lý nhiều lần (đó là golf hơn so với lặp lại).

1e       % Implicit input. Reshape into a row vector of chars
"        % For each char
  G      %   Push input again
  @      %   Push current char
  =      %   Equal (element-wise)? Gives a matrix of zeros and ones, where one
         %   represents the presence of the current char
  4      %   Push 4. This will indicate 4-connectivity
  &1ZI   %   Matrix with labels of connected componnents. Inputs are a number (4)
         %   to indicate connectivity, and a binary matrix. The output is a matrix
         %   the same size as the input where each connected componnent of ones
         %   in the input is replaced by a different integer starting at 1
  1>     %   Greater than 1 (element-wise)? The result is a matrix. If the result 
         %   is true for some entry the input doesn't qualify
  v      %   Concatenate vertically with results from previous iterations
  z      %   Number of nonzero/true values
  g      %   Logical. Converts nonzero to true
         % Implicit end. Implicit display. False / true are displayed as 0 / 1

Befunge-93, 317 byte

Chỉnh sửa: Đã sửa lỗi cho số byte thích hợp. Cũng có thể được đánh gôn hơn nữa

93+:10pv  +93p01+1g01_  v@.1<
gp00g1+>00p~1+:93+`!#^_1-00g10
50p93+:vv_v#!:gg03:p02:<>40p#
!`g01: <>\ 1+:vvp05:+<@^p03_^#
v93$_v# !- g00<4v04g<^1<vp06:<
>+\!\>\ 3v> 40v0>g-v^<.g>:70vp
07_v#:<^ >#+0# g#\<  10\v4gg<^
!#v _$^  g03p <\ v1_#:^5>0g  -
   <    ^ g02p1< >-:#^_^#:g05
-1<   ^p\g06\0\+1:\g06\-1:\g06:\+1g06:g07

In 1 là sự thật, 0 là chim ưng

Dùng thử trực tuyến

Đây là một hình ảnh của con đường mà con trỏ đi

Lưu ý: đây là phiên bản cũ

Làm thế nào nó hoạt động

Đây là một số mã giả nhanh và bẩn

a = 2Darray() # from 12,12 down and to the right
arrayLocation = 12
x = arrayLocation #stored at 0,0
y = arrayLocation #stored at 1,0
i = input()       #stored in the stack
while (i != 0):
    if (i == 10):
        y++
        x = init
    else
        a[x][y] = i
        x++
    i = input

new.x = init    #stored at 2,0
new.y = init    #stored at 3,0

currentChar = 0    #stored at 4,0
chars = array()    #stored at 1,1 onwards
charnum = 0        #stored 5,0
ToCheck = array()  #stored in the stack

current.x = null   #stored at 6,0
current.y = null   #stored at 7,0

while (new.y < y):
    if (a[new] != 0)
        currentChar = a[new]
        toCheck[] = new
        while (toCheck)
            current = toCheck.pop()
            if (a[current] == currentChar)
                toCheck.append(adjacent(current))
                a[current] = 0
        foreach (chars as char)
            if (char == currentChar)
                return 0
        charNum++
        chars[charNum] = char
    new.x++
    if (new.x > x)
        new.x = init
        new.y++

return 1

Về cơ bản, sau khi lưu trữ đầu vào, nó đi qua toàn bộ, kiểm tra từng không gian. Khi tìm thấy một khoảng trắng có ký tự trong đó, nó sẽ thêm tọa độ vào ngăn xếp. Sau đó, nó kiểm tra các khoảng trống xung quanh nó cho cùng một ký tự theo cách đệ quy, đặt từng khoảng trắng thành 0. Khi nó đã hết phần của ký tự đó, nó sẽ kiểm tra xem ký tự đó đã có một phần chưa. Nếu vậy, trả về 0. Nếu không, thêm nó vào mảng các ký tự. Khi nó đã đi qua toàn bộ lưới mà không có bản sao, nó trả về 1.

Đối với những người quen thuộc với Befunge, đây là phiên bản mã cách nhau

96+:10p    v    +69p01+1g01_v
`+96:+1~p00<+1g00pg01g00-1_^#
v                           <
>40p50p96+:v                ^
v    @.1<  >
>:10g `#^_30p:20p:30gg:#v_$>1+:00g-!#v_0   >30g+
v                       <  ^         >$96+1^
>40p30gv                   ^
       >:!#v_70p:60p:70gg40 g-!#v_$>
           v               ^     > ^
1:\g06\+1:g 07\g07\-1:\g07\ +1: <^p\g06\0\-
v          <               ^
>50gv   >5\g1+:50p40g\1p20g^
    >:!#^_:1g40g-!#v_1-
                   >0.@

J, 66 byte

c=.1=+/@,+.]-:]*[:*@+/((,|."1)0,.1 _1)&(|.!.0)
[:*/[:c"2[="_ 0~.@,

cđịnh nghĩa một động từ mà nói với bạn nếu một ma trận của những người thân và số không được c onnected. Nó coi những người độc thân là một trường hợp đặc biệt. Mặt khác, nó cần một số đếm lân cận trực giao của mọi ô, sau đó là dấu của số đó, sau đó nhân với ma trận gốc: nếu sản phẩm đó bằng ma trận gốc, thì nó được kết nối.

Số lượng hàng xóm đạt được bằng cách dịch chuyển theo cả 4 hướng, sau đó tổng hợp. Sự thay đổi 4 hướng đạt được bằng cách sử dụng tính năng " x-arg can by a table" của xoay / shift|.

Cuối cùng, câu trả lời tự đạt được bằng cách tạo ma trận số / số không cho mọi phần tử duy nhất ~. của đầu vào, và sau đó đảm bảo rằng tất cả các ma trận đó được kết nối. Đây là động từ ở dòng thứ hai.

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

JavaScript (ES6), 114 byte

Đưa đầu vào như một mảng của chuỗi. Trả về 0hoặc 1.

a=>(C={},F=x=>!C[c=a[y][x]]|(g=v=>(a[y+v]||[])[x]==c)(-1)|g(1)|g(0,x--)|g(0,x+=2)?a[y+=!c]?F(C[c]=c?x:0):1:0)(y=0)

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

let f =

a=>(C={},F=x=>!C[c=a[y][x]]|(g=v=>(a[y+v]||[])[x]==c)(-1)|g(1)|g(0,x--)|g(0,x+=2)?a[y+=!c]?F(C[c]=c?x:0):1:0)(y=0)

console.log(f([ // 1
  "A"
]))

console.log(f([ // 1
  "AB",
  "AB"
]))

console.log(f([ // 0
  "AB",
  "BA"
]))

console.log(f([ // 1
  "ABCDE"
]))

console.log(f([ // 0
  "ABCDC"
]))

console.log(f([ // 1
  "**::dd22",
  "***:d222",
  "*:::::22"
]))

console.log(f([ // 0
  "$$$%%%&&",
  "$$%%&&&&",
  "&&$$$%&&"
]))

console.log(f([ // 1
  "AABBCDDDE",
  "ABBCCCDEE",
  "ABCCCCDDE",
  "AACCCDDEE",
  "AAAACCCCE",
  "AAAAAACCC"
]))

console.log(f([ // 1
  "AABB",
  "ABBA",
  "AAAA"
]))

console.log(f([ // 1
  "AAAB",
  "AAAA",
  "AAAA"
]))

Định dạng và nhận xét

a => (                            // given an array of strings a
  C = {},                         // C = object holding encountered characters
  F = x =>                        // F = recursive function taking x:
    !C[c = a[y][x]]               //   c = current character; is it a new one?
    | (g = v =>                   //   g = helper function taking v
        (a[y + v] || [])[x] == c  //       and testing whether a[y + v][x] == c
      )(-1)                       //   test a[y - 1][x]
    | g(1)                        //   test a[y + 1][x]
    | g(0, x--)                   //   test a[y][x - 1]
    | g(0, x += 2) ?              //   test a[y][x + 1]; if at least one test passes:
      a[y += !c] ?                //     increment y if c is undefined; if a[y] exists:
        F(C[c] = c ? x : 0)       //       update C, update x and do a recursive call
      :                           //     else:
        1                         //       all characters have been processed -> success
    :                             //   else:
      0                           //     invalid character detected -> failure
)(y = 0)                          // initial call to F, starting with x = y = 0

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

And@@(ConnectedGraphQ@Subgraph[GridGraph@Dimensions[t],Tr/@Position[c,#]]&/@(c=Join@@(t=#)))&

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

Lấy đầu vào dưới dạng danh sách các ký tự 2D: ví dụ: {{"A","B"},{"C","D"}} .

Nhân vật là\[Transpose] .

Làm thế nào nó hoạt động

Đối với mỗi nhân vật ctrong đầu vào, lấy Subgraphcủa GridGraphcủa cùng Dimensionsnhư đầu vào mà tương ứng với mỗi Positiontrong đó cxảy ra, và kiểm tra xem đó là một ConnectedGraphQ.

Python 2 , 247 byte

def f(a):
 b=map(list,a.split('\n'));l=len(b[0])
 for c in set(a):i=a.find(c);g(b,i/l,i%l,c)
 print all(set(l)<={0}for l in b)
def g(a,i,j,c):
 if len(a)>i>-1<j<len(a[0])and a[i][j]==c:
	for x,y in(0,1),(0,-1),(1,0),(-1,0):g(a,i+x,j+y,c);a[i][j]=0

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

JavaScript (ES6), 181 byte

(d,o={})=>{f=(i,j,c,l=d[i])=>{if(c&&l&&l[j]==c){l[j]='';f(i-1,j,c);f(i+1,j,c);f(i,j-1,c);f(i,j+1,c);o[c]=1}};d.map((e,i)=>e.map((c,j)=>o[c]||f(i,j,c)));return!d.some(e=>e.join(''))}

Bất cứ khi nào một ô màu mới được tìm thấy, hãy điền vào các ô được kết nối bằng các chuỗi trống. Nếu thảm được nhóm đúng theo màu, tất cả các ô nên được lấp đầy bằng các chuỗi trống.

Mã kiểm tra

const t =
(d,o={})=>{f=(i,j,c,l=d[i])=>{if(c&&l&&l[j]==c){l[j]='';f(i-1,j,c);f(i+1,j,c);f(i,j-1,c);f(i,j+1,c);o[c]=1}};d.map((e,i)=>e.map((c,j)=>o[c]||f(i,j,c)));return!d.some(e=>e.join(''))}
;

const mat = s=>s.split('\n').filter(l=>l).map(l=>l.split(''));
console.log('true?', t(mat(`
A
`)));
console.log('true?', t(mat(`
AB
AB
`)));
console.log('false?', t(mat(`
AB
BA
`)));
console.log('true?', t(mat(`
ABCDE
`)));
console.log('false?', t(mat(`
ABCDC
`)));
console.log('true?', t(mat(`
**::dd22
***:d222
*:::::22
`)));
console.log('false?', t(mat(`
$$$%%%&&
$$%%&&&&
&&$$$%&&
`)));
console.log('true?', t(mat(`
AABBCDDDE
ABBCCCDEE
ABCCCCDDE
AACCCDDEE
AAAACCCCE
AAAAAACCC
`)));
console.log('true?', t(mat(`
AABB
ABBA
AAAA
`)));
console.log('true?', t(mat(`
AAAB
AAAA
AAAA
`)));