चलो छिपन - छिपाई खेलते हैं!

Question

उपयोगकर्ता छिपाएगा, और कंप्यूटर उन्हें खोजने का प्रयास करेगा।

सबसे पहले, कार्यक्रम ग्रिड के आकार के लिए, एक इनपुट लेगा। 5x5, 10x10, 15x15, आदि की तरह ग्रिड हमेशा एक पूर्ण वर्ग नहीं होगा।

ग्रिड शतरंज की तरह है:

_______________________________
|     |     |     |     |     |
| A1  |     |     |     |     | A
|_____|_____|_____|_____|_____|
|     |     |     |     |     |
|     | B2  |     |     |     | B
|_____|_____|_____|_____|_____|
|     |     |     |     |     |
|     |     | C3  |     |     | C
|_____|_____|_____|_____|_____|
|     |     |     |     |     |
|     |     |     | D4  |     | D
|_____|_____|_____|_____|_____|
|     |     |     |     |     |
|     |     |     |     | E5  | E
|_____|_____|_____|_____|_____|
   1     2     3     4     5

अब, उपयोगकर्ता एक वर्ग का चयन करेगा, जैसे B2(कंप्यूटर को बताए बिना)

कंप्यूटर वर्गों का अनुमान लगाना शुरू कर देगा। यदि यह सही वर्ग चुनता है, तो उपयोगकर्ता इसका जवाब देगा y। यदि नहीं, तो वे उस दिशा को इनपुट करेंगे जो उनकी टाइल एक उठाया (एन, एनई, ई, एसई, एस, एसडब्ल्यू, डब्ल्यू) से है।

इसलिए यदि उपयोगकर्ता ने उठाया B2और कंप्यूटर ने अनुमान लगाया C3, तो उपयोगकर्ता इनपुट करेगा NW।

यहाँ आउटपुट और इनपुट का एक उदाहरण दिया गया है:

Grid?
5x5

C3?
NW

C2?
N

B2?
y

स्कोरिंग:

यह एक सामान्य चुनौती से थोड़ा अलग तरीके से बनाया जाएगा।

विजेता वह प्रोग्राम है जो सबसे कम संख्या में अनुमान लगाता है (औसतन) यह सही वर्ग का अनुमान लगाने के लिए लेता है। परीक्षण के मामलों को औसतन 5x5 और फिर 10x10 में संभव वर्गों में से सभी होंगे।

हालांकि, इसे 26 पंक्तियों (यानी 5x8, 6x2, 20x5, आदि) तक ग्रिड के हर पैटर्न के साथ भी काम करना होगा।

कृपया इसे परीक्षण के लिए एक तरीका शामिल करें, जैसे कि JSFiddle।

और अंत में, एक टाई के मामले में, सबसे छोटा कार्यक्रम जीतता है।

Comments

अगर मैं छुपा रहा हूं A1और कंप्यूटर अनुमान लगा रहा है B9, तो उचित प्रतिक्रिया है NWया W?

— ग्रेग मार्टिन

@GregMartin यह NW होगा .... एन, डब्ल्यू, एस, ई सभी को सीधा होना चाहिए जबकि एक अलग पंक्ति / स्तंभ पर कुछ भी होना चाहिए NW, NE, SW, SE

— JKonowitz

क्या इनपुट और आउटपुट के विशिष्ट प्रारूप में लचीलापन है? यदि 26 से अधिक पंक्तियाँ हैं, तो उन्हें क्या कहा जाता है?

— ग्रेग मार्टिन

@GregMartin आप आउटपुट के साथ लचीले हो सकते हैं लेकिन इसे सरल रखने की कोशिश करें। यह बिल्कुल वैसा ही नहीं है, लेकिन एक समान शैली होनी चाहिए। आपको 26 से ऊपर कुछ भी खाते की आवश्यकता नहीं है, मैं इसे संपादित करूंगा।

— जोकोविट्ज़

