Rompicapo: come generare 7 numeri interi con uguale probabilità usando una moneta distorta che ha un pr (testa) = p?

Questa è una domanda che ho trovato su Glassdoor : come si possono generare 7 numeri interi con uguale probabilità usando una moneta che ha un ?$\mathbb{Pr}(\text{Head}) = p\in(0,1)$

Fondamentalmente, hai una moneta che può essere o non essere giusta, e questo è l'unico processo di generazione di numeri casuali che hai, quindi crea un generatore di numeri casuali che genera numeri interi da 1 a 7 in cui la probabilità di ottenere ciascuno di questi numeri interi è 1/7.

L'efficienza del processo genera dati.

Lancia la moneta due volte. Se atterra HHo TT, ignoralo e capovolgilo di nuovo due volte.

Ora, la moneta ha la stessa probabilità di salire HTo TH. Se si presenta HT, chiama questo H1. Se si presenta TH, chiama questo T1.

Continua a ottenere H1o T1fino a quando non ne hai tre di seguito. Questi tre risultati forniscono un numero basato sulla tabella seguente:

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]

Sostengo che questo funzionerebbe perfettamente, anche se nel processo si avrebbe un sacco di sprechi!

Supponiamo che .$p \in (0,1)$

Fase 1: . Lancia la moneta 5 volte.

Se il risultato è

, ritorno 1 e stop.$(H, H, H, T, T)$$1$

, ritorno 2 e stop.$(H, H, T, T, H)$$2$

, ritorno 3 e stop.$(H, T, T, H, H)$$3$

, ritorno 4 e stop.$(T, T, H, H, H)$$4$

, ritorno 5 e stop.$(T, H, H, H, T)$$5$

, ritorno 6 e stop.$(H, H, T, H, T)$$6$

, ritorno 7 e stop.$(H, T, H, T, H)$$7$

Fase 2: . Se il risultato non è uno dei precedenti, ripetere il passaggio 1.

Si noti che indipendentemente dal valore di , ciascuno dei sette risultati sopra elencati ha probabilità q = p 3 ( 1 - p ) 2 e il numero previsto di gettoni è $p \in (0,1)$$q = p^3(1-p)^2$ . Il lanciatore non ha bisogno di conoscere il valore dip(tranne chep≠0ep≠1); è garantito che i sette numeri interi abbiano la stessa probabilità di essere restituiti dall'esperimento quando termina (ed è garantito che termina con probabilità1).$\displaystyle \frac{5}{7q}$$p$$p\neq 0$$p\neq 1$$1$

Generalizzando il caso descritto da Dilip Sarwate

Alcuni dei metodi descritti nelle altre risposte utilizzano uno schema in cui si lancia una sequenza di $n$ monete in un "turno" e, in base al risultato, si sceglie un numero compreso tra 1 o 7 oppure si scartano i turni e si lancia di nuovo.

Il trucco è trovare nell'espansione delle possibilità un multiplo di 7 risultati con la stessa probabilità $p^k(1-p)^{n-k}$ e abbinarli tra loro.

Poiché il numero totale di risultati non è un multiplo di 7, abbiamo alcuni risultati che non possiamo assegnare a un numero e abbiamo alcune probabilità che dobbiamo scartarli e ricominciare da capo.

---

Il caso dell'utilizzo di 7 lanci di monete per turno

Intuitivamente potremmo dire che lanciare i dadi sette volte sarebbe molto interessante. Dal momento che abbiamo solo bisogno di buttare via 2 delle $2^7$ possibilità. Vale a dire, il 7 volte teste e 0 volte teste.

Per tutte le altre $2^7-2$ possibilità c'è sempre un multiplo di 7 casi con lo stesso numero di teste. Vale a dire 7 casi con 1 testa, 21 casi con 2 teste, 35 casi con 3 teste, 35 casi con 4 teste, 21 casi con 5 teste e 7 casi con 6 teste.

