เครื่องมือพัฒนาสมอง: จะสร้างจำนวนเต็ม 7 จำนวนด้วยความน่าจะเป็นที่เท่าเทียมกันโดยใช้เหรียญลำเอียงที่มี pr (หัว) = p อย่างไร


58

นี่เป็นคำถามที่ฉันพบในGlassdoor : เราสร้างจำนวนเต็ม 7 ตัวที่มีความน่าจะเป็นเท่ากันในการใช้เหรียญที่มีอย่างไรPr(Head)=p(0,1)

โดยทั่วไปคุณมีเหรียญที่อาจจะใช่หรือไม่ยุติธรรมและนี่เป็นกระบวนการสร้างเลขสุ่มเพียงตัวเดียวที่คุณมีดังนั้นเกิดขึ้นกับตัวสร้างตัวเลขสุ่มที่แสดงจำนวนเต็มตั้งแต่ 1 ถึง 7 โดยที่ความน่าจะเป็นที่จะได้จำนวนเต็มแต่ละตัว คือ 1/7

ประสิทธิภาพของกระบวนการสร้างข้อมูล


ที่เกี่ยวข้อง, ไม่ใช่ผู้ล่อลวง: stats.stackexchange.com/questions/256563/…
Reinstate Monica

12
มีวิธีมากมายในการบรรลุเป้าหมายนี้ คำถามที่น่าสนใจมากกว่านี้ขอวิธีที่ดีที่สุดในแง่ที่กำหนดไว้อย่างดี ความรู้สึกตามธรรมชาติที่ดีที่สุดคือจำนวนครั้งที่น้อยที่สุดที่คาดว่าจะสร้างต่อจำนวนเต็ม อีกเวอร์ชั่นที่น่าสนใจคือการอธิบายวิธีแก้ปัญหาที่เป็นไปได้ทั้งหมด (ซึ่งต้องอาศัยการโยนเหรียญอิสระและไม่มีอะไรเพิ่มเติม)
whuber

1
@whuber คำแนะนำที่ดีฉันได้แก้ไขคำถามเพื่อสะท้อนความคิดเห็นของคุณ
Amazonian

<<< โดยทั่วไปคุณมีเหรียญที่อาจจะใช่หรือไม่ยุติธรรมและนี่เป็นเพียงกระบวนการสร้างเลขสุ่มที่คุณมี >>> นี่หมายถึงการใช้เหรียญในวิธีที่แตกต่างจากการพลิกเหรียญและตรวจดูหัว เทียบกับ tail เป็น "ต้องห้าม" เนื่องจากมันจะเป็นอีกกระบวนการสร้างหมายเลขสุ่ม
TinglTanglBob

9
Mod 7 ของปีบนเหรียญ
Nat

คำตอบ:


56

พลิกเหรียญสองครั้ง ถ้ามันตกลงมาHHหรือTTไม่ก็สนใจมันแล้วพลิกมันสองครั้งอีกครั้ง

ตอนนี้เหรียญมีความน่าจะเป็นที่จะเกิดขึ้นHTหรือTHเท่ากัน ถ้ามันขึ้นมาโทรนี้HT H1ถ้ามันขึ้นมาโทรนี้THT1

ได้รับH1หรือT1จนกว่าคุณจะมีสามในแถว ผลลัพธ์ทั้งสามนี้ให้ตัวเลขตามตารางด้านล่าง:

H1 H1 H1 -> 1
H1 H1 T1 -> 2
H1 T1 H1 -> 3
H1 T1 T1 -> 4
T1 H1 H1 -> 5
T1 H1 T1 -> 6
T1 T1 H1 -> 7
T1 T1 T1 -> [Throw out all results so far and repeat]

ฉันยืนยันว่าสิ่งนี้จะทำงานได้อย่างสมบูรณ์แบบแม้ว่าคุณจะมีจำนวนมากที่สูญเปล่าในกระบวนการ!


4
ข้อ จำกัด เพียงอย่างเดียวคือความน่าจะเป็นของหัวคือ "p" หมายเหตุพีที่อาจเป็นหรือ1ดังนั้นสิ่งนี้จึงไม่รับประกันว่าจะทำงานได้ แต่ Sycorax (หรือ Sephan) จะใช้ได้แม้ในกรณีเหล่านั้น 101
gung - Reinstate Monica

8
@ gung: ฉันไม่แน่ใจว่าฉันจะทำงานเพื่อเหรียญที่มีสองหัวหรือสองหาง
S. Kolassa - Reinstate Monica

6
ด้วยความน่าจะเป็นมันจะเสร็จสิ้นในเวลาที่ จำกัด 1
คลาร์

18
สิ่งนี้เรียกว่าการฟอกสีฟัน Von-Neuman
DonFusili

4
คุณสามารถทำซ้ำตัวแยก von Neumann เพื่อแยกเอนโทรปีออกจากลำดับ รวบรวมคู่ HH และ TT ทั้งหมดพิจารณาว่าลำดับใช้ตัวระบาย von Neumann กับสิ่งนั้นและอื่น ๆ
Simmons

47

สมมติว่า(0,1)p(0,1)

ขั้นที่ 1: โยนเหรียญ 5 ครั้ง

หากผลออกมาเป็น

1(H,H,H,T,T) , คืนและหยุด1

2(H,H,T,T,H) , ส่งคืนและหยุด2

3(H,T,T,H,H) , คืนและหยุด3

4(T,T,H,H,H) , ส่งคืนและหยุด4

5(T,H,H,H,T) , คืนและหยุด5

6(H,H,T,H,T) , ส่งคืนและหยุด6

7(H,T,H,T,H) , ส่งคืนและหยุด7

ขั้นตอนที่ 2: หากผลลัพธ์ไม่ตรงตามข้างต้นให้ทำซ้ำขั้นตอนที่ 1

โปรดสังเกตว่าไม่คำนึงถึงมูลค่าของ , ผลลัพธ์ทั้งเจ็ดรายการข้างต้นมีความน่าจะเป็นและจำนวนเหรียญที่คาดว่าจะโยนคือ{} tosser ไม่จำเป็นต้องรู้คุณค่าของ (ยกเว้นว่าและ ); มีการรับประกันว่าจำนวนเต็มเจ็ดจำนวนเท่ากันที่จะถูกส่งคืนโดยการทดลองเมื่อสิ้นสุด (และรับประกันว่าจะจบด้วยความน่าจะเป็น )q = p 3 ( 1 - p ) 2 5p(0,1)q=p3(1p)2 pp0p1157qpp0p11


6
เราสามารถลดจำนวนการโยนที่คาดไว้สำหรับสิ่งนี้ได้โดยอนุญาตให้ลำดับที่ระบุไว้ที่นี่หรือลำดับนั้นกับการพลิกแต่ละครั้ง เช่น: สำหรับ 1, (H, H, H, T, T) หรือ (T, T, T, H, H)
เพิ่มเติม

