Un meandro de relleno de cuadrícula es un camino cerrado que visita cada celda de una cuadrícula cuadrícula al menos una vez, nunca cruza ningún borde entre celdas adyacentes más de una vez y nunca se cruza a sí mismo. Por ejemplo:$N \times N$

Una vez llenos, cada celda de la cuadrícula se puede representar por uno de los siguientes 8 mosaicos:

Numerados de esta manera, los mosaicos del meandro anterior se pueden representar mediante esta matriz:

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

Su tarea es completar un meandro de relleno de cuadrícula dado un conjunto incompleto de mosaicos. Por ejemplo, el meandro incompleto:

... que se puede representar usando 0s para las fichas faltantes:

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

... podría completarse así:

...es decir:

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

Especificaciones

• La entrada siempre tendrá al menos y como máximo mosaicos (no vacíos), donde .$1$$N^2$$2 \le N \le 7$
• Puede usar cualquier conjunto de valores para representar los mosaicos, siempre que se especifique en su respuesta.
• Su entrada y salida pueden estar en cualquier formato y orden, siempre que se especifique en su respuesta.
• Al menos existirá una solución válida para todas las entradas (es decir, no es necesario manejar entradas no válidas).
• Se aplican las reglas estándar de E / S.
• Las lagunas estándar están prohibidas.
• Se alientan las explicaciones, incluso para los idiomas "prácticos".

Casos de prueba

Entrada ( Θ ):

0 6
0 0

Salida ( Θ ):

5 6
4 3

Entrada ( Θ ):

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

Salida ( Θ ):

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

Entrada ( Θ ):

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

Salida ( Θ ):

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 bytes

Salidas modificando la matriz de entrada.

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)

Pruébalo en línea!

(incluye un código de procesamiento posterior para imprimir el resultado como una matriz y como una lista plana compatible con la herramienta de visualización proporcionada por el OP)

Resultados

• Caso de prueba n. ° 1
• Caso de prueba n. ° 2
• Caso de prueba n. ° 3

¿Cómo?

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

Controles iniciales

$n$

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

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

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

Por ahora, supongamos que no hemos vuelto al punto de partida.

Buscando un camino

$n$$0$$h$

$n$$0$

$n$$d$$d$

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

Las últimas 8 entradas no son válidas y se omiten. Las otras 4 entradas inválidas están explícitamente marcadas con guiones.

Como referencia, a continuación se encuentran la tabla decodificada, la brújula y el conjunto de mosaicos que se proporcionan en el desafío:

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

Validando el camino

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

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

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

De ahí el código JS:

!m[v ** .5 | 0]

Fuente formateada

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)