Peças de xadrez (reis, rainhas, torres, bispos e cavaleiros) e peões estão em um tabuleiro, mas não no quadrado a1 ou h8 . Sua tarefa é viajar dos quadrados a1 vazios para os vazios h8 , passando apenas pelos quadrados vazios. As regras de movimento são as seguintes:

1. Você pode prosseguir de qualquer quadrado vazio para qualquer quadrado vazio próximo a ele (mesma classificação, arquivo seguinte ou anterior; ou mesmo arquivo, classificação seguinte ou anterior).
2. Você pode prosseguir de qualquer quadrado vazio para qualquer quadrado vazio na diagonal próximo a ele (classificação seguinte ou anterior, arquivo seguinte ou anterior), desde que os quadrados de cantinho contenham (a) dois peões ou (b) peões / peças opostas cor. (Duas peças que não são de peão, ou uma peça que não é de peão e um peão, da mesma cor são fortes o suficiente para impedir seu progresso no canto, mas dois peões não são; e peças / peões de cor oposta não funcionam Por exemplo, se você estiver em c4 e d5 estiver vazio, poderá prosseguir, desde que c5 e d4 contenham peões ou peças / peões de cor oposta. Veja a seção "Exemplo de diagonais", abaixo, para fotos.

Entrada

Descrição do conselho da FEN . Ou seja: A entrada será uma sequência que inclui uma descrição da classificação 8 , uma barra ( /), uma descrição da classificação 7 , uma barra,… e uma descrição da classificação 1 . A descrição de cada classificação compreende números e letras que vão de um arquivo para outro h , onde as letras indicam peças e peões (os pretos são p= peão, n= cavaleiro, b= bispo, r= torre, q= rainha, k= rei e branco) uns são versões maiúsculas do mesmo) e os números indicam o número sucessivo de quadrados vazios. Por exemplo, rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNé o tabuleiro após um movimento de dobra (peão do rei para e4) em um jogo de xadrez.

a1 e h8 estarão vazios na entrada; ou seja, a primeira barra tem um dígito antes e a última barra tem um dígito depois.

Resultado

Verdade ou falsa, indicando se a passagem bem-sucedida para h8 é possível.

Se a entrada não for uma descrição válida da placa FEN (ou seja, uma que corresponda à minha explicação acima), ou se a1 ou h8 estiver ocupado, a saída poderá ser qualquer coisa ou nada. (Em outras palavras: você pode assumir que a entrada atende aos requisitos acima.)

Pontuação

Este é o código de golfe: o menor número de bytes vence.

Exemplo de entrada e saída

Observe que seu código deve funcionar para todas as entradas válidas, não apenas os exemplos.

Adicione um espaço e um wapós cada FEN para visualizá-lo http://www.dhtmlgoodies.com/scripts/chess-fen/chess-fen-3.html. (Observe que alguns outros visualizadores online da FEN não permitirão um tabuleiro ilegal no xadrez, por exemplo, com um peão no ranking 1 ou 8 , portanto não podem ser usados ​​para nossos propósitos.)

Exemplos de verdade

• 8/8/8/8/8/8/8/8 - o tabuleiro vazio
• 1p1Q4/2p1Q3/2p1Q3/2p1Q3/2p1Q3/2p1Q3/Q1p1Q3/1q3q2- existe um caminho a1 , b2 , b3 , b4 , b5 , b6 , b7 , c8 , d7 , ( não e8 , que está bloqueado, mas) d6 , d5 , d4 , d3 , d2 , d1 , e1 , f2 , f3 , f4 , f5 , f6 , f7 , f8 , g8 , h8
• 8/8/KKKKK3/K3K3/K1K1p3/Kp1K4/K1KK4/2KK4 - um exemplo em que um quadrado bloqueado em um ponto deve ser passado mais tarde (para garantir que você não defina quadrados como intransitáveis)
• K1k1K1K1/1K1k1K1k/K1K1k1K1/1k1K1K1k/K1k1K1k1/1K1k1k1K/K1K1k1K1/1k1k1K1k- existe um único caminho (siga seu nariz: só existe um quadrado para mover a cada passo, a menos que dê um passo para trás); este também é um exemplo em que um quadrado é bloqueado em um ponto, mas necessário posteriormente

Exemplos de Falsey

