Casse-tête: Comment générer 7 nombres entiers avec une probabilité égale en utilisant une pièce biaisée qui a un pr (tête) = p?

C’est une question que j’ai trouvée sur Glassdoor : comment générer 7 nombres entiers avec une probabilité égale en utilisant une pièce de monnaie qui a un ?$\mathbb{Pr}(\text{Head}) = p\in(0,1)$

Fondamentalement, vous avez une pièce qui peut ou peut ne pas être juste, et c'est votre seul processus de génération de nombre aléatoire que vous avez, alors créez un générateur de nombre aléatoire qui génère des nombres entiers de 1 à 7 où la probabilité d'obtenir chacun de ces nombres entiers est 1/7.

L'efficacité du processus de génération de données est importante.

Lancez la pièce deux fois. S'il atterrit HHou si TT, ignorez-le et retournez-le deux fois.

Maintenant, la pièce a une probabilité égale de monter HTou TH. Si cela se produit HT, appelez ceci H1. Si cela se produit TH, appelez ceci T1.

Continuez à obtenir H1ou T1jusqu'à ce que vous en ayez trois de suite. Ces trois résultats vous donnent un nombre basé sur le tableau ci-dessous:

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]

Je soutiens que cela fonctionnerait parfaitement bien, bien que vous auriez beaucoup de pertes inutiles dans le processus!

Supposons que .$p \in (0,1)$

Étape 1: . Lancer la pièce 5 fois.

Si le résultat est

$(H, H, H, T, T)$ , retournez et arrêtez.$1$

$(H, H, T, T, H)$ , retournez et arrêtez.$2$

$(H, T, T, H, H)$ , retournez et arrêtez.$3$

$(T, T, H, H, H)$ , retournez et arrêtez.$4$

$(T, H, H, H, T)$ , retournez et arrêtez.$5$

$(H, H, T, H, T)$ , retournez et arrêtez.$6$

$(H, T, H, T, H)$ , retournez et arrêtez.$7$

Étape 2: . Si le résultat n'est pas ce qui précède, répétez l'étape 1.

Notez que quelle que soit la valeur de , chacun des sept résultats énumérés ci-dessus a une probabilité , et le nombre attendu de lancers de pièces est . Le lanceur n'a pas besoin de connaître la valeur de (sauf que et ); il est garanti que les sept nombres entiers sont également susceptibles d'être renvoyés par l'expérience à la fin de celle-ci (et il est garanti que la probabilité termine ).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$

Généraliser le cas décrit par Dilip Sarwate

Certaines des méthodes décrites dans les autres réponses utilisent un schéma dans lequel vous lancez une séquence de pièces dans un «tour» et, en fonction du résultat, vous choisissez un nombre compris entre 1 et 7 ou vous éliminez le tour et relancez.$n$

L'astuce consiste à trouver dans l'expansion des possibilités un multiple de 7 résultats avec la même probabilité et à les comparer les uns contre les autres.$p^k(1-p)^{n-k}$

Le nombre total de résultats n'étant pas un multiple de 7, nous avons quelques résultats que nous ne pouvons pas affecter à un nombre et nous avons une certaine probabilité que nous devions ignorer les résultats et recommencer.

Le cas de l'utilisation de 7 lancers de pièces par tour

Intuitivement, on pourrait dire que lancer les dés sept fois serait très intéressant. Comme nous n'avons besoin que de rejeter 2 possibilités sur . À savoir, les 7 fois têtes et 0 fois les têtes.$2^7$

Pour toutes les autres possibilités il existe toujours un multiple de 7 observations avec le même nombre de têtes. Soit 7 caisses à 1 tête, 21 caisses à 2 têtes, 35 caisses à 3 têtes, 35 caisses à 4 têtes, 21 caisses à 5 têtes et 7 caisses à 6 têtes.$2^7-2$

Donc, si vous calculez le nombre (en rejetant 0 tête et 7 têtes)

avec Bernoulli variables distribuées (valeur 0 ou 1), alors X modulo 7 est une variable uniforme avec sept résultats possibles.$C_k$

Comparer différents nombres de lancers de pièces par tour

La question reste de savoir quel serait le nombre optimal de rouleaux par tour. Lancer plus de dés par tour vous coûte plus cher, mais vous réduisez la probabilité de devoir relancer.

L'image ci-dessous montre un calcul manuel pour les premiers nombres de lancers de pièces par tour. (Peut-être y aurait-il une solution analytique, mais je pense qu’il est prudent de dire qu’un système à 7 lancers de pièces constitue la meilleure méthode en ce qui concerne la valeur d’attente pour le nombre nécessaire de lancers de pièces)

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

Utiliser une règle d'arrêt précoce

Remarque: les calculs ci-dessous, pour la valeur d’attente du nombre de lancers, sont valables pour une pièce équitable , il serait désastreux de le faire pour un différent , mais le principe reste le même (bien que la comptabilité différente du cas est nécessaire)$p=0.5$$p$

Nous devrions pouvoir choisir les cas (au lieu de la formule pour ) de manière à pouvoir nous arrêter plus tôt.$X$

• Avec 5 lancers de pièces, nous avons pour les six différents ensembles possibles de têtes et de queues non ordonnés:

  1 + 5 + 10 + 10 + 5 + 1 jeux ordonnés

  Et nous pouvons utiliser les groupes à dix cas (c'est-à-dire le groupe à 2 têtes ou le groupe à 2 queues) pour choisir (avec une probabilité égale) un nombre. Cela se produit dans 14 cas sur 2 ^ 5 = 32. Cela nous laisse avec:

  1 + 5 + 3 + 3 + 5 + 1 jeux ordonnés

• Avec un (6 ème) tirage supplémentaire, nous avons pour les sept différents ensembles non ordonnés de têtes et de queues:

  1 + 6 + 8 + 6 + 8 + 6 + 1 ensembles ordonnés

  Et nous pouvons utiliser les groupes à huit cas (c'est-à-dire le groupe à 3 têtes ou le groupe à 3 queues) pour choisir (avec une probabilité égale) un nombre. Cela se produit dans 14 cas sur 2 * (2 ^ 5-14) = 36 cas. Cela nous laisse avec:

  1 + 6 + 1 + 6 + 1 + 6 + 1 jeux ordonnés

• Avec un autre (7 e) jeton supplémentaire, nous avons pour les huit différents ensembles non ordonnés de têtes et de queues:

  1 + 7 + 7 + 7 + 7 + 7 + 7 + 7 + 1 jeux ordonnés

  Et nous pouvons utiliser les groupes de sept cas (tous sauf les queues et tous les cas de têtes) pour choisir (avec une probabilité égale) un nombre. Cela se produit dans 42 cas sur 44. Cela nous laisse avec:

  1 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 jeux ordonnés

  (nous pourrions continuer cela mais ce n'est que dans la 49 ème étape que cela nous donne un avantage)

Donc, la probabilité de choisir un nombre

• à 5 tours est$\frac{14}{32} = \frac{7}{16}$
• at 6 flips is$\frac{9}{16}\frac{14}{36} = \frac{7}{32}$
• à 7 tours est$\frac{11}{32}\frac{42}{44} = \frac{231}{704}$
• pas dans 7 flips c'est$1-\frac{7}{16}-\frac{7}{32}-\frac{231}{704} = \frac{2}{2^7}$

Cela rend la valeur d’attente du nombre de retournements d’un tour conditionnée par le succès et p = 0.5:

La valeur attendue pour le nombre total de retournements (jusqu'à ce qu'il y ait un succès), à condition que p = 0.5, devienne:

La réponse de NcAdams utilise une variante de cette stratégie de règle d’arrêt (à chaque fois propose deux nouveaux lancers de pièces) mais ne sélectionne pas de manière optimale tous les lancers.

La réponse de Clid pourrait être similaire, bien qu’il puisse exister une règle de sélection inégale selon laquelle un numéro peut être choisi pour chaque paire de pièces, mais pas nécessairement avec une probabilité égale (une anomalie est corrigée au cours de lancers de pièces ultérieurs).

Comparaison avec d'autres méthodes

D'autres méthodes utilisant un principe similaire sont celles de NcAdams et AdamO.

Le principe est le suivant : Une décision pour un nombre compris entre 1 et 7 est prise après un certain nombre de têtes et de queues. Après un nombre de retournements, pour chaque décision menant à un nombre il existe une décision similaire, tout aussi probable, menant à un nombre (le même nombre de têtes et de queues mais dans un ordre différent). Certaines séries de têtes et de queues peuvent conduire à une décision de recommencer.$x$$i$$j$

Pour ce type de méthodes, celle qui est placée ici est la plus efficace car elle prend les décisions le plus tôt possible (dès qu’il est possible d’avoir 7 séquences de probabilités égales de têtes et de queues, après le ème retournement, on peut utiliser de prendre une décision sur un nombre et nous n’avons pas besoin de retourner si nous rencontrons un de ces cas).$x$

Ceci est démontré par l'image et la simulation ci-dessous:

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

une autre image qui est mise à l'échelle par pour une meilleure comparaison:$p*(1-p)$

zoomer en comparant les méthodes décrites dans ce post et les commentaires

le «saut conditionnel de la 7ème étape» est une légère amélioration qui peut être apportée par rapport à la règle d'arrêt précoce. Dans ce cas, vous ne sélectionnez pas les groupes à probabilités égales après le 6ème retournement. Vous avez 6 groupes avec des probabilités égales et 1 groupes avec une probabilité légèrement différente (pour ce dernier groupe vous devez retourner une fois de plus en plus lorsque vous avez 6 têtes ou queues et parce avec la même probabilité après tout)

Écrit par StackExchangeStrike

Divisez une boîte en sept régions de surface égale, chacune identifiée par un entier. Jetez la pièce dans la boîte de manière à ce qu’elle ait la même probabilité d’atterrir dans chaque région.

$\pi$

$p = 1$$p=0$

EDIT: basé sur les commentaires des autres.

Voici une pensée intéressante:

définir la liste de {1,2,3,4,5,6,7}. Jetez la pièce pour chaque élément de la liste de manière séquentielle. S'il tombe tête en haut pour un élément particulier, supprimez le numéro de la liste. Si tous les numéros d'une itération particulière de la liste sont supprimés, répétez l'échantillonnage. Faites-le jusqu'à ce qu'il ne reste qu'un seul numéro.

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)

me donne une distribution approximativement uniforme

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

Évaluation de la valeur attendue pour le nombre de lancers de pièces

$x$$y$

$(M-I)v=0$

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

$p>2/3$

Solution trouvée avec 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);

Calculs en 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))

La question est un peu ambiguë: demande-t-il "génère-t-il un nombre entier aléatoire égal ou inférieur à 7 avec une probabilité égale" ou demande-t-il "génère 7 nombres entiers aléatoires avec une probabilité égale?" - mais quel est l'espace des nombres entiers?!?

Je suppose que c'est le premier cas, mais la même logique que celle que j'applique peut également être étendue au dernier cas, une fois le problème résolu.

Avec une pièce biaisée, vous pouvez produire une pièce équitable en suivant la procédure suivante: https://en.wikipedia.org/wiki/Fair_coin#Fair_results_from_a_bias_coin

Un nombre inférieur ou égal à 7 peut être écrit en binaire avec trois {0,1} chiffres. Il suffit donc de suivre la procédure ci-dessus trois fois et de reconvertir le nombre binaire généré en décimal.

Une solution qui ne gaspille jamais les retournements, ce qui aide beaucoup pour les pièces très biaisées.

L'inconvénient de cet algorithme (du moins tel qu'il est écrit) est qu'il utilise une arithmétique à précision arbitraire. Dans la pratique, vous souhaiterez probablement l’utiliser jusqu’à débordement d’entier, puis seulement le jeter et le recommencer.

Aussi, vous devez savoir ce que le biais est ... que vous ne pouvez pas, par exemple, si elle dépend de la température comme la plupart des phénomènes physiques.

En supposant que la chance de la tête est, par exemple, 30%.

• Commencez avec la gamme [1, 8).
• Lancez votre pièce. Si c'est face, utilisez les 30% restants, pour que votre nouvelle gamme soit [1, 3.1). Sinon, utilisez les bons 70%, de sorte que votre nouvelle gamme est [3.1, 8).
• Répétez jusqu'à ce que toute la plage ait la même partie entière.

Code complet:

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

Comme mentionné dans les commentaires antérieurs, ce casse-tête est lié au document de John von Neumann de 1951 intitulé "Diverses techniques utilisées en relation avec des chiffres aléatoires" publié dans la revue de recherche du National Bureau of Standards:

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

Cela ne fonctionne que pour et .$p \neq 1$$p \neq 0$

Nous transformons d’abord la pièce (éventuellement) injuste en une pièce équitable en utilisant le processus de NcAdams :

Lancez la pièce deux fois. S'il atterrit HHou si TT, ignorez-le et retournez-le deux fois.

Maintenant, la pièce a une probabilité égale de monter HTou TH. Si cela se produit HT, appelez ceci H1. Si cela se produit TH, appelez ceci T1.

Nous utilisons maintenant la pièce équitable pour générer un nombre réel compris entre et en binaire. Soit et . Commencez par la ficelle , retournez la pièce et ajoutez le chiffre obtenu à la fin de la ficelle. Répétez avec la nouvelle chaîne. Par exemple, la séquence vous donnerait le nombre .$0$$1$H1$= 1$T1 $= 0$0.H1 H1 T1$0.110$

$1/7$ est un nombre décimal répété, et avec le membre de droite se trouvant en base 2, nous avons:

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

Continuez à tourner la pièce droite pour générer les chiffres décimaux jusqu'à ce que les chiffres de votre séquence ne correspondent plus à l'une des séquences ci-dessus, puis choisissez le nombre tel que votre nombre généré soit inférieur à et supérieur à . Puisque chaque nombre généré est également probable, nous avons choisi un nombre compris entre et avec une probabilité égale.n / 7 ( n - 1 ) / 7 1 $n$$n/7$$(n-1)/7$$1$$7$

Inspiré par la réponse d'AdamO, voici une solution Python qui évite les préjugés:

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

Il y a deux principaux changements ici: le principal est que si tous les numéros sont supprimés lors d'un tour, répétez le tour. De plus, j’inverse le choix de savoir si têtes ou queues signifie jeter chaque fois Cela réduit le nombre de retournements nécessaires dans les cas où p est proche de 0 ou 1 d'environ 70% lorsque p = 0,999.

Il semble que nous sommes autorisés à modifier la cartographie du résultat de chaque retournement, chaque fois que nous inversons . Ainsi, en utilisant par commodité les sept premiers entiers positifs, nous donnons les ordres suivants:

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

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

etc

$T$

$AP$$T$

$N_b$

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

Le nombre de flips inutiles aura ici tendance à

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