Giải quyết Alcazar này cho tôi


39

Gần đây tôi đã chơi một trò chơi tên là Alcazar. Đây là một trò chơi giải đố trong đó mục tiêu của bạn là đi vào từ một cánh cửa, đi qua tất cả các ô vuông và thoát qua một cánh cửa khác. Các quy tắc duy nhất là:

  • Nhập một lần, để lại một lần;
  • Đi qua tất cả các ô vuông;
  • Đừng đi qua một hình vuông nhiều lần

Hình ảnh dưới đây cho thấy một ví dụ về một bảng Alcazar và, ở bên phải của nó, câu đố đã được giải (tất nhiên đây là một câu đố dễ dàng):

Câu đố mẫu Alcazar

Bạn có thể tìm thấy nhiều câu đố hơn tại http://www.theincrediblecompany.com/try-alcazar và tải xuống trò chơi tại PlayStore (PS: Không phải quảng cáo).

Vấn đề của tôi là tôi gần như đã hoàn thành trò chơi, ngoại trừ một cấp độ. Tôi chỉ đơn giản là không thể tìm ra cách để giải quyết nó. Vì vậy, thách thức tôi đề xuất là: tạo ra một thuật toán giải quyết bất kỳ bình thường 1 thể giải quyết được 2 Alcazar cấp.

Tất nhiên, tôi không yêu cầu bất cứ ai xây dựng một trình thông dịch hình ảnh để đọc hình ảnh và giải câu đố (hay tôi?). Vì vậy, tôi đã vẽ lại câu đố trên bằng cách sử dụng các ký tự vẽ hộp. Câu đố và giải pháp của nó sẽ như thế này:

╔═══════╗         ╔═══════╗
║▒ ▒ ▒ ▒║         ║┌─┐ ┌─┐║
║     ║ ║         ║│ │ │║│║
╣▒ ▒ ▒║▒╠         ╣│ └─┘║└╠
║ ══╦═╩═╣         ║│══╦═╩═╣
║▒ ▒║▒ ▒║         ║└─┐║┌─┐║
║   ║   ║   ==>   ║  │║│ │║
╣▒ ▒║▒ ▒║         ╣┐ │║│ │║
║ ║ ║   ║         ║│║│║│ │║
╣▒║▒ ▒ ▒║         ╣│║└─┘ │║
║ ║     ║         ║│║    │║
║▒ ▒ ▒ ▒║         ║└─────┘║
╚═══════╝         ╚═══════╝

Trong bảng trên, là các ô cần điền.

Người ta có thể quan sát rằng có một gab dọc và ngang giữa các ô. Điều này là do tôi đã phải chèn một khoảng trống giữa các ô để thêm các bức tường. Điều này có nghĩa là các ô quan trọng duy nhất là các ô bên trên, bên dưới, bên trái và bên phải của mỗi ô. Các đường chéo có thể được loại bỏ mà không mất thông tin. Ví dụ, trong bảng dưới đây, cả hai đại diện cho cùng một câu đố:

╔════╩╗         ═ ═ ╩ 
║▒ ▒ ▒║        ║▒ ▒ ▒║
║ ═══ ║           ═   
║▒ ▒ ▒║   ==   ║▒ ▒ ▒║
║     ║               
║▒ ▒ ▒║        ║▒ ▒ ▒║
╚╦════╝         ╦═ ══ 

Điều này cũng hợp lệ cho các giải pháp. Đó là, không bắt buộc phải kết nối các ô:

╔════╩╗        ╔════╩╗        ╔════╩╗
║▒ ▒ ▒║        ║┌───┘║        ║┌ ─ ┘║
║ ═══ ║        ║│═══ ║        ║ ═══ ║
║▒ ▒ ▒║   ==   ║└───┐║   =>   ║└ ─ ┐║
║     ║        ║    │║        ║     ║
║▒ ▒ ▒║        ║┌───┘║        ║┌ ─ ┘║
╚╦════╝        ╚╦════╝        ╚╦════╝

Trong ví dụ trên, cả hai giải pháp đều có nghĩa giống nhau.

Vâng, các trường hợp thử nghiệm. Họ đây rồi:

Câu đố 1

