क्या यह स्ट्रिंग मान्य FEN है?

Question

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक स्ट्रिंग इनपुट को फ़ंक्शन पैरामीटर के रूप में या स्टड से लेता है और यह निर्धारित करता है कि क्या यह एक मान्य FEN स्ट्रिंग है।

इनपुट

आप मान सकते हैं कि इनपुट में केवल निम्नलिखित वर्ण (केस संवेदी) शामिल होंगे
pkqrbnPKQRBN12345678/
। इनपुट की लंबाई हमेशा न्यूनतम 1 वर्ण और अधिकतम 100 वर्ण होगी

उत्पादन

आउटपुट एक सत्य / गलत मूल्य होना चाहिए। जब तक वे सुसंगत हैं तब तक ये सभी मूल्य हो सकते हैं (सभी सत्य परिणाम समान आउटपुट होते हैं, सभी गलत परिणाम समान आउटपुट होते हैं)। आपके पास दो अलग-अलग संभावित आउटपुट होने चाहिए।

क्या मान्य के रूप में गिना जाता है

लोअरकेस अक्षर काले टुकड़ों का प्रतिनिधित्व करते हैं, अपरकेस अक्षर सफेद टुकड़ों का प्रतिनिधित्व करते हैं।
आपको यह सुनिश्चित करना चाहिए कि वर्तमान स्थिति में टुकड़ों के लिए शतरंज के खेल में यह संभव है।
प्रत्येक खिलाड़ी के पास हमेशा 1 राजा होगा (k / K)
प्रत्येक खिलाड़ी के पास 8 से अधिक प्यादे (पी / पी) नहीं हो सकते हैं।
प्रत्येक खिलाड़ी की आम तौर पर 1 * क्वीन (q / Q) से
अधिक नहीं होगी। प्रत्येक खिलाड़ी की आम तौर पर कोई अधिक नहीं होगी। 2 * बदमाशों (आर / आर) से
प्रत्येक खिलाड़ी के पास आमतौर पर 2 * शूरवीर (एन / एन)
से अधिक नहीं होंगे। प्रत्येक खिलाड़ी के पास आमतौर पर 2 * बिशप (बी / बी)
* से अधिक नहीं होगा । यह एक खिलाड़ी के लिए कानूनी है ' इन चार टुकड़ों में से किसी एक को 'मोहरा' को बढ़ावा देना।
प्रत्येक खिलाड़ी के लिए प्यादे, रानी, ​​किश्ती, शूरवीर और बिशप की कुल संख्या कभी भी 15 से अधिक नहीं होगी

टुकड़ों की कुल संख्या और खाली वर्ग (संख्याओं से निरूपित) को हमेशा प्रत्येक रैंक के लिए ठीक 8 तक जोड़ना चाहिए। और हमेशा आगे की स्लैश द्वारा अलग-अलग 8 रैंक होनी चाहिए।

जिन चीजों को आप नजरअंदाज कर सकते हैं

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

यह कोड गोल्फ है। बाइट्स जीत में सबसे छोटा कार्यक्रम। सामान्य कमियां और नियम लागू होते हैं।

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

इनपुट rnbqkbnr / pppppppp / 8/8/8/8 / PPPPPPPP / RNBQKBNR
आउटपुट ट्रू

इनपुट 2br2k1 / 1p2n1q1 / P2p2p1 / P1bP1pNp / 1BP2PnP / 1Q1B2P1 / 8 / 3NR2K
आउटपुट ट्रू

इनपुट r2r2k1 / p3q2p / ppR3pr / rP4bp / 3p4 / 5B1P / P4PP1 / 3Q1RK1
आउटपुट फाल्स
(काले में 7 प्यादे और 4 बदमाश हैं - असंभव)

इनपुट 6k1 / pp3ppp / 4p3 / 2P3b1 / bPP3P1 / 3K4 / P3Q1q1
आउटपुट झूठी (केवल 7 रैंक)

इनपुट 3r1rk1 / 1pp1bpp1 / 6p1 / pP1npqPn / 8 / 4N2P / P2PP3 / 1B2BP2 / R2QK2R
आउटपुट झूठी (9 रैंक)

इनपुट 5n1k / 1p3r1qp / p3p3 / 2p1N2Q / 2P1R3 / 2P5 / P2r1PP1 / 4R1K1
आउटपुट झूठा (2 वीं श्रेणी में 9 वर्ग / टुकड़े हैं)

इनपुट rnbqkbnr / pppppppp / 8/35/8/8 / PPPPPPPP / RNBQKBNR
आउटपुट यह सच है
कि इस मामले को स्पष्ट करने के लिए Feersum और Arnauld के लिए धन्यवाद (3 + 5 = 8)

FEN क्या है?

