Nous aimons nos énigmes étranges, nous les Britanniques

Dans quelques journaux britanniques, il existe un jeu appelé Hidato . Il est quelque peu similaire au Sudoku , mais au lieu d'avoir 1-9 dans une ligne et un bloc, il s'agit de placer des nombres de telle sorte qu'ils se connectent dans l'ordre du 01plus haut au plus élevé, de sorte qu'ils se touchent tous horizontalement, diagonalement ou verticalement .

Les entrées contiendront plusieurs lignes séparées par \n, contenant des blocs séparés par un espace, que vous pouvez supposer avoir deux caractères de large. Chaque bloc sera un nombre, un espace vide à remplir (indiqué par --) ou un mur qui ne peut pas contenir de chiffres entre ( XX).

Votre sortie doit correspondre à celle fournie mais avec des blocs vides fournis avec des nombres. Notez qu'il peut ne pas y avoir de solution unique, ou même l'existence d'une solution - certaines peuvent en produire plusieurs en raison de leur ambiguïté, un peu comme Sudoku, et certaines peuvent être littéralement insolubles, auquel cas vous devriez donner une sortie falsey , mais vous peut supposer que les entrées sont formatées comme ci-dessous.

Utilisez un en-tête standard Language: XX bytes. Bon golf!

Exemples

Entrées 01 XX 03, 01 -- 04, 01 --, etc devraient tous retourner quelque chose Falsey .

Contribution:

01 -- --
-- XX 05

Production:

01 03 04
02 XX 05

Contribution:

-- 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 --

Production:

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

Contribution:

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

Production:

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 octets

Il s'agit d'une solution de force brute, elle commence 01et vérifie chaque cellule voisine en recherchant les cellules vides ( --) ou le nombre souhaité et en suivant le chemin vers l'achèvement ou l'impossibilité. Si le nombre souhaité existe et n'est pas un voisin, il raccourcit cette solution. Prend quelques secondes pour la plus grande grille.

Ce n'est probablement pas particulièrement intéressant, mais j'ai pensé essayer de trouver une solution avant de regarder les réponses liées sur Rosetta Code et j'ai pris plaisir à relever un défi un peu plus difficile!

Trouve tout solutions lorsqu'elles existent . Le corps est une fonction qui accepte un tableau à deux dimensions et le pied de page traite l'entrée au format souhaité et renvoie également le résultat au format souhaité. Heureux de fournir plus d'informations (et une mise en œuvre moins golfée s'il y a un intérêt).

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}

Essayez-le en ligne!