Thử thách này dựa trên trò chơi Layerz.

Được cung cấp, trên stdin hoặc làm đối số hàm, một mảng ô hình chữ nhật 2D trong đó mỗi ô chứa một khoảng trống (bạn có thể chọn sử dụng 0 thay vì khoảng trống mà không bị phạt), 1, 2, 3 hoặc 4 ; tìm cách chia nó thành các vùng hợp lệ (như được định nghĩa dưới đây) sao cho mỗi ô không trống được chứa chính xác bởi một vùng. Sau đó, xuất giải pháp tìm thấy trong bất kỳ định dạng hợp lý. Nếu không có giải pháp, hãy dừng lại mà không tạo ra đầu ra hoặc đầu ra một giá trị falsey duy nhất sau đó dừng lại.

Bất kỳ điều nào sau đây tạo thành một khu vực hợp lệ:

• Một ô chứa 1
• Một ô chứa 2 và chính xác là một trong những hàng xóm trực giao không trống của nó
• Một ô chứa 3 và chính xác là hai hàng xóm trực giao không trống của nó
• Một ô chứa 4 và chính xác ba hàng xóm trực giao không trống của nó

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất, tính bằng byte, sẽ thắng.

Một số trường hợp thử nghiệm:

1. Một thứ khá tầm thường:

Và đây là giải pháp, với mỗi vùng có một màu khác nhau:

2. Một điều thú vị hơn

Giải pháp này có nhiều hơn một giải pháp, nhưng đây là một trong số đó:

3. Một cái nhỏ hơn, chứa khoảng trống, không có bất kỳ giải pháp nào (tùy thuộc vào việc bạn sử dụng một trong hai twos để "bắt" ba hay ba để lấy hai trong số các twos, bạn sẽ còn lại một cặp twos không liền kề [và do đó không thể ghép đôi] hoặc một hai cái riêng lẻ):

Vì lưới này không có giải pháp, chương trình của bạn sẽ tạm dừng mà không tạo ra bất kỳ đầu ra nào khi được cung cấp lưới này.

4. Cái này (với 2 ô trên cùng dịch chuyển một ô sang trái) có một giải pháp mặc dù:

Giải pháp:

(Phía dưới bên phải 2 được sử dụng để "chụp" 3)

5. Bởi vì chúng tôi cần một trường hợp thử nghiệm với một số bốn:

Một cách giải quyết:

Tôi biết thử thách này đã hơn một năm tuổi, nhưng tôi chỉ tìm thấy điều này trong "chưa được trả lời" và trông khá thú vị đối với tôi.

Giả sử rằng số của ô "gốc" là số có ý nghĩa duy nhất trong mỗi khu vực (có thể rút ra từ các ví dụ), đây là giải pháp quay lui của tôi:

Python 3 , 355 351 349 byte

from itertools import*
def f(a):
 D=len(a[0])+1;S={D*r+c for r in range(len(a))for c in range(D-1)if a[r][c]};s=[{x,*t}for x in S for t in combinations({x-D,x-1,x+1,x+D}&S,a[x//D][x%D]-1)]
 def B(s,S,d=1):
  if{0}>S:return a
  if[]==s:return 0
  h,*t=s
  if h<=S:
   for x in h:a[x//D][x%D]=d
  return h<=S and B(t,S-h,d+1)or B(t,S,d)
 return B(s,S)

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

Định dạng đầu vào là danh sách số nguyên 2D, khoảng trắng là 0 và định dạng đầu ra cũng là danh sách số nguyên 2D đại diện cho một vùng trên mỗi số. Số khu vực bắt đầu tại một; không được dành riêng cho các ô trống (như trong đầu vào). Nếu đầu vào đã cho là không thể giải quyết được, hàm sẽ trả về số 0 duy nhất (giá trị giả).

Ví dụ, trường hợp thử nghiệm 5 là đầu vào như

[[2,3,2],
 [3,4,3],
 [0,4,0],
 [3,3,3],
 [2,3,2],
 [0,3,0]]

và đầu ra là

[[1,1,1],
 [2,2,2],
 [0,2,0],
 [3,4,5],
 [3,4,5],
 [0,4,0]]

Ungolfed, với ý kiến:

from itertools import*
def f(a):
 # Rows, cols, fake-cols to prevent neighbors wrap around
 R,C=len(a),len(a[0]);D=C+1
 # All valid cells represented as integers
 S={D*r+c for r in range(R) for c in range(C) if a[r][c]}
 # All valid regions rooted at each cell
 s=[{x,*t} for x in S for t in combinations({x-D,x-1,x+1,x+D}&S,a[x//D][x%D]-1)]
 # Start backtracking
 return backtrack(a,s,S,D)

# a: array to fill in the region numbers
# s: current candidates of regions
# S: current remaining cells to cover
# D: constant from f
# d: recursion depth == group number in the result
def backtrack(a,s,S,D,d=1):
 # Empty S: the board is correctly covered, return the result
 if not S:return a
 # Empty s: no more candidate regions to use, return false
 if not s:return 0
 h,*t=s
 # h is not a subset of S: h is not a valid cover, try with the rest using same depth
 if not h<=S:return backtrack(a,t,S,D,d)
 # h is a valid cover, write d to the cells in h
 for x in h:a[x//D][x%D]=d
 return backtrack(a,t,S-h,D,d+1)or backtrack(a,t,S,D,d)
 

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

Lưu ý: Đây là trường hợp đặc biệt của Bộ đóng gói nổi tiếng là hoàn thành NP. Vấn đề cụ thể này có kích thước tập hợp giới hạn (tối đa 4) và tồn tại các thuật toán xấp xỉ để tìm gói đóng gói "tốt" trong thời gian đa thức, nhưng chúng không đảm bảo đóng gói tối đa có thể có (yêu cầu nghiêm ngặt trong vấn đề này).