किंगडम बिल्डर का एक गेम स्कोर करें

Question

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

नियम

किंगडम बिल्डर एक बोर्ड गेम है, जो एक (नुकीला-शीर्ष) हेक्स ग्रिड पर खेला जाता है। बोर्ड चार (रैंडमाइज्ड) क्वाड्रंट्स से बना है, जिनमें से प्रत्येक में 10x10 हेक्स सेल हैं (इसलिए एक पूर्ण बोर्ड 20x20 होगा)। इस चुनौती के प्रयोजनों के लिए, प्रत्येक हेक्स सेल में या तो पानी ( W), पहाड़ ( M) एक शहर ( T), एक महल ( C) या खाली है ( .) है। तो एक चतुर्भुज जैसा दिख सकता था

. . W . . . . . . .
 . M W W . . . . . .
. M . . W . . . T .
 M M . W . . . . . .
. . M . W W . . . .
 . . . . . W W W W W
. T . . . . . . . .
 . . W . . C . . . .
. . W W . . . . M . 
 . . . . . . . M M .

दूसरी पंक्ति हमेशा पहली पंक्ति से दाईं ओर ऑफसेट होगी। खिलाड़ी खाली कोशिकाओं पर प्रत्येक में 40 बस्तियों को जगह 1दे 4सकते हैं (कुछ नियमों का पालन करते हैं जिन्हें हम इस चुनौती के लिए अनदेखा करेंगे)। खेल के अंत में एक संभावित बोर्ड निम्नलिखित है:

3 3 W . . . 4 . 4 . . 2 W . 4 . . 4 . 4
 3 M W W . 1 1 . . 4 2 W . 3 C 4 4 . . 4
3 M 2 2 W 1 1 1 T 3 2 W 4 3 . 1 4 . 4 .
 M M . W 2 2 . . . 2 2 W 3 . 1 1 1 . . .
. 4 M . W W 2 2 2 2 W W 3 . 1 4 . T . .
 . . . . . W W W W W . 3 C 1 . . 2 2 2 2
. T 1 1 1 1 . . 2 . . 4 . . . 2 2 M M M
 4 . W 4 . C 4 4 . . . . . . 2 M M M M M
. 4 W W . . . 4 M . . W . W . 2 2 2 M M
 . . . . . . . M M . . W W . . . . 2 M .
. . . 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 . 1
 M 3 3 . . . . . . . . 4 . T 2 . 2 4 1 .
M M . C . 4 . 4 . . . . . 1 2 4 2 1 1 .
 M . . 1 . 4 . . . . M M 1 2 . . 2 1 . .
. . . W 1 1 4 1 1 . . . 1 2 . . 2 W W W
 . . 1 1 W 1 T . 1 1 1 1 T . . 2 W . 4 .
. 1 1 W . 3 3 . . . . . . . . 2 W 4 C 3
 C 1 3 3 3 . 3 . 4 . 4 . 4 . . 2 W 1 1 M
4 3 3 4 . M 4 3 . . . . . . . 2 W . . .
 . . . 4 . M M 3 . . 4 4 . 4 . 2 W W . .

हम चतुर्भुज की तरह लेबल करेंगे

1 2
3 4

आपका काम इस तरह के बोर्ड को बनाना होगा। एक कोर स्कोर है जो हमेशा उपयोग किया जाता है, और 8 वैकल्पिक स्कोर, जिनमें से 3 प्रत्येक गेम के लिए चुने जाते हैं। ^† निम्नलिखित में, मैं सभी 9 स्कोर का वर्णन और कितने अंक प्रत्येक खिलाड़ी मिलेगा के लिए एक उदाहरण के रूप में ऊपर सेटअप का उपयोग करेंगे।

^{, वास्तविक गेम में 10 स्कोर हैं, लेकिन मैं दो को छोड़ दूंगा क्योंकि कोई भी उन्हें गोल्फ नहीं देना चाहता।}

कोर स्कोर। एक खिलाड़ी को प्रत्येक अंक के लिए 3 अंकC मिलते हैं, जिसके पास उनका निपटान होता है। उदाहरण स्कोर: 18, 0, 15, 12।

वैकल्पिक स्कोर।

1. एक खिलाड़ी को प्रत्येक क्षैतिज पंक्ति के लिए 1 अंक मिलता है, जिस पर उनके पास कम से कम एक निपटान होता है।

   उदाहरण स्कोर: 14, 20, 12, 16।

2. प्रत्येक खिलाड़ी के लिए, क्षैतिज पंक्ति खोजें, जिस पर वे अपनी अधिकांश बस्तियों (टाई के मामले में कोई भी उठाएं)। एक खिलाड़ी को उस पंक्ति पर प्रत्येक निपटान के लिए 2 अंक मिलते हैं ।

   उदाहरण स्कोर: 14 (पंक्ति 16), 8 (पंक्ति 4, 5 या 6), 28 (पंक्ति 11), 10 (पंक्ति 1)।

3. एक खिलाड़ी को प्रत्येक सेटलमेंट के लिए 1 अंक मिलता है जो कि Wएटर के बगल में बनता है।

   उदाहरण स्कोर: 13, 21, 10, 5।

4. एक खिलाड़ी को एक बस्ती के बगल में प्रत्येक बस्ती के लिए 1 अंकM मिलता है।

   उदाहरण स्कोर: 4, 12, 8, 4।

5. प्रत्येक चतुर्थांश में प्रत्येक खिलाड़ी की बस्तियों की गणना करें। प्रति व्यक्ति, बस्तियों की सबसे बड़ी संख्या वाले खिलाड़ियों को 12 अंक प्राप्त होते हैं, दूसरी सबसे बड़ी बस्तियों वाले खिलाड़ियों को प्रत्येक अंक मिलते हैं।

   उदाहरण स्कोर: 18 (6 + 0 + 6 + 6), 36 (12 + 12 + 0 + 12), 12 (0 + 0 + 12 + 0), 18 (12 + 6 + 0 + 0)।

6. प्रत्येक खिलाड़ी के लिए यह निर्धारित किया जाता है कि उनके पास कम से कम बस्तियों की संख्या है। एक खिलाड़ी को उस चतुर्थांश में प्रत्येक निपटान के लिए 3 अंक मिलते हैं ।

   उदाहरण स्कोर: 18 (चतुर्थांश 2), 0 (चतुर्थांश 3), 15 (चतुर्थांश 1 या 2), 27 (चतुर्थांश 3)।

7. एक खिलाड़ी को बस्तियों के प्रत्येक जुड़े समूह के लिए 1 अंक मिलता है ।

   उदाहरण स्कोर: 7, 5, 6, 29।

8. खिलाड़ी को कनेक्टेड बस्तियों के सबसे बड़े समूह के प्रत्येक 2 बस्तियों के लिए 1 अंक मिलता है ।

   उदाहरण स्कोर: 4, 10, 8, 2।

चुनौती

खेल में जैसा कि आप वैकल्पिक स्कोर में से 3 का चयन करेंगे , और दिए गए बोर्ड को कोर स्कोर और उन तीन स्कोर के आधार पर स्कोर करेंगे। आपके कोड को 4 अंकों की सूची तैयार करनी चाहिए। पसंद पर एक प्रतिबंध है, हालांकि: मैंने स्कोर को 3 समूहों में बांटा है, और आप प्रत्येक समूह में से एक को लागू करने के लिए हैं:

• 1 और 2 में से किसी एक को लागू करें ।
• 3, 4, 5 और 6 में से एक को लागू करें ।
• 7 और 8 में से एक को लागू करें ।

आप STDIN, कमांड-लाइन तर्क, प्रॉम्प्ट या फ़ंक्शन पैरामीटर के माध्यम से इनपुट लेते हुए एक प्रोग्राम या फ़ंक्शन लिख सकते हैं। आप परिणाम वापस कर सकते हैं या इसे STDOUT में प्रिंट कर सकते हैं।

आप इनपुट के लिए कोई भी सुविधाजनक 1 डी या 2 डी सूची / स्ट्रिंग प्रारूप चुन सकते हैं। आप पूरी आसन्न जानकारी के साथ एक ग्राफ का उपयोग नहीं कर सकते हैं। यहाँ हेक्स ग्रिड पर कुछ अच्छा पढ़ना है अगर आपको प्रेरणा की आवश्यकता है।

आपका आउटपुट किसी भी सुविधाजनक, अस्पष्ट सूची या स्ट्रिंग प्रारूप में भी हो सकता है।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

