이 Alcazar를 해결해주세요

최근에 나는 Alcazar라는 게임을하고 있습니다. 그것은 당신의 목표가 한 문에서 들어가고 모든 정사각형을 통과하고 다른 문을 통해 빠져 나오는 보드 퍼즐 게임입니다. 유일한 규칙은 다음과 같습니다.

한 번 입력하고 한 번만 두십시오.
모든 사각형을 통과하십시오.
사각형을 두 번 이상 통과하지 마십시오

아래 이미지는 Alcazar 보드의 예와 오른쪽에 해결 된 퍼즐을 보여줍니다 (물론 이것은 쉬운 퍼즐입니다).

http://www.theincrediblecompany.com/try-alcazar 에서 더 많은 퍼즐을 찾고 PlayStore (PS : 광고 아님)에서 게임을 다운로드하십시오.

내 문제는 한 수준을 제외하고는 거의 게임을 마쳤다는 것입니다. 나는 단순히 그것을 해결할 방법을 찾을 수 없습니다. 그래서 내가 제안하는 과제는 정상적인 ¹ 해결할 수있는 ² Alcazar 수준 을 해결하는 알고리즘을 만드는 것입니다.

물론 이미지를 읽고 퍼즐을 풀기 위해 이미지 통역사를 만들도록 요구하지 않습니다. 그래서 나는 상자 그림 문자를 사용하여 위의 퍼즐을 다시 그렸습니다. 퍼즐과 그 해결책은 다음과 같습니다.

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

위의 보드에는 ▒채워질 셀이 있습니다.

셀 사이에 세로 및 가로 개브가 있음을 알 수 있습니다. 벽을 추가하기 위해 셀 사이에 공백을 삽입해야하기 때문입니다. 즉, 각 셀의 위, 아래, 왼쪽 및 오른쪽에 중요한 셀만 있습니다. 정보 손실없이 대각선을 제거 할 수 있습니다. 예를 들어 아래 보드에서 둘 다 동일한 퍼즐을 나타냅니다.

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

솔루션에도 유효합니다. 즉, 셀을 연결할 필요가 없습니다.

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

위의 예에서 두 솔루션 모두 동일합니다.

예, 테스트 사례입니다. 여기 있습니다:

퍼즐 1

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

퍼즐 2

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

퍼즐 3

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

퍼즐 4

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

퍼즐 5

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

퍼즐 6

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

퍼즐 7

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

퍼즐 8 (죄송합니다,이 솔루션은 실제로 없습니다)

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

입력

코드의 입력은 다음 규칙을 따르는 한 어떤 표현이든 가질 수 있습니다.

그래픽 입력이어야합니다. 예를 들어, 좌표 목록을 읽을 수 없습니다.
수평 벽, 수직 벽 및 문은 고유해야하며 시각적 문자 (공백 문자 없음)로 만들어야합니다.
은 ▒블랭크로 대체 될 수있다. 방금 다른 캐릭터를 사용하여 강조했습니다.

산출

다음 규칙을 따르는 한 출력에 표시 할 수도 있습니다.

그래픽 출력이어야합니다. 즉, 경로를 보면 경로를 볼 수 있습니다.
규칙 1은 경로 문자가 다르다는 것을 의미합니다. 즉, 최소한 6 개의 경로 문자가있을 것입니다. 수평, 수직 및 모서리.
대답이 유효하려면 출력은 모든 셀 (내 표현에서는 ▒)이 채워진 입력과 동일한 보드 (명확하게)와 같아야합니다 . 셀 사이의 간격을 채우는 것은 선택 사항입니다.

채점

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

¹ 선택적인 셀과 터널이있는 일부 Alcazar 레벨이 있습니다. 이들은 고려되지 않습니다.

² 불가능한 일부 Alcazar 보드가 있습니다.

code-golf ascii-art puzzle-solver

— 필리프 올레 이닉
소스

내 프로그램에서 퍼즐 8에 대한 해결책을 찾지 못했습니다. 정말 확실합니까? 어쩌면 오타?

— edc65

여기 @ edc65 같은 - # 8 해결책

— NGN

답변:

파이썬 (3) , 809 (728) 723 714 693 688 684 663 657 641 639 627 610 571 569 바이트

편집 : @Felipe Nardi Batista 덕분에 55 바이트를 절약했습니다.

TIO에서 60 초 안에 마지막 테스트 사례를 실행하지 않지만 그럼에도 불구하고 올바르게 작동합니다. 패스의 좌표리스트를 돌려줍니다. 약 400 바이트의 바이트가 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))

온라인으로 사용해보십시오!

— 할 바드 험멜
소스

@HalvardHummel 글쎄, 도전의 나쁜 공식에 대해 죄송합니다. 그래서 나는 다음을 제안합니다. 점수는 바이트 수에 런타임을 곱하여 계산되므로 런타임과 바이트 수 모두 보상됩니다. 어떻게 생각해?

— Phelype Oleinik

@PhelypeOleinik 나는 그것이 아주 좋은 점수 시스템이라고 생각하지 않습니다. 골프 골프를 유지하는 것이 더 나은 솔루션이지만 실제로 솔루션을 찾고 있다면 더 효율적으로 수정할 수 있다고 확신합니다.

— caird coinheringaahing

@cairdcoinheringaahing 가장 우아한 해결책은 그대로 유지하는 것입니다. 그러나 8x12 퍼즐 보드를 해결하는 데 "일 또는 몇 달"이 걸리는 알고리즘은 어느 정도 비효율적입니다. 내가 보는 방식으로, 조금 더 짧은 시간에 문제를 해결하는 알고리즘은 조금 더 길더라도 보상을 받아야합니다.

— Phelype Oleinik

@PhelypeOleinik 코드의 "효율"은 관련이 없습니다. 당신은 우리에게 짧은 코드를 작성하도록 도전했으며, 이것이 당신의 도전의 기초입니다. 프로그램이 믹스에 실행되는 속도를 추가하면 불필요하게 복잡한 일이 발생하고 말도 안되는 점수를 얻을 수 있습니다. 맞춤 점수 시스템은 효과가없는 경향이 있습니다. 짧은 코드를 원한다면 코드 골프 질문을하십시오. 빠른 코드를 원하면 가장 빠른 코드 질문을하십시오. 그것들을 혼합하려고 시도하는 것은 좋은 생각이 아닙니다.

— LyricLy

당신의에서 exec(...)문자열로 표현 다섯 개 개의 새로운 라인,가 \n, 5 * 2 = 10 바이트. 삼중 따옴표로 묶인 문자열을 사용하면 ...''...''...실제 줄 바꿈 문자를 사용할 수 있으므로 4 바이트 ( ) 가 추가 되지만 5 바이트가 제거됩니다. 전체적으로 이것은 1 바이트를 절약 할 수 있습니다.

— Jonathan Frech

APL (Dyalog Classic) , 319 바이트

i←N⍴j←⍳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:g⍪j/⍨d=1⋄0≡≢e:0⋄2>⌊/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(0↑e)j
a[1+2×⍳N]←' ??┌?─┐┬?└│├┘┴┤┼'[2⊥(↑(⊂i),¨¨{⊖∘⍉⍣⍵⊢n⍪¯1↓⌽∘⍉⍣⍵⊢i}¨⍳4)∊↓r⍪⌽r]
a

온라인으로 사용해보십시오!

클래식 문자셋 에 맞추기 위해 =#F7LJ<>^v.대신 입력을 사용 합니다 .═║╔╗╚╝╣╠╩╦▒

마지막 테스트를 제외한 모든 테스트 사례는 몇 초 안에 통과합니다.

마지막 테스트는 내 컴퓨터에서 47 분이 걸리며 해결책이 없습니다.

결과 경로가 모퉁이 근처의 문을 사용하는 경우 잘못 렌더링 될 수 있지만 (트레일 분기점과 다른 가상 문을 통과하는 것처럼) 여전히 식별 할 수 있고 명확합니다.

— ngn
소스