╔════╩╗        ╔════╩╗
║▒ ▒ ▒║        ║┌ ─ ┘║
║ ═══ ║        ║ ═══ ║
║▒ ▒ ▒║   =>   ║└ ─ ┐║
║     ║        ║     ║
║▒ ▒ ▒║        ║┌ ─ ┘║
╚╦════╝        ╚╦════╝

Câu đố 2

╔═════╗        ╔═════╗
║▒ ▒ ▒║        ║┌ ─ ┐║
║   ║ ║        ║   ║ ║
╣▒ ▒║▒║        ╣└ ┐║│║
║ ║ ║ ║   =>   ║ ║ ║ ║
╣▒║▒ ▒╠        ╣┐║│ │╠
║ ║   ║        ║ ║   ║
║▒ ▒ ▒║        ║└ ┘ │║
╚════╦╝        ╚════╦╝

Câu đố 3

╔════╩══╗        ╔════╩══╗
║▒ ▒ ▒ ▒║        ║┌ ┐ └ ┐║
║ ║   ║ ║        ║ ║   ║ ║
╣▒║▒ ▒║▒╠        ╣┘║└ ┐║│╠
║ ╚══ ║ ║        ║ ╚══ ║ ║
║▒ ▒ ▒ ▒╠   =>   ║┌ ─ ┘ │╠
║   ═══ ║        ║   ═══ ║
║▒ ▒ ▒ ▒║        ║│ ┌ ┐ │║
║   ║   ║        ║   ║   ║
║▒ ▒║▒ ▒║        ║└ ┘║└ ┘║
╚═══╩═══╝        ╚═══╩═══╝

câu đố 4

╔═══════╗        ╔═══════╗
║▒ ▒ ▒ ▒║        ║┌ ┐ ┌ ┐║
║     ║ ║        ║     ║ ║
╣▒ ▒ ▒║▒╠        ╣│ └ ┘║└╠
║ ══╦═╩═╣        ║ ══╦═╩═╣
║▒ ▒║▒ ▒║        ║└ ┐║┌ ┐║
║   ║   ║   =>   ║   ║   ║
╣▒ ▒║▒ ▒║        ╣┐ │║│ │║
║ ║ ║   ║        ║ ║ ║   ║
╣▒║▒ ▒ ▒║        ╣│║└ ┘ │║
║ ║     ║        ║ ║     ║
║▒ ▒ ▒ ▒║        ║└ ─ ─ ┘║
╚═══════╝        ╚═══════╝

Câu đố 5

╔══╩══════╗        ╔══╩══════╗
║▒ ▒ ▒ ▒ ▒║        ║┌ ─ ┐ ┌ ┐║
║   ║     ║        ║   ║     ║
║▒ ▒║▒ ▒ ▒╠        ║└ ┐║└ ┘ │╠
║   ╠════ ║        ║   ╠════ ║
║▒ ▒║▒ ▒ ▒║   =>   ║┌ ┘║┌ ─ ┘║
║   ║     ║        ║   ║     ║
║▒ ▒║▒ ▒ ▒╠        ║└ ┐║└ ─ ─╠
║   ╠═════╣        ║   ╠═════╣
║▒ ▒║▒ ▒ ▒║        ║┌ ┘║┌ ─ ┐║
║   ║     ║        ║   ║     ║
║▒ ▒ ▒ ▒ ▒║        ║└ ─ ┘ ┌ ┘║
╚══╦═══╦══╝        ╚══╦═══╦══╝

Câu đố 6

╔═══════════╗        ╔═══════════╗
║▒ ▒ ▒ ▒ ▒ ▒║        ║┌ ┐ ┌ ┐ ┌ ┐║
║           ║        ║           ║
║▒ ▒ ▒ ▒ ▒ ▒║        ║│ └ ┘ └ ┘ │║
║       ═══ ║        ║       ═══ ║
║▒ ▒ ▒ ▒ ▒ ▒║        ║└ ┐ ┌ ─ ─ ┘║
║     ═══   ║        ║     ═══   ║
╣▒ ▒ ▒ ▒ ▒ ▒╠   =>   ╣┐ │ │ ┌ ┐ ┌╠
║           ║        ║           ║
║▒ ▒ ▒ ▒ ▒ ▒║        ║│ │ │ │ │ │║
║   ║   ║   ║        ║   ║   ║   ║
║▒ ▒║▒ ▒║▒ ▒║        ║│ │║│ │║│ │║
║   ║   ║   ║        ║   ║   ║   ║
║▒ ▒ ▒ ▒ ▒ ▒║        ║└ ┘ └ ┘ └ ┘║
╚═══════════╝        ╚═══════════╝

