Rompecabezas: ¿Cómo generar 7 enteros con la misma probabilidad usando una moneda sesgada que tiene una pr (cabeza) = p?

Esta es una pregunta que encontré en Glassdoor : ¿Cómo se generan 7 enteros con la misma probabilidad usando una moneda que tiene un ?$\mathbb{Pr}(\text{Head}) = p\in(0,1)$

Básicamente, tiene una moneda que puede ser justa o no, y este es el único proceso de generación de números aleatorios que tiene, por lo tanto, cree un generador de números aleatorios que genere enteros del 1 al 7 donde la probabilidad de obtener cada uno de estos enteros es 1/7.

La eficiencia del proceso de generación de datos es importante.

Lanza la moneda dos veces. Si aterriza HHo TT, ignóralo y dale la vuelta dos veces.

Ahora, la moneda tiene la misma probabilidad de aparecer HTo TH. Si aparece HT, llame a esto H1. Si aparece TH, llame a esto T1.

Sigue obteniendo H1o T1hasta que tengas tres seguidos. Estos tres resultados le dan un número basado en la tabla a continuación:

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]

¡Argumento que esto funcionaría perfectamente bien, aunque tendrías muchos tiros desperdiciados en el proceso!

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

Paso 1: . Lanza la moneda 5 veces.

Si el resultado es

, regrese 1 y pare.$(H, H, H, T, T)$$1$

, regrese 2 y pare.$(H, H, T, T, H)$$2$

, regrese 3 y pare.$(H, T, T, H, H)$$3$

, regrese 4 y pare.$(T, T, H, H, H)$$4$

, regrese 5 y pare.$(T, H, H, H, T)$$5$

, regrese 6 y pare.$(H, H, T, H, T)$$6$

, regrese 7 y pare.$(H, T, H, T, H)$$7$

Paso 2: . Si el resultado no es ninguno de los anteriores, repita el Paso 1.

Tenga en cuenta que, independientemente del valor de , cada uno de los siete resultados enumerados anteriormente tiene una probabilidad q = p 3 ( 1 - p ) 2 , y el número esperado de lanzamiento de monedas es $p \in (0,1)$$q = p^3(1-p)^2$ . El lanzador no necesita saber el valor dep(excepto quep≠0yp≠1); se garantiza que los siete enteros tienen la misma probabilidad de ser devueltos por el experimento cuando finaliza (y se garantiza que terminará con la probabilidad1).$\displaystyle \frac{5}{7q}$$p$$p\neq 0$$p\neq 1$$1$

Generalizando el caso descrito por Dilip Sarwate

Algunos de los métodos descritos en las otras respuestas usan un esquema en el que lanzas una secuencia de $n$ monedas en un 'turno' y, dependiendo del resultado, eliges un número entre 1 o 7 o descartas el turno y vuelves a lanzar.

El truco consiste en encontrar en la expansión de posibilidades un múltiplo de 7 resultados con la misma probabilidad $p^k(1-p)^{n-k}$ y compararlos entre sí.

Debido a que el número total de resultados no es un múltiplo de 7, tenemos algunos resultados que no podemos asignar a un número, y tenemos alguna probabilidad de que debamos descartar los resultados y comenzar de nuevo.

El caso de usar 7 lanzamientos de monedas por turno

Intuitivamente podríamos decir que tirar los dados siete veces sería muy interesante. Ya que solo necesitamos tirar 2 de las $2^7$ posibilidades. A saber, las cabezas de 7 veces y las cabezas de 0 veces.

Para todas las otras $2^7-2$ posibilidades, siempre hay un múltiplo de 7 casos con el mismo número de cabezas. A saber, 7 casos con 1 cabezales, 21 casos con 2 cabezas, 35 casos con 3 cabezas, 35 casos con 4 cabezas, 21 casos con 5 cabezas y 7 casos con 6 cabezas.

Entonces, si calcula el número (descartando 0 cabezas y 7 cabezas)

con $C_k$ variables distribuidas de Bernoulli (valor 0 o 1), entonces X módulo 7 es una variable uniforme con siete resultados posibles.

Comparar diferentes números de lanzamientos de monedas por turno

La pregunta sigue siendo cuál sería el número óptimo de rollos por turno. Tirar más dados por turno le cuesta más, pero reduce la probabilidad de tener que tirar nuevamente.

La imagen a continuación muestra cálculos manuales para los primeros números de lanzamientos de monedas por turno. (posiblemente podría haber una solución analítica, pero creo que es seguro decir que un sistema con 7 monedas arroja el mejor método con respecto al valor esperado para la cantidad necesaria de monedas)

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

Usar una regla de detención temprana