इसके अलावा अनुमान

आप मान सकते हैं कि ...

• ... प्रत्येक खिलाड़ी में कम से कम 1 समझौता होता है और प्रत्येक खिलाड़ी की 40 से अधिक बस्तियां नहीं होती हैं।
• ... प्रत्येक चतुर्थांश में एक शहर और दो महल होते हैं, या दो शहर और एक महल होते हैं।
• ... कस्बों और महल बहुत दूर हैं, जैसे कि कोई भी बस्ती उनमें से दो से सटे नहीं हो सकती।

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

अभी भी उपरोक्त बोर्ड का उपयोग करते हुए, स्कोरिंग तंत्र के सभी संभावित विकल्पों के लिए यहां व्यक्तिगत स्कोर हैं:

Chosen Scores      Total Player Scores
1 3 7              52 46 43 62
1 3 8              49 51 45 35
1 4 7              43 37 41 61
1 4 8              40 42 43 34
1 5 7              57 61 45 75
1 5 8              54 66 47 48
1 6 7              57 25 48 84
1 6 8              54 30 50 57
2 3 7              52 34 59 56
2 3 8              49 39 61 29
2 4 7              43 25 57 55
2 4 8              40 30 59 28
2 5 7              57 49 61 69
2 5 8              54 54 63 42
2 6 7              57 13 64 78
2 6 8              54 18 66 51

Comments

क्या कोई बोर्ड है जिसमें एक खिलाड़ी हमेशा संयोजन की परवाह किए बिना जीतता है?

— थ्री एफएक्स

@ThreeFx चूंकि प्रति खिलाड़ी बस्तियों की संख्या पर निचली सीमा 1 है, इसलिए इसे स्थापित करना काफी सरल है। ;) लेकिन प्रत्येक खिलाड़ी के लिए समान बस्तियों के साथ, मैं वास्तव में नहीं जानता।

— मार्टिन एंडर

Answer 1

पायथन 2, 367 बाइट्स

T=range(20)
N=lambda r,c:{(a,b)for a,b in{(r+x/3-1,c+x%3-1+(x/3!=1)*r%2)for x in[0,1,3,5,6,7]}if-1<b<20>a>-1}
def S(B):
 def F(r,c):j=J[r][c]!=i;J[r][c]*=j;j or map(F,*zip(*N(r,c)));return j
 J=map(list,B);X=lambda r,c,x,y:x+y in{B[r][c]+B[a][b]for a,b in N(r,c)};return[sum((i in B[r])+20*(3*X(r,c,"C",i)-~X(r,c,i,"W")-F(r,c))for r in T for c in T)/20for i in"1234"]

कार्यक्रम स्कोर 1, 3, 7 का उपयोग करता है। इनपुट प्रत्येक सेल का प्रतिनिधित्व करने वाले वर्णों की सूची की एक सूची है। आसानी से उदाहरण बोर्ड का परीक्षण करने के लिए, हम कर सकते हैं:

board = """
3 3 W . . . 4 . 4 . . 2 W . 4 . . 4 . 4
 3 M W W . 1 1 . . 4 2 W . 3 C 4 4 . . 4
3 M 2 2 W 1 1 1 T 3 2 W 4 3 . 1 4 . 4 .
 M M . W 2 2 . . . 2 2 W 3 . 1 1 1 . . .
. 4 M . W W 2 2 2 2 W W 3 . 1 4 . T . .
 . . . . . W W W W W . 3 C 1 . . 2 2 2 2
. T 1 1 1 1 . . 2 . . 4 . . . 2 2 M M M
 4 . W 4 . C 4 4 . . . . . . 2 M M M M M
. 4 W W . . . 4 M . . W . W . 2 2 2 M M
 . . . . . . . M M . . W W . . . . 2 M .
. . . 3 3 3 3 3 3 3 3 3 3 3 3 3 3 2 . 1
 M 3 3 . . . . . . . . 4 . T 2 . 2 4 1 .
M M . C . 4 . 4 . . . . . 1 2 4 2 1 1 .
 M . . 1 . 4 . . . . M M 1 2 . . 2 1 . .
. . . W 1 1 4 1 1 . . . 1 2 . . 2 W W W
 . . 1 1 W 1 T . 1 1 1 1 T . . 2 W . 4 .
. 1 1 W . 3 3 . . . . . . . . 2 W 4 C 3
 C 1 3 3 3 . 3 . 4 . 4 . 4 . . 2 W 1 1 M
4 3 3 4 . M 4 3 . . . . . . . 2 W . . .
 . . . 4 . M M 3 . . 4 4 . 4 . 2 W W . .
"""