एफईएन एक शतरंज बोर्ड पर टुकड़ों की स्थिति दर्ज करने के लिए एक मानक संकेतन है। छवि क्रेडिट http://www.chessgames.com

Comments

"प्रत्येक खिलाड़ी के पास आमतौर पर 1 * रानी से अधिक नहीं होगा" - कृपया स्पष्ट करें कि क्या मायने रखता है, क्योंकि मुझे लगता है कि यह "सामान्य" के रूप में मायने नहीं रखता है। क्या सफेद के लिए नौ रानियाँ होना मान्य है? दस रानियाँ? आठ प्यादे और दो रानियाँ? शून्य राजा? पहली या आखिरी रैंक पर एक अनप्रोटेक्टेड मोहरा?

— एंडर्स केसरग

@AndersKaseorg * It is legal for a player to 'promote' a pawn to any of these four pieces.खिलाड़ी की संख्या 9 रानियों तक हो सकती है क्योंकि क्षतिपूर्ति करने के लिए प्यादों की संख्या कम हो जाती है। आपको टुकड़ों के कानूनी या अवैध होने की स्थिति के बारे में चिंता करने की आवश्यकता नहीं है, केवल टुकड़ों की संख्या।

— डैरेन एच।

आपके तीसरे टेस्ट-केस में, ब्लैक में 6 प्यादे हैं, 7 नहीं, इसे 'ट्रू' (?)

— बनाकर

@ डारेनह फेर्सम द्वारा प्रस्तावित एफईएन स्थिति आपके वर्तमान नियमों के अनुसार मान्य है। 358 खाली वर्गों का वर्णन करने के लिए सिर्फ एक असामान्य तरीका है।

— अरनुलद

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

— डैरेन एच।

Answer 1

रेटिना , 105 बाइट्स

[1-8]
$*
^
/
iG`^(/[1KQRBNP]{8}){8}$
G`K
G`k
A`K.*K|k.*k
{2`N

2`B

2`R

1`Q

K

T`L`P
8`P

A`P
}T`l`L
^.

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

[1-8]
$*

खाली वर्गों के लिए अंकों का विस्तार करें, जिसे हम 1एस का उपयोग करके दर्शाते हैं ।

^
/
iG`^(/[1KQRBNP]{8}){8}$

इनपुट हटाएं यदि यह 8 वैध वर्गों के 8 सेटों के साथ मेल नहीं खाता है तो /एस के साथ जुड़ गया । ( /चेक को सरल बनाने के लिए एक अतिरिक्त उपसर्ग है।)

G`K
G`k
A`K.*K|k.*k

इनपुट को हटा दें यदि इसमें कोई सफेद या कोई काला राजा नहीं है, या यदि इसमें से दो भी हैं।

{2`N

2`B

2`R

1`Q

K

सफेद रंग के शुरुआती टुकड़े हटा दें, अगर वे अभी भी वहां हैं।

T`L`P

किसी भी बचे हुए सफेद मोहरे को मोहरे के लिए समर्पित करें।

8`P

वैध सफेद पंजे को हटा दें।

A`P

यदि कोई सफ़ेद प्यादे बचे हैं तो इनपुट हटाएं।

}T`l`L

फिर से जांच करें लेकिन काले टुकड़ों के साथ।

^.

जब तक लाइन हटाई नहीं जाती तब तक एक सत्य मान का उत्पादन करें।

Answer 2

जावास्क्रिप्ट (ईएस 6), 168 174 ... 155

इस उत्तर को कई बार शर्मनाक बताया गया है। उम्मीद है, वर्तमान संस्करण विश्वसनीय और शालीनता से दोनों पर आधारित है।

---

एक बूलियन देता है।

s=>[...s].map(c=>++n%9?+c?n+=--c:a[i='pP/KkQqRrBbNn'.search(c),i&=i>4&a[i]>(i>6)||i]=-~a[i]:x+=c=='/',a=[x=n=0])&&!([p,P,s,k,K]=a,n-71|x-7|s|k*K-1|p>8|P>8)

प्रारूपित और टिप्पणी की गई

