8-Bit-Schachpixelzählung

20

Tor

Sie spielen ein computergesteuertes Schachspiel. Die Anzeige ist nur in Schwarzweiß und die Pixel sind klobig. Weiße Pixel verbrauchen viel Energie im Vergleich zu schwarzen Pixeln und Sie sorgen sich um Ihren CO2-Fußabdruck.

Geben Sie bei einem Quadrat und einer Figur in Schachnotation die Anzahl der weißen Pixel zurück, die auf dem Quadrat angezeigt werden.

Die Lösung kann in Form einer Funktion oder eines vollständigen Programms vorliegen.

Eingang

Eine 4-stellige Zeichenfolge, die Folgendes definiert:

  1. Eines wbfür ein weißes oder schwarzes Stück. (Nicht Teil der normalen Schachnotation, aber für dieses Puzzle erforderlich.)
  2. Eines KQBNRPfür einen König, eine Königin, einen Bischof, eine Nacht, einen Turm oder einen Bauern.
  3. Eine abcdefghfür die Akte des Stückes (Spalte).
  4. Einer 12345678für den Rang des Stückes (Reihe).

Ausgabe

Die Anzahl der weißen Pixel, die zum Zeichnen der Schachfigur und des darunter liegenden Quadrats verwendet werden.

Bedarf

  • Schachquadrate haben eine Größe von 8 x 8 Pixel und sind entweder alle weiß oder alle schwarz.
  • a1 ist ein schwarzes Quadrat.
  • Weiße Schachfiguren werden weiß mit einem schwarzen Umriss gezeichnet. Schwarze Teile sind schwarz mit einem weißen Umriss. Alle Teile haben transparente Pixel, die das darunter liegende Quadrat anzeigen.
  • Bei der Eingabe wird zwischen Groß- und Kleinschreibung unterschieden.
  • Angenommen, die Eingabe ist gültig.

Die Schachfiguren haben folgende Sprites.
.ist die Farbe des Stückes.
#ist die Umkehrung der Farbe des Stücks.
/ist die Farbe des zugrunde liegenden Quadrats. 

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

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

Die Anzahl der Pixel in der Farbe des Stücks, der Kontur des Stücks und des zugrunde liegenden Quadrats für jedes Stück beträgt:

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

Testfälle

Input  Output
wRa1   23
bRa1   18
wPc2   54
bKg8   51

Wertung

Der kürzeste Code in Bytes am Weihnachtstag bringt ein kleines Extra in den Vorrat.

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

Antworten:

2

Pyth, 54 53 Bytes

Der Code enthält nicht druckbare Zeichen. Hier ist ein umkehrbarer xxdHexdump:

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

Alternativ finden Sie hier eine kopier- und einfügefreundliche Version, die Sie auch online testen oder die Testsuite verwenden können :

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

C # 6, 107 Bytes

Hier ist meine eigene Antwort. Ich erwarte keine Punkte, die die Herausforderung gestellt haben.

Ich habe mich von der Antwort von user81655 inspirieren lassen .

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

Die Pixelzahlen werden in 6-Bit-Blöcken codiert. Der Umriss oder die Füllung wird zum Quadrat hinzugefügt (wenn es weiß ist). Schließlich wird der 6-Bit-Block für das entsprechende Stück extrahiert.

Zum Glück wirkte sich der Vorrang der Operation sehr positiv auf mich aus.

— Hand-E-Food
quelle
5

JavaScript (ES6), 106

Als anonyme Funktion. 

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

Inzwischen verfolge ich den einfachsten Weg, um die Antwort mit einer Berechnung zu finden - dies könnte nicht der beste Weg sein.

Die Antwort über einem schwarzen Quadrat ist die Größe der Füllung für weiße Teile und die Größe der Kontur für schwarze Teile. Über einem weißen Quadrat müssen Sie den freien Platz hinzufügen. Siehe die Tabelle unten (im Snippet)

Ich behalte die Größe der Füllung und des Umrisses für jedes Stück bei. Der freie Platz innerhalb des Quadrats wird von 64 abgezogen. Um Platz zu sparen, wird der Umriss als einstellige Zahl nach Subtraktion 9 gespeichert. Die Füllung ist schwieriger, da der Bereich breiter ist , überprüfe den Code (so werden die Teile nach belegtem Platz sortiert)

Testschnipsel:

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>
Erweitern Sie das Snippet

— edc65
quelle
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))

Jedes \u00xxsollte ein einzelnes Ein-Byte-Zeichen sein. Sie werden hier als Codes dargestellt, da Stack Exchange automatisch nicht lesbare Zeichen aus Beiträgen entfernt.

Erläuterung

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

Prüfung

Code-Snippet anzeigen

— user81655
quelle
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]))

Könnte wahrscheinlich die Byteanzahl durch Codierung der Daten verringern, aber ich mag irgendwie die aktuelle Tabellenmethode.

Basiert die Farbe des Quadrats auf den ASCII-Wert von 'w' oder 'b', wobei die Tatsache ausgenutzt wird, dass einer gerade und einer ungerade ist. Weist einen ganzzahligen Wert des Stücks basierend auf der Position des Stücksymbols in der mZeichenfolgenvariablen zu. Ob ein Quadrat dunkel oder hell ist, wird durch (l+n)%2erneutes Ausnutzen des ASCII-Werts geregelt.

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 durch Entfernen c=c%2vor dem printund Verwenden d[c%2][p]statt d[c][p].

— Cyv
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.