board = [row.split() for row in board.strip().split("\n")]
print S(board)

# [52, 46, 43, 62]

---

हेक्स ग्रिड को संभालना

चूंकि हम एक हेक्स ग्रिड पर हैं, इसलिए हमें पड़ोसियों के साथ थोड़ा अलग व्यवहार करना होगा। यदि हम अपने प्रतिनिधित्व के रूप में पारंपरिक 2D ग्रिड का उपयोग करते हैं, तो (1, 1)हमारे पास है:

. N N . .       . N N . .                (0, 1), (0, 2)            (-1, 0), (-1, 1)
 N X N . .  ->  N X N . .  -> Neighbours (1, 0), (1, 2) -> Offsets (0, -1), (0, 1)
. N N . .       . N N . .                (2, 1), (2, 2)            (1, 0), (1, 1)

करीब से निरीक्षण करने पर, हमें पता चलता है कि आप जिस पंक्ति पर हैं, उसकी समानता पर निर्भर करता है। उपरोक्त उदाहरण विषम पंक्तियों के लिए है, लेकिन पंक्तियों पर भी ऑफ़सेट हैं

(-1, -1), (-1, 0), (0, -1), (0, 1), (1, -1), (1, 0)

केवल एक चीज जो बदल गई है वह यह है कि 1, 2, 5 वीं और 6 वीं जोड़ियों ने अपने दूसरे समन्वय को 1 से घटाया है।

लैम्ब्डा फ़ंक्शन Nएक समन्वय जोड़ी लेता है (row, col)और ग्रिड के भीतर सेल के सभी पड़ोसियों को वापस करता है। अंदरूनी समझ उपरोक्त आधारों को एक साधारण आधार 3 एन्कोडिंग से निकालकर उत्पन्न करता है, दूसरा समन्वय को बढ़ाता है यदि पंक्ति विषम है और पड़ोसी को देने के लिए प्रश्न में सेल में ऑफ़सेट जोड़ता है। बाहरी समझ तब फिल्टर करती है, जिससे पड़ोसी केवल ग्रिड की सीमा के भीतर रह जाते हैं।

Ungolfed

def neighbours(row, col):
    neighbour_set = set()

    for dr, dc in {(-1,-1), (-1,0), (0,-1), (0,1), (1,-1), (1,0)}:
        neighbour_set.add((row + dr, col + dc + (1 if dr != 0 and row%2 == 1 else 0)))

    return {(r,c) for r,c in neighbour_set if 20>r>-1 and 20>c>-1}

def solve(board):
    def flood_fill(char, row, col):
        # Logic negated in golfed code to save a few bytes
        is_char = (dummy[row][col] == char)
        dummy[row][col] = "" if is_char else dummy[row][col]

        if is_char:
            for neighbour in neighbours(row, col):
                flood_fill(char, *neighbour)

        return is_char

    def neighbour_check(row, col, char1, char2):
        return board[row][col] == char1 and char2 in {board[r][c] for r,c in neighbours(row, col)}

    dummy = [row[:] for row in board] # Need to deep copy for the flood fill
    scores = [0]*4

    for i,char in enumerate("1234"):
        for row in range(20):
            for col in range(20):
                scores[i] += (char in board[row])                        # Score 1
                scores[i] += 20 * 3*neighbour_check(row, col, "C", char) # Core score
                scores[i] += 20 * neighbour_check(row, col, char, "W")   # Score 3
                scores[i] += 20 * flood_fill(char, row, col)             # Score 7

        # Overcounted everything 20 times, divide out
        scores[i] /= 20

    return scores

Comments

नहीं कर सकते def Fएक आंतरिक समारोह एक अलग समारोह के बजाय हो सकता है? kसे हटाया नहीं जा सकता def F:?

— जस्टिन

