Obbiettivo

Stai giocando a una partita di scacchi computerizzata. Il display è solo in bianco e nero e i pixel sono grossi. I pixel bianchi consumano molta energia rispetto ai pixel neri e sei preoccupato per la tua impronta di carbonio.

Dato un quadrato e un pezzo nella notazione di scacchi, restituisce il numero di pixel bianchi visualizzati nel quadrato.

La soluzione può essere sotto forma di una funzione o di un programma completo.

Ingresso

Una stringa di 4 caratteri che definisce:

Uno wbper un pezzo bianco o nero. (Non fa parte della normale notazione di scacchi, ma è richiesto per questo puzzle.)
Uno KQBNRPper un re, una regina, un vescovo, una notte, una torre o un pedone.
Uno dei abcdefghper il file del pezzo (colonna).
Uno 12345678per il rango del pezzo (fila).

Produzione

Il numero di pixel bianchi utilizzati per disegnare il pezzo degli scacchi e il quadrato sottostante.

Requisiti

I quadrati degli scacchi sono 8x8 pixel e sono tutti bianchi o tutti neri.
a1 è un quadrato nero.
I pezzi degli scacchi bianchi sono disegnati come bianchi con un contorno nero. I pezzi neri sono neri con un contorno bianco. Tutti i pezzi hanno pixel trasparenti che mostrano il quadrato sottostante.
L'input fa distinzione tra maiuscole e minuscole.
Supponiamo che l'input sia valido.

I pezzi degli scacchi hanno sprite come segue.
.è il colore del pezzo.
#è l'inverso del colore del pezzo.
/è il colore del quadrato sottostante.

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

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

Il numero di pixel nel colore del pezzo, contorno del pezzo e quadrato sottostante per ogni pezzo è:

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

Casi test

Input  Output
wRa1   23
bRa1   18
wPc2   54
bKg8   51

punteggio

Il codice più breve in byte entro il giorno di Natale ottiene qualcosa in più nella loro calza.

code-golf kolmogorov-complexity chess

— Hand-e-alimentari
fonte

2

Pyth, 54 53 byte

Il codice contiene caratteri non stampabili, quindi ecco un xxdhexdump reversibile :

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

In alternativa, ecco una versione amichevole copia-incolla, che puoi anche provare online o utilizzare la suite di test :

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

— PurkkaKoodari
fonte

6

C # 6, 107 byte

Ecco la mia risposta. Non mi aspetto che siano i punti a porre la sfida.

Ho preso ispirazione dalla risposta di user81655 .

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

I conteggi dei pixel sono codificati in blocchi di 6 bit. Il contorno o il riempimento viene aggiunto al quadrato (se è bianco). Infine, viene estratto il blocco a 6 bit per il pezzo appropriato.

Per fortuna, la precedenza dell'operazione ha funzionato pesantemente a mio favore.

— Hand-e-alimentari
fonte

5

JavaScript (ES6), 106

Come una funzione anonima.

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

Ormai sto seguendo il modo più semplice di trovare la risposta con un calcolo - questo potrebbe non essere il modo migliore.

Su un quadrato nero, la risposta è la dimensione del riempimento per i pezzi bianchi e la dimensione del contorno per i pezzi neri. Su un quadrato bianco, è necessario aggiungere lo spazio libero. Vedi la tabella sotto (all'interno dello snippet)

Mantengo le dimensioni del riempimento e del contorno per ogni pezzo, lo spazio libero all'interno del quadrato può essere sottratto da 64. Per risparmiare spazio, il contorno viene memorizzato come una sola cifra per sottrarre 9. Il riempimento è più complicato poiché l'intervallo è più ampio , controlla il codice (in questo modo i pezzi sono ordinati per spazio occupato)

Snippet di prova:

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>

Espandi frammento

— edc65
fonte

3

JavaScript (ES6), 135 112 byte

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

Ogni \u00xx dovrebbe essere un singolo carattere a un byte. Sono rappresentati qui come codici perché Stack Exchange rimuove automaticamente i caratteri illeggibili dai post.

Spiegazione

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

Test

Mostra snippet di codice

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>

Espandi frammento

— user81655
fonte

1

Lua, 158 155 byte

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

Probabilmente potrebbe ridurre il numero di byte codificando i dati, ma mi piace il metodo della tabella corrente.

Basa il colore del quadrato sul valore ASCII di 'w' o 'b' sfruttando il fatto che uno è pari e uno è dispari. Assegna il valore intero del pezzo in base alla posizione del simbolo del pezzo nella mvariabile stringa. Se un quadrato è scuro o chiaro viene gestito (l+n)%2sfruttando nuovamente il valore ASCII.

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 byte rimuovendo c=c%2prima di printe usando d[c%2][p]invece di d[c][p].

— CYV
fonte

Conteggio pixel degli scacchi a 8 bit