Cuenta de píxeles de ajedrez de 8 bits

20

Objetivo

Estás jugando un juego de ajedrez computarizado. La pantalla está en blanco y negro solamente y los píxeles son gruesos. Los píxeles blancos usan mucha energía en comparación con los píxeles negros y le preocupa su huella de carbono.

Dado un cuadrado y una pieza en notación de ajedrez, devuelve el número de píxeles blancos que se muestran en el cuadrado.

La solución puede ser en forma de una función o un programa completo.

Entrada

Una cadena de 4 caracteres que define:

  1. Uno wbpara una pieza blanca o negra. (No forma parte de la notación de ajedrez normal, pero se requiere para este rompecabezas).
  2. Uno KQBNRPpara un Rey, Reina, Obispo, Noche, Torre o Peón.
  3. Uno de abcdefghpara el archivo de la pieza (columna).
  4. Uno de 12345678para el rango de la pieza (fila).

Salida

El número de píxeles blancos utilizados para dibujar la pieza de ajedrez y el cuadrado subyacente.

Requisitos

  • Los cuadros de ajedrez son de 8x8 píxeles y son todos blancos o negros.
  • a1 Es un cuadrado negro.
  • Las piezas de ajedrez blancas se dibujan en blanco con un contorno negro. Las piezas negras son negras con un contorno blanco. Todas las piezas tienen píxeles transparentes que muestran el cuadrado subyacente.
  • La entrada distingue entre mayúsculas y minúsculas.
  • Suponga que la entrada es válida.

Las piezas de ajedrez tienen sprites de la siguiente manera.
.Es el color de la pieza.
#es el inverso del color de la pieza.
/es el color del cuadrado subyacente. 

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

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

El número de píxeles en el color de la pieza, el contorno de la pieza y el cuadrado subyacente para cada pieza es:

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 prueba

Input  Output
wRa1   23
bRa1   18
wPc2   54
bKg8   51

Puntuación

El código más corto en bytes para el día de Navidad obtiene algo extra en sus medias.

code-golf  kolmogorov-complexity  chess 
— Hand-E-Food
fuente

Respuestas:

2

Pyth, 54 53 bytes

El código contiene caracteres no imprimibles, así que aquí hay un xxdhexdump reversible :

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

Alternativamente, aquí hay una versión amigable de copiar y pegar, que también puede probar en línea o usar el conjunto de pruebas :

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

C # 6, 107 bytes

Aquí está mi propia respuesta. No espero ningún punto siendo el que planteó el desafío.

Me inspiré en la respuesta de user81655 .

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

Los recuentos de píxeles están codificados en bloques de 6 bits. El contorno o relleno se agrega al cuadrado (si es blanco). Finalmente, se extrae el bloque de 6 bits para la pieza apropiada.

Afortunadamente, la precedencia de la operación trabajó mucho a mi favor.

— Hand-E-Food
fuente
5

JavaScript (ES6), 106

Como una función 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))

Por ahora, sigo la forma más simple de encontrar la respuesta con un cálculo: esta podría no ser la mejor manera.

Sobre un cuadrado negro, la respuesta es el tamaño de relleno para las piezas blancas y el tamaño del contorno para las piezas negras. Sobre un cuadrado blanco, debe agregar el espacio libre. Ver la tabla a continuación (dentro del fragmento)

Mantengo el tamaño de relleno y contorno para cada pieza, el espacio libre dentro del cuadrado se puede restar de 64. Para ahorrar espacio, el contorno se almacena como un solo dígito después de la resta 9. El relleno es más complicado ya que el rango es más amplio , verifique el código (de esa manera las piezas se ordenan por espacio ocupado)

Fragmento de prueba:

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>
Expandir fragmento

— edc65
fuente
3

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 \u00xxdeben ser un solo carácter de un byte. Se representan aquí como códigos porque Stack Exchange elimina automáticamente los caracteres ilegibles de las publicaciones.

Explicación

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

Prueba

Mostrar fragmento de código

— usuario81655
fuente
1

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]))

Probablemente podría reducir el recuento de bytes al codificar los datos, pero me gusta un poco el método de la tabla actual.

Basa el color del cuadrado en el valor ASCII de 'w' o 'b' aprovechando el hecho de que uno es par y el otro es impar. Asigna el valor entero de la pieza en función de la posición del símbolo de la pieza en la mvariable de cadena. Si un cuadrado es oscuro o claro se maneja (l+n)%2aprovechando nuevamente el valor ASCII.

Sin golf

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 eliminando c=c%2antes printy usando en d[c%2][p]lugar de d[c][p].

— Cyv
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.