nota: los cálculos a continuación, para el valor esperado del número de lanzamientos, son para una moneda justa $p=0.5$ , sería un desastre hacer esto para diferentes $p$ , pero el principio sigue siendo el mismo (aunque la contabilidad diferente del se necesitan casos)

Deberíamos poder elegir los casos (en lugar de la fórmula para $X$ ) de modo que podamos detenernos antes.

• Con 5 lanzamientos de monedas tenemos los seis posibles conjuntos diferentes de cabezas y colas desordenadas:

  1 + 5 + 10 + 10 + 5 + 1 conjuntos ordenados

  Y podemos usar los grupos con diez casos (es decir, el grupo con 2 cabezas o el grupo con 2 colas) para elegir (con igual probabilidad) un número. Esto ocurre en 14 de 2 ^ 5 = 32 casos. Esto nos deja con:

  1 + 5 + 3 + 3 + 5 + 1 conjuntos ordenados

• Con un lanzamiento de moneda adicional (6º) tenemos para los siete posibles conjuntos diferentes de cabezas y colas desordenadas:

  1 + 6 + 8 + 6 + 8 + 6 + 1 conjuntos ordenados

  Y podemos usar los grupos con ocho casos (es decir, el grupo con 3 cabezas o el grupo con 3 colas) para elegir (con igual probabilidad) un número. Esto ocurre en 14 de 2 * (2 ^ 5-14) = 36 casos. Esto nos deja con:

  1 + 6 + 1 + 6 + 1 + 6 + 1 conjuntos ordenados

• Con otro lanzamiento de moneda adicional (7º) tenemos para los ocho posibles conjuntos de cabezas y colas diferentes sin ordenar:

  1 + 7 + 7 + 7 + 7 + 7 + 7 + 1 conjuntos ordenados

  Y podemos usar los grupos con siete casos (todos excepto los casos con todas las colas y todas las cabezas) para elegir (con igual probabilidad) un número. Esto ocurre en 42 de 44 casos. Esto nos deja con:

  Conjuntos ordenados 1 + 0 + 0 + 0 + 0 + 0 + 0 + 1

  (podríamos continuar esto, pero solo en el paso 49 nos da una ventaja)

Entonces la probabilidad de seleccionar un número

• a 5 vueltas es $\frac{14}{32} = \frac{7}{16}$
• a las 6 vueltas es $\frac{9}{16}\frac{14}{36} = \frac{7}{32}$
• a las 7 vueltas es $\frac{11}{32}\frac{42}{44} = \frac{231}{704}$
• no en 7 flips es $1-\frac{7}{16}-\frac{7}{32}-\frac{231}{704} = \frac{2}{2^7}$

Esto hace que el valor esperado para el número de vueltas en un turno, sea condicional que haya éxito y p = 0.5:

El valor esperado para el número total de vueltas (hasta que haya un éxito), condicional de que p = 0.5, se convierte en:

La respuesta de NcAdams utiliza una variación de esta estrategia de regla de detención (cada vez que aparece dos nuevos lanzamientos de monedas) pero no está seleccionando de manera óptima todos los lanzamientos.

La respuesta de Clid también podría ser similar, aunque podría haber una regla de selección desigual de que cada moneda arroje un número podría elegirse, pero no necesariamente con la misma probabilidad (una discrepancia que se repara durante las monedas lanzadas posteriormente)

Comparación con otros métodos.

Otros métodos que utilizan un principio similar son el de NcAdams y AdamO.

El principio es : una decisión para un número entre 1 y 7 se toma después de un cierto número de caras y colas. Después de un número $x$ de vueltas, para cada decisión que conduce a un número $i$ hay una decisión similar, igualmente probable, que conduce a un número $j$ (el mismo número de caras y colas pero solo en un orden diferente). Algunas series de cara y cruz pueden llevar a la decisión de comenzar de nuevo.

Para este tipo de métodos, el que se coloca aquí es el más eficiente porque toma las decisiones lo antes posible (tan pronto como exista la posibilidad de 7 secuencias de igual probabilidad de cara y cruz, después de la $x$ giro -th, podemos usar para que tomen una decisión sobre un número y no es necesario que volteemos más si encontramos uno de esos casos).

Esto se demuestra en la imagen y simulación a continuación:

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

otra imagen que está escalada por $p*(1-p)$ para una mejor comparación:

amplíe los métodos de comparación descritos en esta publicación y comentarios

El 'salto condicional del séptimo paso' es una ligera mejora que se puede hacer en la regla de detención temprana. En este caso, selecciona no grupos con probabilidades iguales después de la sexta vuelta. Tienes 6 grupos con probabilidades iguales, y 1 grupos con una probabilidad ligeramente diferente (para este último grupo necesitas voltear una vez más cuando tienes 6 caras o colas y porque descartas las 7 caras o 7 colas, terminarás con la misma probabilidad después de todo)

