गो का एक गेम स्कोर करें

Question

गो गेम को स्कोर करना एक ऐसा कार्य है जो बहुत आसान नहीं है। अतीत में सभी अजीब कोने के मामलों को कवर करने के लिए नियमों को डिज़ाइन करने के तरीके के बारे में कई बहसें हुई हैं। सौभाग्य से, इस कार्य में आपको जीवन और मृत्यु या सेकी का पता लगाने जैसी जटिल चीजें नहीं करनी हैं। इस कार्य में, आपको एक प्रोग्राम लागू करना होगा जो ट्रॉम-टेलर नियमों के अनुसार गेम स्कोर करता है कोमी के बिना ।
स्कोरिंग प्रक्रिया बहुत सरल है:

एक बिंदु P, रंगीन C नहीं है, C तक पहुंचने के लिए कहा जाता है, अगर P के रंग से P के रंग के निकट (लंबवत या क्षैतिज) पथ का कोई बिंदु है।
एक खिलाड़ी का स्कोर उसके रंग के बिंदुओं की संख्या है , प्लस केवल उसके रंग तक पहुंचने वाले खाली बिंदुओं की संख्या।

उदाहरण के लिए, निम्नलिखित बोर्ड पर विचार करें। X, Oऔर- काले, सफेद और बिना चौराहों के निरूपित करें:

- - - X - O - - -
- - - X - O - - -
- - - X - O - - -
- - - X O - - O -
X X X O - O O - -
- - - X O - - O O
- - - X - O - - -
- - - X - O - X -
- - - - - O - - -

स्कोरिंग नियम लागू करने से निम्नलिखित परिणाम प्राप्त होते हैं। x, oऔर -अघोषित चौराहों का प्रतिनिधित्व करते हैं जिन्हें काले, सफेद और किसी के अंक के रूप में नहीं गिना जाता है।

x x x X - O o o o
x x x X - O o o o
x x x X - O o o o
x x x X O o o O o
X X X O o O O o o
- - - X O - - O O
- - - X - O - - -
- - - X - O - X -
- - - - - O - - -

आरेख के अनुसार, काले में 23 अंक हैं, सफेद के 29 क्षेत्र हैं। इस प्रकार, आपका कार्यक्रम W+6इस बोर्ड के लिए प्रिंट होना चाहिए ।

मुझे उम्मीद है कि यह इस तरह से स्पष्ट है।

इनपुट और आउटपुट

इनपुट एक स्ट्रिंग है वास्तव में होता है n² पात्रों में से X, O, -जहां n संकलन समय पर ज्ञात नहीं है। आपके कार्यक्रम को इनपुट स्ट्रीम में अन्य सभी वर्णों को अनदेखा करना चाहिए। यदि कोई पूर्णांक n नहीं है तो व्यवहार अपरिभाषित है जैसे कि XO-वर्णों की मात्रा n² के बराबर है । आप मान सकते हैं कि n में है [0, 255] ।

वर्णों के अनुक्रम की व्याख्या n पंक्तियों और स्तंभों के गो-बोर्ड के रूप में की जानी है । आउटपुट दशमलव प्रतिनिधित्व में सफेद और काले रंग के बिंदुओं की कुल राशि के अंतर का पूर्ण मूल्य है। यदि सफेद में अधिक अंक हैं, तो यह उपसर्ग है W+, यदि काले में अधिक अंक हैं तो यह उपसर्ग है B+। इस मामले में कि दोनों खिलाड़ियों के बराबर अंक हैं, आउटपुट है Jigo।

इनपुट को कार्यान्वयन परिभाषित तरीके से पढ़ा जाना है। इनपुट स्रोत कोड का हिस्सा नहीं हो सकता है।

जीतने की स्थिति

यह कोड-गोल्फ है। सामान्य कोड-गोल्फ सम्मेलनों लागू होते हैं। इसके स्रोत में कम से कम पात्रों के साथ सबमिशन जीतता है। केवल ऐसे कार्यक्रम जो विनिर्देश को पूरी तरह से लागू करते हैं, जीत सकते हैं।

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

इनपुट:

- - - X - O - - -
- - - X - O - - -
- - - X - O - - -
- - - X O - - O -
X X X O - O O - -
- - - X O - - O O
- - - X - O - - -
- - - X - O - X -
- - - - - O - - -

आउटपुट: W+6

इनपुट:

Xavier is insane -- says Oliver

आउटपुट: Jigo

inpout:

Code-Golf

आउटपुट: Jigo

इनपुट:

-XXXXXXX-XOOOOOOOXXO-OXXXOXXXOX--XOXXOOX
-
XOOXXOX--XOXXXOXXXO-OXXOOOOOOOX-XXXXXXX-

आउटपुट: B+21

इनपुट:

- - X O O O O X X - - - - - - X O O -
- X X O X O X X O X X X X X X - X O -
- X O O X X X - O O O X O O X X X O -
- X O O O X X O O O O O O X X X O - -
- - X X O X - X X X X O O O O O O O -
- - X O O X X X - X X X O O O X X O -
- - X O - O X O X O O O O O X X X O -
- X O O - O O O X X X X X O O X O - -
- X X X O - - - O X O X X X O X O - -
X O O O O - - O - O O O O X X X O O -
X X O - - - O - - O O X X - - X X O O
X O O O - - O - O O X - - - - X O O X
- X X X O O X O O X X - - - - X X X X
X - X X X O X X O O X - - X X O X O O
X X O O X O X O X X - - - X O O O O -
X O - O X X X O X - - - - - X O - - -
O O - O X O O O O X X - X X X X O - -
O O - O O O X O X X - - X - X X O - -
- - O - - O X X X - - - - X O O O - -

आउटपुट: B+6

जल्द ही और भी मामले सामने आएंगे।

संदर्भ कार्यान्वयन

मैंने एएनएसआई सी में लिखा एक संदर्भ कार्यान्वयन बनाया है । यह कार्यान्वयन मानक इनपुट से इनपुट पढ़ता है और मानक आउटपुट पर आउटपुट लिखता है।

/* http://codegolf.stackexchange.com/q/6693/134
 * reference implementation
 * by user FUZxxl
 */

#include <stdio.h>
#include <stdlib.h>

#define MAXBOARD 256

/* bit 0x01: black colour
 * bit 0x02: white colour
 * bit 0x04: there is a stone on the intersection
 */

enum colour {
    UNCOLOURED    = 0x0,
    BLACK_REACHED = 0x1,
    WHITE_REACHED = 0x2,
    BOTH_REACHED  = 0x3,
    HAS_STONE     = 0x4,
    BLACK         = 0x5,
    WHITE         = 0x6
};

static enum colour board[MAXBOARD * MAXBOARD] = { 0 };

static int bsize = 0;

static void read_input(void);
static void fill_board(void);
static void show_score(void);

int main()
{
    read_input();
    fill_board();
    show_score();
    return EXIT_SUCCESS;
}

static void read_input(void)
{
    int n = 0;
    int invalue;

    while ((invalue = getchar()) != EOF) {
        switch (invalue) {
            case '-': board[n++] = UNCOLOURED; break;
            case 'X': board[n++] = BLACK; break;
            case 'O': board[n++] = WHITE; break;
        }
    }

    while (bsize * bsize < n) bsize++;

    /* your program may exhibit undefined behaviour if this is true */
    if (bsize * bsize != n) exit(EXIT_FAILURE);
}

static void fill_board(void)
{
    int i,j;
    int changes;
    enum colour here, top, bottom, left, right, accum;

    do {
        changes = 0;

        for (i = 0; i < bsize; ++i) {
            for (j = 0; j < bsize; ++j) {

                here   = board[i * bsize + j];
                if (here >= BOTH_REACHED) continue;

                top    = i == 0 ? UNCOLOURED : board[(i - 1) * bsize + j];
                left   = j == 0 ? UNCOLOURED : board[i * bsize + j - 1];
                bottom = i == bsize-1 ? UNCOLOURED : board[(i + 1) * bsize + j];
                right  = j == bsize-1 ? UNCOLOURED : board[i * bsize + j + 1];

                accum = here | top | bottom | left | right;
                accum &= ~HAS_STONE;

                changes |= board[i * bsize + j] != accum;

                board[i * bsize + j] = accum;

            }
        }

    } while (changes);
}

static void show_score(void) {
    int w = 0, b = 0, n;

    for (n = 0; n < bsize*bsize; ++n) switch (board[n] & ~HAS_STONE) {
        case BLACK_REACHED: ++b; break;
        case WHITE_REACHED: ++w; break;
    }

    if (b != w)
        printf("%s%i\n",b>w?"B+":"W+",abs(b-w));
    else
        printf("Jigo\n");
}

Comments

शायद आप पिछले उत्पादन होने का मतलब है W+7?

— dckckee

नहीं ... आप इस निष्कर्ष पर कैसे आए?

— फ़ूजएक्सएक्सएल