मुझे नहीं पता कि "समान शैली" का क्या मतलब है। क्या हम पूर्णांक (पंक्ति #, कॉल #) की एक जोड़ी के रूप में इनपुट ले सकते हैं? (पुनश्च: इस प्रकार के प्रश्न सैंडबॉक्स में पूर्व-पोस्टिंग चुनौतियों का एक बड़ा कारण है।)

— ग्रेग मार्टिन

Answer 1

पायथन 3.6 , 466 398 392 बाइट, न्यूनतम

x, y = 1, 1
w, h = [int(x) for x in input('Grid?\n').split('x')]


def split_factor(a, b):
    N = b-y
    W = a-x
    S = h+~N
    E = w+~W
    return max(1, N, W, S, E, N*W, S*W, S*E, N*E)


def move(a, b):
    *Z, = zip([a, x, a, a+1, x, x, a+1, a+1],
              [y, b, b+1, b, y, b+1, b+1, y],
              [1, a-x, 1, w+x+~a, a-x, a-x, w+x+~a, w+x+~a],
              [b-y, 1, h+y+~b, 1, b-y, h+y+~b, h+y+~b, b-y])
    return Z[['N', 'W', 'S', 'E', 'NW', 'SW', 'SE', 'NE'].index(d)]

d = ''
while d != 'y':
    print()
    splits = {(a, b): split_factor(a, b) for a in range(x, x+w) for b in range(y, y+h)}
    a, b = min(splits, key=splits.get)
    d = input(f'{a}{"ABCDEFGHIJKLMNOPQRSTUVWXYZ"[b]}?\n')
    x, y, w, h = move(a, b)

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

अपठनीय संस्करण:

x=y=d=1
w,h=map(int,input('Grid?\n').split('x'))
while d!='y':print();s={(a,b):max(b-y,h+y+~b)*max(w+x+~a,a-x)for a in range(x,x+w)for b in range(y,y+h)};a,b=min(s,key=s.get);d=input(f'{a}{chr(64+b)}?\n');*z,=zip([a+1,x,a+1,x,a,a,a+1,x],[b+1,b+1,y,y,b+1,y,b,b],[w+x+~a,a-x,w+x+~a,a-x,1,1,w+x+~a,a-x],[h+y+~b,h+y+~b,b-y,b-y,h+y+~b,b-y,1,1]);x,y,w,h=z[~'WENS'.find(d)or-'NWNESWSE'.find(d)//2-5]

Answer 2

गणितज्ञ, परीक्षण मामलों पर इष्टतम व्यवहार, 260 बाइट्स

For[a=f=1;{c,h}=Input@Grid;z=Characters;t=<|Thread[z@#->#2]|>&;r="";v=Floor[+##/2]&;b:=a~v~c;g:=f~v~h,r!="y",r=Input[g Alphabet[][[b]]];{{a,c},{f,h}}={t["NSu",{{a,b-1},{b+1,c},{b,b}}]@#,t["uWX",{{g,g},{f,g-1},{g+1,h}}]@#2}&@@Sort[z@r/.{c_}:>{c,"u"}/."E"->"X"]]

इस कार्यक्रम को वुल्फराम क्लाउड में उपरोक्त कोड को काटकर और पेस्ट करके परीक्षण किया जा सकता है । (जल्दी से परीक्षण करें, हालांकि: मुझे लगता है कि प्रत्येक कार्यक्रम को चलाने के लिए एक समय सीमा है।) कार्यक्रम का अनुमान 2 cइसके बजाय की तरह दिखता है C2, लेकिन अन्यथा यह ऊपर की कल्पना के अनुसार चलता है। ग्रिड को एक पूर्ण जोड़े के पूर्णांक के रूप में इनपुट होना चाहिए, जैसे {26,100}, और प्रोग्राम के अनुमानों पर प्रतिक्रियाएं स्ट्रिंग्स के रूप में "NE"या जैसे इनपुट होनी चाहिए "y"।

कार्यक्रम छोटी और सबसे बड़ी पंक्ति संख्या और स्तंभ संख्या का ट्रैक रखता है जो अब तक के इनपुट के अनुरूप है, और हमेशा संभावनाओं के सबग्रिड के केंद्र बिंदु का अनुमान लगाता है (एनडब्ल्यू को गोल करता है)। कार्यक्रम नियतात्मक है, इसलिए एक निश्चित ग्रिड पर औसतन इसके लिए आवश्यक अनुमानों की संख्या की गणना करना आसान है। 10x10 ग्रिड पर, प्रोग्राम को एक एकल वर्ग के लिए 1 अनुमान, 8 वर्ग के लिए 2 अनुमान, 64 वर्गों के लिए 3 अनुमान और शेष 27 वर्गों के लिए 4 अनुमान, 3.17 के औसत के लिए आवश्यक है; और यह सैद्धांतिक न्यूनतम है, यह देखते हुए कि कितने 1-अनुमान, 2-अनुमान, आदि अनुक्रम सही अनुमान लगा सकते हैं। वास्तव में, कार्यक्रम को समान कारणों के लिए किसी भी आकार के ग्रिड पर सैद्धांतिक न्यूनतम हासिल करना चाहिए। (5x5 ग्रिड पर, अनुमानों की औसत संख्या 2.6 है।)

थोड़ा कोड स्पष्टीकरण, हालांकि यह गोल्फिंग के अलावा काफी सीधा है। (मैंने एक्सपोज़ररी उद्देश्यों के लिए कुछ प्रारंभिक बयानों के क्रम का आदान-प्रदान किया - बाइट काउंट पर कोई प्रभाव नहीं।)

1  For[a = f = 1; z = Characters; t = <|Thread[z@# -> #2]|> &;
2      v = Floor[+##/2] &; b := a~v~c; g := f~v~h;
3      r = ""; {c, h} = Input@Grid, 
4    r != "y", 
5    r = Input[g Alphabet[][[b]]];
6      {{a, c}, {f, h}} = {t["NSu", {{a, b - 1}, {b + 1, c}, {b, b}}]@#, 
7        t["uWX", {{g, g}, {f, g - 1}, {g + 1, h}}]@#2} & @@ 
8        Sort[z@r /. {c_} :> {c, "u"} /. "E" -> "X"]
   ]

लाइनें 1-3 Forलूप को इनिशियलाइज़ करती हैं , जो वास्तव Whileमें भेस में सिर्फ एक लूप है, इसलिए हे, दो कम बाइट्स। किसी भी क्षण संभव पंक्ति-संख्या और स्तंभ-संख्या श्रेणियां संग्रहीत होती हैं {{a, c}, {f, h}}, और उस उप-ग्रिड में केंद्रित अनुमान {b, g}पंक्ति 2 में परिभाषित कार्यों द्वारा गणना की जाती है । पंक्ति 3 उपयोगकर्ता इनपुट से अधिकतम-पंक्ति cऔर अधिकतम-स्तंभ hको प्रारंभ करती है , और rलूप-टेस्टेड वैरिएबल और इसके बाद के यूजर इनपुट्स को भी इनिशियलाइज़ करता है।

जबकि लाइन 4 पर परीक्षण संतुष्ट है, लाइन 5 को उपयोगकर्ता से इनपुट मिलता है, जहां वर्तमान अनुमान से संकेत मिलता है {b, g}( Alphabet[][[b]]]पंक्ति संख्या को एक पत्र में परिवर्तित करता है)। फिर लाइनें 6-8 सबग्रिड-ऑफ-प्रॉस्पेक्ट्स को अपडेट करती हैं (और इसलिए अगले अनुमान से)। उदाहरण के लिए, t["NSu", {{a, b - 1}, {b + 1, c}, {b, b}}]( tलाइन 1 की परिभाषा को देखते हुए ) का विस्तार होता है

<| "N" -> {a, b - 1}, "S" -> {b + 1, c}, "u" -> {b, b}|>

जहां आप उपयोगकर्ता के अंतिम इनपुट के अनुसार अपडेट की जा रही न्यूनतम-पंक्ति और अधिकतम-पंक्ति संख्या देख सकते हैं। पंक्ति 8 किसी भी संभावित इनपुट को प्रपत्र के वर्णों के क्रमबद्ध जोड़े में परिवर्तित करती है { "N" | "S" | "u", "u" | "W" | "X"}; यहाँ "u"एक सही पंक्ति या स्तंभ है, और "X"पूर्व के लिए खड़ा है (सिर्फ Sortअच्छी तरह से काम करने की अनुमति देने के लिए)। जब उपयोगकर्ता अंततः इनपुट करता है "y", तो ये लाइनें एक त्रुटि फेंकती हैं, लेकिन फिर लूप-टेस्ट विफल हो जाता है और त्रुटि कभी भी प्रचारित नहीं होती है (कार्यक्रम बस वैसे भी रुक जाता है)।

Answer 3

बैच, फूट डालो और जीतो

@echo off
set z = ABCDEFGHIJKLMNOPQRSTUVWXYZ
set /p g = Grid?
set /a w = 0, n = 0, e = %g :x= + 1, s = % + 1
:l
set /a x = (w + e) / 2, y = (n + s) / 2
call set c = %%z :~%y%,1%%
set /p g = %c %%x%?
if %g :w=.% == %g % set /a w = x
if %g :n=.% == %g % set /a n = y
if %g :e=.% == %g % set /a e = x
if %g :s=.% == %g % set /a s = y
if %g :y=.% == %g % goto l

अभी भी खोजे जाने वाले क्षेत्र के बाउंडिंग बॉक्स बनाकर काम करता है। अगला अनुमान हमेशा बॉक्स का केंद्र होता है। उन कम्पास बिंदुओं के लिए जो प्रतिक्रिया में शामिल नहीं हैं, उस दिशा में बॉक्स कम हो जाता है। उदाहरण के लिए N, बॉक्स के बाएं, दाएं और नीचे अनुमानित वर्ग में सेट किए गए हैं।

369 बाइट्स में मैं किसी को हराने की उम्मीद नहीं कर रहा हूं इसलिए मैंने पठनीयता के लिए रिक्त स्थान छोड़ दिए हैं।

Comments

ठीक है, विभाजन और जीत आम तौर पर बड़े टेस्टकेस के लिए उपयोगी है, लेकिन छोटे मामलों के लिए नहीं, किसी भी बेहतर एल्गोरिदम के लिए?

— मैथ्यू रो

@SIGSEGV निश्चित नहीं कि आपका क्या मतलब है; ग्रेग और बेन के जवाब बॉक्स पद्धति के केंद्र का भी उपयोग करते हैं।

— नील

हमें अभी भी एक बेहतर एल्गोरिथ्म की आवश्यकता है।

— मैथ्यू रो

@SIGSEGV बॉक्स विधि का केंद्र इष्टतम है। कोई बेहतर एल्गोरिदम नहीं है।

— TheNumberOne