Brain teaser: Bagaimana cara menghasilkan 7 bilangan bulat dengan probabilitas yang sama menggunakan koin bias yang memiliki pr (head) = p?

Ini adalah pertanyaan yang saya temukan di Glassdoor : Bagaimana cara menghasilkan 7 bilangan bulat dengan probabilitas yang sama menggunakan koin yang memiliki ?$\mathbb{Pr}(\text{Head}) = p\in(0,1)$

Pada dasarnya, Anda memiliki koin yang mungkin atau mungkin tidak adil, dan ini adalah satu-satunya proses penghasil angka acak yang Anda miliki, jadi buatlah generator bilangan acak yang menghasilkan bilangan bulat dari 1 hingga 7 di mana kemungkinan mendapatkan masing-masing bilangan bulat ini adalah 1/7.

Efisiensi data-menghasilkan hal-hal proses.

Balikkan koin dua kali. Jika itu mendarat HHatau TT, abaikan dan balikkan dua kali lagi.

Sekarang, koin memiliki probabilitas yang sama untuk muncul HTatau TH. Jika muncul HT, panggil ini H1. Jika muncul TH, panggil ini T1.

Terus dapatkan H1atau T1sampai Anda memiliki tiga berturut-turut. Tiga hasil ini memberi Anda angka berdasarkan tabel di bawah ini:

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]

Saya berpendapat bahwa ini akan bekerja dengan baik, meskipun Anda akan memiliki banyak lemparan yang sia-sia dalam prosesnya!

Asumsikan .$p \in (0,1)$

Langkah 1: . Lempar koin 5 kali.

Jika hasilnya

$(H, H, H, T, T)$ , kembali dan berhenti.$1$

$(H, H, T, T, H)$ , kembali dan berhenti.$2$

$(H, T, T, H, H)$ , kembali dan berhenti.$3$

$(T, T, H, H, H)$ , kembali dan berhenti.$4$

$(T, H, H, H, T)$ , kembali dan berhenti.$5$

$(H, H, T, H, T)$ , kembali dan berhenti.$6$

$(H, T, H, T, H)$ , kembali dan berhenti.$7$

Langkah 2: . Jika hasilnya tidak ada di atas, ulangi Langkah 1.

Perhatikan bahwa terlepas dari nilai , masing-masing dari tujuh hasil yang tercantum di atas memiliki probabilitas , dan jumlah lemparan koin yang diharapkan adalah . Server tidak perlu mengetahui nilai (kecuali bahwa dan ); dijamin bahwa tujuh bilangan bulat memiliki kemungkinan yang sama untuk dikembalikan oleh percobaan ketika berakhir (dan dijamin berakhir dengan probabilitas ).q = p 3 ( 1 - p ) 2 $p \in (0,1)$$q = p^3(1-p)^2$ pp≠0p≠1$\displaystyle \frac{5}{7q}$$p$$p\neq 0$$p\neq 1$$1$

Generalisasi kasus yang dijelaskan oleh Dilip Sarwate

Beberapa metode yang dijelaskan dalam jawaban lain menggunakan skema di mana Anda melempar urutan $n$ koin dalam 'belokan' dan tergantung pada hasil Anda memilih angka antara 1 atau 7 atau membuang belokan dan melempar lagi.

Kuncinya adalah menemukan dalam perluasan kemungkinan kelipatan 7 hasil dengan probabilitas yang sama $p^k(1-p)^{n-k}$ dan mencocokkannya dengan satu sama lain.

Karena jumlah total hasil bukan kelipatan 7, kami memiliki beberapa hasil yang tidak dapat kami tetapkan ke suatu angka, dan memiliki beberapa probabilitas bahwa kami perlu membuang hasil dan memulai lagi.

Kasus menggunakan 7 koin membalik per giliran

Secara intuitif kita bisa mengatakan bahwa melempar dadu tujuh kali akan sangat menarik. Karena kita hanya perlu membuang 2 dari $2^7$ kemungkinan. Yakni, 7 kali head dan 0 kali head.

Untuk semua kemungkinan selalu ada kelipatan 7 kasus dengan jumlah kepala yang sama. Yaitu 7 kasus dengan 1 kepala, 21 kasus dengan 2 kepala, 35 kasus dengan 3 kepala, 35 kasus dengan 4 kepala, 21 kasus dengan 5 kepala, dan 7 kasus dengan 6 kepala.$2^7-2$

Jadi jika Anda menghitung angka (membuang 0 kepala dan 7 kepala)

dengan variabel terdistribusi Bernoulli (nilai 0 atau 1), maka X modulo 7 adalah variabel seragam dengan tujuh kemungkinan hasil.$C_k$

Membandingkan jumlah flips koin yang berbeda per giliran

Pertanyaannya adalah berapa jumlah gulungan optimal per giliran. Menggulirkan lebih banyak dadu per gilirannya akan membuat Anda lebih mahal, tetapi Anda mengurangi kemungkinan harus berguling lagi.

Gambar di bawah ini menunjukkan perhitungan manual untuk beberapa angka pertama flips koin per giliran. (mungkin mungkin ada solusi analitis, tapi saya yakin aman untuk mengatakan bahwa sistem dengan 7 membalik koin memberikan metode terbaik mengenai nilai ekspektasi untuk jumlah membalik koin yang diperlukan)

# 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)
}

Menggunakan aturan penghentian awal

catatan: perhitungan di bawah ini, untuk nilai ekspektasi jumlah flips, adalah untuk koin yang adil , itu akan menjadi berantakan untuk melakukan hal ini untuk berbeda , tetapi prinsipnya tetap sama (meskipun pembukuan yang berbeda dari kasus diperlukan)$p=0.5$$p$

Kita harus bisa memilih kasing (bukan rumus untuk ) sehingga kita bisa berhenti lebih awal.$X$

• Dengan 5 koin membalik kita miliki untuk enam set kepala dan ekor yang tidak berurutan yang berbeda:

  1 + 5 + 10 + 10 + 5 + 1 set yang dipesan

  Dan kita dapat menggunakan kelompok dengan sepuluh kasus (yaitu kelompok dengan 2 kepala atau kelompok dengan 2 ekor) untuk memilih (dengan probabilitas yang sama) angka. Ini terjadi pada 14 dari 2 ^ 5 = 32 kasus. Ini membuat kita dengan:

  1 + 5 + 3 + 3 + 5 + 1 set yang dipesan

• Dengan flip koin ekstra (6-th) yang kami miliki untuk tujuh set kepala dan ekor unordered yang berbeda:

  1 + 6 + 8 + 6 + 8 + 6 + 1 set yang dipesan

  Dan kita dapat menggunakan kelompok dengan delapan kasus (yaitu kelompok dengan 3 kepala atau kelompok dengan 3 ekor) untuk memilih (dengan probabilitas yang sama) angka. Ini terjadi pada 14 dari 2 * (2 ^ 5-14) = 36 kasus. Ini membuat kita dengan:

  1 + 6 + 1 + 6 + 1 + 6 + 1 set yang dipesan

• Dengan flip koin ekstra lain (7-th) yang kami miliki untuk delapan set kepala dan ekor unordered yang berbeda:

  1 + 7 + 7 + 7 + 7 + 7 + 7 + 1 set yang dipesan

  Dan kita dapat menggunakan kelompok dengan tujuh kasus (semua kecuali semua ekor dan semua kasus kepala) untuk memilih (dengan probabilitas yang sama) angka. Ini terjadi pada 42 dari 44 kasus. Ini membuat kita dengan:

  1 + 0 + 0 + 0 + 0 + 0 + 0 + 1 set pesanan

  (kita bisa melanjutkan ini tetapi hanya pada langkah ke-49 hal ini memberi kita keuntungan)

Jadi probabilitas untuk memilih nomor

• pada 5 membalik adalah $\frac{14}{32} = \frac{7}{16}$
• pada 6 membalik adalah $\frac{9}{16}\frac{14}{36} = \frac{7}{32}$
• pada 7 membalik adalah $\frac{11}{32}\frac{42}{44} = \frac{231}{704}$
• tidak dalam 7 membalik adalah $1-\frac{7}{16}-\frac{7}{32}-\frac{231}{704} = \frac{2}{2^7}$

Ini membuat nilai ekspektasi untuk jumlah flips dalam satu giliran, dengan syarat bahwa ada keberhasilan dan p = 0,5:

Nilai ekspektasi untuk jumlah total flips (sampai ada keberhasilan), dengan syarat bahwa p = 0,5, menjadi:

Jawaban oleh NcAdams menggunakan variasi dari strategi stopping-rule ini (setiap kali menghasilkan dua flips koin baru) tetapi tidak secara optimal memilih semua flips.

Jawaban oleh Clid mungkin serupa juga walaupun mungkin ada aturan pemilihan yang tidak rata bahwa masing-masing dua koin membalik nomor mungkin dipilih tetapi tidak harus dengan probabilitas yang sama (perbedaan yang sedang diperbaiki selama membalik koin kemudian)

Perbandingan dengan metode lain

Metode lain yang menggunakan prinsip serupa adalah yang dilakukan oleh NcAdams dan AdamO.

Prinsipnya adalah : Keputusan untuk angka antara 1 dan 7 dibuat setelah sejumlah kepala dan ekor. Setelah jumlah $x$ membalik, untuk setiap keputusan yang mengarah ke nomor $i$ ada keputusan yang sama, kemungkinan sama, yang mengarah ke nomor $j$ (jumlah kepala dan ekor yang sama tetapi hanya dalam urutan yang berbeda). Beberapa seri kepala dan ekor dapat mengarah pada keputusan untuk memulai kembali.

Untuk jenis metode seperti itu, yang ditempatkan di sini adalah yang paling efisien karena membuat keputusan sedini mungkin (segera setelah ada kemungkinan untuk 7 urutan probabilitas kepala dan ekor yang sama, setelah flip ke- $x$ , kita dapat menggunakan mereka untuk membuat keputusan pada nomor dan kita tidak perlu membalik lebih jauh jika kita menemukan salah satu dari kasus-kasus itu).

Ini ditunjukkan oleh gambar dan simulasi di bawah ini:

#### 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)
}

gambar lain yang diskalakan dengan $p*(1-p)$ untuk perbandingan yang lebih baik:

perbesar metode perbandingan yang dijelaskan dalam pos dan komentar ini

'lompatan bersyarat dari langkah ke-7' adalah sedikit perbaikan yang dapat dilakukan pada aturan penghentian awal. Dalam hal ini Anda memilih bukan grup dengan probabilitas yang sama setelah membalik ke-6. Anda memiliki 6 grup dengan probabilitas yang sama, dan 1 grup dengan probabilitas yang sedikit berbeda (untuk grup terakhir ini Anda perlu membalik satu kali lagi ketika Anda memiliki 6 kepala atau ekor dan karena Anda membuang 7 kepala atau 7 ekor, Anda akan berakhir setelah itu dengan probabilitas yang sama)

Ditulis oleh StackExchangeStrike

Bagilah kotak menjadi tujuh wilayah dengan luas yang sama, masing-masing diberi label dengan bilangan bulat. Lempar koin ke dalam kotak sedemikian rupa sehingga memiliki kemungkinan pendaratan yang sama di setiap wilayah.

$\pi$

$p = 1$$p=0$

EDIT: berdasarkan umpan balik orang lain.

Inilah pemikiran yang menarik:

atur daftar {1,2,3,4,5,6,7}. Lempar koin untuk setiap elemen dalam daftar secara berurutan. Jika kepala mengarah ke atas untuk elemen tertentu, hapus nomor dari daftar. Jika semua angka dari iterasi tertentu dari daftar dihapus, ulangi pengambilan sampel. Lakukan sampai hanya satu nomor yang tersisa.

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)

memberi saya distribusi sekitar seragam

> 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$

Evaluasi nilai ekspektasi untuk jumlah lemparan koin

$x$$y$

$(M-I)v=0$

$E(n) = \frac{24}{7}p(1-p)$

$p>2/3$

Solusi ditemukan dengan 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);

Perhitungan dalam 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))

Pertanyaannya agak ambigu, apakah ia bertanya "menghasilkan bilangan bulat acak sama atau kurang dari 7 dengan probabilitas sama", atau apakah ia bertanya "menghasilkan 7 bilangan bulat acak dengan probabilitas sama?" - tapi apa ruang bilangan bulat?!?