Câu đố 7

╔════╩════════╦╩╗        ╔════╩════════╦╩╗
║▒ ▒ ▒ ▒ ▒ ▒ ▒║▒║        ║┌ ─ ─ ─ ─ ─ ┐║│║
║ ║       ║   ║ ║        ║ ║       ║   ║ ║
║▒║▒ ▒ ▒ ▒║▒ ▒ ▒║        ║│║┌ ─ ─ ┐║┌ ┘ │║
║ ║ ║ ═══ ║     ║        ║ ║ ║ ═══ ║     ║
║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒╠        ║│ │║┌ ─ ┘ └ ┐ │╠
║   ║           ║        ║   ║           ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║        ║│ │ └ ┐ ┌ ┐ └ ┘║
║     ║ ║     ══╣        ║     ║ ║     ══╣
║▒ ▒ ▒║▒║▒ ▒ ▒ ▒║        ║│ └ ┐║│║│ └ ─ ┐║
║     ║ ║       ║        ║     ║ ║       ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║        ║│ ┌ ┘ │ └ ┐ ┌ ┘║
║           ║ ══╣   =>   ║           ║ ══╣
║▒ ▒ ▒ ▒ ▒ ▒║▒ ▒║        ║└ ┘ ┌ ┘ ┌ ┘║└ ┐║
╠══       ║ ╚══ ║        ╠══       ║ ╚══ ║
║▒ ▒ ▒ ▒ ▒║▒ ▒ ▒║        ║┌ ┐ └ ┐ │║┌ ─ ┘║
║     ║ ║ ║     ║        ║     ║ ║ ║     ║
║▒ ▒ ▒║▒║▒ ▒ ▒ ▒║        ║│ └ ┐║│║│ └ ─ ┐║
║ ║   ║ ║ ╔══   ║        ║ ║   ║ ║ ╔══   ║
║▒║▒ ▒ ▒ ▒║▒ ▒ ▒║        ║│║┌ ┘ │ │║┌ ┐ │║
║ ║     ║ ║     ║        ║ ║     ║ ║     ║
║▒ ▒ ▒ ▒║▒ ▒ ▒ ▒║        ║│ └ ─ ┘║└ ┘ │ │║
║       ╚══     ║        ║       ╚══     ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║        ║└ ─ ─ ─ ─ ─ ┘ │║
╚════╦═╦═╦═════╦╝        ╚════╦═╦═╦═════╦╝

Câu đố 8 (Xin lỗi, tôi thực sự không có giải pháp cho câu hỏi này)

╔══╩╦══╩═══╩═╩═╩═══╩╗
║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║
║   ║               ║
╣▒ ▒║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║
║   ╚══ ╔══     ╔═══╣
╣▒ ▒ ▒ ▒║▒ ▒ ▒ ▒║▒ ▒╠
║       ║   ╔══ ║   ║
╣▒ ▒ ▒ ▒ ▒ ▒║▒ ▒ ▒ ▒╠
║           ║       ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒╠
║           ║       ║
╣▒ ▒ ▒ ▒ ▒ ▒║▒ ▒ ▒ ▒╠
║   ╔═══╗   ╚══     ║
╣▒ ▒║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒║
║   ║   ║           ║
╣▒ ▒║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒╠
║ ══╝   ║       ╔══ ║
║▒ ▒ ▒ ▒║▒ ▒ ▒ ▒║▒ ▒║
║   ══╗ ╚══ ╔══ ║   ║
╣▒ ▒ ▒║▒ ▒ ▒║▒ ▒ ▒ ▒╠
║     ║     ║   ║   ║
╣▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║▒ ▒║
║   ═══   ══╗   ║   ║
╣▒ ▒ ▒ ▒ ▒ ▒║▒ ▒ ▒ ▒╠
╠══ ║       ║   ╔══ ║
║▒ ▒║▒ ▒ ▒ ▒ ▒ ▒║▒ ▒╠
║   ╚══ ║   ║   ║   ║
╣▒ ▒ ▒ ▒║▒ ▒║▒ ▒ ▒ ▒╠
║       ║   ║       ║
║▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒║
╚══╦═══╦═══╦═╦═╦═╦═╦╝

