Comptage de pixels d'échecs 8 bits

20

Objectif

Vous jouez à un jeu d'échecs informatisé. L'affichage est en noir et blanc uniquement et les pixels sont gros. Les pixels blancs consomment beaucoup d'énergie par rapport aux pixels noirs et vous êtes préoccupé par votre empreinte carbone.

Étant donné un carré et une pièce en notation d'échecs, retournez le nombre de pixels blancs affichés dans le carré.

La solution peut prendre la forme d'une fonction ou d'un programme complet.

Contribution

Une chaîne de 4 caractères définissant:

  1. Un wbpour une pièce blanche ou noire. (Ne fait pas partie de la notation d'échecs normale, mais est requis pour ce puzzle.)
  2. Un KQBNRPpour un roi, une reine, un évêque, une nuit, une tour ou un pion.
  3. Un abcdefghpour le fichier de la pièce (colonne).
  4. Un 12345678pour le rang de la pièce (ligne).

Production

Le nombre de pixels blancs utilisés pour dessiner la pièce d'échecs et le carré sous-jacent.

Exigences

  • Les carrés d'échecs mesurent 8 x 8 pixels et sont tous blancs ou noirs.
  • a1 est un carré noir.
  • Les pièces d'échecs blanches sont dessinées en blanc avec un contour noir. Les pièces noires sont noires avec un contour blanc. Toutes les pièces ont des pixels transparents qui montrent le carré sous-jacent.
  • L'entrée est sensible à la casse.
  • Supposons que l'entrée est valide.

Les pièces d'échecs ont des sprites comme suit.
.est la couleur de la pièce.
#est l'inverse de la couleur de la pièce.
/est la couleur du carré sous-jacent. 

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

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

Le nombre de pixels dans la couleur de la pièce, le contour de la pièce et le carré sous-jacent pour chaque pièce est:

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

Cas de test

Input  Output
wRa1   23
bRa1   18
wPc2   54
bKg8   51

Notation

Le code le plus court en octets le jour de Noël obtient un petit quelque chose en plus dans leur stockage.

code-golf kolmogorov-complexity chess Hand-E-Food
la source

Réponses:

2

Pyth, 54 53 octets

Le code contient des caractères non imprimables, voici donc un xxdhexdump réversible :

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

Alternativement, voici une version conviviale du copier-coller, que vous pouvez également essayer en ligne ou utiliser la suite de tests :

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

C # 6, 107 octets

Voici ma propre réponse. Je ne m'attends à aucun point étant celui qui a posé le défi.

Je me suis inspiré de la réponse de user81655 .

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

Le nombre de pixels est codé en blocs de 6 bits. Le contour ou le remplissage est ajouté au carré (s'il est blanc). Enfin, le bloc 6 bits de la pièce appropriée est extrait.

Heureusement, la priorité des opérations a grandement contribué à ma faveur.

Hand-E-Food
la source
5

JavaScript (ES6), 106

En tant que fonction anonyme. 

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

À l'heure actuelle, je suis en train de suivre la manière la plus simple de trouver la réponse avec un calcul - cela pourrait ne pas être la meilleure façon.

Sur un carré noir, la réponse est la taille du remplissage pour les pièces blanches et la taille du contour pour les pièces noires. Sur un carré blanc, vous devez ajouter l'espace libre. Voir le tableau ci-dessous (à l'intérieur de l'extrait)

Je garde la taille du remplissage et du contour pour chaque pièce, l'espace libre à l'intérieur du carré peut être trouvé en soustrayant de 64. Pour économiser de l'espace, le contour est stocké comme un seul chiffre après le sous-tracé 9. Le remplissage est plus délicat car la plage est plus large , vérifiez le code (c'est ainsi que les pièces sont triées par espace occupé)

Extrait de test:

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>
Développer l'extrait

edc65
la source
3

JavaScript (ES6), 135 112 octets

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

Chacun \u00xxdoit être un seul caractère d'un octet. Ils sont représentés ici sous forme de codes car Stack Exchange supprime automatiquement les caractères illisibles des publications.

Explication

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

Tester

Afficher l'extrait de code

user81655
la source
1

Lua, 158155 octets

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

Pourrait probablement réduire le nombre d'octets en encodant les données, mais j'aime un peu la méthode de table actuelle.

Base la couleur du carré sur la valeur ASCII de «w» ou «b» en profitant du fait que l'un est pair et l'autre est impair. Attribue la valeur entière de la pièce en fonction de la position du symbole de la pièce dans la mvariable de chaîne. Qu'un carré soit sombre ou clair est géré en (l+n)%2tirant à nouveau parti de la valeur ASCII.

Non 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 octets en supprimant c=c%2avant le printet en utilisant d[c%2][p]au lieu de d[c][p].

Cyv
la source