Cel

Grasz w komputerową grę w szachy. Wyświetlacz jest tylko czarno-biały, a piksele są masywne. Białe piksele zużywają dużo energii w porównaniu do czarnych pikseli i martwisz się o swój ślad węglowy.

Biorąc pod uwagę kwadrat i element w notacji szachowej, zwróć liczbę białych pikseli wyświetlanych na kwadracie.

Rozwiązanie może mieć postać funkcji lub pełnego programu.

Wejście

Ciąg 4 znaków definiujący:

1. Jeden z wbbiałych lub czarnych elementów. (Nie jest to część normalnej notacji szachowej, ale jest wymagana dla tej układanki.)
2. Jeden z KQBNRPkróla, królowej, biskupa, nocy, wieży lub pionka.
3. Jeden z abcdefghplików utworu (kolumna).
4. Jeden 12345678dla rangi (rzędu).

Wynik

Liczba białych pikseli użytych do narysowania szachy i leżącego poniżej kwadratu.

Wymagania

• Kwadraty szachowe mają wymiary 8 x 8 pikseli i są białe lub czarne.
• a1 to czarny kwadrat.
• Białe szachy są rysowane jako białe z czarnym konturem. Czarne kawałki są czarne z białym konturem. Wszystkie elementy mają przezroczyste piksele, które pokazują podstawowy kwadrat.
• W danych wejściowych rozróżniana jest wielkość liter.
• Załóż, że dane wejściowe są prawidłowe.

Szachy mają duszki w następujący sposób.
.jest kolorem utworu.
#jest odwrotnością koloru utworu.
/jest kolorem bazowym kwadratu.

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

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

Liczba pikseli w kolorze elementu, jego obrysie i kwadracie leżącym u podstaw każdego elementu wynosi:

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

Przypadki testowe

Input  Output
wRa1   23
bRa1   18
wPc2   54
bKg8   51

Punktacja

Najkrótszy kod w bajtach na Święta Bożego Narodzenia zyskuje coś więcej w swoich zapasach.

Pyth, 54 53 bajtów

Kod zawiera znaki niedrukowalne, więc oto odwracalny xxdzrzut heksowy:

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

Alternatywnie, oto wersja przyjazna dla kopiowania i wklejania, którą możesz również wypróbować online lub użyć zestawu testów :

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

C # 6, 107 bajtów

Oto moja własna odpowiedź. Nie spodziewam się żadnych punktów, które byłyby wyzwaniem.

Czerpałem inspirację z odpowiedzi user81655 .

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

Liczby pikseli są kodowane w blokach 6-bitowych. Kontur lub wypełnienie zostanie dodane do kwadratu (jeśli jest biały). Na koniec wyodrębniany jest 6-bitowy blok dla odpowiedniego elementu.

Na szczęście pierwszeństwo operacji działało na moją korzyść.

JavaScript (ES6), 106

Jako funkcja anonimowa.

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

Do tej pory podążam za najprostszym sposobem znalezienia odpowiedzi za pomocą obliczeń - może to nie być najlepszy sposób.

Nad czarnym kwadratem odpowiedzią jest rozmiar wypełnienia dla białych elementów i rozmiar konturu dla czarnych elementów. Nad białym kwadratem musisz dodać wolne miejsce. Zobacz poniższą tabelę (wewnątrz fragmentu)

Zachowuję wielkość wypełnienia i konturu dla każdego elementu, można znaleźć wolną przestrzeń wewnątrz kwadratu odejmując od 64. Aby zaoszczędzić miejsce, kontur jest przechowywany jako pojedyncza cyfra po odjęciu 9. Wypełnienie jest trudniejsze, ponieważ zakres jest szerszy , sprawdź kod (w ten sposób elementy są sortowane według zajętego miejsca)

Fragment testowy:

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 bajtów

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

Każdy \u00xxpowinien być pojedynczym jednobajtowym znakiem. Są one reprezentowane tutaj jako kody, ponieważ Stack Exchange automatycznie usuwa nieczytelne znaki z postów.

Wyjaśnienie

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

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 bajtów

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

Prawdopodobnie mógłbym zmniejszyć liczbę bajtów przez kodowanie danych, ale trochę podoba mi się metoda bieżącej tabeli.

Kolor kwadratu opiera się na wartości ASCII „w” lub „b”, wykorzystując fakt, że jeden jest parzysty, a drugi nieparzysty. Przypisuje wartość całkowitą elementu na podstawie pozycji symbolu elementu w mzmiennej typu string. Niezależnie od tego, czy kwadrat jest ciemny, czy jasny, można (l+n)%2ponownie wykorzystać wartość ASCII.

Nie golfił

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 Bajty przez usunięcie c=c%2przed printi użycie d[c%2][p]zamiast d[c][p].