Đầu vào

Đầu vào của mã của bạn có thể có bất kỳ đại diện nào miễn là tuân theo các quy tắc sau:

  1. Nó phải là một đầu vào đồ họa. Vì vậy, không thể đọc một danh sách tọa độ, ví dụ.

  2. Tường ngang, tường dọc và cửa phải khác biệt và chúng phải được làm bằng một ký tự có thể nhìn thấy (không có ký tự trống).

  3. thể được thay thế bằng khoảng trống. Tôi chỉ sử dụng một nhân vật khác để làm nổi bật chúng.

Đầu ra

Đầu ra cũng có thể có bất kỳ đại diện nào miễn là tuân theo các quy tắc sau:

  1. Nó phải là một đầu ra đồ họa. Đó là, người ta có thể nhìn thấy con đường bằng cách nhìn vào nó.

  2. Quy tắc số một ngụ ý rằng các ký tự đường dẫn là khác nhau. Đó là, sẽ có ít nhất 6 nhân vật đường dẫn; ngang, dọc và góc.

  3. Để câu trả lời là hợp lệ, đầu ra phải cùng bảng với đầu vào (rõ ràng) với tất cả các ô (trong biểu diễn của tôi, ) được điền. Lấp đầy khoảng trống giữa các ô là tùy chọn.

Chấm điểm

Đây là , vì vậy mã ngắn nhất tính bằng byte sẽ thắng.

1 Có một số cấp độ Alcazar có các ô và đường hầm tùy chọn. Những điều này sẽ không được xem xét.

2 Có một số bảng Alcazar là không thể.


2
Chương trình của tôi không tìm thấy giải pháp cho câu đố 8. Bạn có chắc là nó có thể giải được không? Có lẽ một số lỗi đánh máy?
edc65

1
@ edc65 tương tự ở đây - không có giải pháp nào cho # 8
ngn

Câu trả lời:


5

Python 3 , 809 728 723 714 693 688 684 663 657 641 639 627 610 571 569 byte

Chỉnh sửa: Đã lưu 55 byte nhờ @Felipe Nardi Batista

Không chạy trường hợp thử nghiệm cuối cùng trong 60 giây trên TIO, nhưng dù sao cũng nên hoạt động chính xác. Trả về một danh sách tọa độ cho đường dẫn. Khoảng 400 byte được sử dụng để lấy danh sách dữ liệu từ I / O.

A=enumerate
I,J="═║"
B=range
L=len
K=-1
Z=1,0
X=0,1
C=K,0
V=0,K
E=lambda a,b,p:(((a,b)in d)*L(p)==H*h)*p or max([E(q+a,w+b,p+[(q+a,w+b)])for q,w in y[a][b]if~-((q+a,w+b)in p)*-h>w+b>K<q+a<H]+[[]])
x=input().split("\n")
h=L(x[0])//2
H=L(x)//2
y=[[{C,Z,V,X}for i in B(h)]for j in B(H)]
d=[]
exec('d+=[(%s,i)for i,a in A(x[%s][1::2])if I<a]\nfor i,u in A(x[%s:%s:2]):\n d+=[(i,0)]*(J<u[0])+[(i,h-1)]*(J<u[K])\n for j,w in A(u[%s:%s:2]):\n  if"%s"==w:y[i][j]-={%s};y[i+%s][j+%s]-={%s}\n'*2%(0,*X,"",2,K,J,X,*X,V,H-1,K,2,K,1,"",I,Z,*Z,C))
print(max(E(*D,[D])for D in d))

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


@HalvardHummel Vâng, xin lỗi vì công thức tồi của thử thách. Vì vậy, tôi đề xuất như sau. Điểm sẽ được tính bằng cách nhân số byte với thời gian chạy, do đó cả thời gian chạy và số byte sẽ được thưởng. Bạn nghĩ sao?
Phelype Oleinik

1
@PhelypeOleinik Tôi không nghĩ rằng đó là một hệ thống tính điểm rất tốt. Giữ nó cho golf coed là một giải pháp tốt hơn, nhưng nếu bạn thực sự tìm kiếm một giải pháp tôi chắc chắn rằng điều này có thể được sửa đổi để hiệu quả hơn.
caird coinheringaahing

@cairdcoinheringaahing Tôi hiểu rằng giải pháp tao nhã nhất là giữ nguyên trạng. Nhưng một thuật toán mất "vài ngày hoặc thậm chí vài tháng" để giải một bảng câu đố 8x12 bằng cách nào đó không hiệu quả, bạn có nghĩ vậy không? Theo cách tôi thấy, một thuật toán giải quyết vấn đề trong thời gian ngắn hơn nên được khen thưởng, ngay cả khi nó dài hơn một chút.
Phelype Oleinik

3
@PhelypeOleinik "Hiệu quả" của mã là không liên quan. Bạn đã thách thức chúng tôi viết mã ngắn, và đó là cơ sở cho thử thách của bạn. Thêm tốc độ mà chương trình chạy vào hỗn hợp chỉ làm phức tạp những thứ không cần thiết và cũng có thể bị khai thác cho điểm vô lý. Hệ thống tính điểm tùy chỉnh không có xu hướng hoạt động. Nếu bạn muốn mã ngắn, hãy tạo một câu hỏi về mã golf. Nếu bạn muốn mã nhanh, hãy tạo một câu hỏi mã nhanh nhất. Cố gắng trộn chúng lại với nhau không phải là một ý tưởng tốt.
LyricLy

Trong exec(...)chuỗi của bạn có năm dòng mới, được biểu thị là \n, 5 * 2 = 10 byte. Sử dụng một chuỗi ba trích dẫn sẽ thêm 4 byte ( ...''...''...) nhưng sau đó loại bỏ 5 byte, vì các ký tự dòng mới thực sự có thể được sử dụng. Tổng cộng điều này có thể tiết kiệm một byte.
Jonathan Frech

5

APL (Dyalog Classic) , 319 byte

iNj←⍳1+n←×/N←⌊2÷⍨⍴a←⎕⋄e←↑⊃,/{(,~'#='∊⍨a[(⍵⌽⍳2)∘+¨2×⍳N+⍵=⍳2])/,2,/[⍵]⊃,[⍵]/n i n}¨⍳2
r←{e g c←⍵⋄d←+/j∘.=∊g⋄e⌿⍨←(≠/c[e])∧2>⌈/d[e]⋄n≡≢g:gj/⍨d=10≡≢e:02>⌊/d+D←+/j∘.=,e:0⋄u←,¯1↑e←e[⍒⌊/D[e];]⋄e↓⍨←¯1⋄0≢r←∇e(g⍪u)(c-(-/c[u])×c=c[⊃u]):r⋄∇e g c}e(0e)j
a[1+2×⍳N]←' ??┌?─┐┬?└│├┘┴┤┼'[2⊥(↑(⊂i),¨¨{⊖∘⍉⍣⍵⊢n⍪¯1↓⌽∘⍉⍣⍵⊢i}¨⍳4)∊↓r⍪⌽r]
a

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

Sử dụng đầu vào =#F7LJ<>^v.thay vì ═║╔╗╚╝╣╠╩╦▒để phù hợp với bộ ký tự cổ điển .

Tất cả các trường hợp thử nghiệm ngoại trừ lần cuối cùng vượt qua trong vài giây.

Bài kiểm tra cuối cùng mất 47 phút trên máy tính của tôi và không mang lại giải pháp.

Khi đường dẫn kết quả sử dụng một cánh cửa gần một góc, nó có thể được hiển thị không chính xác (như thể đường mòn rẽ và đi qua một cửa tưởng tượng thêm), nhưng nó vẫn rõ ràng và không rõ ràng.


Rất tốt! Nếu tôi có thể hỏi, cách sử dụng mã của bạn để giải quyết? Tìm kiếm đầy đủ hoặc một cái gì đó thanh lịch hơn? Ngoài ra, như tôi đã nói, tôi đã không giải được câu đố cuối cùng bằng tay. Nó không có giải pháp từng bước rõ ràng và yêu cầu, ngay cả khi giải quyết bằng tay, một phỏng đoán để tìm ra câu trả lời. Câu đố này được bao gồm trong trò chơi gốc, nhưng nó có thể không có lời giải, vì vậy có lẽ không nên tính đến.
Phelype Oleinik