Saya akan berasumsi itu yang pertama, tetapi logika yang sama yang saya terapkan dapat diperluas ke kasus yang terakhir juga, setelah masalah itu diselesaikan.

Dengan koin bias, Anda dapat menghasilkan koin yang adil dengan mengikuti prosedur berikut: https://en.wikipedia.org/wiki/Fair_coin#Fair_results_from_a_ gantung_coin

Angka 7 atau kurang dapat ditulis dalam biner sebagai tiga {0,1} digit. Jadi yang perlu dilakukan adalah mengikuti prosedur di atas tiga kali, dan mengonversi angka biner yang dihasilkan menjadi desimal.

Sebuah solusi yang tidak pernah membuang membalik, yang banyak membantu untuk koin yang sangat bias.

Kerugian dari algoritma ini (seperti yang ditulis, setidaknya) adalah bahwa ia menggunakan aritmatika presisi arbitrer. Secara praktis, Anda mungkin ingin menggunakan ini sampai integer overflow, dan hanya kemudian membuangnya dan memulai lagi.

Juga, Anda perlu tahu apa bias adalah ... yang Anda mungkin tidak, katakanlah, jika suhu tergantung seperti fenomena fisik yang paling.

Dengan asumsi peluang kepala, katakanlah, 30%.

• Mulai dengan kisaran [1, 8).
• Balikkan koin Anda. Jika menuju, gunakan 30% kiri, jadi rentang baru Anda [1, 3.1). Lain, gunakan 70% yang tepat, jadi rentang baru Anda [3.1, 8).
• Ulangi sampai seluruh rentang memiliki bagian integer yang sama.

Kode lengkap:

#!/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()

Seperti disebutkan dalam komentar sebelumnya, teka-teki ini berkaitan dengan makalah John von Neumann tahun 1951 "Berbagai Teknik yang Digunakan Sehubungan dengan Digit Acak" yang diterbitkan dalam jurnal penelitian National Bureau of Standards:

$p$$f(p)$$f$ $f(p)=\min\{1,2p\}$$N$ persidangan.

$p \neq 1$$p \neq 0$

Kami pertama-tama mengubah (mungkin) koin yang tidak adil menjadi koin yang adil menggunakan proses dari jawaban NcAdams :

Balikkan koin dua kali. Jika itu mendarat HHatau TT, abaikan dan balikkan dua kali lagi.

Sekarang, koin memiliki probabilitas yang sama untuk muncul HTatau TH. Jika muncul HT, panggil ini H1. Jika muncul TH, panggil ini T1.

$0$$1$H1$= 1$T1 $= 0$0.H1 H1 T1$0.110$

$1/7$

$1/7 = 0.001 001 001 ...$

$2/7 = 0.010 010 010 ...$

$3/7 = 0.011 011 011 ...$

$4/7 = 0.100 100 100 ...$

$5/7 = 0.101 101 101 ...$

$6/7 = 0.110 110 110 ...$

$n$$n/7$$(n-1)/7$$1$$7$

Terinspirasi oleh jawaban AdamO, berikut adalah solusi Python yang menghindari bias:

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

Ada dua perubahan utama di sini: Yang utama adalah jika semua nomor dibuang dalam satu putaran, ulangi putaran itu. Saya juga membalik pilihan apakah kepala atau ekor berarti membuang setiap waktu. Ini mengurangi jumlah flips yang dibutuhkan dalam kasus di mana p mendekati 0 atau 1 hingga ~ 70% ketika p = 0,999

Tampaknya kita diizinkan untuk mengubah pemetaan hasil setiap flip, setiap kali kita flip . Jadi, untuk kenyamanan tujuh bilangan bulat positif pertama, kami memberikan perintah berikut:

$H \to 1$
$H \to 2$

$H \to 7$
$H \to 1$

dll

$T$

$AP$$T$

$N_b$

$B(p,n=5)$$p^3(1-p)^2$

Hitungan flips yang tidak berguna di sini akan cenderung

$AP$

$p>0.0467$$AP$

$p$$AP$$DS$$p\approx 0.5967$

$0.67$$p=0.1$$0.3$$p=0.2$$0.127$$p=0.4$