Quindi se calcoli il numero (scartando 0 teste e 7 teste)

$$X = \sum_{k=1}^{7} (k-1) \cdot C_k$$

con $C_k$ variabili variabili distribuite da Bernoulli (valore 0 o 1), quindi X modulo 7 è una variabile uniforme con sette possibili risultati.

---

Confronto tra un numero diverso di lanci di monete per turno

La domanda rimane quale sarebbe il numero ottimale di tiri per turno. Tirare più dadi per turno ti costa di più, ma riduci la probabilità di dover rotolare di nuovo.

L'immagine seguente mostra un calcolo manuale per i primi numeri di lanci di monete per turno. (forse potrebbe esserci una soluzione analitica, ma credo sia sicuro affermare che un sistema con 7 lanci di monete fornisce il metodo migliore per quanto riguarda il valore di aspettativa per il numero necessario di lanci di monete)

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

---

Utilizzando una regola di arresto anticipato

$p=0.5$$p$

$X$

• Con 5 lanci di monete abbiamo per le sei possibili diverse serie non ordinate di teste e code:

  1 + 5 + 10 + 10 + 5 + 1 set ordinati

  E possiamo usare i gruppi con dieci casi (cioè il gruppo con 2 teste o il gruppo con 2 code) per scegliere (con uguale probabilità) un numero. Ciò si verifica in 14 casi su 2 ^ 5 = 32. Questo ci lascia con:

  1 + 5 + 3 + 3 + 5 + 1 set ordinati

• Con un lancio di monete extra (6 °) abbiamo per le sette possibili diverse serie non ordinate di teste e code:

  1 + 6 + 8 + 6 + 8 + 6 + 1 set ordinati

  E possiamo usare i gruppi con otto casi (ovvero il gruppo con 3 teste o il gruppo con 3 code) per scegliere (con uguale probabilità) un numero. Ciò si verifica in 14 casi su 2 * (2 ^ 5-14) = 36 casi. Questo ci lascia con:

  1 + 6 + 1 + 6 + 1 + 6 + 1 set ordinati

• Con un altro (7 °) lancio di monete extra abbiamo per le otto possibili diverse serie non ordinate di teste e code:

  1 + 7 + 7 + 7 + 7 + 7 + 7 + 1 set ordinati

  E possiamo usare i gruppi con sette casi (tutti tranne tutti i casi e tutti i capi) per scegliere (con uguale probabilità) un numero. Ciò si verifica in 42 casi su 44. Questo ci lascia con:

  1 + 0 + 0 + 0 + 0 + 0 + 0 + 1 set ordinati

  (potremmo continuare questo, ma solo nel 49 ° passaggio questo ci dà un vantaggio)

Quindi la probabilità di selezionare un numero

• $\frac{14}{32} = \frac{7}{16}$
• $\frac{9}{16}\frac{14}{36} = \frac{7}{32}$
• $\frac{11}{32}\frac{42}{44} = \frac{231}{704}$
• $1-\frac{7}{16}-\frac{7}{32}-\frac{231}{704} = \frac{2}{2^7}$

Questo rende il valore di aspettativa per il numero di lanci in un turno, a condizione che ci sia successo e p = 0,5:

$$5 \cdot \frac{7}{16}+ 6 \cdot \frac{7}{32} + 7 \cdot \frac{231}{704} = 5.796875$$

