Tujuan

Anda memainkan permainan catur terkomputerisasi. Layar hanya hitam dan putih dan pikselnya tebal. Piksel putih menggunakan banyak daya dibandingkan piksel hitam dan Anda khawatir tentang jejak karbon Anda.

Dengan kotak dan notasi catur, kembalikan jumlah piksel putih yang ditampilkan di kotak.

Solusinya mungkin dalam bentuk fungsi atau program lengkap.

Memasukkan

String 4 karakter yang mendefinisikan:

1. Salah satunya wbuntuk bagian putih atau hitam. (Bukan bagian dari notasi Catur normal, tetapi diperlukan untuk puzzle ini.)
2. Salah satunya KQBNRPuntuk Raja, Ratu, Uskup, KNight, Benteng atau Gadai.
3. Salah satunya abcdefghuntuk file bagian (kolom).
4. Salah satunya 12345678untuk peringkat potongan (baris).

Keluaran

Jumlah piksel putih yang digunakan untuk menggambar bidak catur dan kotak yang mendasarinya.

Persyaratan

• Kotak catur adalah 8x8 piksel dan semuanya berwarna putih atau hitam.
• a1 adalah kotak hitam.
• Potongan catur putih digambar putih dengan garis hitam. Potongan hitam berwarna hitam dengan garis putih. Semua bagian memiliki piksel transparan yang menunjukkan kotak yang mendasarinya.
• Input peka huruf besar-kecil.
• Anggap inputnya valid.

Potongan-potongan catur memiliki sprite sebagai berikut.
.adalah warna bagian itu.
#adalah kebalikan dari warna bagian itu.
/adalah warna kotak yang mendasarinya.

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

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

Jumlah piksel dalam warna keping, garis besar keping, dan kotak yang mendasari untuk masing-masing keping adalah:

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

Uji Kasus

Input  Output
wRa1   23
bRa1   18
wPc2   54
bKg8   51

Mencetak gol

Kode terpendek dalam byte pada Hari Natal mendapat sedikit tambahan dalam stocking mereka.

Pyth, 54 53 byte

Kode ini berisi karakter yang tidak patut xxddicetak , jadi ini adalah hexdump yang dapat dibalik:

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

Atau, inilah versi ramah-rekatkan-tempel, yang juga bisa Anda coba online atau gunakan test suite :

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

C # 6, 107 byte

Ini jawaban saya sendiri. Saya tidak berharap ada poin yang menjadi tantangan.

Saya telah mengambil beberapa inspirasi dari jawaban user81655 .

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

Hitungan piksel dikodekan dalam blok 6-bit. Garis atau isian ditambahkan ke kotak (jika itu putih). Akhirnya, blok 6-bit untuk bagian yang sesuai diekstraksi.

Untungnya, operasi diutamakan bekerja sangat mendukung saya.

JavaScript (ES6), 106

Sebagai fungsi anonim.

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

Sekarang, saya mengikuti cara paling sederhana untuk menemukan jawaban dengan perhitungan - ini mungkin bukan cara terbaik.

Di atas kotak hitam, jawabannya adalah ukuran isi untuk potongan putih dan ukuran garis untuk potongan hitam. Di atas kotak putih, Anda perlu menambahkan ruang kosong. Lihat tabel di bawah ini (di dalam cuplikan)

Saya menjaga ukuran isian dan garis besar untuk setiap bagian, ruang kosong di dalam kotak dapat ditemukan dikurangi dari 64. Untuk menghemat ruang, garis besar disimpan sebagai satu digit afer subtracing 9. Isi lebih rumit karena rentang lebih lebar , periksa kode (dengan cara itu potongan-potongan itu diurutkan berdasarkan ruang yang ditempati)

Cuplikan uji:

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

Setiap karakter \u00xxharus berupa satu byte tunggal. Mereka diwakili di sini sebagai kode karena Stack Exchange secara otomatis menghapus karakter yang tidak dapat dibaca dari posting.

Penjelasan

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

Uji

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

Mungkin bisa mengurangi jumlah byte dengan menyandikan data, tapi saya agak suka metode tabel saat ini.

Basa warna kotak pada nilai ASCII 'w' atau 'b' mengambil keuntungan dari fakta bahwa seseorang genap dan satu aneh. Menetapkan nilai integer bagian berdasarkan posisi simbol bagian dalam mvariabel string. Apakah kotak gelap atau terang ditangani dengan (l+n)%2mengambil keuntungan dari nilai ASCII lagi.

Tidak disatukan

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 dengan menghapus c=c%2sebelum printdan menggunakan d[c%2][p]alih-alih d[c][p].