5
คุณสามารถเพิ่มส่วนประกอบได้เช่นกัน หากผลลัพธ์คือ (H, H, H, T, T) หรือ (T, T, T, H, H), ส่งคืน 1 และหยุดเป็นต้นในกรณีนั้นความน่าจะเป็นสำหรับแต่ละผลลัพธ์คือ 3 q=p3(1p)2+p2(1p)3
Sextus Empiricus

2
เป็นไปได้หรือไม่ที่จะเพิ่มการพลิกเหรียญอีกครั้งหากผลลัพธ์ไม่ได้อยู่ในการจัดการ (H, H, H, T, T) ด้วยการโยนเหรียญเพิ่มเติมคุณต้องใช้การแมปอื่น (H, H, H, T, T, T) และ (H, H, T, T, T, T) และ XT (7-x) H รวมกัน ที่สามารถจัดเรียงใน 7 หรือมากกว่าคำสั่งที่แตกต่างกันไปยังหมายเลข 1 ถึง 7 แทนที่จะเขียนซ้ำทั้ง 5 เหรียญนี้จะเพิ่มเพียง 1 โยนเพิ่มเติม แต่ฉันไม่แน่ใจว่ามันทำงาน: D
TinglTanglBob

5
อาจเป็นสิ่งที่ดีที่สุดในการพลิกเหรียญทันที 7 ครั้งเนื่องจากมีการรับประกันว่าคุณจะได้รับหมายเลขสุ่มจากมัน (มีข้อยกเว้นเท่านั้นคือเหรียญจะขึ้นหรือเพิ่มทั้งหมด 7 ครั้ง) . ดังนั้นด้วยการโยน 7 ครั้งคุณสามารถจบลงด้วย 1 ถึง 6 หัว (ฉันไม่รวมตัวเลือก 0 และ 7 ที่นี่ตั้งแต่ไม่มีจุดหมาย) หากหัวหนึ่งมีการเตรียมการที่แตกต่างกัน 7 ของ (H, T, T, T, T, T, T) เป็นไปได้; ถ้า 2 หัวเป็น 21 ถ้า 3 หัวเป็น 35 ถ้า 4 35 หัว; ถ้า 5 21 หัว; ถ้า 6 7 หัว; แต่ละรายการสามารถแมปได้อย่างสมบูรณ์แบบกับหมายเลข 1-7 โดยไม่เสียค่าผสม
TinglTanglBob

2
@TinglTanglBob นี่คือคำตอบของ Martijn Weterings ;-)
M.Herzkamp

22

การสรุปกรณีที่อธิบายโดย Dilip Sarwate

วิธีการบางอย่างที่อธิบายไว้ในคำตอบอื่น ๆ ใช้รูปแบบที่คุณโยนลำดับของเหรียญใน 'เทิร์น' และขึ้นอยู่กับผลที่คุณเลือกตัวเลขระหว่าง 1 หรือ 7 หรือทิ้งการหมุนและโยนอีกครั้งn

เคล็ดลับคือจะหาได้ในการขยายตัวของความเป็นไปได้หลาย 7 ผลแบบเดียวกับที่ความน่าจะเป็นและตรงกับแต่ละอื่น ๆpk(1p)nk

เนื่องจากจำนวนผลลัพธ์ทั้งหมดนั้นไม่ใช่ผลคูณของ 7 เราจึงมีผลลัพธ์ไม่กี่อย่างที่เราไม่สามารถกำหนดให้กับตัวเลขได้และมีความเป็นไปได้ที่เราต้องทิ้งผลลัพธ์และเริ่มต้นใหม่


กรณีของการใช้ 7 เหรียญพลิกต่อเทิร์น

เราสามารถบอกได้ว่าการกลิ้งลูกเต๋าเจ็ดครั้งนั้นน่าสนใจมาก เนื่องจากเราจะต้องโยนออก 2 ออกจากความเป็นไปได้ กล่าวคือหัว 7 ครั้งและ 0 ครั้งหัว27

สำหรับความเป็นไปได้อื่น ๆ ทั้งหมดของนั้นจะมีหลายกรณี 7 กรณีที่มีจำนวนหัวเท่ากันเสมอ แบ่งออกเป็น 7 กรณีมี 1 หัว, 21 รายมี 2 หัว, 35 รายมี 3 หัว, 35 รายมี 4 หัว, 21 รายมี 5 หัวและ 7 รายมี 6 หัว272

ดังนั้นถ้าคุณคำนวณจำนวน (ทิ้ง 0 หัวและ 7 หัว)

X=k=17(k1)Ck

ด้วย Bernoulli ตัวแปรกระจาย (ค่า 0 หรือ 1) จากนั้น X modulo 7 เป็นตัวแปรชุดที่มีเจ็ดผลลัพธ์ที่เป็นไปได้Ck


เปรียบเทียบจำนวนการโยนเหรียญที่แตกต่างกันต่อเทิร์น

คำถามยังคงเป็นสิ่งที่จำนวนม้วนที่เหมาะสมที่สุดต่อรอบจะเป็นอย่างไร การหมุนลูกเต๋าสี่เหลี่ยมลูกเต๋าต่อเทิร์นจะทำให้คุณเสียค่าใช้จ่ายมากขึ้น แต่คุณลดโอกาสที่จะต้องหมุนอีกครั้ง

ภาพด้านล่างแสดงการคำนวณด้วยตนเองสำหรับการโยนเหรียญสองถึงสามครั้งแรกต่อเทิร์น (อาจจะมีวิธีการวิเคราะห์ แต่ฉันเชื่อว่ามันปลอดภัยที่จะบอกว่าระบบที่มีการโยน 7 เหรียญให้วิธีที่ดีที่สุดเกี่ยวกับค่าความคาดหวังสำหรับจำนวนการโยนเหรียญที่จำเป็น)

จำนวนที่คาดหวังของการโยนเหรียญ

# plot an empty canvas
plot(-100,-100,
     xlab="flips per turn",
     ylab="E(total flips)",
     ylim=c(7,400),xlim=c(0,20),log="y")
title("expectation value for total number of coin flips
(number of turns times flips per turn)")

# loop 1
# different values p from fair to very unfair 
# since this is symmetric only from 0 to 0.5 is necessary 

# loop 2
# different values for number of flips per turn
# we can only use a multiple of 7 to assign 
#   so the modulus will have to be discarded
#   from this we can calculate the probability that the turn succeeds
#   the expected number of flips is 
#       the flips per turn 
#             divided by 
#       the probability for the turn to succeed 

for (p in c(0.5,0.2,0.1,0.05)) {
  Ecoins <- rep(0,16)
  for (dr in (5:20)){
    Pdiscards = 0
    for (i in c(0:dr)) { 
      Pdiscards = Pdiscards + p^(i)*(1-p)^(dr-i) * (choose(dr,i) %% 7)
    }
    Ecoins[dr-4] = dr/(1-Pdiscards)
  }
  lines(5:20, Ecoins)
  points(5:20, Ecoins, pch=21, col="black", bg="white", cex=0.5)
  text(5, Ecoins[1], paste0("p = ",p), pos=2)
}

ใช้กฎการหยุดก่อน

หมายเหตุ: การคำนวณด้านล่างสำหรับค่าความคาดหวังของจำนวนการโยนสำหรับเหรียญที่เป็นธรรมมันจะกลายเป็นความยุ่งเหยิงเมื่อต้องทำสิ่งนี้สำหรับแตกต่างกันแต่หลักการยังคงเหมือนเดิม (แม้ว่าการเก็บหนังสือที่แตกต่างกัน กรณีจำเป็น)p=0.5p

เราควรจะสามารถเลือกเคส (แทนที่จะเป็นสูตรสำหรับ ) เพื่อที่เราจะได้หยุดก่อนหน้านี้X

  • ด้วยการโยนเหรียญ 5 ครั้งเรามีหัวและก้อยที่ไม่เรียงลำดับหกชุดที่เป็นไปได้:

    1 + 5 + 10 + 10 + 5 + 1 ชุดที่สั่ง

    และเราสามารถใช้กลุ่มที่มีสิบกรณี (นั่นคือกลุ่มที่มี 2 หัวหรือกลุ่มที่มี 2 ก้อย) เพื่อเลือกจำนวน (ที่มีความน่าจะเป็นเท่ากัน) สิ่งนี้เกิดขึ้นใน 14 จาก 2 ^ 5 = 32 ราย สิ่งนี้ทำให้เรามี:

    1 + 5 + 3 + 3 + 5 + 1 ชุดที่สั่ง

  • ด้วยการพลิกเหรียญพิเศษ (6-th)เรามีเจ็ดชุดที่ไม่ได้เรียงกันของหัวและก้อย:

    1 + 6 + 8 + 6 + 8 + 6 + 1 ชุดที่สั่ง

    และเราสามารถใช้กลุ่มที่มีแปดกรณี (นั่นคือกลุ่มที่มี 3 หัวหรือกลุ่มที่มี 3 ก้อย) เพื่อเลือก (ที่มีความน่าจะเป็นเท่ากัน) เป็นตัวเลข สิ่งนี้เกิดขึ้นใน 14 จาก 2 * (2 ^ 5-14) = 36 ราย สิ่งนี้ทำให้เรามี:

    1 + 6 + 1 + 6 + 1 + 6 + 1 ชุดที่สั่ง

  • ด้วยการพลิกเหรียญพิเศษอีกครั้ง (7-th)เรามีแปดชุดที่ไม่ได้เรียงกันของหัวและก้อย:

    1 + 7 + 7 + 7 + 7 + 7 + 7 + 1 ชุดที่สั่ง

    และเราสามารถใช้กลุ่มที่มีเจ็ดกรณี (ทั้งหมดยกเว้นก้อยทั้งหมดและหัวทุกกรณี) เพื่อเลือก (ที่มีความน่าจะเป็นเท่ากัน) จำนวนหนึ่ง เรื่องนี้เกิดขึ้นใน 42 จาก 44 กรณี สิ่งนี้ทำให้เรามี:

    1 + 0 + 0 + 0 + 0 + 0 + 0 + 1 ชุดที่สั่ง

    (เราสามารถทำสิ่งนี้ต่อไปได้ แต่ในขั้นตอนที่ 49 เท่านั้นที่ทำให้เราได้เปรียบ)

ความน่าจะเป็นที่จะเลือกตัวเลข

  • ที่ 5 flips คือ1432=716
  • ที่ 6 flips คือ9161436=732
  • ที่ 7 flips คือ11324244=231704
  • ไม่ได้อยู่ใน 7 flips คือ1716732231704=227

สิ่งนี้ทำให้ค่าการคาดหวังสำหรับจำนวนการพลิกในครั้งเดียวโดยมีเงื่อนไขว่ามีความสำเร็จและ p = 0.5:

5716+6732+7231704=5.796875

ค่าความคาดหวังสำหรับรวมจำนวนพลิก (จนกว่าจะมีความสำเร็จ) ตามเงื่อนไขที่ p = 0.5, กลายเป็น:

(5716+6732+7231704)27272=539=5.88889


คำตอบโดย NcAdams ใช้รูปแบบของกลยุทธ์การหยุดกฎนี้ (แต่ละครั้งมาพร้อมกับการโยนเหรียญสองครั้งใหม่) แต่ไม่ได้เลือกการโยนทั้งหมดอย่างเหมาะสม

คำตอบโดย Clid อาจคล้ายกันแม้ว่าอาจจะมีกฎการเลือกที่ไม่สม่ำเสมอที่เหรียญสองเหรียญจะพลิกจำนวนหนึ่งอาจเลือกได้ แต่ไม่จำเป็นต้องมีโอกาสเท่ากัน (ความคลาดเคลื่อนซึ่งกำลังได้รับการซ่อมแซมในระหว่างการโยนเหรียญในภายหลัง)


เปรียบเทียบกับวิธีอื่น ๆ

วิธีการอื่นที่ใช้หลักการที่คล้ายกันก็คือวิธีหนึ่งโดย NcAdams และ AdamO

หลักการคือ : การตัดสินใจสำหรับจำนวนระหว่าง 1 และ 7 จะทำหลังจากจำนวนหัวและก้อย หลังจากการพลิกจำนวนสำหรับการตัดสินใจแต่ละครั้งที่นำไปสู่หมายเลขการตัดสินใจที่คล้ายกันน่าจะเท่าเทียมกันนำไปสู่หมายเลข (จำนวนหัวและก้อยเท่ากัน แต่เรียงตามลำดับที่แตกต่างกัน) หัวและก้อยบางชุดสามารถนำไปสู่การตัดสินใจเริ่มต้นใหม่xij

สำหรับวิธีการดังกล่าวประเภทที่วางไว้ที่นี่มีประสิทธิภาพมากที่สุดเพราะทำให้การตัดสินใจเร็วที่สุดเท่าที่จะทำได้ (ทันทีที่มีความเป็นไปได้สำหรับลำดับความน่าจะเป็นที่เท่าเทียมกัน 7 อันของหัวและก้อยหลังจากการพลิก -th เราสามารถใช้ พวกเขาเพื่อทำการตัดสินใจเกี่ยวกับตัวเลขและเราไม่จำเป็นต้องพลิกกลับไปอีกถ้าเราเจอหนึ่งในกรณีเหล่านั้น)x

นี่คือภาพและการจำลองด้านล่างนี้:

การเปรียบเทียบ

#### mathematical part #####
set.seed(1)


#plotting this method
p <- seq(0.001,0.999,0.001)
tot <- (5*7*(p^2*(1-p)^3+p^3*(1-p)^2)+
       6*7*(p^2*(1-p)^4+p^4*(1-p)^2)+
       7*7*(p^1*(1-p)^6+p^2*(1-p)^5+p^3*(1-p)^4+p^4*(1-p)^3+p^5*(1-p)^2+p^6*(1-p)^1)+
        7*1*(0+p^7+(1-p)^7) )/
             (1-p^7-(1-p)^7)
plot(p,tot,type="l",log="y",
     xlab="p",
     ylab="expactation value number of flips"
     )

#plotting method by AdamO
tot <- (7*(p^20-20*p^19+189*p^18-1121*p^17+4674*p^16-14536*p^15+34900*p^14-66014*p^13+99426*p^12-119573*p^11+114257*p^10-85514*p^9+48750*p^8-20100*p^7+5400*p^6-720*p^5)+6*
          (-7*p^21+140*p^20-1323*p^19+7847*p^18-32718*p^17+101752*p^16-244307*p^15+462196*p^14-696612*p^13+839468*p^12-806260*p^11+610617*p^10-357343*p^9+156100*p^8-47950*p^7+9240*p^6-840*p^5)+5*
          (21*p^22-420*p^21+3969*p^20-23541*p^19+98154*p^18-305277*p^17+733257*p^16-1389066*p^15+2100987*p^14-2552529*p^13+2493624*p^12-1952475*p^11+1215900*p^10-594216*p^9+222600*p^8-61068*p^7+11088*p^6-1008*p^5)+4*(-
          35*p^23+700*p^22-6615*p^21+39235*p^20-163625*p^19+509425*p^18-1227345*p^17+2341955*p^16-3595725*p^15+4493195*p^14-4609675*p^13+3907820*p^12-2745610*p^11+1592640*p^10-750855*p^9+278250*p^8-76335*p^7+13860*p^6-
          1260*p^5)+3*(35*p^24-700*p^23+6615*p^22-39270*p^21+164325*p^20-515935*p^19+1264725*p^18-2490320*p^17+4027555*p^16-5447470*p^15+6245645*p^14-6113275*p^13+5102720*p^12-3597370*p^11+2105880*p^10-999180*p^9+371000
           *p^8-101780*p^7+18480*p^6-1680*p^5)+2*(-21*p^25+420*p^24-3990*p^23+24024*p^22-103362*p^21+340221*p^20-896679*p^19+1954827*p^18-3604755*p^17+5695179*p^16-7742301*p^15+9038379*p^14-9009357*p^13+7608720*p^12-
           5390385*p^11+3158820*p^10-1498770*p^9+556500*p^8-152670*p^7+27720*p^6-2520*p^5))/(7*p^27-147*p^26+1505*p^25-10073*p^24+49777*p^23-193781*p^22+616532*p^21-1636082*p^20+3660762*p^19-6946380*p^18+11213888*p^17-
           15426950*p^16+18087244*p^15-18037012*p^14+15224160*p^13-10781610*p^12+6317640*p^11-2997540*p^10+1113000*p^9-305340*p^8+55440*p^7-5040*p^6)
lines(p,tot,col=2,lty=2)

#plotting method by NcAdam
lines(p,3*8/7/(p*(1-p)),col=3,lty=2)

legend(0.2,500,
       c("this method calculation","AdamO","NcAdams","this method simulation"),
       lty=c(1,2,2,0),pch=c(NA,NA,NA,1),col=c(1,2,3,1))


##### simulation part ######

#creating decision table
mat<-matrix(as.numeric(intToBits(c(0:(2^5-1)))),2^5,byrow=1)[,c(1:12)]
colnames(mat) <- c("b1","b2","b3","b4","b5","b6","b7","sum5","sum6","sum7","decision","exit")

# first 5 rolls
mat[,8] <- sapply(c(1:2^5), FUN = function(x) {sum(mat[x,1:5])})

mat[which((mat[,8]==2)&(mat[,11]==0))[1:7],12] = rep(5,7) # we can stop for 7 cases with 2 heads
mat[which((mat[,8]==2)&(mat[,11]==0))[1:7],11] = c(1:7)   
mat[which((mat[,8]==3)&(mat[,11]==0))[1:7],12] = rep(5,7) # we can stop for 7 cases with 3 heads
mat[which((mat[,8]==3)&(mat[,11]==0))[1:7],11] = c(1:7)    

# extra 6th roll
mat <- rbind(mat,mat)
mat[c(33:64),6] <- rep(1,32)
mat[,9] <- sapply(c(1:2^6), FUN = function(x) {sum(mat[x,1:6])})

mat[which((mat[,9]==2)&(mat[,11]==0))[1:7],12] = rep(6,7) # we can stop for 7 cases with 2 heads
mat[which((mat[,9]==2)&(mat[,11]==0))[1:7],11] = c(1:7)   
mat[which((mat[,9]==4)&(mat[,11]==0))[1:7],12] = rep(6,7) # we can stop for 7 cases with 4 heads
mat[which((mat[,9]==4)&(mat[,11]==0))[1:7],11] = c(1:7)    

# extra 7th roll
mat <- rbind(mat,mat)
mat[c(65:128),7] <- rep(1,64)
mat[,10] <- sapply(c(1:2^7), FUN = function(x) {sum(mat[x,1:7])})

for (i in 1:6) {
  mat[which((mat[,10]==i)&(mat[,11]==0))[1:7],12] = rep(7,7) # we can stop for 7 cases with i heads
  mat[which((mat[,10]==i)&(mat[,11]==0))[1:7],11] = c(1:7)   
}


mat[1,12] = 7           # when we did not have succes we still need to count the 7 coin tosses
mat[2^7,12] = 7


draws = rep(0,100)
num = rep(0,100)
# plotting simulation
for (p in seq(0.05,0.95,0.05)) {
  n <- rep(0,1000)
  for (i in 1:1000) {
    coinflips <- rbinom(7,1,p)  # draw seven numbers
    I <- mat[,1:7]-matrix(rep(coinflips,2^7),2^7,byrow=1) == rep(0,7)                      # compare with the table
    Imatch = I[,1]*I[,2]*I[,3]*I[,4]*I[,5]*I[,6]*I[,7]        # compare with the table 
      draws[i] <- mat[which(Imatch==1),11]                 # result which number
      num[i]   <- mat[which(Imatch==1),12]                 # result how long it took
  }
  Nturn <- mean(num)                   #how many flips we made
  Sturn <- (1000-sum(draws==0))/1000   #how many numbers we got (relatively)
  points(p,Nturn/Sturn)
}

รูปภาพอื่นที่ถูกปรับอัตราส่วนโดยเพื่อการเปรียบเทียบที่ดีกว่า:p(1p)

การเปรียบเทียบกับค่าคาดหวังที่ปรับสัดส่วน

ขยายวิธีเปรียบเทียบที่อธิบายไว้ในโพสต์และความคิดเห็นนี้

วิธีการเปรียบเทียบที่อธิบายไว้ที่นี่

'การข้ามเงื่อนไขของขั้นตอนที่ 7' เป็นการปรับปรุงเล็กน้อยซึ่งสามารถทำได้ในกฎการหยุดก่อน ในกรณีนี้คุณไม่ได้เลือกกลุ่มที่มีความน่าจะเป็นเท่ากับหลังจากการพลิกครั้งที่ 6 คุณมี 6 กลุ่มที่มีความน่าจะเป็นที่เท่ากันและ 1 กลุ่มที่มีโอกาสแตกต่างกันเล็กน้อย (สำหรับกลุ่มสุดท้ายนี้คุณต้องพลิกอีกหนึ่งช่วงเวลาพิเศษเมื่อคุณมี 6 หัวหรือก้อยและเนื่องจากคุณทิ้ง 7 หัวหรือ 7 ก้อยคุณจะจบ ขึ้นกับความน่าจะเป็นที่เหมือนกันหลังจากทั้งหมด)


เขียนโดยStackExchangeStrike


ฉันเพิ่งจะเริ่มทำการคำนวณสำหรับคดี n = 7 เพราะฉันรู้สึกว่ามันอาจจะดีกว่า n = 1 มี upvote ของฉันครับ!
M.Herzkamp

@ M.Herzkamp ยังคงมีการปรับปรุงเล็กน้อย หมายเลขหนึ่ง (การพลิกหนึ่งเหรียญ) ไม่จำเป็นสำหรับการคำนวณเนื่องจากมีค่าสัมประสิทธิ์ 0 หมายเลขนี้จำเป็นสำหรับการพิจารณากรณีของหัวทั้งหมดหรือก้อยทั้งหมดและสามารถละเว้นได้เมื่อเรารู้แล้วว่าเรา มีกรณีผสม XCkX
Sextus Empiricus

ดังนั้นการปรับปรุงทำให้เหรียญพลิกได้มากกว่า 6 เหรียญตามมูลค่าที่คาดไว้สำหรับจำนวนการโยนเหรียญที่ต้องการ มันจะแตกต่างกันแม้ว่าจะพิสูจน์ว่านี่เป็นทางออกที่ดีที่สุด รูปแบบที่สร้างโดย Clid เบี่ยงเบนไปเล็กน้อยอนุญาตให้เลือกตัวเลขที่จำนวนเหรียญที่โยนได้แต่ไม่น่าจะเท่ากัน (อย่างน้อยไม่ใช่สำหรับขั้นตอนนั้นจะได้รับการแก้ไขในภายหลัง)
Sextus Empiricus

แต่ถ้าคุณตัดสินใจว่าจะพลิกเหรียญที่หกตามผลลัพธ์ห้าอันดับแรกความน่าจะเป็นของแต่ละเซ็ตหรือไม่คุณจะได้รับการโยนถึงหกครั้งเหมือนกับชุดอื่น ๆ หรือไม่
สะสม

@ การคำนวณคุณสามารถวาดมันเป็นต้นไม้ไบนารีที่มี 7 ระดับ เราจะเลือกระหว่างโหนดถ้ามี 7 ที่มีความน่าจะเป็นเท่ากัน มันเหมือนกับคุณตัดกิ่งไม้บางต้นก่อนหน้านี้ (ที่ระดับ 5 หรือ 6) หากคุณต้องการคุณสามารถดำเนินการต่อไปจนถึง 7 ขั้นตอนแทนที่จะทำก่อนหน้านี้ แต่สำหรับกรณีเหล่านี้การพลิกเหรียญครั้งที่ 6 และ 7 จะไม่สร้างความแตกต่าง
Sextus Empiricus

20

แบ่งกล่องออกเป็นเจ็ดส่วนที่เท่ากันพื้นที่แต่ละส่วนมีป้ายกำกับเป็นจำนวนเต็ม โยนเหรียญลงในกล่องในลักษณะที่มีความน่าจะเป็นเท่ากับการลงจอดในแต่ละภูมิภาค

π

p=1p=0


2
คุณสามารถแนะนำวิธีแบ่งกล่องออกเป็นเจ็ดส่วนที่เท่ากันเพื่อลดอคติจากการพลิกกระเด้งออกมาจากกำแพง ฯลฯ ได้หรือไม่? เจ็ดมุมของมุม 360/7
smci

1
@smci นั่นเป็นเหตุผลที่ฉันกำหนดว่าคุณต้องโยนเหรียญเพื่อให้มีความน่าจะเป็นเหมือนกันในการลงจอดในแต่ละช่อง หากกระเด้งออกมาจากกำแพงมีอิทธิพลต่อความน่าจะเป็นนั้นคุณจะต้องคำนึงถึงมันในการโยนของคุณ
Reinstate Monica

17
ใช่ฉันรู้ว่าและฉันกำลังชี้ให้คุณว่าเพียงแค่พูดว่า"โยนมันในทางที่เป็นกลาง"โดยไม่ต้องกำหนดวิธีการที่จะบรรลุว่ามันไม่ได้เป็นคำตอบที่แท้จริง ... ในกรณีที่พลิก -H / T วิธีการที่ใช้จะดีกว่า
smci

1
"พื้นที่ที่เท่าเทียมกับการโยนที่มีโอกาสลงจอดเท่ากันในแต่ละภูมิภาค" อาจเป็นเรื่องยากที่จะสร้างขึ้นในทางปฏิบัติ ในทางปฏิบัติมันอาจจะง่ายกว่าที่จะทำเครื่องหมาย "ฝึกซ้อมวิ่ง" จำนวนมากแล้วแบ่งพื้นที่ลงจอดในพื้นที่ที่สวมใส่ได้อย่างประจักษ์ (เช่นเมื่อมีการขว้าง 700 ครั้งออกกฎให้เป็นเส้นที่ตัดการขว้างที่สุด 100 ครั้งจากนั้น 100 และอื่น ๆ ) ความเรียบง่ายของสิ่งนี้เพื่อสร้างบิตสุ่มเพียงครั้งเดียวคือการโยนเหรียญสองครั้ง - ถ้าการโยนครั้งแรกดำเนินต่อไปบิตนั้นคือ0และถ้าการโยนครั้งที่สองดำเนินต่อไปมันจะเป็น1
Silverfish

4
มีคำตอบที่ดีจาก @TheScienceBoy ที่น่าเศร้าที่ถูกลบไปด้วยทางเลือกที่น่าสนใจในเรื่องนี้ - ได้อย่างมีประสิทธิภาพโดยใช้เหรียญเป็นเครื่องปั่นด้ายและทำเครื่องหมาย 7 ส่วนตามเส้นรอบวงของมัน - ซึ่งรักษาวิญญาณส่วนใหญ่ของคำตอบนี้ ดำเนินต่อไป!
Silverfish

8

แก้ไข: ขึ้นอยู่กับความคิดเห็นของผู้อื่น

นี่คือความคิดที่น่าสนใจ:

กำหนดรายการ {1,2,3,4,5,6,7} โยนเหรียญสำหรับแต่ละองค์ประกอบในรายการตามลำดับ ถ้ามันหัวขึ้นสำหรับองค์ประกอบเฉพาะเอาหมายเลขจากรายการ ถ้าตัวเลขทั้งหมดจากการวนซ้ำของรายการถูกลบออกให้ทำซ้ำการสุ่มตัวอย่าง ทำจนกว่าจะเหลือเพียงหนึ่งหมายเลข

drop.one <- function(x, p) {
  drop <- runif(length(x)) < p
  if (all(drop))
    return(x)
  return(x[!drop])
}

sample.recur <- function(x, p) {
  if (length(x) > 1)
    return(sample.recur(drop.one(x, p), p))
  return(x)
}

# x <- c(1:7,7:1)
x <- 1:7
p <- 0.01

out <- replicate(1e5, sample.recur(x, p))

round(prop.table(table(out)), 2)

ให้การกระจายที่สม่ำเสมอโดยประมาณ

> round(prop.table(table(out)), 2)
out
   1    2    3    4    5    6    7 
0.14 0.14 0.15 0.14 0.14 0.14 0.14 

N


การประเมินมูลค่าความคาดหวังสำหรับจำนวนการโยนเหรียญ

xy

M=[q700000117p1q6q600000021p2q56p1q5q50000035p3q415p2q45q4q4000035p4q320p3q310p2q34p1q3q300021p5q215p4q210p3q26p2q23p1q2q2007p6q16p5q15p4q14p3q13p2q12p1q100p7p6p5p4p3p200]

(MI)v=0

E(n)=247p(1p)

การเปรียบเทียบค่าความคาดหวังของการโยนเหรียญ

p>2/3

พบวิธีแก้ปัญหาด้วย wxMaxima

M: matrix(
 [(1-p)^7,        0,          0,0,0,0,1,1], 
 [7* p*(1-p)^6,   (1-p)^6,        0,0,0,0,0,0], 
 [21*p^2*(1-p)^5, 6*p*(1-p)^5,    (1-p)^5,0,0,0,0,0], 
 [35*p^3*(1-p)^4, 15*p^2*(1-p)^4, 5*p*(1-p)^4,(1-p)^4,0,0,0,0], 
 [35*p^4*(1-p)^3, 20*p^3*(1-p)^3, 10*p^2*(1-p)^3,4*p*(1-p)^3,(1-p)^3,0,0,0], 
 [21*p^5*(1-p)^2, 15*p^4*(1-p)^2, 10*p^3*(1-p)^2,6*p^2*(1-p)^2,3*p*(1-p)^2,(1-p)^2,0,0], 
 [7* p^6*(1-p)^1, 6*p^5*(1-p),    5*p^4*(1-p),4*p^3*(1-p),3*p^2*(1-p),2*(1-p)*p,0,0], 
 [p^7,        p^6,        p^5,p^4,p^3,p^2,0,0]
);
z: nullspace(M-diagmatrix(8,1));
x : apply (addcol, args (z));
t : [7,6,5,4,3,2,0,0];
plot2d(t.x/x[7],[p,0,1],logy);

การคำนวณใน R

# plotting empty canvas
plot(-100,-100,
     xlab="p",
     ylab="E(total flips)",
     ylim=c(10,1000),xlim=c(0,1),log="y")

# plotting simulation
for (p in seq(0.1,0.9,0.05)) {

  n <- rep(0,10000)
  for (i in 1:10000) {
    success  = 0
    tests = c(1,1,1,1,1,1,1)     # start with seven numbers in the set
    count = 0
    while(success==0) {
      for (j in 1:7)  {
        if (tests[j]==1) {
          count = count + 1
          if  (rbinom(1,1,p) == 1) {
            tests[j] <- 0        # elliminate number when we draw heads
          }
        }
      }
      if (sum(tests)==1) {
        n[i] = count
        success = 1              # end     when 1 is left over
      }
      if (sum(tests)==0) {
        tests = c(1,1,1,1,1,1,1) # restart when 0 are left over
      }
    }
  }
  points(p,mean(n))
}

# plotting formula
p <- seq(0.001,0.999,0.001)

tot <- (7*(p^20-20*p^19+189*p^18-1121*p^17+4674*p^16-14536*p^15+34900*p^14-66014*p^13+99426*p^12-119573*p^11+114257*p^10-85514*p^9+48750*p^8-20100*p^7+5400*p^6-720*p^5)+6*
    (-7*p^21+140*p^20-1323*p^19+7847*p^18-32718*p^17+101752*p^16-244307*p^15+462196*p^14-696612*p^13+839468*p^12-806260*p^11+610617*p^10-357343*p^9+156100*p^8-47950*p^7+9240*p^6-840*p^5)+5*
    (21*p^22-420*p^21+3969*p^20-23541*p^19+98154*p^18-305277*p^17+733257*p^16-1389066*p^15+2100987*p^14-2552529*p^13+2493624*p^12-1952475*p^11+1215900*p^10-594216*p^9+222600*p^8-61068*p^7+11088*p^6-1008*p^5)+4*(-
    35*p^23+700*p^22-6615*p^21+39235*p^20-163625*p^19+509425*p^18-1227345*p^17+2341955*p^16-3595725*p^15+4493195*p^14-4609675*p^13+3907820*p^12-2745610*p^11+1592640*p^10-750855*p^9+278250*p^8-76335*p^7+13860*p^6-
    1260*p^5)+3*(35*p^24-700*p^23+6615*p^22-39270*p^21+164325*p^20-515935*p^19+1264725*p^18-2490320*p^17+4027555*p^16-5447470*p^15+6245645*p^14-6113275*p^13+5102720*p^12-3597370*p^11+2105880*p^10-999180*p^9+371000
   *p^8-101780*p^7+18480*p^6-1680*p^5)+2*(-21*p^25+420*p^24-3990*p^23+24024*p^22-103362*p^21+340221*p^20-896679*p^19+1954827*p^18-3604755*p^17+5695179*p^16-7742301*p^15+9038379*p^14-9009357*p^13+7608720*p^12-
 5390385*p^11+3158820*p^10-1498770*p^9+556500*p^8-152670*p^7+27720*p^6-2520*p^5))/(7*p^27-147*p^26+1505*p^25-10073*p^24+49777*p^23-193781*p^22+616532*p^21-1636082*p^20+3660762*p^19-6946380*p^18+11213888*p^17-
  15426950*p^16+18087244*p^15-18037012*p^14+15224160*p^13-10781610*p^12+6317640*p^11-2997540*p^10+1113000*p^9-305340*p^8+55440*p^7-5040*p^6)
lines(p,tot)

#plotting comparison with alternative method
lines(p,3*8/7/(p*(1-p)),lty=2)

legend(0.2,500,
       c("simulation","calculation","comparison"),
       lty=c(0,1,2),pch=c(1,NA,NA))

1
แนวคิดที่ดี (+1) โดยสังหรณ์ใจมันควรจะทำงานได้เนื่องจากความสมมาตรจะทำให้อคติต่อจำนวนใด ๆ เป็นโมฆะ ถึงกระนั้นฉันก็ชอบที่จะเห็นหลักฐาน
Reinstate Monica

6
ความคิดนี้เป็นสิ่งที่ดีจริงๆ แต่มีความเป็นไปได้สูงที่จะเกิดขึ้น (คิดเลขนั้น) ฉันคิดว่าตัวเลขสุดท้ายในแถวมีโอกาสที่ดีที่สุดที่จะ "เอาตัวรอด" เนื่องจากคนอื่น ๆ อาจจะมีการเปลี่ยนแปลงโดยไม่โยนเหรียญตามลำดับ แต่ขนานกับตัวเลขทั้งหมดใน x Runtime ของสคริปต์อาจเพิ่มฉันเดา :)
TinglTanglBob