아주 좋아요! 내가 물을 수 있다면, 당신의 코드는 어떤 접근법을 사용하여 해결합니까? 철저한 검색이나 더 우아한 무언가? 또한 내가 말했듯이, 나는 마지막 퍼즐을 손으로 풀지 않았습니다. 명확한 단계별 솔루션이 없으며 손으로 해결할 때도 답을 찾기위한 추측이 필요합니다. 이 퍼즐은 원래 게임에 포함되어 있지만 해결 방법이 없을 수 있으므로 고려해야합니다.

— Phelype Oleinik

@PhelypeOleinik 예, 그것은 다소 정교하지 않은 광범위한 검색입니다. 그것이 기존 솔루션을 빨리 찾는 이유는 더 가능성이 높은 경우를 먼저 시도하기 때문입니다 (그래프의 특정 가장자리가없는 vs. 마지막 경우에 끔찍하게 수행하는 이유는 어쨌든 모든 가능성을 테스트하고 명백한 모순에서만 재귀를 제거하기 때문입니다. 특별한 경우 경계도 (≤4 개 이웃) 그래프의 경우에도 좋은 해밀턴 경로 알고리즘은 알려지지 않은 것 같습니다.

— ngn

자바 스크립트 (ES6), 274 바이트

여러 줄 문자열로 입력되며 각 줄은 줄 바꿈 문자로 끝납니다. 문은 문자 '2'로 표시됩니다

경로가 문자 '1'로 표시된 여러 줄 문자열로 출력되므로 매우 쉽게 식별 할 수 있습니다.

이것은 뎁스 퍼스트 검색 (Depth First Search )으로 모든 경로를 시도하고 멈췄을 때 역 트래킹합니다. 전혀 효율적이지 않지만 1 분 안에 퍼즐 1-6을 풀 수 있습니다.

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

덜 골프

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

테스트 스 니펫에는 1 분 안에 퍼즐 7을 해결하는 제약이있는 DFS를 사용하는 솔루션이 있습니다 (내 PC에서). 퍼즐 8에는 해결책이 없습니다. 제약 사항 :

모든 빈 셀은 현재 셀에서 도달 할 수 있어야합니다. 빈 공간은 두 부분으로 분할되어서는 안됩니다
접근 가능한 문이 있어야합니다
셀 구성을 두 번 이상 탐색 할 수 없습니다
인접한 빈 셀이 하나만있는 셀을 건너 뛸 수 없습니다

테스트

퍼즐 7은 모든 브라우저에서 자바 스크립트 실행 시간 초과를 초과하지 않습니다 (Short and Slow 솔버 사용)

코드 스 니펫 표시

var Short=
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,' '))

var Fast=
b=>{
N=0
console.clear()
    F=(b,p,n) => D.reduce((n,d) => b[p+d] < 1 && b[p+d+d] < 1? F(b, p+d+d, n) : n, n+1, b[p]=1)
    A=(s, f, o, q, k)=>{
        D.map(d => b[s[1] + d] == 2 && (++o, q = s[1] + d));

        ++b[s[0]];
        if (++f < t)
        {
            if (o < m && !K[k=b.reduce((k,c,i)=>c>3?k+' '+i:k,s[1])] && F(b.slice(), s[K[k] = 1], f) >= t
                && R(D.reduce((n,d) =>(b[s[1] + d] == 0 && b[s[1] + d + d ] == 0 && n.push([s[1] + d, s[1] + d + d ]),n),[]),f,o,b[s[1]]=4))
                return 1;
        }
        else
        {
            b[s[1]] = 4;
            if (q) return b[q]++;
        }
        --b[s[0]]
        b[s[1]]=0
    }

    R=(s, f, o)=>{
        if (!s[1]) return A(s[0], f, o);
        var e, n, z=[];
        if (s.some(s =>(
                n = D.reduce( (n,d) => b[s[1]+d]>1 || (b[s[1]+d]<1 && b[s[1]+d+d]<1) ? n+1 : n, 0),
                n>2 ? !z.push(s) 
                : n>1 ? !z.unshift(s) 
                : n>0 && (e||(e=s,0))
        ))) return 0
        if (e) return A(e, f, o);
        return z.some(s => A(s, f, o))
    }

    w = b.search`\n` + 1;
    h = b.length / w;
    t = (w - 2) * (h - 1) / 4;
    D = [ 1, -1, w, -w ];
    b = [...b];
    K = {};
    s = [];
    b.forEach( (c,i) => -c ?  
        m = s.push( [i,i < w ? i + w : (x = i % w) > w - 3 ? i - 1 : x ? i - w : i + 1]):0
    )
    R(s, 0, 0);
    return b.join``.replace(/\d/g, c => ' oXOo'[c])
}

