अज्ञात पूर्वाग्रह साथ एक सिक्के को देखते हुए , मैं कैसे वेरिएंट उत्पन्न कर सकता हूं - जितना संभव हो उतना कुशलता से - कि बर्नौली को प्रायिकता 0.5 के साथ वितरित किया जाता है? यही है, प्रति उत्पन्न चर की न्यूनतम फ़्लिप संख्या का उपयोग करना।
अज्ञात पूर्वाग्रह साथ एक सिक्के को देखते हुए , मैं कैसे वेरिएंट उत्पन्न कर सकता हूं - जितना संभव हो उतना कुशलता से - कि बर्नौली को प्रायिकता 0.5 के साथ वितरित किया जाता है? यही है, प्रति उत्पन्न चर की न्यूनतम फ़्लिप संख्या का उपयोग करना।
जवाबों:
यह कई अच्छे समाधानों के साथ एक प्रसिद्ध समस्या है, जिसकी चर्चा यहाँ और स्टैकओवरफ़्लो में की गई है (ऐसा लगता है कि मैं एक से अधिक लिंक पोस्ट नहीं कर सकता लेकिन एक त्वरित Google खोज आपको कुछ दिलचस्प प्रविष्टियाँ देता है)। विकिपीडिया प्रविष्टि पर एक नज़र डालें
http://en.wikipedia.org/wiki/Fair_coin#Fair_results_from_a_biased_coin
यह एक क्लासिक समस्या है, मेरा मानना है कि मूल रूप से वॉन न्यूमैन को जिम्मेदार ठहराया गया है। एक समाधान जोड़े में सिक्के को अलग रखने तक है, जब तक कि जोड़े अलग-अलग न हों, और फिर जोड़ी में पहले सिक्के के परिणाम के लिए स्थगित कर दें।
स्पष्ट रूप से टॉस का परिणाम है , जिसमें पहला सिक्का है, और दूसरा सिक्का है। प्रत्येक सिक्के में प्रमुखता के होते हैं। फिर समरूपता के कारण, जिसका अर्थ है | इस समरूपता को स्पष्ट रूप से देखने के लिए कि तात्पर्य है कि परिणाम या , दोनों स्वतंत्रता के कारण समान रूप से संभावित हैं।मैं एक्स मैं Y मैं पी पी ( एक्स मैं = एच | एक्स मैं ≠ वाई मैं ) = पी ( एक्स मैं = टी | एक्स मैं ≠ वाई मैं ) पी ( एक्स मैं = एच | एक्स मैं ≠ वाई मैं ) = 1 / 2 एक्स मैं ≠ Y ( एच , टी ) ( टी , एच )
जाहिर है, ऐसी असमान जोड़ी तक प्रतीक्षा समय है
जो ऊपर चल रही है के रूप में हो जाता है करीब करने के लिए 0 या 1 (जो समझ में आता है)।
मुझे यकीन नहीं है कि शब्दों को कुशलता से कैसे योग किया जाए, लेकिन जब भी रोल की कुल संख्या और की कुल संख्या इस तरह की हो सकती है, तो हम रोक सकते हैं कि तब भी है जब हम अलग-अलग विभाजन कर सकते हैं। आदेश जो हम प्राप्त कर सकते हैं और अलग-अलग आउटपुट लेबल के अनुरूप प्रत्येक के बराबर संभावना के दो समूहों में । हम सावधान रहने की है कि हम पहले से ही इन तत्वों, अर्थात् के लिए बंद कर दिया है नहीं, कि कोई भी तत्व लंबाई का एक उपसर्ग है की जरूरत है के साथ सफलताओं ऐसी है कि भी है। मुझे यकीन नहीं है कि कैसे इसे अपेक्षित संख्या में फ़्लिप किया जाए।टी ( एन ntn′t′ ( n′)
उदाहरण देकर स्पष्ट करने के लिए:
हम TH या HT पर रोक सकते हैं क्योंकि इनमें समान संभावना है। पास्कल के त्रिभुज को नीचे ले जाने पर, अगली पंक्ति भी चौथी पंक्ति में है: 4, 6, 4. इसका मतलब है कि हम रोल्स के बाद रुक सकते हैं यदि एक सिर ऊपर आ गया है क्योंकि हम एक द्विदलीय मिलान बना सकते हैं: एचएचएचटी एचएचटीएच के साथ, और तकनीकी रूप से एचटीएचएच के साथ यद्यपि हम पहले ही उन लोगों के लिए रुक गए थे। इसी तरह, TTHH के साथ मैचिंग एचएचटीटी (बाकी, हम उन तक पहुँचने से पहले ही रोक दिया जाता है) की पैदावार करते हैं।
के लिए , दृश्यों के सभी उपसर्गों बंद कर दिया है। यह पर थोड़ा और दिलचस्प हो जाता है, जहाँ हम FFFFTTFT को FFFFTTTF से मिलाते हैं।( 8
के लिए 8 रोल के बाद, बंद नहीं होने की संभावना है अगर हम में से बंद कर दिया है रोल के अपेक्षित संख्या के साथ । समाधान के लिए जहां हम जोड़े को अलग-अलग रखने तक रोकते हैं, रुके हुए नहीं होने की संभावना अपेक्षित संख्या में रोल के साथ होती है यदि हम 4 से बंद हो गए हैं। पुनरावृत्ति द्वारा, अपेक्षित फ़्लिप पर एक ऊपरी सीमा प्रस्तुत एल्गोरिथ्म के लिए । १ ५३ १ 128
मैंने रुकने के बिंदुओं के बारे में जानने के लिए एक पायथन प्रोग्राम लिखा:
import scipy.misc
from collections import defaultdict
bins = defaultdict(list)
def go(depth, seq=[], k=0):
n = len(seq)
if scipy.misc.comb(n, k, True) % 2 == 0:
bins[(n,k)].append("".join("T" if x else "F"
for x in seq))
return
if n < depth:
for i in range(2):
seq.append(i)
go(depth, seq, k+i)
seq.pop()
go(8)
for key, value in sorted(bins.items()):
for i, v in enumerate(value):
print(v, "->", "F" if i < len(value) // 2 else "T")
print()
प्रिंट:
FT -> F
TF -> T
FFFT -> F
FFTF -> T
FFTT -> F
TTFF -> T
TTFT -> F
TTTF -> T
FFFFFT -> F
FFFFTF -> T
TTTTFT -> F
TTTTTF -> T
FFFFFFFT -> F
FFFFFFTF -> T
FFFFFFTT -> F
FFFFTTFF -> T
FFFFTTFT -> F
FFFFTTTF -> T
FFFFTTTT -> F
TTTTFFFF -> T
TTTTFFFT -> F
TTTTFFTF -> T
TTTTFFTT -> F
TTTTTTFF -> T
TTTTTTFT -> F
TTTTTTTF -> T