Objetivo

Você está jogando um jogo de xadrez computadorizado. A exibição é apenas em preto e branco e os pixels são grandes. Pixels brancos usam muita energia em comparação com pixels pretos e você está preocupado com sua pegada de carbono.

Dado um quadrado e uma peça na notação de xadrez, retorne o número de pixels brancos exibidos no quadrado.

A solução pode estar na forma de uma função ou de um programa completo.

Entrada

Uma cadeia de 4 caracteres que define:

1. Um wbpara uma peça branca ou preta. (Não faz parte da notação normal do xadrez, mas é necessário para este quebra-cabeça.)
2. Um KQBNRPpara um rei, rainha, bispo, kNight, torre ou peão.
3. Um abcdefghpara o arquivo da peça (coluna).
4. Um 12345678para o ranking da peça (linha).

Saída

O número de pixels brancos usados ​​para desenhar a peça de xadrez e o quadrado subjacente.

Exigências

• Quadrados de xadrez têm 8x8 pixels e são todos brancos ou todos pretos.
• a1 é um quadrado preto.
• Peças de xadrez brancas são desenhadas em branco com um contorno preto. Peças pretas são pretas com um contorno branco. Todas as peças têm pixels transparentes que mostram o quadrado subjacente.
• A entrada diferencia maiúsculas de minúsculas.
• Suponha que a entrada seja válida.

As peças de xadrez têm sprites da seguinte maneira.
.é a cor da peça.
#é o inverso da cor da peça.
/é a cor do quadrado subjacente.

King        Queen       Bishop  
////////    ////////    ////////
///#.#//    /#.#.#.#    ///#.#//
//#...#/    //#...#/    //##..#/
///#.#//    ///###//    //#.#.#/
///###//    //#...#/    ///###//
//#...#/    //#...#/    //#...#/
//#...#/    //#...#/    //#...#/
//#.#.#/    //#.#.#/    //#.#.#/

kNight      Rook        Pawn    
////////    ////////    ////////
////////    /#.#.#.#    ////////
//#..#//    /#.....#    ////////
/#....#/    /##...##    ///#.#//
///#..#/    //#...#/    //#...#/
//#..#//    //#...#/    ///#.#//
//#...#/    //#...#/    //#...#/
//#...#/    //#...#/    //#...#/

O número de pixels na cor da peça, no contorno da peça e no quadrado subjacente de cada peça é:

Piece    Fill  Outline  Square
==============================
King     13    16       35
Queen    17    18       29
Bishop   13    18       33
Knight   16    12       36
Rook     23    18       23
Pawn     11    10       43

Casos de teste

Input  Output
wRa1   23
bRa1   18
wPc2   54
bKg8   51

Pontuação

O código mais curto em bytes no dia de Natal recebe um pouco mais de sua meia.

Pitão, 54 53 bytes

O código contém caracteres não imprimíveis, então aqui está um xxdhexdump reversível :

0000000: 732a 562b 5f57 2543 687a 322c 3031 2573  s*V+_W%Chz2,01%s
0000010: 434d 7474 7a32 4063 434d 2e22 0a2b 011e  CMttz2@cCM.".+..
0000020: d699 71d0 c6dc 3db8 eeae 2233 252a 4368  ..q...=..."3%*Ch
0000030: 747a 5433 31                             tzT31

Como alternativa, aqui está uma versão amigável para copiar e colar, que você também pode experimentar on - line ou usar o conjunto de testes :

s*V+_W%Chz2,01%sCMttz2@cCM."\n+\x01\x1e\xd6\x99q\xd0\xc6\xdc=\xb8\xee\xae"3%*ChtzT31

C # 6, 107 bytes

Aqui está a minha própria resposta. Eu não espero que nenhum ponto seja aquele que colocou o desafio.

Eu me inspirei na resposta do usuário81655 .

long P(string a)=>(a[0]>99?12201284685:11042628752)+(a[2]+a[3])%2*46566348643>>"KQBNRP".IndexOf(a[1])*6&63;

As contagens de pixels são codificadas em blocos de 6 bits. O contorno ou preenchimento é adicionado ao quadrado (se for branco). Finalmente, o bloco de 6 bits para a peça apropriada é extraído.

Felizmente, a precedência da operação funcionou muito a meu favor.

JavaScript (ES6), 106

Como uma função anônima.

x=>(o=+'137999'[p='PNKBQR'.search(x[1])],f=+'262149'[p]+p,(parseInt(x[2]+x[3],19)%2?9:55-f-o)+(x>'w'?f:o))

Até agora, estou seguindo a maneira mais simples de encontrar a resposta com um cálculo - essa pode não ser a melhor.

Sobre um quadrado preto, a resposta é o tamanho do preenchimento para peças brancas e o tamanho do contorno das peças pretas. Sobre um quadrado branco, você precisa adicionar o espaço livre. Veja a tabela abaixo (dentro do snippet)

