Pezzi di scacchi (re, regine, corvi, vescovi e cavalieri) e pedine sono su una tavola, ma non sul quadrato a1 o h8 . Il tuo compito è di viaggiare dal vuoto a1 ai vuoti h8 quadrati, passando solo per i quadrati vuoti. Le regole di movimento sono le seguenti:

1. Puoi procedere da qualsiasi quadrato vuoto a qualsiasi quadrato vuoto accanto ad esso (stesso rango, file successivo o precedente; o stesso file, rango successivo o precedente).
2. Puoi procedere da qualsiasi quadrato vuoto a qualsiasi quadrato vuoto in diagonale accanto ad esso (rango successivo o precedente, file successivo o precedente), a condizione che i quadrati degli angoli catty contengano (a) due pedine o (b) pedine / pezzi di opposti colore. (Due pezzi non pedone, o un pezzo non pedone e un pedone, dello stesso colore sono abbastanza forti da bloccare i tuoi progressi attraverso l'angolo, ma due pedine non lo sono; e pezzi / pedine di colore opposto non funzionano in concerto per impedirti.) Ad esempio, se sei su c4 e d5 è vuoto, puoi procedere a condizione che c5 e d4 contengano pedine o contengano pezzi / pedine di colore opposto. Vedere la sezione "Esempio di diagonali", di seguito, per le immagini.

Ingresso

Descrizione della scheda FEN . Cioè: l'input sarà una stringa che include una descrizione di rango 8 , una barra ( /), una descrizione di rango 7 , una barra, ... e una descrizione di rango 1 . La descrizione di ogni rango comprende numeri e lettere che vanno dal file a al file h , dove le lettere indicano pezzi e pedine (quelli neri sono p= pedone, n= cavaliere, b= vescovo, r= torre, q= regina, k= re e il bianco quelli sono versioni maiuscole degli stessi) e i numeri indicano il numero successivo di quadrati vuoti. Ad esempio, rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNè la tavola dopo una mossa di strato (pedina del re su e4) in una partita a scacchi.

a1 e h8 saranno vuoti nell'input; cioè, la prima barra ha una cifra prima di essa e l'ultima barra ha una cifra dopo di essa.

Produzione

Verità o falsità, indicando se è possibile un passaggio riuscito a h8 .

Se l'input non è una descrizione della scheda FEN valida (ovvero, che corrisponde alla mia spiegazione sopra), o se a1 o h8 è occupato, l'output può essere qualsiasi cosa o nulla. (In altre parole: si può presumere che l'input soddisfi i requisiti di cui sopra.)

punteggio

Questo è il codice golf: vince il minor numero di byte.

Esempio di input e output

Si noti che il codice deve funzionare per tutti gli input validi, non solo per gli esempi.

Aggiungi uno spazio e un wdopo ogni FEN per visualizzarlo in http://www.dhtmlgoodies.com/scripts/chess-fen/chess-fen-3.html. (Nota che alcuni altri visualizzatori FEN online non consentiranno una scacchiera illegale negli scacchi, ad esempio con una pedina di grado 1 o 8 , quindi non può essere utilizzata per i nostri scopi.)

Esempi sinceri

• 8/8/8/8/8/8/8/8 - la tavola vuota
• 1p1Q4/2p1Q3/2p1Q3/2p1Q3/2p1Q3/2p1Q3/Q1p1Q3/1q3q2- c'è un percorso a1 , b2 , b3 , b4 , b5 , b6 , b7 , c8 , d7 , ( non e8 , che è bloccato, ma) d6 , d5 , d4 , d3 , d2 , d1 , e1 , f2 , f3 , f4 , f5 , f6 , f7 , f8 , g8 , h8
• 8/8/KKKKK3/K3K3/K1K1p3/Kp1K4/K1KK4/2KK4 - un esempio in cui un quadrato bloccato in un punto deve essere passato più tardi (per assicurarsi di non impostare i quadrati come impraticabili)
• K1k1K1K1/1K1k1K1k/K1K1k1K1/1k1K1K1k/K1k1K1k1/1K1k1k1K/K1K1k1K1/1k1k1K1k- c'è un solo percorso (basta seguire il naso: c'è solo un quadrato in cui spostarsi ad ogni passo, a meno che non faccia un passo indietro); questo è anche un esempio in cui un quadrato è bloccato in un punto ma necessario in seguito

Esempi di Falsey

• 6Q1/5N2/4Q3/3N4/2Q5/1N6/2Q5/1N6 - qualsiasi tentativo di percorso dovrà passare attraverso due pezzi dello stesso colore situati in diagonale
• N1q1K1P1/1R1b1p1n/r1B1B1Q1/1p1Q1p1b/B1P1R1N1/1B1P1Q1R/k1k1K1q1/1K1R1P1r- l'unica via attraverso la diagonale a8-h1 è in f2-g3 , ma ciò richiederebbe il passaggio attraverso e1-d2 o f2-e3 , che sono entrambi impossibili.
• 4Q3/4q3/4Q3/5Q2/6Q1/3QqP2/2Q5/1Q6
• 4q3/4Q3/4q3/5q2/6q1/3qQp2/2q5/1q6

Diagonali di esempio

Nel caso in cui la prosa sopra non fosse chiara, ecco alcune immagini.

Diagonali passabili

Diagonali impraticabili

VBA 668 666 633 622 548 510 489 435 331 322 319 319 byte

Function Z(F):Dim X(7,7):While Q<64:R=R+1:V=Asc(Mid(F,R))-48:If V>9 Then X(Q\8,Q Mod 8)=(3+(V\8=V/8))*Sgn(48-V):V=1
Q=Q-V*(V>0):Wend:X(7,0)=1:For W=0 To 2E3:Q=W Mod 8:P=W\8 Mod 8:For T=Q+(Q>0) To Q-(Q<7):For S=P+(P>0) To P-(P<7):If X(S,T)=0 Then X(S,T)=(1=X(P,Q))*(6>X(P,T)*X(S,Q))
Next S,T,W:Z=X(0,7):End Function

La lettura della stringa di input occupa fino a "Wend". Bell'effetto collaterale: questo abbandona la stringa di input una volta che la scheda [X] è completamente codificata, quindi puoi lasciare una descrizione alla fine.

Nella codifica del tabellone, i pedoni sono 2, gli altri pezzi sono 3, il nero è negativo. Le pedine sono riconosciute da 'P' e 'p' con codici carattere divisibili per 8.

'X (7,0) = 1', impostazione a1 accessibile, è dove iniziano i controlli del percorso. Questo esegue ripetutamente la scansione della scacchiera cercando di aggiungere quadrati accessibili da quadrati contrassegnati come accessibili (1) finora. L'accesso diagonale e l'occupazione sono controllati in un calcolo logico IF + che una volta viveva in una funzione ma ora si trova in cicli adiacenti annidati. Il controllo di accesso diagonale si basa sul prodotto dei due quadrati degli angoli del gattino, che è solo a 6 o più se i pezzi hanno lo stesso colore e almeno uno è un pezzo non una pedina.

Chiama nel foglio di calcolo; restituisce il valore in X (0,7) - 1 se h8 accessibile e 0 in caso contrario - che Excel riconosce come verità / falsa. = IF (Z (C2), "sì", "no")

Forse mi sono lasciato trascinare dal fare scricchiolare il codice sopra, quindi ecco una versione commentata semi-non-golf:

Function MazeAssess(F)  'input string F (FEN)
Dim X(7, 7)             'size/clear the board; also, implicitly, Q = 0: R = 0
'Interpret string for 8 rows of chessboard
While Q < 64
    R = R + 1           ' next char
    V = Asc(Mid(F, R)) - 48  ' adjust so numerals are correct
    If V > 9 Then X(Q \ 8, Q Mod 8) = (3 + (V \ 8 = V / 8)) * Sgn(48 - V): V = 1 ' get piece type (2/3) and colour (+/-); set for single column step
    Q = Q - V * (V > 0) ' increment column (unless slash)
Wend
'Evaluate maze
X(7, 0) = 1             ' a1 is accessible
For W = 0 To 2000       ' 1920 = 30 passes x 8 rows x 8 columns, golfed to 2E3
    Q = W Mod 8         ' extracting column
    P = W \ 8 Mod 8     ' extracting row
    For T = Q + (Q > 0) To Q - (Q < 7)     ' loop on nearby columns Q-1 to Q+1 with edge awareness
        For S = P + (P > 0) To P - (P < 7) ' loop on nearby rows (as above)
            If X(S, T) = 0 Then X(S, T) = (1 = X(P, Q)) * (6 > X(P, T) * X(S, Q)) ' approve nearby empty squares if current square approved and access is possible
        Next 'S
    Next 'T
Next 'W
MazeAssess = X(0, 7)    ' report result for h8
End Function

Note sullo stato di avanzamento

Modifica 1: Il codice non è ora come 666-diabolico :-D e ha perso le sue funzioni; Ho trovato un modo abbastanza breve per scriverli per evitare il sovraccarico.

Modifica 2: Un altro grande passo avanti, che ha finito il lavoro di rimozione delle funzioni inc / dec, sospiro e uso di un paio di globi. Potrei finalmente riuscire a capire ...

La codifica di pezzi e quadrati è cambiata. Nessun effetto sulla lunghezza del codice.

Modifica 3: ritorno di funzioni (false), eliminando tutti quei fastidiosi Callbyte e alcune altre modifiche.

Modifica 4: Attraversando la grande 500, woohoo - ha trasformato i loop 3 in 1.

Modifica 5: Jiminy Cricket, un altro grosso calo quando ho combinato le due funzioni insieme: il mio controllo di accesso diagonale passa sempre per i quadrati adiacenti, quindi ...

Modifica 6: Holy niblicks, un'altra goccia enorme. Arrivederci a funzioni esterne e quindi a livello globale ... Sono passato a meno della metà della lunghezza originale pubblicata ...

Modifica 7: aggiungi la versione non modificata

Modifica 8: rivisto il processo di lettura per qualche dollaro in più

Modifica 9: spremuto un paio di espressioni per le ultime gocce di sangue

Modifica 10: L' Nextistruzione Compund perde alcuni byte

Per interesse, la grafica delle schede dopo l'analisi dell'accessibilità (i numeri di codice non sono aggiornati ma ...) i quadrati accessibili sono verdi, i quadrati inaccessibili bianchi e gli altri colori sono pezzi o pedine.

Un paio di schede sfida: h8 è accessibile in entrambi:

• P1Pq2p1 / 1P1R1R1p / 1K2R1R1 / 1p1p1p2 / p1b1b1np / 1B1B1N1k / Q1P1P1N1 / 1r1r1n2 - 10 passaggi da risolvere
• P1P3r1 / 1P1R2r1 / 1N1R1N2 / 1P1P1P2 / 1n1p1ppp / 1B1B4 / 1b1pppp1 / 1P6 - un percorso tortuoso

Matlab, 636 887 byte salvati (incluso rientro)

Questa soluzione non è molto giocosa, ma volevo andare avanti e metterlo su.

function[n] = h(x)
o=[];
for i=x
 b={blanks(str2num(i)),'K','k',i};o=[o b{~cellfun(@isempty,regexp(i,{'\d','[NBRQK]','[nbrqk]','p|P'}))}];
end
o=fliplr(reshape(o,8,8))
for i=1:64
 b=i-[-8,8,7,-1,-9,1,9,-7];
 if mod(i,8)==1
  b=b(1:5);
 elseif mod(i,8)==0
  b=b([1,2,6:8]);
 end
 b=b(b<65&b>0);c=o(b);dn=b(isspace(c)&ismember(b,i-[9,7,-9,-7]));
 for j=dn
  g=o(b(ismember(b,j-[-8,8,7,-1,-9,1,9,-7])));
  if ~isempty(regexp(g,'pk|kp|PK|KP|kk|KK'));c(b==j)='X';end;
 end
 Bc{i}=b(c==32);
end
n=Bc{1};
on=[];
while length(n)>length(on)
 on=n;
 for i=1:length(n)
  n=unique([n Bc{n(i)}]);
 end
end
any(n==64)
end

Legge una stringa di bordo xcome specificato sopra e la trasforma nel più completamente rappresentato o, quindi trova tutte le mosse (bordi del grafico) tra gli spazi, quindi capisce quali mosse sono possibili (non in spazi riempiti), quindi capisce quali mosse possibili hanno " cancelli "di due pezzi da attraversare, quindi capisce se il cancello è aperto (pedine, colori opposti) o chiuso (stesso colore e incluso un pedone). Quindi, passa attraverso per trovare posizioni raggiungibili con percorsi dal quadrato in basso a sinistra e se un percorso può raggiungere lo spazio 64, è una scheda Sì.