सिक्का फ्लिप अनुक्रम विकल्पों का विश्लेषण करने के लिए एक कार्यक्रम बनाएँ

Question

मेरी एक पुरानी किताब की एक पहेली में, एक गेम को परिभाषित किया गया है जिसमें दो खिलाड़ी सिक्के के उतार-चढ़ाव का चयन करते हैं कि वे मानते हैं कि एक सिक्का बार-बार फ़्लिप होने पर सबसे पहले दिखाई देगा। (यह वास्तव में अजीब था और यहां तक ​​कि पासा रोल भी था, लेकिन समस्या की समानता के संदर्भ में यह थोड़ा विस्तार मायने नहीं रखता है।)

यह ध्यान दिया जाता है कि यदि खिलाड़ी 1 चुनता है TTTऔर खिलाड़ी 2 चुनता है HTT, तो उस खिलाड़ी 2 में गेम जीतने का 7/8 मौका होता है, क्योंकि एकमात्र तरीका TTTपहले आ सकता HTTहै यदि पहले तीन फ़्लिप सभी पूंछ हैं।

आपका काम एक प्रोग्राम या फ़ंक्शन बनाना है जो इस संभावना को कम कर देगा कि दो चुने हुए अनुक्रमों में से एक पहले आएगा। आपका कार्यक्रम इनपुट की दो लाइनें (या तर्क के रूप में दो तार) ले जाएगा, प्रत्येक 10 या उससे कम लंबाई के अनुक्रम का प्रतिनिधित्व करेगा:

HTT
TTT

और संभावना है कि पहले खिलाड़ी जीत जाएगा उत्पादन , अंश या दशमलव रूप में:

7/8
0.875

किसी भी भाषा में ऐसा करने वाला सबसे छोटा कोड जीत जाता है।

Comments

क्या अनुक्रम हमेशा एक-दूसरे के समान लंबाई के होते हैं?

— उड़ी ग्रांट

@UriZarfaty नहीं, जरूरी नहीं।

— जो

हालांकि संभवतः अनुक्रमों को अलग-अलग होना चाहिए (क्योंकि आउटपुट एक टाई को निर्दिष्ट नहीं कर सकता है)।

— उड़ी ग्रान्ट

हां, क्रम अलग होना चाहिए।

— जो जेड

विशेष रूप से, एक दूसरे का टर्मिनल विकल्प नहीं हो सकता।

— जो

Answer 1

अजगर 3 (139 136 134 132 126 115 143)

यहाँ वर्णित के रूप में कॉनवे के एल्गोरिथ्म का उपयोग करता है । सभी अनुक्रम जोड़े को संभालता है जब तक कि पहला दूसरे की समाप्ति के बाद (निर्देशों के अनुसार) नहीं है।

def f(a,b):c=lambda x,y=a:sum((x[~i:]==y[:i+1])<<i for i in range(len(x)));return 0 if b in a else(1/(1+(c(a)-c(a,b))/(c(b,b)-c(b))),1)[a in b]

6 बाइट्स शेविंग के लिए धन्यवाद xnor। थैंक्स के साथ बग को स्पॉट करने के लिए धन्यवाद जर्ब।

Comments

वर्तमान संस्करण मेरे लिए काम नहीं करता है। इनपुट के लिए "HTT"और "TTT", oका मूल्य है -1और यह इसे से विभाजित करता है 0।

— जक्यूब

अच्छा गोल्फ! मुझे डिफ़ॉल्ट तर्क चाल पसंद है। (अप्रयुक्त) सुझावों की एक जोड़ी: आप के 2**iसाथ गुणा कर सकते हैं <<i, और आउटपुट संभावना के रूप में लिखा जा सकता है 1/(1/o + 1), जिसमें आप oसीधे के पारस्परिक डाल सकते हैं।

— xnor

धन्यवाद। अच्छा स्पॉट री ओ / (1 + ओ)। कुछ हद तक शर्मिंदा है <<!

— उड़ी ग्रंता

@Jakube क्षमा करें, आपकी टिप्पणी को हाजिर नहीं किया! वर्तमान संस्करण मेरे लिए "HTT" और "TTT" के साथ ठीक काम करता है।

— उड़ी ग्रांट

यह एक गैर- खिलाड़ी के लिए जवाब देता है HTHऔर Tभले ही पहला खिलाड़ी जीत नहीं सकता। दूसरे उत्तर में भी यही समस्या है।

— जर्गब

Answer 2

CJam, 44 38 36 बाइट्स

यहाँ के रूप में एक ही कॉनवे के एल्गोरिथ्म का उपयोग करना ।

ll]_m*{~1$,,@f>\f{\#!}2b}/\-:X--Xd\/

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

मैं बाधाओं को जीतने के सूत्र का उपयोग कर रहा हूं (p पहले खिलाड़ी A के लिए ) को

तब संभावना को परिभाषित किया गया है

जो, सरलीकृत होने के बाद

और कुछ सरलीकरण के बाद, बन जाता है

---

उदाहरण इनपुट:

HTT
TTT

आउटपुट:

0.875

इसे यहाँ ऑनलाइन आज़माएँ

Comments

जो ने टिप्पणियों में कहा (इसके बाद पोस्ट किया गया था) कि तार जरूरी नहीं कि एक ही लंबाई के हों। फिर भी, +1 क्योंकि मुझे सीजेम समझ में नहीं आता है।

— mdc32

@ mdc32 तय, अब 1 बाइट::

— ऑप्टिमाइज़र

आप पहले से ही मुझे विश्वास दिलाते हैं कि कोडगोल्फएस अब लाटेक्स का समर्थन करता है ... = (

— त्रुटी

@ फ़्लावर हाहा। इसके बारे में क्षमा करें :(! ये ऑनलाइन LaTeX संपादक से PNG हैं।

— ऑप्टिमाइज़र

यह एक गैर- खिलाड़ी के लिए जवाब देता है HTHऔर Tभले ही पहला खिलाड़ी जीत नहीं सकता। दूसरे उत्तर में भी यही समस्या है।

— जर्गब

Answer 3

लुआ 211 190 184

इसके अलावा कॉनवे के एल्गोरिथ्म का उपयोग करना। लुआ के लिए अभी भी नया है ताकि यह सुनिश्चित करने के लिए और अधिक गोल्फ हो सके।

z=io.read;e=function(s,t)r='';for d in s:gmatch"."do r=r..(d==t:sub(1,1)and 1 or 0);end;return tonumber(r,2);end;a=z();b=z();print((e(a,a)-e(a,b))/(e(b,b)-e(b,a))/(1/((1/2)^b:len())));

Ungolfed

z=io.read;
e=function(s,t)
r='';
    for d in s:gmatch"."do 
        r=r..(d==t:sub(1,1)and 1 or 0);
    end;
    return tonumber(r,2);
end;
a=z();
b=z();
print((e(a,a)-e(a,b))/(e(b,b)-e(b,a))/(1/((1/2)^b:len())));

पहला संस्करण

z=io.read;
e=function(s,t) 
    r=0;
    for d in s:gmatch"."do 
        r=r*10;
        if d==t:sub(1,1)then r=r+1 end;
    end
    return tonumber(r,2);
end;
f=function(n,o)
    return ((e(n,n)-e(n,o))/(e(o,o)-e(o,n)))/(1/((1/2)^3));
end;
print(f(z(),z()));