Out=(e,s)=>e.textContent = s

function Test(num)
{  
  var puzzle = document.getElementById('Z'+num).textContent;
  var solver = MF.checked ? Fast : Short
  Out(S,'...wait...')
  Out(T,'');
  
  var t0=performance.now()
  setTimeout(_=>(
    Out(S,solver(puzzle)),Out(T,((performance.now()-t0)/1000).toFixed(3)+' sec')
  ),10)
}

td { border: 1px solid #000; font-family: helvetica; font-size:12px; vertical-align: top; }
pre { line-height: 13px; }

Short and slow <input type='radio' value='S' name='M' id='MS'>
Long and faster <input type='radio' checked value='F'name ='M' id='MF'>
<table >
<tr>
<td id=T>Solution</td>
<td>Puzzle 1<input type='radio' name='T' onclick="Test(1)"></td>
<td>Puzzle 2<input type='radio' name='T' onclick="Test(2)"></td>
<td>Puzzle 3<input type='radio' name='T' onclick="Test(3)"></td>
<td>Puzzle 4<input type='radio' name='T' onclick="Test(4)"></td>
<td>Puzzle 5<input type='radio' name='T' onclick="Test(5)"></td>
<td>Puzzle 6<input type='radio' name='T' onclick="Test(6)"></td>
<td>Puzzle 7<input type='radio' name='T' onclick="Test(7)"></td>
</tr>
<tr>
<td><pre id=S></pre></td>
<td><pre id='Z1'>╔════2╗
║     ║
║ ═══ ║
║     ║
║     ║
║     ║
╚2════╝
</pre></td>
<td><pre id='Z2'>╔═════╗
║     ║
║   ║ ║
2   ║ ║
║ ║ ║ ║
2 ║   2
║ ║   ║
║     ║
╚════2╝
</pre></td>
<td><pre id='Z3'>╔════2══╗
║       ║
║ ║   ║ ║
2 ║   ║ 2
║ ╚══ ║ ║
║       2
║   ═══ ║
║       ║
║   ║   ║
║   ║   ║
╚═══╩═══╝
</pre></td>
<td><pre id='Z4'>╔═══════╗
║       ║
║     ║ ║
2     ║ 2
║ ══╦═╩═╣
║   ║   ║
║   ║   ║
2   ║   ║
║ ║ ║   ║
2 ║     ║
║ ║     ║
║       ║
╚═══════╝
</pre></td>
<td><pre id='Z5'>╔══2══════╗
║         ║
║   ║     ║
║   ║     2
║   ╠════ ║
║   ║     ║
║   ║     ║
║   ║     2
║   ╠═════╣
║   ║     ║
║   ║     ║
║         ║
╚══2═══2══╝
</pre></td>
<td><pre id='Z6'>╔═══════════╗
║           ║
║           ║
║           ║
║       ═══ ║
║           ║
║     ═══   ║
2           2
║           ║
║           ║
║   ║   ║   ║
║   ║   ║   ║
║   ║   ║   ║
║           ║
╚═══════════╝
</pre></td>
<td><pre id='Z7'>╔════2════════╦2╗
║             ║ ║
║ ║       ║   ║ ║
║ ║       ║     ║
║ ║ ║ ═══ ║     ║
║   ║           2
║   ║           ║
║               ║
║     ║ ║     ══╣
║     ║ ║       ║
║     ║ ║       ║
║               ║
║           ║ ══╣
║           ║   ║
╠══       ║ ╚══ ║
║         ║     ║
║     ║ ║ ║     ║
║     ║ ║       ║
║ ║   ║ ║ ╔══   ║
║ ║       ║     ║
║ ║     ║ ║     ║
║       ║       ║
║       ╚══     ║
║               ║
╚════2═2═2═════2╝
</pre></td>
</tr>
</table>

스 니펫 확장

— edc65
소스