Eu mantenho o tamanho do preenchimento e do contorno de cada peça, o espaço livre dentro do quadrado pode ser encontrado subtraindo de 64. Para economizar espaço, o contorno é armazenado como um dígito após a subtrace 9. O preenchimento é mais complicado, pois o intervalo é maior. , verifique o código (é assim que as peças são classificadas por espaço ocupado)

Snippet de teste:

F=x=>(
  o=+'137999'[p='PNKBQR'.search(x[1])], // get outline - 9
  f=+'262149'[p]+p, // get fill -9
  (
    parseInt(x[2]+x[3],19) // parse with an odd base the differentiate between odd and even rows
    %2?9:55-f-o // black square if odd,, white if even so calc free space
  ) +(x>'w'?f:o) // add fill or outline based on piece color
)

// Test suite

console.log=x=>O.innerHTML+=x+'\n'

for(i=0; z='PNKBQR'[i]; i++)
{
  o = '';
  t = 'w'+z+'c2'; // white piece, white square
  o += t+' '+F(t)+', '
  t = 'b'+z+'c2'; // black piece, white square
  o += t+' '+F(t)+', '
  t = 'w'+z+'a1'; // white piece, black square
  o += t+' '+F(t)+', '
  t = 'b'+z+'a1'; // black piece, black square
  o += t+' '+F(t)
  console.log(o);
}

<pre>
Piece    Fill  Outline  Free  w/w b/w w/b b/b
=============================================
Pawn     11    10       43     54  53  11  10
Knight   16    12       36     52  48  16  12
King     13    16       35     48  51  13  16
Bishop   13    18       33     46  51  13  18
Queen    17    18       29     46  47  17  18
Rook     23    18       23     46  41  23  18
</pre>    
<pre id=O></pre>

JavaScript (ES6), 135 112 bytes

s=>(c={K:`\u000a\u0010\u0023`,Q:`\u0011\u0012\u001d`,B:`\u000a\u0012\u0021`,N:`\u0010\u000c\u0024`,R:`\u0017\u0012\u0017`,P:`\u000b\u000a\u002b`}[s[1]])[f="charCodeAt"](s<"w")+((s[f](2)-s[3])%2&&c[f](2))

Todos \u00xxdevem ter um caractere de um byte. Eles são representados aqui como códigos porque o Stack Exchange remove automaticamente caracteres ilegíveis das postagens.

Explicação

s=>

  // c = string of three (mostly unreadable) characters, the ASCII code of each character
  //     represents the number of pixels in the fill, outline and square respectively
  (c={
    K:`\u000a\u0010\u0023`,
    Q:`\u0011\u0012\u001d`,
    B:`\u000a\u0012\u0021`,
    N:`\u0010\u000c\u0024`,
    R:`\u0017\u0012\u0017`,
    P:`\u000b\u000a\u002b`
  }[s[1]])

  [f="charCodeAt"](s<"w") // if piece is black add outline pixels, else add fill pixels
  +((s[f](2)-s[3])%2      // this returns 1 if the square is white or 0 if black
    &&c[f](2))            // if the square is white add the square's pixels

Teste

var solution = s=>(c={K:`\u000a\u0010\u0023`,Q:`\u0011\u0012\u001d`,B:`\u000a\u0012\u0021`,N:`\u0010\u000c\u0024`,R:`\u0017\u0012\u0017`,P:`\u000b\u000a\u002b`}[s[1]])[f="charCodeAt"](s<"w")+((s[f](2)-s[3])%2&&c[f](2))

<input type="text" id="input" value="bKg8" />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

Lua, 158 155 bytes

c,p,l,n=(...):byte(1,4)m="KQBNRP"d={}d[1]={13,17,13,16,23,11}d[0]={16,18,18,12,18,10}p=m:find(string.char(p))print(d[c%2][p]+(l+n)%2*(64-d[0][p]-d[1][p]))

Provavelmente poderia reduzir a contagem de bytes, codificando os dados, mas eu meio que gosto do método da tabela atual.

Baseia a cor do quadrado no valor ASCII de 'w' ou 'b', aproveitando o fato de que um é par e um é ímpar. Atribui o valor inteiro da peça com base na posição do símbolo da peça na mvariável de sequência. Se um quadrado é escuro ou claro é tratado por(l+n)%2 aproveitando o valor ASCII novamente.

Ungolfed

c,p,l,n=(...):byte(1,4)   --stores input of all characters into variables
m="KQBNRP"                --piece encoded string
d={}                      --data table
d[1]={13,17,13,16,23,11}  --fill
d[0]={16,18,18,12,18,10}  --outline
p=m:find(string.char(p))  --position in string for position in tables
print(d[c%2][p] +         --takes data element from corresponding table according to color of piece and type of piece
     (l+n)%2  *           --is square black or white? 0 if back, 1 if white
     (64-d[0][p]-d[1][p]) --if white, pixels not used by piece would be area (64) minus pixels used by piece, or corresponding data in the tables
     )

-3 bytes removendo c=c%2antes de printe usando em d[c%2][p]vez de d[c][p].