Escrito por StackExchangeStrike

Divida una caja en siete regiones de área igual, cada una etiquetada con un número entero. Tire la moneda en la caja de tal manera que tenga la misma probabilidad de aterrizar en cada región.

$\pi$ usando un procedimiento físico de Monte Carlo, como dejar caer granos de arroz en papel con un círculo dibujado sobre él.

$p = 1$$p=0$

EDITAR: basado en los comentarios de otros.

Aquí hay un pensamiento interesante:

establecer la lista de {1,2,3,4,5,6,7}. Lanza la moneda para cada elemento de la lista secuencialmente. Si aterriza con la cabeza hacia arriba para un elemento en particular, elimine el número de la lista. Si se eliminan todos los números de una iteración particular de la lista, repita el muestreo. Hazlo hasta que solo quede un número.

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 da una distribución aproximadamente 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$

Evaluación del valor esperado para el número de lanzamientos de monedas.

$x$$y$

$(M-I)v=0$ ) representa cuánto tiempo se pasa relativamente en qué estado. Luego, el séptimo estado es la frecuencia con la que podrá dibujar un número del 1 al 7. Los otros estados indican cuántas monedas arroja.

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

$p>2/3$ . Pero también el rendimiento no es simétrico. Se podría lograr un rendimiento general simétrico y mejor cuando se hiciera una regla de cambio probabilístico que cambie la regla de decisión de colas a cabezas cuando las cabezas sean improbables.

Solución encontrada 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);

Cálculos 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 pregunta es un poco ambigua, ¿está preguntando "generar un número entero aleatorio igual o menor a 7 con igual probabilidad", o es "generar 7 números enteros aleatorios con igual probabilidad"? - ¿Pero cuál es el espacio de los enteros?

Asumiré que es el primero, pero la misma lógica que estoy aplicando también se puede extender al último caso, una vez que se solucione el problema.

Con una moneda sesgada, puede producir una moneda justa siguiendo el siguiente procedimiento: https://en.wikipedia.org/wiki/Fair_coin#Fair_results_from_a_limited_coin

Un número 7 o menos puede escribirse en binario como tres {0,1} dígitos. Entonces, todo lo que hay que hacer es seguir el procedimiento anterior tres veces y convertir el número binario producido de nuevo a decimal.

Una solución que nunca desperdicia lanzamientos, lo que ayuda mucho a las monedas muy sesgadas.

La desventaja de este algoritmo (como está escrito, al menos) es que está usando aritmética de precisión arbitraria. Prácticamente, es probable que desee usar esto hasta que se desborde el número entero, y solo luego desecharlo y comenzar de nuevo.

Además, es necesario saber lo que el sesgo es ... que no se puede, por ejemplo, si es dependiente de la temperatura como la mayoría de los fenómenos físicos.

Suponiendo que la probabilidad de que salgan cabezas es, digamos, 30%.

• Comience con el rango [1, 8).
• Lanza tu moneda. Si sale cara, use el 30% de la izquierda, entonces su nuevo rango es [1, 3.1). De lo contrario, use el 70% correcto, por lo que su nuevo rango es [3.1, 8).
• Repita hasta que todo el rango tenga la misma parte entera.

Código 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()

Como se mencionó en los comentarios anteriores, este rompecabezas se relaciona con John von Neumann 1951 papel "diferentes técnicas utilizadas en conexión con al azar dígitos", publicado en la revista de investigación de la Oficina Nacional de Normalización:

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

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

Primero convertimos la (posiblemente) moneda injusta en una moneda justa usando el proceso de la respuesta de NcAdams :

Lanza la moneda dos veces. Si aterriza HHo TT, ignóralo y dale la vuelta dos veces.

Ahora, la moneda tiene la misma probabilidad de aparecer HTo TH. Si aparece HT, llame a esto H1. Si aparece TH, llame a esto 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$

Inspirado por la respuesta de AdamO, aquí hay una solución de Python que evita el sesgo:

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

Aquí hay dos cambios principales: el principal es que si todos los números se descartan en una ronda, repita la ronda. También cambio la elección de si cara o cruz significa descartar todo el tiempo. Esto reduce el número de vueltas necesarias en casos donde p está cerca de 0 o 1 en ~ 70% cuando p = 0.999

Parece que podemos cambiar el mapeo del resultado de cada volteo, cada vez que volteamos . Entonces, usando por conveniencia los primeros siete enteros positivos, damos las siguientes órdenes:

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

El recuento de volteretas inútiles tenderá aquí a

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