1
@PhelypeOleinik Vâng, đó là một tìm kiếm khá khó hiểu. Lý do nó tìm thấy các giải pháp hiện có một cách nhanh chóng là vì nó đã thử trường hợp có nhiều khả năng trước tiên (với vs không có cạnh nhất định trong biểu đồ - heuristic của tôi là cực tiểu của hai đỉnh, thấp hơn là dễ hơn). Lý do nó thực hiện khủng khiếp trong trường hợp cuối cùng là vì dù sao nó cũng kiểm tra tất cả các khả năng và chỉ cắt bỏ đệ quy trên các mâu thuẫn rõ ràng. Dường như không biết các thuật toán đường dẫn Hamilton tốt, ngay cả đối với trường hợp đặc biệt của đồ thị mức độ giới hạn (≤4 lân cận).
ngn

3

JavaScript (ES6), 274 byte

Nhập dưới dạng một chuỗi nhiều dòng, mỗi dòng kết thúc bằng một ký tự dòng mới. Các cánh cửa được đánh dấu bằng ký tự '2'

Xuất ra dưới dạng một chuỗi nhiều dòng với đường dẫn được đánh dấu bằng ký tự '1', rất dễ nhận thấy.

Đây là Tìm kiếm Đầu tiên Sâu , thử tất cả các đường dẫn và backtraking khi bị mắc kẹt. Nó hoàn toàn không hiệu quả, nhưng có thể giải các câu đố 1 .. 6 trong chưa đầy 1 phút.

z=>(w=z.search`
`+1,t=(w-2)*(z.length/w-1)/4,z=[...z],R=(p,l,q)=>[1,-1,w,-w].some(d=>l<t?z[q=p+d]<1&z[q+d]<1&&(R(q+d,++z[q]+l)||--z[q]):z[p+d]>1&&--z[p+d],++z[p])||--z[p],z.some((c,i)=>-c&&(x=i%w,R(i<w?i+w:x?x>w-3?i-1:i-w:i+1,--z[i])||++z[i]*0))&&z.join``.replace(/0/g,' '))

Ít chơi gôn

z => (
  w = z.search`\n`+1, // board width and offset to next row
  t = (w-2)*(z.length/w-1)/4, // total size of board, number of cells that must be filled
  z = [...z], // convert string to array
  d = [1, -1, w, -w], // delta to next position in all directions
  // recursive search
  // given a current position, try to move in all directions
  // if the board is not full, look for an emoty cell
  // if the board is full, look for a door
  R = (p, // current position
       l, // fill level
       q  // parameter used as a local variable
      ) => (
        ++z[p], // mark current position
        // .some will terminate early if the called function returns true
        // in case of return true the recursive function returns all way up leaving the path marked
        // in case of return false we need to unmark path and backtrack
        d.some( d => // for each direction, offset in d
          l < t // check if board is full
          ? z[q=p+d] < 1 & z[q+d] < 1 // not full, try to advance 
            && (++z[q], // mark intermediate cell
                R(q+d, 1+l) // recursive call incrementing fill level
                || --z[q] // if R return false, backtrack: unmark intermediate cell
               )
          : z[p+d] > 1 && --z[p+d]
        ) // full, ok only if I find a door nearby
        || --z[p], // if some returns false, unmark and backtrak
  // look for doors and for each door call R 
  // when R returns true, stop and return the marked board
  // if R returns false for each door, no solution, return false
  z.some((c,i) => 
   -c && // if numeric and != 0
    (x = i%w,
     z[i]=1, // marking starting position (door)
     R(i<w ? i+w : x ? x > w-3 ? i-1 : i-w : i+1, 1)
     || (z[i] = 2, false) // if R returned false, unmark a return false
    ) 
  ) && z.join``.replace(/0/g,' ') 
)

Bên trong đoạn kiểm tra có một giải pháp sử dụng DFS với một số ràng buộc để giải câu đố 7 trong chưa đầy một phút (trên PC của tôi). Câu đố 8 không có lời giải. Các ràng buộc:

  • Tất cả các ô trống phải có thể truy cập được từ ô hiện tại - không gian trống không được chia thành hai phần
  • Phải có một cánh cửa có thể tiếp cận
  • Một cấu hình của các ô không thể được khám phá nhiều lần
  • Không thể bỏ qua một ô chỉ có một ô trống liền kề

Kiểm tra

Coi chừng, câu đố 7 vượt quá thời gian chờ để thực thi javascript trong bất kỳ trình duyệt nào (sử dụng trình giải ngắn và chậm)

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.