2
ฉันเห็นด้วยกับ @TinglTanglBob - เมื่อฉันตั้งค่าp <- 0.99ฉันจะได้รับผลลัพธ์0.89 0.02 0.02 0.02 0.02 0.02 0.02
Silverfish

6
จะไม่ทำการกำจัดใน 'รอบ' แก้ไขปัญหาอคติหรือไม่ เริ่มด้วยตัวเลข 7 ตัว โยนเหรียญตามจำนวนที่เหลืออยู่และกำจัดเหรียญที่โยนหัว หากตัวเลขที่เหลือทั้งหมดถูกตัดออกในรอบให้ปัดผลลัพธ์ของรอบนั้นแล้วลองอีกครั้ง ฉันไม่รู้วิธีที่จะพิสูจน์มัน แต่ลำดับของจำนวนที่ไม่สำคัญอีกต่อไปไม่ว่าพวกเขาจะเป็น 'ผู้ชนะ'
Phil

1
p=0.01

5

คำถามนี้ค่อนข้างคลุมเครือหรือเปล่ามันถามว่า "สร้างจำนวนเต็มสุ่มเท่ากับหรือน้อยกว่า 7 ด้วยความน่าจะเป็นที่เท่ากัน" หรือมันจะถามว่า - แต่เนื้อที่ของจำนวนเต็มคืออะไร!?

ฉันจะถือว่ามันเป็นอดีต แต่ตรรกะเดียวกันกับที่ฉันใช้สามารถขยายไปถึงกรณีหลังได้เช่นกันเมื่อปัญหานั้นหมดไป

ด้วยเหรียญที่มีอคติคุณสามารถผลิตเหรียญที่ยุติธรรมได้โดยทำตามขั้นตอนต่อไปนี้: https://en.wikipedia.org/wiki/Fair_coin#Fair_results_from_a_biased_coin

ตัวเลข 7 หรือน้อยกว่าสามารถเขียนเป็นเลขฐานสองเป็นตัวเลข {0,1} หลัก ดังนั้นสิ่งหนึ่งที่ต้องทำคือทำตามขั้นตอนข้างต้นสามครั้งและแปลงเลขฐานสองที่ผลิตกลับเป็นทศนิยม


1
การเปรียบเทียบคำตอบของฉันกับ @NcAdams เป็นที่ชัดเจนว่าฉันรวม 0 เป็นผลลัพธ์ที่ต้องการ!
Cam.Davidson.Pilon

ฉันไม่เข้าใจว่าคำตอบของคุณแตกต่างกันอย่างไร หากคุณรวม {0,0,0} -> 1 แล้ว {1,1,1} แผนที่จะทำอะไร มีความเป็นไปได้ 8 อย่าง
AdamO

1
000 แผนที่เป็น 0 ดังนั้นความคิดเห็นของฉันเกี่ยวกับการรวม 0 เป็นค่าที่เป็นไปได้ สิ่งนี้ถูกโพสต์ก่อนการแก้ไข OP และพร้อมกันเกือบเป็น NcAdams
Cam.Davidson.Pilon

ครึ่งหนึ่งของคำตอบนี้เป็นความคิดเห็นและเนื้อหาจริงของคำตอบนั้นเป็นลิงค์เท่านั้น โปรดสะกดคำตอบที่แท้จริงของคุณแทนที่จะเชื่อมโยงกับมัน
Cubic

3

วิธีการแก้ปัญหาที่ไม่เคยทิ้งความล้มเหลวซึ่งช่วยได้มากสำหรับเหรียญที่มีลำเอียงมาก

ข้อเสียของอัลกอริทึมนี้ (อย่างน้อยก็เขียน) ก็คือว่ามันใช้เลขคณิตความแม่นยำโดยพลการ ในทางปฏิบัติคุณอาจต้องการใช้สิ่งนี้จนกระทั่งมีจำนวนเต็มล้นจากนั้นจึงโยนทิ้งและเริ่มต้นใหม่

นอกจากนี้คุณต้องรู้ว่าอคติคืออะไร ... ซึ่งคุณอาจจะไม่พูดถ้ามันขึ้นอยู่กับอุณหภูมิเหมือนปรากฏการณ์ทางกายภาพส่วนใหญ่


