Adoriamo i nostri strani puzzle, noi inglesi

In alcuni giornali britannici esiste un gioco noto come Hidato . È in qualche modo simile al Sudoku , anche se invece di avere 1-9 in una linea e blocco, si tratta di posizionare numeri in modo tale che si colleghino dall'ordine 01fino a quello più alto, quindi si toccano tutti in orizzontale, in diagonale o in verticale .

Gli input conterranno più righe separate da \n, contenenti blocchi separati da uno spazio, che puoi assumere con una larghezza di due caratteri. Ogni blocco sarà un numero, uno spazio vuoto da riempire (indicato da --) o un muro che non può contenere numeri in ( XX).

L'output deve corrispondere a quello fornito anche se con blocchi vuoti forniti di numeri. Nota che potrebbe non esserci una soluzione unica, o addirittura l'esistenza, una - alcuni potrebbero produrre multipli a causa della loro ambiguità, molto simile al Sudoku, e alcuni potrebbero essere letteralmente irrisolvibili, nel qual caso dovresti dare un risultato falso , ma tu può presumere che gli input siano formattati come di seguito.

Usa un'intestazione standard Language: XX bytes. Buon golf!

Esempi

Ingressi 01 XX 03, 01 -- 04, 01 --, ecc dovrebbero tutti di ritorno qualcosa Falsey .

Ingresso:

01 -- --
-- XX 05

Produzione:

01 03 04
02 XX 05

Ingresso:

-- 33 35 -- -- XX XX XX    
-- -- 24 22 -- XX XX XX      
-- -- -- 21 -- -- XX XX
-- 26 -- 13 40 11 XX XX
27 -- -- -- 09 -- 01 XX
XX XX -- -- 18 -- -- XX
XX XX XX XX -- 07 -- --
XX XX XX XX XX XX 05 --

Produzione:

32 33 35 36 37 XX XX XX
31 34 24 22 38 XX XX XX
30 25 23 21 12 39 XX XX
29 26 20 13 40 11 XX XX
27 28 14 19 09 10 01 XX
XX XX 15 16 18 08 02 XX
XX XX XX XX 17 07 06 03
XX XX XX XX XX XX 05 04

Ingresso:

XX XX XX XX -- 53 XX XX XX XX
XX XX XX XX -- -- XX XX XX XX
XX XX 56 -- -- -- 30 -- XX XX
XX XX -- -- -- -- -- -- XX XX
XX -- -- 20 22 -- -- -- -- XX
XX 13 -- 23 47 -- 41 -- 34 XX
-- -- 11 18 -- -- -- 42 35 37
-- -- -- -- 05 03 01 -- -- --
XX XX XX XX -- -- XX XX XX XX
XX XX XX XX 07 -- XX XX XX XX

Produzione:

XX XX XX XX 52 53 XX XX XX XX
XX XX XX XX 54 51 XX XX XX XX
XX XX 56 55 28 50 30 31 XX XX
XX XX 26 27 21 29 49 32 XX XX
XX 25 24 20 22 48 45 44 33 XX
XX 13 19 23 47 46 41 43 34 XX
14 12 11 18 04 02 40 42 35 37
15 16 17 10 05 03 01 39 38 36
XX XX XX XX 09 06 XX XX XX XX
XX XX XX XX 07 08 XX XX XX XX

JavaScript (Node.js) , 482 byte

Questa è una soluzione a forza bruta, inizia a 01e controlla ogni cella vicina controllando le celle vuote ( --) o il numero desiderato e seguendo il percorso verso il completamento o l'impossibilità. Se il numero desiderato esiste e non è un vicino, abbrevia questa soluzione. Richiede alcuni secondi per la griglia più grande.

Questo probabilmente non è particolarmente interessante, ma ho pensato di provare a trovare una soluzione prima di guardare le risposte collegate a Rosetta Code e mi è piaciuto affrontare una sfida leggermente più difficile!

Trova tutte le soluzioni quando ne esistono molte . Il corpo è una funzione che accetta un array bidimensionale e il piè di pagina elabora l'input nel formato desiderato e restituisce anche il risultato nel formato desiderato. Felice di fornire maggiori informazioni (e un'implementazione meno golfizzata se c'è interesse).

f=a=>{F=(D,n,j)=>[Z=[].concat(...D),z=Z.indexOf(j),z>-1&&[x=z%w,y=z/w|0],z>-1&&[[x-1,y-1],[x,y-1],[x+1,y-1],[x-1,y],[x+1,y],[x-1,y+1],[x,y+1],[x+1,y+1]]][n];C=q=>q.map(Q=>Q.slice());w=a[0][L='length'];l=F(a,0).filter(c=>c!='XX')[L];R=[];r=(s,d)=>{let n=`0${+s+1}`.slice(-2);N=F(d,2,n);n>l?R.push(C(d)):~F(d,1,s)?(p=F(d,3,s),p.filter(P=>P==N+'')[L]?r(n,C(d)):!~F(d,1,n)?p.map(I=>{[x,y]=I,(x<0||x>w-1||y<0||y>d[L]-1)||d[y][x]=='--'&&(D=C(d),r(D[y][x]=n,D))}):0):0};r('01',a);return R}

Provalo online!