अरे ... मैं मान लिया है कि S+(क्योंकि आप पहले या तो के रूप में संभव उत्पादन सूचीबद्ध लिखने में कोई त्रुटि थी W+, B+या, Jigo) और मैं अपने कीबोर्ड को देखा और देखा Sके पास है W... या फिर आप ड्वोरक प्रयोग करते हैं?

— dmckee

@ मानकी मुझे लगता है कि "एस" जर्मन "श्वार्ज़" के बजाय "ब्लैक" से आता है।

— हावर्ड

ओह ... आप सही कह रहे हैं। इसके लिए क्षमा करें

— फूज़लीन

Answer 1

गोल्फस्क्रिप्ट (105 बाइट्स)

{'-XO'?}/]-1-.{2*3%}%{.,:N),{.*N=}?/{{[{.2$+1={+.}*}*]}%zip}N*[]*.1--,\}2*-.{.0>'W+B+'2/=\abs}{;'Jigo'}if

ऑनलाइन डेमो ।

मेरे पहले के इस उत्तर से बाढ़-भरण अनुकूलित ।

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

Comments

काफी उचित। आप इस दौर को जीत सकते हैं।

— FUZxxl

Answer 2

सी ( 438 434 413 382 364 336 322 298 294 292 290 अक्षर)

#define I b[d*g+e
a;b[65536];c;d;e;f;g;main(){for(;d=getchar()+1;f++)b[f]=d-80?d-89?d-46&&
f--:5:6,g+=g*g<f;while(!c--)for(d=g;d--;)for(e=g;e--;)I]<3?a=3&(I]|!!d*I
-g]|!!e*I-1]|(d<g-1)*I+g]|(e<g-1)*I+1]),c&=I]==a,I]=a:0;while(f--)c+=b[f
]%2-b[f]/2%2;printf(c?"%c+%i":"Jigo",c>0?66:87,abs(c));}

बढ़ी हुई विरासत के लिए पहले एक को छोड़कर सभी नई सुर्खियाँ। एक टिप्पणी और थोड़ा अधिक सुपाठ्य संस्करण यहाँ पाया जा सकता है ।

यह उत्तर मूल रूप से संदर्भ समाधान है लेकिन उस सभी बेकार सामानों के साथ (जैसे प्रकार [जिन्हें किसी intभी तरह से कुछ अलग करने की आवश्यकता है ?] और मानकों का अनुपालन [मुख्य का वापसी मूल्य! कृपया!]

सुधार और सुधार

438 → 434

चर के स्पष्ट आरंभ को छोड़ने के बाद मैंने खुद को आश्वस्त किया कि वे 0मानक के अनुसार स्वचालित रूप से प्रारंभिक हैं ।

434 → 413

हटाए गए केस स्टेटमेंट: यदि कोई अघोषित चौराहा काले और सफेद दोनों से उपलब्ध है, तो हम इसे दोनों को कार्यक्रम को सरल बनाने के लिए एक बिंदु के रूप में गिन सकते हैं। नकार से बचने के लिए तार्किक शाखाओं का स्विच।

413 → 382

कोष्ठक के एक जोड़े को बचाने के dलिए असाइन करें getchar()+1। इस धारणा के तहत कि सभी बयानों bको त्यागते हुए, शून्य को फिर से शुरू किया जाता है । से लंबा है । से लंबा है ।casebreak(a>b?c:0)(a>b)*c(d+1)*g+ed*g+e+g

382 → 364

बेहतर लूपिंग, आउटपुट में कोई नयापन नहीं, छोटी आउटपुट दिनचर्या।

364 → 336

उस switchबयान से छुटकारा मिला । (धन्यवाद, हावर्ड!), दो पात्रों के लिए अंकों का अंतर। cएक पात्र के लिए नेगेट । चार वर्ण बड़े या खंड में।

336 → 323

जगह &से %चार अक्षर के लिए ब्रेसिज़ को हटाने की अनुमति देता है। एक या ifएक वर्ण के लिए हटाए गए नौ या तो वर्ण (हाँ!) के लिए इनपुट लूप के साथ वर्ग-रूट का उपयोग किया ।

323 → 298

Hअक्सर होने वाले और भारी b[d*g+e]निर्माण को बदलने के लिए मैक्रो का परिचय दिया ।

298 → 294

a&=~4के a&=3रूप में हम केवल हर तीन सबसे कम बाइट्स का निरीक्षण करने के लिए बदलें a। यह भी लूप बॉडी में बदल गया ((a=I])<3)?a|=...है I]<3?a=I]|...जिसमें से दो अक्षर छोटे हैं। इसके अलावा, hपुन: उपयोग करने के बजाय परिचय दें c, जो एक वर्ण छोटा है।

