Un relleno de caballero es un relleno de inundación utilizando la conectividad de la pieza de ajedrez de caballero. Específicamente:

 1 1
1   1
  0
1   1
 1 1

(0 es el punto inicial, 1 muestra las celdas conectadas)

Desafío

Dada una cuadrícula 2D de espacios y paredes, y una ubicación inicial, realiza un relleno de caballero en la cuadrícula. El código más corto gana.

Reglas

• Puede tomar entradas y producir salidas en cualquier formato que desee (imagen, cadena, matriz, lo que sea). Puede tomar la ubicación inicial como parte de la cuadrícula de entrada o como una coordenada separada. A los fines de esta explicación, se utilizará el siguiente formato:

  ########    # = wall
  ########    x = initial location
  ## x  ##
  ##    ##
  ########
  ##    ##
  ########
  ########
  

• La salida es una copia de la cuadrícula de entrada con el resultado de relleno de caballero agregado

• Su relleno no debe estar en el mismo "color" que el espacio o las paredes, pero puede ser el mismo que el marcador de ubicación inicial. Por ejemplo, dada la imagen de arriba, una salida válida sería:

  ########    # = wall
  ########    @ = fill (could also have been x)
  ## @ @##
  ## @ @##
  ########
  ##@ @ ##
  ########
  ########
  

• Puede suponer que la cuadrícula de entrada siempre contendrá una pared de 2 celdas en todos los lados

• Puede suponer que la ubicación inicial nunca estará dentro de una pared
• Puede suponer que la cuadrícula nunca será mayor que 1000x1000
• Los builtins están bien
• El código más corto (en bytes) gana

Casos de prueba

En todos los casos de prueba, #denota un muro, denota un espacio vacío y xdenota la ubicación inicial del relleno. @denota el relleno de salida.

Input 1:

########
########
## x  ##
##    ##
########
##    ##
########
########

Output 1:

########
########
## @ @##
## @ @##
########
##@ @ ##
########
########

Input 2:

############
############
## ##    x##
## ##     ##
#####     ##
##        ##
############
############

Output 2:

############
############
## ##@@@@@##
##@##@@@@@##
#####@@@@@##
## @@@@@@@##
############
############

Input 3:

####################
####################
##  ##            ##
##  ##            ##
##  ##  ########  ##
##  ##  ########  ##
##  ##  ##    ##  ##
##  ##  ##    ##  ##
##  ##  ##    ##  ##
##  ##  ##    ##  ##
##  ##  ########  ##
##  ##  ########  ##
##  ##        ##  ##
##  ##       x##  ##
##  ############  ##
##  ############  ##
##                ##
##                ##
####################
####################

Output 3:

####################
####################
##@@##@@@@@@@@@@@@##
##@@##@@@@@@@@@@@@##
##@@##@@########@@##
##@@##@@########@@##
##@@##@@##    ##@@##
##@@##@@##    ##@@##
##@@##@@##    ##@@##
##@@##@@##    ##@@##
##@@##@@########@@##
##@@##@@########@@##
##@@##@@@@@@@@##@@##
##@@##@@@@@@@@##@@##
##@@############@@##
##@@############@@##
##@@@@@@@@@@@@@@@@##
##@@@@@@@@@@@@@@@@##
####################
####################

Input 4:

################
################
##           ###
##     x     ###
##  #######  ###
##  #######  ###
##  ##   ##  ###
##  ##   ##  ###
##  ##   ##  ###
##  ########  ##
##  ########  ##
##        ##  ##
##        ##  ##
################
################

Output 4:

################
################
##   @   @   ###
## @   @   @ ###
##  #######  ###
##@ ####### @###
##  ##   ##  ###
## @##   ##@ ###
##  ##   ##  ###
##@ ########@ ##
##  ########  ##
## @   @  ## @##
##   @   @##  ##
################
################

Input 5:

##############
##############
##         ###
##         ###
##         ###
##   ###   ###
##   #x#   ###
##   ###   ###
##         ###
##         ###
##         ###
##############
##############

Output 5:

##############
##############
##@@@@@@@@@###
##@@@@@@@@@###
##@@@@@@@@@###
##@@@###@@@###
##@@@#@#@@@###
##@@@###@@@###
##@@@@@@@@@###
##@@@@@@@@@###
##@@@@@@@@@###
##############
##############

Octava, 73 bytes

function a=F(s,a)do;b=a;until(a=~s&imdilate(a,de2bi(")0#0)"-31)))==b;a+=s

Demo en línea!

* Algunos cambios se aplicaron para ejecutarse en rextester.

Una función que toma una matriz 2d de 0 y 2 como pared y una matriz de 0 y 1 como ubicación inicial y genera una matriz de 0 y 1 y 2.

JavaScript (ES6), 116 bytes

f=(s,l=s.search`
`,t=s.replace(eval(`/(x| )([^]{${l-2}}(....)?|[^]{${l+l}}(..)?)(?!\\1)[x ]/`),'x$2x'))=>s==t?s:f(t)

v=(s,l=s.search`
`)=>!/^(#+)\n\1\n[^]*x[^]*\n\1\n\1$/.test(s)|s.split`
`.some(s=>s.length-l|!/^##.+##$/.test(s))&&`Invalid Input`

textarea{font-family:monospace}

<textarea rows=11 cols=33 oninput=o.value=v(this.value)||f(this.value)></textarea><textarea rows=11 cols=33 id=o reaodnly></textarea>

Basado en mi respuesta a Detect Failing Castles . Llena usando xs.

Python 3 , 394 387 381 356 352 347 319 313 154 139 bytes

• 154 bytes después de contar solo la función principal y no la función relativa al formato de E / S
• guardado 7 bytes: gracias a @Jacoblaw y @ Mr.Xcoder: except:0
• guardado 28 bytes !!!: Gracias a @ovs: eliminé el try: exceptbloque y varios otros campos de golf.
• Gracias a @Dave por el hermoso módulo de prueba.
• guardado 6 bytes: g[(a,b)]como solog[a,b]
• @nore guardó 15 bytes !!! :

def x(g,a,b,m):
 if(a,b)in g and"!">g[a,b]or m:
  g[a,b]="@"
  for i in 1,2,-1,-2:
   for j in 3-abs(i),abs(i)-3:g=x(g,a+i,b+j,0)
 return g

Pruébalo en línea!

Mathematica, 117 bytes

La historia habitual: poderosos complementos pero nombres largos ...

HighlightGraph[g,ConnectedComponents[h=Subgraph[g=KnightTourGraph@@Dimensions@#,Flatten@#~Position~1],#2]~Prepend~h]&

¡Pruébalo en el sandbox de Wolfram!

Se necesitan dos entradas: primero es la cuadrícula de entrada como una matriz de 0s (para las paredes) 1ys (para espacios), luego un solo entero para la posición inicial, que se encuentra numerando la cuadrícula a lo largo de las filas de arriba a abajo, por ejemplo

1  2  3  4  5
6  7  8  9  10
11 12 13 14 ...

Puedes llamar a la función como HighlightGraph[...~Prepend~h]&[{{0,0,...,0}, {0,0,...,0}, ..., {0,0,...,0}}, 20].

La KnightTourGraphfunción construye un gráfico con vértices correspondientes a las posiciones en la cuadrícula y los bordes correspondientes a los movimientos válidos de los caballeros, luego tomamos Subgraphlos vértices que no son paredes y encontramos el ConnectedComponentsvértice inicial. La salida es un gráfico (se muestra girado 90º en sentido antihorario) con los vértices que no son de pared resaltados en rojo y los vértices rellenos resaltados en amarillo. Por ejemplo, para el primer caso de prueba, la salida se ve así: