6 या उससे कम चाल में मास्टरमाइंड को हल करना

Question

आपका लक्ष्य एक प्रोग्राम लिखना है जो 6 या उससे कम चालों में किसी भी मास्टरमाइंड पहेली को हल करेगा।

पृष्ठभूमि

मास्टरमाइंड एक बोर्ड गेम है। खेल का लक्ष्य अन्य खिलाड़ी द्वारा छिपाए गए 4 रंगीन खूंटों के संयोजन (रंगों और व्यवस्था) का सटीक अनुमान लगाना है। जब एक अनुमान लगाया जाता है, तो दूसरा खिलाड़ी 0 और 4 सफेद और लाल खूंटे के बीच प्रतिक्रिया करता है। एक लाल खूंटी जहां रंग और स्थान सही है। एक सफेद खूंटी वह जगह है जहां रंग को शेष टुकड़ों में दर्शाया जाता है, लेकिन गलत स्थान पर है। यदि अनुमान में डुप्लिकेट रंग हैं, तो गुप्त में संबंधित रंग के अनुसार केवल एक खूंटी से सम्मानित किया जाएगा। (इसलिए - यदि रहस्य में 1 ब्लू होता है, और अनुमान में 2 ब्लूज़ एक सही स्थान पर होते हैं, तो एक लाल मिर्च दी जाएगी)। 6 अलग-अलग रंग हैं, और डुप्लिकेट का उपयोग किया जा सकता है।

उदाहरण के लिए, एक खेल इस प्रकार हो सकता है: (हल मानकर रेड ग्रीन ग्रीन ब्लू है)

1:  Blue Purple Black Green - 2 white pegs
2:  Green Red Black Blue    - 2 white pegs, 1 red peg
3:  Green Green Green Blue  - 3 red pegs
4:  Red Green Green Blue    - 4 red pegs

विकिपीडिया पर नियमों का विस्तार किया गया है

आवश्यकताएँ

• कार्यक्रम को स्टडिन से पढ़ना चाहिए, और स्टडआउट को लिखना चाहिए
• मैं रंगों के बजाय सरलता के लिए संख्याओं का उपयोग करूंगा। अनुमान लगाने का संयोजन 1 और 6 के बीच 4 संख्याएं होंगी

• उन्हें अपने अनुमानों को एक नई पंक्ति के साथ 4 स्थान से अलग संख्या की संख्या के रूप में 1 से 6 तक समाप्त करना चाहिए। उदाहरण के लिए:

  1 5 2 2 \ n

• यह कार्यक्रम बाद में इनपुट के रूप में प्राप्त करेगा, इसके अनुमान के बाद 0 और 4 के बीच 2 पूर्णांक एक स्थान से अलग हो जाते हैं और एक नई रेखा के साथ समाप्त होते हैं। पहला होगा सफेद खूंटे की मात्रा, दूसरा लाल खूंटे की मात्रा।

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

उदाहरण इनपुट / आउटपुट

> is your programs output
< is the responding input
Solution is 1 5 6 6

> 1 2 3 4
< 0 1
> 4 1 6 6
< 1 2
> 1 6 5 6
< 2 2
> 1 5 6 6
< 0 4 

स्कोरिंग

• यह शुद्ध और सरल कोड गोल्फ है । बाइट्स में सबसे छोटा समाधान जीतता है।

यह मेरा पहला कोड गोल्फ प्रश्न है। मेरी माफी अगर मैंने कुछ गलत किया है, लेकिन मैंने यह सुनिश्चित करने के लिए यथासंभव प्रयास किया है कि कोई अस्पष्टता नहीं है, और जितना संभव हो सके उतने नियमों को रोकें। अगर मैं अस्पष्ट या अस्पष्ट हूं, तो कृपया बेझिझक सवाल पूछें।

Comments

आपके उदाहरण में इनपुट / आउटपुट 1 2 3 4वापस नहीं आना चाहिए 0 1?

— गफ्फी

और उदाहरण के पाठ में, "ग्रीन ग्रीन ग्रीन ब्लू" एक सफेद खूंटी नहीं देना चाहिए (पहले हरे रंग के लिए)? EDIT - विकिपीडिया स्पष्ट करता है कि कोई भी श्वेत नहीं दिया जाना चाहिए, जैसा आपने लिखा है। लेकिन मुझे लगता है कि प्रश्न में सफेद / काले नियमों को स्पष्ट रूप से कहा जाना चाहिए।

— ugoren

इसे काम करने की अनुमति कितनी धीमी होगी?

— काउंटरक्लेविस

@ गफ्फी - बिलकुल सही - फिक्स्ड

— lochok

सफेद खूंटे के नियम यहां नहीं बताए गए हैं। मान लीजिए कि आपने 1234 को चुना और मुझे लगता है कि 5611 है। मेरे दोनों 1s गलत जगह पर सही रंग हैं, इसलिए जिस तरह से आपने नियमों को बताया है, मैं कहूंगा कि मुझे 2 गोरे मिले। लेकिन नहीं - विकिपीडिया कहते हैं कि यह 1 सफेद है। कार्यक्रम के लिए गलत तरीका भी आसान है (लेकिन स्टीवन रूंबल्स्की ने विकिपीडिया के नियमों को सही ढंग से लागू किया है)।

— बदसूरत

Answer 1

पायथन 2 पायथन 3, 359 365 338 चार्ट

from itertools import*
from collections import*
m=h=set(product(*['123456']*4))
def f(g,k):b=sum(x==y for x,y in zip(g,k));return'%s %s'%(sum(min(g.count(c),k.count(c))for c in set(g))-b,b)
while len(m)>1:g=min(h,key=lambda g:max(Counter(f(g,k)for k in m).values()));print(*g);s=input();m=set(x for x in m if s==f(g,x))
print(*(m.pop()))

मजेदार, यह महसूस करने के लिए कि मुझे पाँच चरित्र चर नाम मिला, मुझे कई संपादन लेने पड़े।

मुझे लंबे आयात पसंद नहीं हैं। ऐसा लगता है कि मुझे एक प्रतिस्थापन लागू करने में सक्षम होना चाहिए, collections.Counterजिससे आयात को बचाया जा सके।

मुझे भी print(*(m.pop()))अंत पसंद नहीं है । ऐसा लगता है कि इसे लूप में गायब होना चाहिए, लेकिन मैं इसे लंबे समय तक किए बिना इसे करने का कोई तरीका नहीं ढूंढ सकता।

Comments

TypeError: join() takes exactly one argument (2 given)पर है return j(sum(min(g.count(c),k.count(c))for c in set(g))-b,b)। इसके अलावा, योग () एक इंट रिटर्न देता है, जबकि j (str.join) को एक पुनरावृत्ति लेना चाहिए

— ब्लेज़र

मेरी लूप संरचना फाइनल से छुटकारा पाती है print, और मुझे लगता है कि यह थोड़ा कम है। यह अनुरोधित व्यवहार से बेहतर तरीके से मेल खाता है (जब आप उत्तर जानते हैं तो "4 0" पर रोकना)। और len(m)>1== m[1:]। आयात वास्तव में कष्टप्रद है - from a,b import *अच्छा होता।

— ugoren

जब भी यह सही लगता है तो यह कार्यक्रम बाहर निकल जाता है। एक बार मैंने इसे चलाया और यह 5 अनुमानों पर रुका, यह सही नहीं था। अगली बार यह 4 अनुमानों पर बंद हो गया और यह सही था, लेकिन मैंने 4 0अभी तक इनपुट नहीं किया था , जो कि वस्तुनिष्ठ मानदंडों में है, और अन्य बार यह एक अपवाद के साथ बाहर निकल जाएगा:print(*(m.pop())) KeyError: 'pop from an empty set'

— ब्लेजर

@Blazer। इस उत्पादन के कारण कौन से परीक्षण मामले हैं?

— स्टीवन रूम्बल्स्की

@ ब्लेज़र: 4 0चार सफेद खूंटे हैं। मुझे लगता है कि आपके पास स्कोरिंग है।

— स्टीवन रूम्बल्स्की

Answer 2

हास्केल, 317 304

q[0,4]_=error""
q[n,m]l=(\s->all(==4-m)[g s,n+g(u(foldr((u((.drop 1).(++)).).break.(==)))$unzip s)]).c(u(/=)).zip l
u=uncurry;m=map;g=length;c=filter
f a=[head.c(($(zipWith q(take n a)$f a)).all.flip($)).sequence$replicate 4[1..6]|n<-[0..]]
main=interact$unlines.m(unwords.m show).f.m(m read.words).lines

मुझे विशुद्ध रूप से कार्यात्मक इंटरैक्टिव कार्यक्रम लिखना पसंद है! लेकिन निश्चित रूप से इस शैली की कुछ सीमाएँ हैं: यह अब एक त्रुटि के साथ समाप्त होता है, लेकिन आपने निर्दिष्ट नहीं किया कि यह ठीक नहीं है। मुझे IOग़ैर-त्रुटि से बाहर निकलने के लिए पूरी चीज़ को मठ में वापस लाने की आवश्यकता होगी ।

Comments

क्या यह 6 चालों में एक सही अनुमान की गारंटी देता है?

— ugoren

उह। मैंने सोचा था कि यह (ओपी के उदाहरण और अन्य समाधानों के लिए काम करता है), लेकिन संपूर्ण परीक्षण से पता चलता है कि इसे कभी-कभी 7 अनुमानों की आवश्यकता होती है। मुझे अभी इस पर काम करना होगा!

— को बंद करना

Answer 3

पायथन, 385 357 चार्ट, 5 चाल में हल

जितना अधिक मैं इसे बदलता हूं, यह स्टीवन रूंबल्स्की की तरह अधिक से अधिक बढ़ता है ... मुख्य अंतर यह है कि वह पूर्णांक के बजाय तार के साथ काम करता है।
लागू किया गया नथ का एल्गोरिथ्म (सही ढंग से अब, मुझे आशा है)।
स्टीवन रूंबल्स्की से स्कोरिंग फ़ंक्शन उधार लिया।
पहले अनुमान को उत्पन्न करने में लंबा समय लगता है, बाद में बेहतर हो जाता है। यदि आप इसका परीक्षण करना चाहते हैं, तो
इसे हार्ड-कोड करना ( g=len(A)==1296 and [1,1,2,2] or ...) जीवन को आसान बनाता है।
मैं 4 न्यूलाइन्स + टैब जोड़े की गिनती नहीं करता हूं, जो अर्धविराम द्वारा प्रतिस्थापित किया जा सकता है।

from collections import*
from itertools import*
a=B=A=list(product(*[range(1,7)]*4))
r=lambda g,k:(sum(x==y for x,y in zip(g,k)),sum(min(g.count(c),k.count(c))for c in set(g)))
while a!=4:
    g=A[1:]and min(B,key=lambda x:max(Counter(r(x,i)for i in A).values()))or A[0]
    print"%d "*4%tuple(g)
    b,a=map(int,raw_input().split())
    A=[x for x in A if r(g,x)==(a,a+b)]

Comments

"%d "*4%tuple(g)

— जिब्बलर

from collections import*

— जिब्बलर

a,b=map(int,raw_input())

— गनिबलर

product(*[range(1,7)]*4)

— जिब्बलर

Counter(r(x,i)for i in A).values()

— जिब्बलर