สมมติว่าโอกาสของหัวคือพูด 30%

  • [1, 8)เริ่มต้นด้วยช่วง
  • พลิกเหรียญของคุณ ถ้าหัวใช้ซ้าย 30% [1, 3.1)ดังนั้นช่วงใหม่ของคุณ อื่นใช้สิทธิ 70% [3.1, 8)ดังนั้นช่วงใหม่ของคุณ
  • ทำซ้ำจนกระทั่งช่วงทั้งหมดมีส่วนจำนวนเต็มเหมือนกัน

รหัสเต็ม:

#!/usr/bin/env python3
from fractions import Fraction
from collections import Counter
from random import randrange


BIAS = Fraction(3, 10)
STAT_COUNT = 100000


calls = 0
def biased_rand():
    global calls
    calls += 1
    return randrange(BIAS.denominator) < BIAS.numerator


def can_generate_multiple(start, stop):
    if stop.denominator == 1:
        # half-open range
        stop = stop.numerator - 1
    else:
        stop = int(stop)
    start = int(start)
    return start != stop


def unbiased_rand(start, stop):
    if start < 0:
        # negative numbers round wrong
        return start + unbiased_rand(0, stop - start)
    assert isinstance(start, int) and start >= 0
    assert isinstance(stop, int) and stop >= start
    start = Fraction(start)
    stop = Fraction(stop)
    while can_generate_multiple(start, stop):
        if biased_rand():
            old_diff = stop - start
            diff = old_diff * BIAS
            stop = start + diff
        else:
            old_diff = stop - start
            diff = old_diff * (1 - BIAS)
            start = stop - diff
    return int(start)


def stats(f, *args, **kwargs):
    c = Counter()
    for _ in range(STAT_COUNT):
        c[f(*args, **kwargs)] += 1

    print('stats for %s:' % f.__qualname__)
    for k, v in sorted(c.items()):
        percent = v * 100 / STAT_COUNT
        print('  %s: %f%%' % (k, percent))