s => [...s].map(c =>                  // for each character 'c' in the FEN string 's':
  ++n % 9 ?                           //   if we haven't reached the end of a rank:
    +c ?                              //     if the character is a digit:
      n += --c                        //       advance the board pointer by c - 1 squares
    :                                 //     else:
      a[                              //       update the piece counter array:
        i =                           //         i = piece identifier (0 to 12)
          'pP/KkQqRrBbNn'.search(c),  //             with special case: '/' --> 2
        i &=                          //         we count it as a promoted pawn instead if:
          i > 4 &                     //           it's a Q, R, B or N and we already have
          a[i] > (i > 6) ||           //           2 of them for R, B, N or just 1 for Q
          i                           //           else, we keep the identifier unchanged
      ] = -~a[i]                      //         '-~' allows to increment 'undefined'
  :                                   //   else:
    x += c == '/',                    //     check that the expected '/' is there
  a = [                               //   initialize the piece counter array 'a'
    x =                               //   initialize the '/' counter 'x',
    n = 0 ]                           //   initialize the board pointer 'n'
) &&                                  // end of map()
!(                                    // now it's time to perform all sanity checks:
  [p, P, s, K, k] = a,                //   copy the 5 first entries of 'a' to new variables
  n - 71 |                            //   have we reached exactly the end of the board?
  x - 7 |                             //   have we identified exactly 7 ends of rank?
  s |                                 //   have we encountered any unexpected '/' character?
  k * K - 1 |                         //   do we have exactly one king on each side?
  p > 8 |                             //   no more than 8 black pawns, including promotions?
  P > 8)                              //   no more than 8 white pawns, including promotions?

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

let f =

s=>[...s].map(c=>++n%9?+c?n+=--c:a[i='pP/KkQqRrBbNn'.search(c),i&=i>4&a[i]>(i>6)||i]=-~a[i]:x+=c=='/',a=[x=n=0])&&!([p,P,s,k,K]=a,n-71|x-7|s|k*K-1|p>8|P>8)

console.log(f("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR")) // True
console.log(f("2br2k1/1p2n1q1/p2p2p1/P1bP1pNp/1BP2PnP/1Q1B2P1/8/3NR2K")) // True
console.log(f("r2r2k1/p3q2p/ppR3pr/rP4bp/3p4/5B1P/P4PP1/3Q1RK1")) // False (black has 7 pawns and 4 rooks - impossible)
console.log(f("6k1/pp3ppp/4p3/2P3b1/bPP3P1/3K4/P3Q1q1")) // False (only 7 ranks)
console.log(f("3r1rk1/1pp1bpp1/6p1/pP1npqPn/8/4N2P/P2PP3/1B2BP2/R2QK2R")) // False (9 ranks)
console.log(f("5n1k/1p3r1qp/p3p3/2p1N2Q/2P1R3/2P5/P2r1PP1/4R1K1")) // False (2nd rank has 9 squares/pieces)
console.log(f("rnbqkbnr/pppppppp/8/35/8/8/PPPPPPPP/RNBQKBNR")) // True
console.log(f("rnbqkbnr/pppppppp/8/9/7/8/PPPPPPPP/RNBQKBNR")) // False (additional test case suggested by Rick Hitchcock)
console.log(f("rnbqkbnr/pppp/ppp/8/8/8/8/PPPPPPPP/RNBQKBNR")) // False (additional test case)

Answer 3

पायथन 3, 284 259 236 225 247 234 बाइट्स

import re
s=input()
t,c=s.split("/"),s.count;P=p=9;o=0
for x in"pqrnb":p-=max(0,c(x)-o);P-=max(0,c(x.upper())-o);o+=o<2
v=8==len(t)and all(8==sum(int(x)for x in re.sub("[A-z]","1",p))for p in t)and p>0<P and c('k')==c('K')==1
print(v)

इसे ऑनलाइन आज़माएं!

परीक्षण के सभी मामलों के साथ इसे ऑनलाइन आज़माएं!

-11 बाइट्स मिस्टर एक्सकोडर की बदौलत

-13 बाइट्स जोनाथन एलन को धन्यवाद

१२. मैं राजाओं को भूल गया।

कुछ स्पष्टीकरण के साथ अर्ध-अधूरा:

import re
string = input()
split = string.split("/")
count = string.count # find # of occurences of char in string
pawns = 9 # represents the # of pawns a player has out of the game... plus one, e.g. 1 is all in game, 2 is one out, 0 is invalid
PAWNS = 9 # would be 8, but then I would need >= instead of >
offset = 0 # default for pawns
for char in "pqrnb": # for each pawn, each queen over 1, and each rook/knight/bishop over 2 for each player
    # subtract one from the players 'pawns' var, which must end up 1 or greater to be valid
    # otherwise too many pawns/queens/etc of that player are on the board
    pawns -= max(0,count(char)-offset)
    PAWNS -= max(0,count(char.upper())-offset)
    offset += (offset 0 and PAWNS>0 and \ # make sure each player does not have an invalid number of pawns/q/n/b/r
    count('k')==count('K')==1 # correct # of kings
print(valid)

Comments

234 बाइट्स । मैंने ,p,P=9,9साथ दिया ;P=p=9।

— मिस्टर एक्सकोडर

230 बाइट्स । आपके पास अनावश्यक स्थान क्यों हैं for-loop: /

— श्री Xcoder

225 बाइट्स : आप 5 बाइट्स बचाने p>0<Pके p>0and P>0लिए भी उपयोग कर सकते हैं । वैकल्पिक रूप से, आप p and P(-3 बाइट्स के लिए) का उपयोग कर सकते थे , आपको इसकी आवश्यकता नहीं है >0, क्योंकि पायथन में गैर-शून्य मान

— सत्य हैं

प्यादों को अपग्रेड किया जा सकता है, कल्पना कहती है कि 7 लोअरकेस प्यादे और 4 बदमाश हैं, जबकि मेरी आँखें केवल 6 लोअरकेस के पी देखती हैं।

— pizzapants184

आप o=0लूप के पहले के साथ शुरू करने और o+=o<2लूप के शरीर के अंत में वृद्धि के साथ 13 बाइट्स बचा सकते हैं ।

— जोनाथन एलन

Answer 4

PHP , 269 बाइट्स

$t=($o=count_chars($a="$argn/"))[47]==8&$o[107]==1&$o[75]==1&9>($w=$u=$o[80])&9>$b=$l=$o[112];foreach([81,82,78,66]as$k=>$v){$z=$k?11:10;$b+=$x=$o[32+$v];$t&=$l+$x<$z;$w+=$x=$o[$v];$t&=$u+$x<$z;}$t&=$b<16&$w<16;for(;$c=$a[$n++];)$c<A?$c>0?$s+=$c:$t&=!$s-=8:++$s;echo$t;

इसे ऑनलाइन आज़माएं!

Answer 5

जावास्क्रिप्ट (ईएस 6), 181 172 174 बाइट्स

f=([c,...s],n=1,o={p:0,P:0})=>c?c=='/'&&n%9?0:f(s,n+(+c||1),(o[c]=(o[c]||0)+(/[qrbn]/i.test(c)&&o[c]>1-/q/i.test(c)?!o[c>'a'?'p':'P']++:1),o)):o.p<9&o.P<9&n==72&o.k==1&o.K==1

Ungolfed:

f=
  ([c,...s],                 //c is current character
   n=1,                      //n is current square, range [1-72] (board is 9x8 due to slashes)
   o={p:0,P:0}               //o holds piece counts
  )=>
  c?
    c=='/'&&n%9?0:           //ensure 8 squares per row
    f(s,
      n+(+c||1),             //increment n by the correct number of squares
      (o[c]=(o[c]||0)+(/[qrbn]/i.test(c)&&o[c]>1-/q/i.test(c)?!o[c>'a'?'p':'P']++:1),o)
                             //"depromote" extra queens, rooks, bishops, or knights
     ):
  o.p<9&o.P<9&               //no more than 8 pawns per side (accounting for promotions)
  o.k==1&o.K==1&             //each side has one and only one king  
  n==72                      //correct number of squares

f=([c,...s],n=1,o={p:0,P:0})=>c?c=='/'&&n%9?0:f(s,n+(+c||1),(o[c]=(o[c]||0)+(/[qrbn]/i.test(c)&&o[c]>1-/q/i.test(c)?!o[c>'a'?'p':'P']++:1),o)):o.p<9&o.P<9&n==72&o.k==1&o.K==1

console.log(f('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR')); //true
console.log(f('2br2k1/1p2n1q1/p2p2p1/P1bP1pNp/1BP2PnP/1Q1B2P1/8/3NR2K')) //true
console.log(f('r2r2k1/p3q2p/ppR3pr/rP4bp/3p4/5B1P/P4PP1/3Q1RK1')); //false
console.log(f('6k1/pp3ppp/4p3/2P3b1/bPP3P1/3K4/P3Q1q1')); //false
console.log(f('3r1rk1/1pp1bpp1/6p1/pP1npqPn/8/4N2P/P2PP3/1B2BP2/R2QK2R')); //false
console.log(f('5n1k/1p3r1qp/p3p3/2p1N2Q/2P1R3/2P5/P2r1PP1/4R1K1')); //false
console.log(f('rnbqkbnr/pppppppp/8/35/8/8/PPPPPPPP/RNBQKBNR')); //true
console.log(f('rnbqkbnr/pppppppp/8/35/8/8/PPPPPPPP/RNQQKBNR')); //false, too many queens

Answer 6

पायथन 3 , 263 बाइट्स

s=input()
n=0
for a in s.split('/'):n+=sum([int(c)if c in"123456789"else 1for c in a])
m=lambda k:{c:s.count(c)for c in s}.get(k,0)
p=[m("p"),m("P")]
for c in"rnbqRNGQ":b=c in"qQ";p[c<"Z"]+=m(c)+b-2if m(c)>2-b else 0
print((n==64)&(p[0]<9>p[1])&(m("K")>0<m("k")))

इसे ऑनलाइन आज़माएं!

सबसे छोटा पायथन प्रस्तुत नहीं है, लेकिन मुझे लगता है कि यह अभी भी कुछ वादा करता है।