Un méandre remplissant une grille est un chemin fermé qui visite chaque cellule d'une grille carrée au moins une fois, ne traversant jamais aucun bord entre des cellules adjacentes plus d'une fois et ne se croisant jamais. Par exemple:$N \times N$

Une fois remplie, chaque cellule de la grille peut être représentée par l'une des 8 tuiles suivantes:

Numérotées de cette façon, les tuiles du méandre ci-dessus peuvent être représentées par cette matrice:

5 6 5 6
4 8 3 2
5 7 6 2
4 3 4 3

Votre tâche consiste à terminer un méandre remplissant la grille étant donné un ensemble incomplet de tuiles. Par exemple, le méandre incomplet:

... qui peut être représenté à l'aide de 0s pour les tuiles manquantes:

5 0 0 0 6
0 0 7 0 0
0 0 0 0 3
2 4 0 0 0
0 0 3 0 0

... pourrait être complété comme ceci:

...c'est à dire:

5 6 5 1 6
4 8 7 6 2
5 7 7 7 3
2 4 8 8 6
4 1 3 4 3

Caractéristiques

• L'entrée aura toujours au moins et au plus tuiles (non vides), où .$1$$N^2$$2 \le N \le 7$
• Vous pouvez utiliser n'importe quel ensemble de valeurs pour représenter les tuiles, tant qu'il est spécifié dans votre réponse.
• Vos entrées et sorties peuvent être dans n'importe quel format et ordre, tant qu'elles sont spécifiées dans votre réponse.
• Au moins une solution valide existera pour toutes les entrées (c'est-à-dire que vous n'avez pas besoin de gérer les entrées non valides).
• Les règles d'E / S standard s'appliquent.
• Les failles standard sont interdites.
• Des explications, même pour les langues "pratiques", sont encouragées.

Cas de test

Entrée ( Θ ):

0 6
0 0

Sortie ( Θ ):

5 6
4 3

Entrée ( Θ ):

5 6 5 6
4 0 3 2
5 7 6 2
4 3 4 3

Sortie ( Θ ):

5 6 5 6
4 8 3 2
5 7 6 2
4 3 4 3

Entrée ( Θ ):

5 0 0 0 6
0 0 7 0 0
0 0 0 0 3
2 4 0 0 0
0 0 3 0 0

Sortie ( Θ ):

5 6 5 1 6
4 8 7 6 2
5 7 7 7 3
2 4 8 8 6
4 1 3 4 3

JavaScript (ES7),  236 ... 193  185 octets

Sorties en modifiant la matrice d'entrée.

m=>(g=(d,x,y,v,r=m[y],h=_=>++r[x]<9?g(d,x,y,v)||h():r[x]=0)=>r&&1/(n=r[x])?x|y|!v?n?g(d='21100--13203-32-21030321'[n*28+d*3+7&31],x+--d%2,y+--d%2,v+=n<7||.5):h():!m[v**.5|0]:0)(0,0,0,0)

Essayez-le en ligne!

(comprend un code de post-traitement pour imprimer le résultat à la fois sous forme de matrice et de liste plate compatible avec l' outil de visualisation fourni par l'OP)

Résultats

• Cas de test # 1
• Cas de test # 2
• Cas de test # 3

Comment?

Variables

$g$$d$$(x,y)$$v$

$g$

• $r$

  r = m[y]

• $h$$1$$8$$g$$g$$0$

  h = _ => ++r[x] < 9 ? g(d, x, y, v) || h() : r[x] = 0

Vérifications initiales

$n$

r && 1 / (n = r[x]) ? ... ok ... : ... failed ...

$(0,0)$$v>0$

x | y | !v ? ... no ... : ... yes ...

Pour l'instant, supposons que nous ne sommes pas revenus au point de départ.

À la recherche d'un chemin

$n$$0$$h$

$n$$0$

$n$$d$$d$

d = '21100--13203-32-21030321'[n * 28 + d * 3 + 7 & 31]

Les 8 dernières entrées sont invalides et omises. Les 4 autres entrées invalides sont explicitement marquées par des tirets.

Pour référence, voici le tableau décodé, la boussole et le jeu de tuiles fournis dans le défi:

   | 1 2 3 4 5 6 7 8
---+-----------------
 0 | 0 - - 1 3 - 3 1          1
 1 | - 1 - - 2 0 2 0        0 + 2
 2 | 2 - 1 - - 3 1 3          3
 3 | - 3 0 2 - - 0 2

$g$$1/2$$v$$7$$8$$1$

g(d, x + --d % 2, y + --d % 2, v += n < 7 || .5)

$d$$x$$y$

Validation du chemin

$(0,0)$$v>0$

$7$$8$$1/2$$v$

$v = N^2$$v > N^2$$v < N^2$$k$$k=\lfloor\sqrt{v}\rfloor$

D'où le code JS:

!m[v ** .5 | 0]

Source formatée

m => (
  g = (
    d,
    x, y,
    v,
    r = m[y],
    h = _ => ++r[x] < 9 ? g(d, x, y, v) || h() : r[x] = 0
  ) =>
    r && 1 / (n = r[x]) ?
      x | y | !v ?
        n ?
          g(
            d = '21100--13203-32-21030321'[n * 28 + d * 3 + 7 & 31],
            x + --d % 2,
            y + --d % 2,
            v += n < 7 || .5
          )
        :
          h()
      :
        !m[v ** .5 | 0]
    :
      0
)(0, 0, 0, 0)