@Quincunx Fबाढ़ भरण कार्य है और Jइसे एक्सेस करने की आवश्यकता है , इसलिए यह Jएक पैरामीटर के रूप में गुजरने से बचाने के लिए अंदर है (मैं यह देखने के लिए थोड़ा प्रयोग करूंगा कि क्या मैं गहरी नकल प्राप्त कर सकता हूं)। kहालाँकि, आप इसके बारे में सही हैं , धन्यवाद :) (नया कोड थोड़ा सा

— मज़ेदार

Answer 2

उत्तर सेट प्रोग्रामिंग, 629 बाइट्स

d(X,Y):-b(X,Y,_).p(1;2;3;4).n(X,Y,(((X-2;X+2),Y);((X-1;X+1),(Y-1;Y+1)))):-d(X,Y).n(X,Y,I,J):-n(X,Y,(I,J));d(I,J).t(X,Y,P):-n(X,Y,I,J);b(I,J,P).s(c,P,S*3):-S={t(X,Y,P):b(X,Y,"C")};p(P).s(1,P,S*1):-S=#count{r(Y):b(_,Y,P)};p(P).s(3,P,S):-S={b(X,Y,P):t(X,Y,"W")};p(P).o(X,Y,Y+X*100):-d(X,Y).h(P,X,Y,I,J):-o(X,Y,O);o(I,J,Q);O<Q;n(X,Y,I,J);b(X,Y,P);b(I,J,P);p(P).h(P,X,Y,I,J):-o(X,Y,O);o(I,J,Q);O<Q;h(P,X,Y,K,L);n(K,L,I,J);b(I,J,P);p(P).c(P,X,Y):-h(P,X,Y,_,_);not h(P,_,_,X,Y).c(P,X,Y):-{h(P,X,Y,_,_);h(P,_,_,X,Y)}0;b(X,Y,P);p(P).s(7,P,S):-S=#count{c(P,X,Y):c(P,X,Y)};p(P).s(t,P,C+S+T+U):-s(c,P,C);s(1,P,S);s(3,P,T);s(7,P,U).#shows/3.

ASP तर्क प्रोग्रामिंग भाषा परिवार से संबंधित है, यहाँ पोटासको फ्रेमवर्क द्वारा अवतरित किया गया है , विशेष रूप से क्लिंगो (ग्राउंडर ग्रिंगो + सॉल्वर क्लैप) में। प्रतिमान सीमा के कारण, यह बोर्ड को सीधे आउटपुट के रूप में नहीं ले सकता है, इसलिए डेटा का प्रीप्रोसेसिंग आवश्यक है (यहां अजगर में प्रदर्शन किया गया है)। यह प्रीप्रोसेसिंग कुल बाइट स्कोर में नहीं गिना जाता है।

इसका पहला कोड गोल्फ है, और इसका उद्देश्य एक ऐसी भाषा है जिसे मैं प्यार करता हूँ, जो कि मैंने गोल्फ में पहले कभी नहीं देखा था, वास्तव में खेल जीतने के लिए। इसके अलावा, मैं एएसपी के एक विशेषज्ञ से बहुत दूर हूं, इसलिए कोड के कई अनुकूलन कम बाइट्स में परिणाम के लिए निश्चित रूप से प्रदर्शन कर सकते हैं।

ज्ञान निरूपण

अजगर कोड है जो परमाणुओं में बोर्ड को परिवर्तित करता है:

def asp_str(v):
    return ('"' + str(v) + '"') if v not in '1234' else str(v)

with open('board.txt') as fd, open('board.lp', 'w') as fo:
        [fo.write('b('+ str(x) +','+ str(y) +','+ asp_str(v) +').\n')
         for y, line in enumerate(fd)
         for x, v in enumerate(line) if v not in ' .\n'
        ]

उदाहरण के लिए, उदाहरण बोर्ड की पहली पंक्ति के लिए दिए गए परमाणु b (__b__oard के लिए) निम्नलिखित हैं:

b(0,0,3).
b(2,0,3).
b(4,0,"W").
b(12,0,4).
b(16,0,4).
b(22,0,2).
b(24,0,"W").
b(28,0,4).
b(34,0,4).
b(38,0,4).

जहाँ b (0,0,3) एक परमाणु है जो वर्णन करता है कि खिलाड़ी 3 में निर्देशांक (0; 0) पर एक समझौता है।

एएसपी हल

कई वैकल्पिक अंकों के साथ ASP कोड लागू है:

% input : b(X,Y,V) with X,Y the coordinates of the V value

domain(X,Y):- b(X,Y,_).
player("1";"2";"3";"4").

% neighbors of X,Y
neighbors(X,Y,((X-2,Y);(X+2,Y);((X-1;X+1),(Y-1;Y+1)))) :- domain(X,Y).
neighbors(X,Y,I,J):- neighbors(X,Y,(I,J)) ; domain(I,J).

% Player is next to X,Y iff has a settlement next to.
next(X,Y,P):- neighbors(X,Y,I,J) ; b(I,J,P).


% SCORES

% Core score : 3 point for each Castle "C" with at least one settlement next to.
score(core,P,S*3):- S={next(X,Y,P): b(X,Y,"C")} ; player(P).

% opt1: 1 point per settled row
score(opt1,P,S*1):- S=#count{row(Y): b(_,Y,P)} ; player(P).

% opt2: 2 point per settlement on the most self-populated row
% first, defines how many settlements have a player on each row
rowcount(P,Y,H):- H=#count{col(X): b(X,Y,P)} ; domain(_,Y) ; player(P).
score(opt2,P,S*2):- S=#max{T: rowcount(P,Y,T)} ; player(P).

% opt3: 1 point for each settlements next to a Water "W".
score(opt3,P,S):- S={b(X,Y,P): next(X,Y,"W")} ; player(P).

% opt4: 1 point for each settlements next to a Mountain "M".
score(opt4,P,S):- S={b(X,Y,P): next(X,Y,"M")} ; player(P).

% opt5:
%later…

% opt6:
%later…

% opt7: 1 point for each connected component of settlement
% first we need each coord X,Y to be orderable.
% then is defined path/5, that is true iff exists a connected component of settlement of player P
%   that links X,Y to I,J
% then is defined the connected component atom that give the smaller coords in each connected component
% then computing the score.
order(X,Y,Y+X*100):- domain(X,Y).
path(P,X,Y,I,J):- order(X,Y,O1) ; order(I,J,O2) ; O1<O2 ; % order
                  neighbors(X,Y,I,J) ; b(X,Y,P) ; b(I,J,P) ; player(P). % path iff next to
path(P,X,Y,I,J):- order(X,Y,O1) ; order(I,J,O2) ; O1<O2 ; % order
                  path(P,X,Y,K,L) ; neighbors(K,L,I,J) ; % path if path to next to
                  b(I,J,P) ; player(P).
concomp(P,X,Y):- path(P,X,Y,_,_) ; not path(P,_,_,X,Y). % at least two settlements in the connected component
concomp(P,X,Y):- 0 { path(P,X,Y,_,_) ; path(P,_,_,X,Y) } 0 ; board(X,Y,P) ; player(P). % concomp of only one settlements
score(opt7,P,S):- S=#count{concomp(P,X,Y): concomp(P,X,Y)} ; player(P).

% opt8: 0.5 point for each settlement in the bigger connected component
%later…


% total score:
score(total,P,C+S1+S2+S3):- score(core,P,C) ; score(opt1,P,S1) ; score(opt3,P,S2) ; score(opt7,P,S3).

#show. # show nothing but the others show statements
#show total_score(P,S): score(total,P,S).
%#show score/3. % scores details

इस कार्यक्रम को कमांड के साथ लॉन्च किया जा सकता है:

clingo board.lp golf.lp 

और केवल एक समाधान मिलेगा (इसका प्रमाण है कि अंक वितरित करने का केवल एक ही तरीका है):

s(c,1,18) s(c,2,0) s(c,3,15) s(c,4,12) s(1,1,14) s(1,2,20) s(1,3,12) s(1,4,16) s(3,1,13) s(3,2,21) s(3,3,10) s(3,4,5) s(7,1,7) s(7,2,5) s(7,3,6) s(7,4,29) s(t,1,52) s(t,2,46) s(t,3,43) s(t,4,62)

जहाँ s (7,3,6) का कहना है कि खिलाड़ी 3 वैकल्पिक स्कोर 7 के साथ 6 अंक प्राप्त करता है, और s (t, 4,62) का कहना है कि खिलाड़ी 4 कुल 62 अंक हासिल करता है (कोर + 1 + 3 + 7)।

एक फैंसी टेबल के लिए पार्स करना आसान है!