def main():
    #stats(biased_rand)
    stats(unbiased_rand, 1, 7+1)
    print('used %f calls at bias %s' % (calls/STAT_COUNT, BIAS))


if __name__ == '__main__':
    main()

3
[0,1]00006666k

นั่นเหมือนกันสำหรับเอาต์พุตเดี่ยวใช่ไหม ดีขึ้นสำหรับหลาย ๆ ฉันจะเขียนมันตามที่diff *= 7ฉันคิดว่า ... อันที่จริงแล้วไม่จำเป็นต้องใช้ฐานเดียวกันในแต่ละครั้ง
o11c

ใช่มันเหมือนกันถ้าคุณต้องการเอาท์พุทเดียว; มันจะปรับปรุงประสิทธิภาพถ้าคุณต้องการหลาย ๆ
Federico Poloni

pp

การทำเช่นนี้เป็นการสิ้นเปลืองหากคุณต้องการเอาต์พุตเดี่ยว สำหรับเหรียญที่ยุติธรรมเทคนิคมาตรฐาน (ม้วนเหรียญสามครั้งและทำซ้ำถ้าคุณได้รับ TTT) ให้จำนวนที่คาดหวังของ 24/7 = 3 + 3/7 ม้วน หากคุณใช้เทคนิคการคำนวณทางคณิตศาสตร์นี้คุณจะหมุนอย่างน้อยสี่ครั้งเว้นแต่ว่าคุณจะได้รับ HHH หรือ TTT ซึ่งจะให้จำนวนที่คาดหวังมากกว่า 15/4 = 3 + 3/4 ม้วน
Peter Shor

3

ดังที่ได้กล่าวไว้ในความคิดเห็นก่อนหน้านี้ปริศนานี้เกี่ยวข้องกับกระดาษของ John von Neumann ในปี 1951 “ เทคนิคต่าง ๆ ที่ใช้ในการเชื่อมต่อกับ Random Digits” ที่ตีพิมพ์ในวารสารวิจัยของสำนักงานมาตรฐานแห่งชาติ:

ป้อนคำอธิบายรูปภาพที่นี่

pf(p)f f(p)=min{1,2p}N ของการทดลอง


2

p1p0

อันดับแรกเราจะเปลี่ยนเหรียญที่ไม่เป็นธรรมออกเป็นเหรียญที่ยุติธรรมโดยใช้กระบวนการจากNcAdams ตอบ :

พลิกเหรียญสองครั้ง ถ้ามันตกลงมาHHหรือTTไม่ก็สนใจมันแล้วพลิกมันสองครั้งอีกครั้ง

ตอนนี้เหรียญมีความน่าจะเป็นที่จะเกิดขึ้นHTหรือTHเท่ากัน ถ้ามันขึ้นมาโทรนี้HT H1ถ้ามันขึ้นมาโทรนี้THT1

01H1=1T1 =00.H1 H1 T10.110

1/7

1/7=0.001001001...

2/7=0.010010010...

3/7=0.011011011...

4/7=0.100100100...

5/7=0.101101101...

6/7=0.110110110...

nn/7(n1)/717


1
1/7

1
1/7k=1(1/8)k=17

1
nT(n)=2n62nn3
3+n=31T(n)=4.5
8733.42

2

ได้รับแรงบันดาลใจจากคำตอบของ AdamO นี่คือโซลูชัน Python ที่หลีกเลี่ยงอคติ:

def roll(p, n):
    remaining = range(1,n+1)
    flips = 0
    while len(remaining) > 1:
        round_winners = [c for c in remaining if random.choices(['H','T'], [p, 1.0-p]) == ['H']]
        flips += len(remaining)
        if len(round_winners) > 0:
            remaining = round_winners
        p = 1.0 - p
    return remaining[0], flips

มีการเปลี่ยนแปลงหลักสองประการที่นี่: การเปลี่ยนแปลงหลักคือหากจำนวนทั้งหมดถูกยกเลิกในรอบให้ทำซ้ำรอบ นอกจากนี้ฉันพลิกตัวเลือกว่าหัวหรือก้อยหมายถึงทิ้งทุกครั้ง สิ่งนี้จะช่วยลดจำนวนการพลิกที่จำเป็นในกรณีที่ p ใกล้เคียงกับ 0 หรือ 1 โดย ~ 70% เมื่อ p = 0.999


2
"ฉันพลิกตัวเลือกว่าหัวหรือก้อยหมายถึงทิ้งทุกครั้งหรือไม่ซึ่งช่วยลดจำนวนการพลิกที่จำเป็นในกรณีที่ p อยู่ใกล้กับ 0 หรือ 1 โดย ~ 70% เมื่อ p = 0.999" - การคิดอย่างชาญฉลาด!
Silverfish

1
การสลับหัวหรือก้อยเป็นการพัฒนาที่ดีกว่าการทิ้งหัว - เสมอ แต่บางทีมันจะดีกว่าถ้าหลังจากการโยนเหรียญสำหรับตัวเลือกที่เหลือแต่ละตัวหากพวกมันเหมือนกันเราจะทำการ reflipping พวกเขาซ้ำทั้งหมด มากที่สุดเท่าที่หัวก้อยเรากำจัดตัวเลือกที่เหลือที่สอดคล้องกับหัวมิฉะนั้นเราจะกำจัดตัวเลือกที่เหลือที่สอดคล้องกับก้อย
เดวิดแครี

2

มันจะปรากฏขึ้นที่เราได้รับอนุญาตให้เปลี่ยนการทำแผนที่ของผลของแต่ละพลิกทุกครั้งที่เราพลิก ดังนั้นเพื่อความสะดวกในจำนวนเต็มบวกเจ็ดตัวแรกเราจะให้คำสั่งต่อไปนี้:

H1
H2

H7
H1

ฯลฯ

T


APT

PAP(no integers generated)=(1p)7

Nb

CountAP(useless flips)7Nb(1p)7

B(p,n=5)p3(1p)2

PDS(no integers generated)=17p3(1p)2

การนับการโยนที่ไร้ประโยชน์จะเกิดขึ้นที่นี่

CountDS(useless flips)5Nb[17p3(1p)2]

AP

CountAP(useless flips)<CountDS(useless flips)

7Nb(1p)7<5Nb[17p3(1p)2]

7(1p)7<5[17p3(1p)2]

p>0.0467AP

pAPDSp0.5967

CountAP(useless flips)CountDS(useless flips)

0.67p=0.10.3p=0.20.127p=0.4


p(0,1)

1
@Sycorax ฉันเพิ่มบางสิ่งบางอย่างแม้ว่าฉันไม่แน่ใจว่ามันเป็นไปตามบรรทัดที่คุณแนะนำ
Alecos Papadopoulos

H

1
12345679999999

1
p17p
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.