Il valore di aspettativa per il numero totale di lanci (fino a quando non c'è un successo), a condizione che p = 0,5, diventi:

$$\left(5 \cdot \frac{7}{16}+ 6 \cdot \frac{7}{32} + 7 \cdot \frac{231}{704}\right) \frac{2^7}{2^7-2} = \frac{53}{9} = 5.88889$$

---

La risposta di NcAdams utilizza una variante di questa strategia delle regole di arresto (ogni volta escono due nuovi lanci di monete) ma non sta selezionando in modo ottimale tutti i lanci.

Anche la risposta di Clid potrebbe essere simile anche se potrebbe esserci una regola di selezione irregolare secondo cui ogni due gettoni lancia un numero, ma non necessariamente con uguale probabilità (una discrepanza che viene riparata durante i gettoni successivi)

---

Confronto con altri metodi

Altri metodi che usano un principio simile sono quelli di NcAdams e AdamO.

$x$$i$$j$

$x$

Ciò è dimostrato dall'immagine e dalla simulazione seguenti:

#### 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*(1-p)$

ingrandire i metodi di confronto descritti in questo post e commenti

il "salto condizionato del 7 ° passaggio" è un leggero miglioramento che può essere apportato alla regola di arresto anticipato. In questo caso non si selezionano gruppi con pari probabilità dopo il 6 ° lancio. Hai 6 gruppi con pari probabilità e 1 gruppo con una probabilità leggermente diversa (per quest'ultimo gruppo devi capovolgere un altro tempo in più quando hai 6 teste o code e poiché scarti le 7 teste o 7 code, finirai dopo con la stessa probabilità dopo tutto)

---

Scritto da StackExchangeStrike

Dividi un riquadro in sette regioni di uguale area, ciascuna etichettata con un numero intero. Getta la moneta nella scatola in modo tale che abbia pari probabilità di atterrare in ogni regione.

$\pi$

Questa è una delle uniche risposte valide per il caso di $p = 1$$p=0$

EDIT: basato sul feedback degli altri.

Ecco un pensiero interessante:

imposta l'elenco di {1,2,3,4,5,6,7}. Lancia la moneta per ciascun elemento nell'elenco in sequenza. Se arriva a testa in su per un particolare elemento, rimuovi il numero dall'elenco. Se tutti i numeri di una particolare iterazione dell'elenco vengono rimossi, ripetere il campionamento. Fallo finché non rimane un solo numero.

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)

mi dà una distribuzione approssimativamente 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$ esiti binomiali come la somma di 13 lanci della moneta (contando 0 teste come risultato) e mappando {0,1 , 2, ..., 12,13} indice nell'elenco precedente di {1,2,3, ..., 3,2,1}. Non so proprio come provare che il mio metodo funzioni.

---

Valutazione del valore di aspettativa per il numero di lanci di monete

$x$$y$

$$M = \begin{bmatrix} q^7 & 0 & 0 & 0 &0 & 0 & 1 & 1\\ 7p^1q^6 & q^6 & 0 & 0 & 0 & 0 & 0 & 0 \\ 21p^2q^5 & 6p^1q^5 & q^5 & 0 & 0 & 0 & 0 & 0\\ 35 p^3q^4 & 15 p^2q^4 & 5q^4 & q^4 & 0 & 0 & 0 & 0\\ 35 p^4q^3 & 20 p^3q^3 & 10 p^2q^3 & 4 p^1q^3 & q^3 & 0 & 0 & 0\\ 21p^5q^2 & 15 p^4q^2 & 10 p^3q^2 & 6 p^2q^2 & 3 p^1q^2 & q^2 & 0 & 0\\ 7p^6q^1 & 6 p^5q^1 & 5 p^4q^1 & 4 p^3q^1 & 3p^2q^1 & 2p^1q^1 & 0 & 0\\ p^7 & p^6 & p^5 & p^4 & p^3 & p^2 & 0 & 0 \end{bmatrix}$$

$(M-I)v=0$

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

$p>2/3$ . Ma anche le prestazioni non sono simmetriche. Una prestazione complessiva simmetrica e migliore potrebbe essere realizzata quando verrebbe fatta una regola di commutazione probabilistica che modifica la regola di decisione da code a teste quando le teste risultano improbabili.

Soluzione trovata con 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);

Calcoli in 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 domanda è un po 'ambigua, sta chiedendo "genera un numero intero casuale uguale o inferiore a 7 con uguale probabilità" o sta chiedendo "genera 7 numeri interi casuali con uguale probabilità?" - ma qual è lo spazio degli interi?!?

