Un riempimento cavaliere è un riempimento inondazione che utilizza la connettività del pezzo degli scacchi cavaliere. In particolare:

 1 1
1   1
  0
1   1
 1 1

(0 è il punto iniziale, 1s mostra le celle collegate)

Sfida

Data una griglia 2D di spazi e pareti e una posizione iniziale, eseguire un riempimento cavaliere sulla griglia. Il codice più corto vince.

Regole

• Puoi prendere input e produrre output in qualsiasi formato tu voglia (immagine, stringa, matrice, qualunque cosa). È possibile prendere la posizione iniziale come parte della griglia di input o come coordinate separate. Ai fini di questa spiegazione, verrà utilizzato il seguente formato:

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

• L'output è una copia della griglia di input con il risultato di riempimento del cavaliere aggiunto

• Il riempimento non deve avere lo stesso "colore" dello spazio o dei muri, ma può essere uguale al marcatore di posizione iniziale. Ad esempio, data l'immagine sopra, un output valido sarebbe:

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

• Si può presumere che la griglia di input conterrà sempre una parete a 2 celle su tutti i lati

• Si può presumere che la posizione iniziale non sarà mai all'interno di un muro
• Si può presumere che la griglia non sarà mai più grande di 1000x1000
• I builtin vanno bene
• Il codice più breve (in byte) vince

Casi test

In tutti i casi di test, #indica un muro, indica spazio vuoto e xindica la posizione iniziale del riempimento. @indica il riempimento in uscita.

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:

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

Ottava, 73 byte

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

Demo online!

* Alcune modifiche applicate per l'esecuzione in rextester.

Una funzione che accetta un array 2d di 0 & 2 come wall e un array di 0 & 1 come posizione iniziale e genera un array di 0 & 1 & 2.

JavaScript (ES6), 116 byte

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>

Sulla base della mia risposta a Rileva castelli falliti . Riempie usando xs.

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

• 154 byte dopo aver contato solo la funzione principale e non la funzione relativa alla formattazione I / O
• salvato 7 byte: grazie a @Jacoblaw e @ Mr.Xcoder: except:0
• salvato 28 byte !!!: Grazie a @ovs: si è sbarazzato del try: exceptblocco e di molti altri campi da golf
• Grazie a @Dave per il bellissimo modulo di test.
• salvato 6 byte: g[(a,b)]come solog[a,b]
• @nore ha salvato 15 byte !!! :

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

Provalo online!

Mathematica, 117 byte

La solita storia: potenti incorporati ma nomi lunghi ...

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

Provalo nella sandbox Wolfram!

Ci vogliono due input: il primo è la griglia di input come una matrice di 0s (per i muri) e 1s (per gli spazi), quindi un singolo numero intero per la posizione iniziale, che si trova numerando la griglia lungo le file dall'alto verso il basso, ad es.

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

È possibile chiamare la funzione come HighlightGraph[...~Prepend~h]&[{{0,0,...,0}, {0,0,...,0}, ..., {0,0,...,0}}, 20] .

La KnightTourGraphfunzione costruisce un grafico con i vertici corrispondenti alle posizioni nella griglia e gli spigoli corrispondenti ai movimenti validi del cavaliere, quindi prendiamo Subgraphi vertici che non sono muri e troviamo il ConnectedComponentsvertice iniziale. L'output è un grafico (mostrato ruotato di 90º in senso antiorario) con i vertici non a parete evidenziati in rosso e i vertici riempiti evidenziati in giallo. Ad esempio, per il primo caso di test, l'output è simile a: