लक्ष्य

आप एक कम्प्यूटरीकृत शतरंज का खेल खेल रहे हैं। डिस्प्ले केवल ब्लैक एंड व्हाइट में है और पिक्सल चंकी हैं। काले पिक्सेल की तुलना में सफेद पिक्सेल बहुत अधिक शक्ति का उपयोग करते हैं और आप अपने कार्बन पदचिह्न के बारे में चिंतित हैं।

शतरंज संकेतन में एक वर्ग और एक टुकड़े को देखते हुए, वर्ग में प्रदर्शित सफेद पिक्सेल की संख्या लौटाएं।

समाधान एक समारोह या एक पूर्ण कार्यक्रम के रूप में हो सकता है।

इनपुट

एक 4-वर्ण स्ट्रिंग परिभाषित करना:

एक wbसफेद या काले टुकड़े के लिए। (सामान्य शतरंज संकेतन का हिस्सा नहीं, लेकिन इस पहेली के लिए आवश्यक है।)
एक KQBNRPराजा, रानी, बिशप, kNight, Rook या प्यादा के लिए एक।
में से एक abcdefghटुकड़ा की फाइल (स्तंभ) के लिए।
में से एक 12345678टुकड़ा की रैंक (पंक्ति) के लिए।

उत्पादन

शतरंज के टुकड़े और अंतर्निहित वर्ग को खींचने के लिए उपयोग किए जाने वाले सफेद पिक्सेल की संख्या।

आवश्यकताएँ

शतरंज वर्ग 8x8 पिक्सेल हैं और सभी सफेद या सभी काले हैं।
a1 एक काला वर्ग है।
सफेद शतरंज के टुकड़े एक काले रंग की रूपरेखा के साथ सफेद रंग के होते हैं। काले टुकड़े एक सफेद रूपरेखा के साथ काले होते हैं। सभी टुकड़ों में पारदर्शी पिक्सेल होते हैं जो अंतर्निहित वर्ग को दर्शाते हैं।
इनपुट केस-संवेदी है।
मान लें कि इनपुट मान्य है।

शतरंज के मोहरे इस प्रकार हैं।
.टुकड़ा का रंग है।
#टुकड़ा के रंग का विलोम है।
/अंतर्निहित वर्ग का रंग है।

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

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

टुकड़े के रंग, टुकड़े की रूपरेखा और प्रत्येक टुकड़े के लिए अंतर्निहित वर्ग में पिक्सेल की संख्या है:

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

परीक्षण के मामलों

Input  Output
wRa1   23
bRa1   18
wPc2   54
bKg8   51

स्कोरिंग

क्रिसमस के दिन बाइट्स में सबसे छोटा कोड उनके स्टॉकिंग में कुछ अतिरिक्त हो जाता है।

code-golf kolmogorov-complexity chess

— हाथ-ए-खाना
स्रोत

2

पायथ, 54 53 बाइट्स

कोड में अनपेक्षित वर्ण हैं, इसलिए यहां एक प्रतिवर्ती xxdहेक्सडंप है:

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

वैकल्पिक रूप से, यहां एक कॉपी-पेस्ट फ्रेंडली संस्करण है, जिसे आप ऑनलाइन भी आज़मा सकते हैं या परीक्षण सूट का उपयोग कर सकते हैं :

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

— PurkkaKoodari
स्रोत

6

सी # 6, 107 बाइट्स

यहाँ मेरा अपना जवाब है। मैं किसी भी ऐसे बिंदु की उम्मीद नहीं करता, जो चुनौती पेश करता हो।

मैंने user81655 के उत्तर से कुछ प्रेरणा ली है ।

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

पिक्सेल की गणना 6-बिट ब्लॉक में एन्कोडेड है। बाह्यरेखा या भराव वर्ग में जोड़ा जाता है (यदि यह सफेद है)। अंत में, उपयुक्त टुकड़े के लिए 6-बिट ब्लॉक निकाला जाता है।

शुक्र है, ऑपरेशन की पूर्वता ने मेरे पक्ष में भारी काम किया।

— हाथ-ए-खाना
स्रोत

5

जावास्क्रिप्ट (ईएस 6), 106

एक अनाम फ़ंक्शन के रूप में।

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

अब तक, मैं गणना के साथ उत्तर खोजने का सबसे सरल तरीका अपना रहा हूं - यह सबसे अच्छा तरीका नहीं हो सकता है।

एक काले वर्ग पर, उत्तर सफेद टुकड़ों के लिए भरने का आकार और काले टुकड़ों के लिए रूपरेखा का आकार है। एक सफेद वर्ग में, आपको मुफ्त स्थान जोड़ने की आवश्यकता है। नीचे दी गई तालिका देखें (स्निपेट के अंदर)

मैं प्रत्येक टुकड़े के लिए भरण और रूपरेखा का आकार रखता हूं, वर्ग के अंदर मुक्त स्थान 64 से घटाया जा सकता है। अंतरिक्ष को बचाने के लिए, एक ही अंक के रूप में संग्रहीत रूपरेखा को उप-सीमा 9 के रूप में भरा जाता है। सीमा के रूप में भराव पेचीदा होता है। , कोड की जाँच करें (यह तरीका है कि टुकड़ों को कब्जे वाले स्थान द्वारा क्रमबद्ध किया गया है)

टेस्ट स्निपेट:

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>

स्निपेट का विस्तार करें

— edc65
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 135 112 बाइट्स

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

हर \u00xxएक एकल-बाइट चरित्र होना चाहिए। उन्हें यहां कोड के रूप में दर्शाया गया है क्योंकि स्टैक एक्सचेंज स्वचालित रूप से पोस्ट से अपठनीय वर्णों को हटा देता है।

व्याख्या

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

परीक्षा

कोड स्निपेट दिखाएं

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>

स्निपेट का विस्तार करें

— user81655
स्रोत

1

लुआ, 158 155 बाइट्स

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

संभवत: डेटा को एन्कोडिंग करके बाइट की संख्या को कम कर सकता है, लेकिन मैं वर्तमान तालिका पद्धति की तरह काम करता हूं।

'W' या 'b' के ASCII मान पर वर्ग का रंग इस तथ्य का लाभ उठाता है कि एक सम है और एक विषम है। mस्ट्रिंग चर में टुकड़े के प्रतीक की स्थिति के आधार पर टुकड़े के पूर्णांक मान को असाइन करता है। एक वर्ग अंधेरा है या प्रकाश (l+n)%2फिर से 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 बाइट्स को हटाने c=c%2से पहले printऔर d[c%2][p]इसके बजाय का उपयोग करके d[c][p]।

— Cyv
स्रोत

8-बिट शतरंज पिक्सेल की गिनती