294 → 292

hचर को हटा दें । यदि हम इसके बजाय के cसाथ परीक्षण करते !c--हैं !c++, cतो बाढ़-भरने वाले लूप के अंत में 0 के बराबर होता है और इस प्रकार इसका उपयोग इस उद्देश्य के लिए किया जा सकता है h(यानी स्कोर रखने से पहले)।

292 → 290

उस निर्माण d-46?f--:0को बदलें, d-46&&f--जो किसी वर्ण से छोटा है और aआंतरिक लूप में दो असाइनमेंट को संयोजित करता है ।

Comments

आप {b[f]=d-80?d-89?d-46?f--:0:5:6;f++;}कई वर्णों को सहेजने के लिए स्विच स्टेटमेंट को कुछ के साथ बदल सकते हैं ।

— हावर्ड

@ हॉवर्ड: हाँ। यह वास्तव में अच्छा काम किया! धन्यवाद

— FUZxxl

"बढ़ी हुई विरासत के लिए" - जैसे कि।

— टॉस

@tomsmeding खैर, एक पंक्ति को स्क्रॉल करना बहुत कम सुपाठ्य है। इसके अलावा, एक टिप्पणी संस्करण से जुड़ा हुआ है।

— FUZxxl

@FUZxxl यह मजाक में किया गया था। :) इसके अलावा, आप यह कहने में सही हैं कि यह 1 पंक्ति से बेहतर है।

— tomsmeding

Answer 3

J ( 140 136 131 129 129 119 117 वर्ण)

अपने जे कौशल को सुधारने के बाद, मैं आखिरकार जे में एक सबमिशन प्रदान कर सकता हूं। हालांकि यह थोड़ा लंबा है।

exit echo>(*{'Jigo';('B+',":);'W+',":@|)+/,-/1 2=/(]OR(0=[)*[:OR((,.|.)0,i:1)|.!.0])^:_~($~,~@%:@#)3-.~'-XO'i:1!:1]3

इस सबमिशन द्वारा लागू किया गया एल्गोरिदम, संदर्भ कार्यान्वयन के समान है, लेकिन जिस तरह से कब्जा कर लिया गया है, उसी तरह से अलग है।

यहाँ आसान समझ के लिए अधिक भागों में विभाजित समाधान है। गोल्फ का हल इससे थोड़ा अलग है, लेकिन अंतर बहुत बड़ा नहीं है।

input =. 3 -.~ '-XO' i: 1!:1 ] 3
board =. ($~ ,~@%:@#) input
NB. shift up, down, left, right
rotm =. (,. |.) 0 , i: 1
fill =. ] OR (0 = [) * [: OR rotm |.!.0 ]
filledboard =. fill^:_~ board
score =. +/ , -/ 1 2 =/ filledboard
echo > (* { 'Jigo' ; ('B+' , ":) ; ('W+', ":@|)) score
exit 0

Answer 4

GolfScript, 190 अक्षर

{"XO-"?)},:v,.),\{\.*=}+,~:s.*:`0\,{s%!\2*+}/:r;88{0v@{=\2*+}+/}:%~79%1${{:<.r|r^2*|<2/r|r^|<2s?:h/|<h*|1$|1$^2`?(&}`*}:a~@@a\;.2$|2${^2*)2base{+}*}:m~@2$|@m-.{"BW"1/1$0>="+"@abs}{;"Jigo"}if

शुरुआत में मैंने जितना सोचा था, स्क्रिप्ट उससे कहीं ज्यादा लंबी हो गई। एसटीडीआईएन पर कोई भी इनपुट पास करें और प्रोग्राम समाप्त होने पर आउटपुट प्रिंट हो जाएगा।

Answer 5

रूबी (314)

कुछ और समय के साथ कम किया जा सकता है:

q={?-=>0,?X=>5,?O=>6};b=[];$<.chars{|c|(t=q[c])&&b<<t}
z=Math.sqrt b.size
loop{c=b.each_with_index.map{|h,i|
next h if h>2
x=i%z
y=i/z
u=y<1?0:b[i-z]
l=x<1?0:b[i-1]
d=y>z-2?0:b[i+z]
r=x>z-2?0:b[i+1]
~4&(h|u|d|l|r)}
break if c==b
b=c}
b.map!{|h|h&~4}
s=b.count(1)-b.count(2)
puts s==0?"Jigo":s>0?"B+#{s}":"W+#{-s}"