Presumo sia il primo, ma la stessa logica che sto applicando può essere estesa anche al secondo caso, una volta chiarito il problema.

Con una moneta distorta, puoi produrre una moneta giusta seguendo la seguente procedura: https://en.wikipedia.org/wiki/Fair_coin#Fair_results_from_a_biased_coin

Un numero 7 o inferiore può essere scritto in binario come tre cifre {0,1}. Quindi tutto ciò che occorre fare è seguire la procedura sopra descritta tre volte e riconvertire il numero binario prodotto in decimale.

Una soluzione che non spreca mai lanci, che aiuta molto per le monete molto distorte.

Lo svantaggio di questo algoritmo (almeno come scritto) è l'utilizzo dell'aritmetica di precisione arbitraria. Praticamente, probabilmente vorrai usarlo fino al trabocco di numeri interi, e solo allora buttarlo via e ricominciare.

Inoltre, è necessario sapere che cosa il bias è ... che non si potrebbe, ad esempio, se è dipendente dalla temperatura come la maggior parte dei fenomeni fisici.

---

Supponendo che la probabilità di testa sia, diciamo, del 30%.

• Inizia con l'intervallo [1, 8).
• Lancia la tua moneta. Se esce testa, usa il 30% a sinistra, quindi la tua nuova gamma è [1, 3.1). Altrimenti, usa il giusto 70%, quindi la tua nuova gamma è [3.1, 8).
• Ripetere fino a quando l'intero intervallo ha la stessa parte intera.

---

Codice completo:

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

Come accennato nei commenti precedenti, questo puzzle si riferisce al 1951 di John von Neumann carta "varie tecniche utilizzate in connessione con Random Digits", pubblicato sulla rivista di ricerca del National Bureau of Standards:

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

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

Trasformiamo prima la moneta (forse) ingiusta in una moneta equa usando il processo della risposta di NcAdams :

Lancia la moneta due volte. Se atterra HHo TT, ignoralo e capovolgilo di nuovo due volte.

Ora, la moneta ha la stessa probabilità di salire HTo TH. Se si presenta HT, chiama questo H1. Se si presenta TH, chiama questo 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$

Ispirato dalla risposta di AdamO, ecco una soluzione Python che evita distorsioni:

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

Ci sono due principali cambiamenti qui: il principale è che se tutto il numero viene scartato in un round, ripetere il round. Inoltre capovolgo la scelta se testa o croce significa scartare ogni volta. Ciò riduce il numero di capovolgimenti necessari nei casi in cui p è vicino a 0 o 1 del ~ 70% quando p = 0,999

Sembra che ci sia permesso di cambiare la mappatura del risultato di ogni lancio, ogni volta che giriamo . Quindi, usando per comodità i primi sette numeri interi positivi, forniamo i seguenti ordini:

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

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

eccetera

$T$

$AP$$T$

$$P_{AP}(\text{no integers generated}) = (1-p)^7$$

$N_b$

$$\text{Count}_{AP}(\text{useless flips}) \to 7\cdot N_b(1-p)^7$$

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

$$P_{DS}(\text{no integers generated}) = 1-7\cdot p^3(1-p)^2$$

Il conteggio di lanci inutili tenderà qui a

$$\text{Count}_{DS}(\text{useless flips}) \to 5\cdot N_b\cdot [1-7\cdot p^3(1-p)^2]$$

$AP$

$$\text{Count}_{AP}(\text{useless flips}) < \text{Count}_{DS}(\text{useless flips})$$

$$\implies 7\cdot N_b(1-p)^7 < 5\cdot N_b\cdot [1-7\cdot p^3(1-p)^2]$$

$$\implies 7\cdot (1-p)^7 < 5\cdot [1-7\cdot p^3(1-p)^2]$$

$p>0.0467$$AP$

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

$$\frac{\text{Count}_{AP}(\text{useless flips})}{\text{Count}_{DS}(\text{useless flips})}$$

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