• 6Q1/5N2/4Q3/3N4/2Q5/1N6/2Q5/1N6 - qualquer tentativa de caminho terá que passar por duas peças da mesma cor na diagonal
• N1q1K1P1/1R1b1p1n/r1B1B1Q1/1p1Q1p1b/B1P1R1N1/1B1P1Q1R/k1k1K1q1/1K1R1P1r- o único caminho através da diagonal a8-h1 é em f2-g3 , mas isso exigiria a passagem por e1-d2 ou f2-e3 , que são impossíveis.
• 4Q3/4q3/4Q3/5Q2/6Q1/3QqP2/2Q5/1Q6
• 4q3/4Q3/4q3/5q2/6q1/3qQp2/2q5/1q6

Diagonais de exemplo

Caso a prosa acima não esteja clara, aqui estão algumas fotos.

Diagonais aceitáveis

Diagonais intransponíveis

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

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

A leitura da sequência de entrada ocupa até 'Wend'. Bom efeito colateral - isso abandona a string de entrada quando o cartão [X] estiver totalmente codificado, para que você possa deixar uma descrição no final.

Na codificação do tabuleiro, os peões são 2, as outras peças são 3, o preto é negativo. Os peões são reconhecidos por 'P' e 'p' com códigos de caracteres divisíveis por 8.

'X (7,0) = 1', configurando a1 acessível, é onde as verificações de caminho começam. Isso varre repetidamente o quadro, tentando adicionar quadrados acessíveis dos quadrados marcados como acessíveis (1) até o momento. O acesso diagonal e a ocupação são verificados em um cálculo lógico + IF que antes vivia em uma função, mas agora fica em loops vizinhos aninhados. A verificação de acesso diagonal depende do produto dos dois quadrados de canto dos gatinhos, que são apenas 6 ou mais se as peças tiverem a mesma cor e pelo menos uma for uma peça e não um peão.

Chamada em planilha; retorna o valor em X (0,7) - 1 se h8 acessível e 0 se não - que o Excel reconhece como verdade / falsidade. = SE (Z (C2), "sim", "não")

Talvez eu tenha me empolgado em escrever o código acima, então aqui está uma versão comentada semi-não-golfista:

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

Notas de progresso

Edit 1: O código agora não é tão 666-devilish :-D e perdeu suas funções; Eu encontrei uma maneira curta o suficiente para escrevê-los para evitar a sobrecarga.

Edit 2: Outro grande salto em frente, efetivamente terminando o trabalho de remover as funções inc / dec, suspiro e usar algumas globais. Eu posso finalmente estar pegando o jeito disso ....

A codificação de peças e quadrados mudou. Nenhum efeito no comprimento do código.

Editar 3: Retorno de funções (falsas), removendo todos os Callbytes irritantes e alguns outros ajustes.

Edit 4: Rompendo os 500 grandes, woohoo - dividiu os loops 3 For em 1.

Edit 5: Jiminy Cricket, outra grande queda quando juntei as duas funções - minha verificação de acesso diagonal sempre passa por quadrados adjacentes, então ...

Edit 6: Holy niblicks, outra queda massiva. Adeus a funções externas e, portanto, globais ... eu já estou com menos da metade do tamanho original publicado ...

Editar 7: Adicionar versão não destruída

Edit 8: Revisou o processo de leitura por mais alguns dólares

Edit 9: Espremeu algumas expressões nas últimas gotas de sangue

Editar 10: a Nextinstrução Compund lança alguns bytes

Por interesse, os gráficos das placas após a análise de acessibilidade (os números de código estão desatualizados, mas ...) os quadrados acessíveis são verdes, os quadrados inacessíveis são brancos e as outras cores são peças ou peões.

Alguns painéis de desafio: o h8 pode ser acessado em ambos:

• P1Pq2p1 / 1P1R1R1p / 1K2R1R1 / 1p1p1p2 / p1b1b1np / 1B1B1N1k / Q1P1P1N1 / 1r1r1n2 - 10 passes para resolver
• P1P3r1 / 1P1R2r1 / 1N1R1N2 / 1P1P1P2 / 1n1p1ppp / 1B1B4 / 1b1pppp1 / 1P6 - um caminho sinuoso

Matlab, 636 887 bytes salvos (incluindo indentação)

Essa solução não é muito eficiente, mas eu queria ir em frente e colocá-la em prática.

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

Lê uma sequência de caracteres do quadro xconforme especificado acima e a transforma na mais completamente representada o, depois encontra todos os movimentos (arestas do gráfico) entre os espaços, depois descobre quais movimentos são possíveis (não nos espaços preenchidos) e depois descobre quais movimentos possíveis têm " portões "de duas peças para passar entre elas, e descobre se o portão está aberto (peões, cores opostas) ou fechado (mesma cor e incluindo um não-peão). Em seguida, ele percorre para encontrar locais acessíveis por caminhos a partir do quadrado inferior esquerdo e se um caminho pode alcançar o espaço 64, é um quadro Sim.