Quebra-cabeças: Como gerar 7 números inteiros com igual probabilidade usando uma moeda tendenciosa que tem um pr (cabeça) = p?

Esta é uma pergunta que encontrei no Glassdoor : Como gerar 7 números inteiros com igual probabilidade usando uma moeda que possui ?$\mathbb{Pr}(\text{Head}) = p\in(0,1)$

Basicamente, você tem uma moeda que pode ou não ser justa, e esse é o único processo de geração de número aleatório que você possui; portanto, crie um gerador de número aleatório que produz números inteiros de 1 a 7, onde a probabilidade de obter cada um desses números inteiros é 1/7.

A eficiência dos dados gera questões de processo.

Jogue a moeda duas vezes. Se ele cair HHou TT, ignore-o e gire-o duas vezes novamente.

Agora, a moeda tem igual probabilidade de aparecer HTou TH. Se aparecer HT, ligue para isso H1. Se aparecer TH, ligue para isso T1.

Continue obtendo H1ou T1até ter três em sequência. Esses três resultados fornecem um número com base na tabela abaixo:

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 isso funcionaria perfeitamente bem, apesar de você ter perdido muitos arremessos no processo!

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

Passo 1: . Atire a moeda 5 vezes.

Se o resultado for

$(H, H, H, T, T)$ , retorne e pare.$1$

$(H, H, T, T, H)$ , retorne e pare.$2$

$(H, T, T, H, H)$ , retorne e pare.$3$

$(T, T, H, H, H)$ , retorne e pare.$4$

$(T, H, H, H, T)$ , retorne e pare.$5$

$(H, H, T, H, T)$ , retorne e pare.$6$

$(H, T, H, T, H)$ , retorne e pare.$7$

Passo 2: . Se o resultado não estiver acima, repita a Etapa 1.

Observe que, independentemente do valor de , cada um dos sete resultados listados acima tem probabilidade , e o número esperado de sorteios é . O tosser não precisa saber o valor de (exceto que e ); é garantido que os sete inteiros têm a mesma probabilidade de serem retornados pelo experimento quando ele terminar (e é garantido que termine com a probabilidade ).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$

Generalizando o caso descrito por Dilip Sarwate

Alguns dos métodos descritos nas outras respostas usam um esquema no qual você joga uma sequência de moedas em um 'turn' e, dependendo do resultado, escolhe um número entre 1 ou 7 ou descarta o turn e joga novamente.$n$

O truque é encontrar na expansão de possibilidades um múltiplo de 7 resultados com a mesma probabilidade e combinar os resultados entre si.$p^k(1-p)^{n-k}$

Como o número total de resultados não é um múltiplo de 7, temos alguns resultados que não podemos atribuir a um número e temos alguma probabilidade de que precisamos descartá-los e recomeçar.

O caso de usar 7 lançamentos de moedas por turno

Intuitivamente, poderíamos dizer que rolar os dados sete vezes seria muito interessante. Uma vez que só precisamos jogar fora 2 das possibilidades. Ou seja, as 7 vezes cabeças e 0 vezes cabeças.$2^7$

Para todas as outras possibilidades há sempre um múltiplo de 7 casos com o mesmo número de cabeças. Nomeadamente 7 casos com 1 cabeça, 21 casos com 2 cabeças, 35 casos com 3 cabeças, 35 casos com 4 cabeças, 21 casos com 5 cabeças e 7 casos com 6 cabeças.$2^7-2$

Portanto, se você calcular o número (descartando 0 e 7 cabeças)

com as variáveis ​​distribuídas Bernoulli (valor 0 ou 1), o módulo X 7 é uma variável uniforme com sete resultados possíveis.$C_k$

Comparando diferentes números de lançamentos de moedas por turno

A questão permanece qual seria o número ideal de jogadas por turno. Jogar mais dados por turno custa mais, mas você reduz a probabilidade de ter que jogar novamente.

A imagem abaixo mostra um cálculo manual para os primeiros números de lançamentos de moedas por turno. (possivelmente pode haver uma solução analítica, mas acredito que seja seguro dizer que um sistema com 7 lançamentos de moedas fornece o melhor método em relação ao valor esperado para o número necessário de lançamentos de moedas)

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

Usando uma regra de parada antecipada

nota: os cálculos abaixo, para o valor esperado do número de lançamentos, são para uma moeda justa , seria uma bagunça fazer isso para diferente , mas o princípio permanece o mesmo (embora contabilidade diferente da casos é necessário)$p=0.5$$p$

Deveríamos poder escolher os casos (em vez da fórmula para ) para que possamos parar mais cedo.$X$

• Com 5 lançamentos de moedas , temos para os seis conjuntos diferentes possíveis de cara e coroa:

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

  E podemos usar os grupos com dez casos (ou seja, o grupo com 2 cabeças ou o grupo com 2 caudas) para escolher (com igual probabilidade) um número. Isso ocorre em 14 dos 2 ^ 5 = 32 casos. Isso nos deixa com:

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

• Com um lançamento de moeda extra (6ª) , temos para os sete possíveis conjuntos diferentes de cara e coroa:

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

  E podemos usar os grupos com oito casos (ou seja, o grupo com 3 cabeças ou o grupo com 3 caudas) para escolher (com igual probabilidade) um número. Isso ocorre em 14 de 2 * (2 ^ 5-14) = 36 casos. Isso nos deixa com:

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

• Com outro (7º) lançamento de moeda extra , temos para os oito possíveis conjuntos diferentes de cabeças e coroas não ordenadas:

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

  E podemos usar os grupos com sete casos (todos, exceto os casos com todas as caudas e todas as cabeças) para escolher (com igual probabilidade) um número. Isso ocorre em 42 dos 44 casos. Isso nos deixa com:

  1 + 0 + 0 + 0 + 0 + 0 + 0 + 1 conjuntos ordenados

  (poderíamos continuar, mas somente na 49ª etapa isso nos dá uma vantagem)

Portanto, a probabilidade de selecionar um número

• em 5 movimentos é$\frac{14}{32} = \frac{7}{16}$
• em 6 movimentos é$\frac{9}{16}\frac{14}{36} = \frac{7}{32}$
• em 7 movimentos é$\frac{11}{32}\frac{42}{44} = \frac{231}{704}$
• não em 7 movimentos é$1-\frac{7}{16}-\frac{7}{32}-\frac{231}{704} = \frac{2}{2^7}$

Isso torna o valor esperado para o número de lançamentos em um turno, desde que haja sucesso ep = 0,5:

O valor esperado para o número total de lançamentos (até que haja sucesso), condicional que p = 0,5, se torne:

A resposta de NcAdams usa uma variação dessa estratégia de regra de parada (cada vez que surgem dois novos lançamentos de moedas), mas não é a melhor escolha para todos os lançamentos.

A resposta de Clid também pode ser semelhante, embora possa haver uma regra de seleção desigual de que cada duas moedas vira um número que pode ser escolhido, mas não necessariamente com igual probabilidade (uma discrepância que está sendo reparada durante os lançamentos de moedas posteriores)

Comparação com outros métodos

Outros métodos que usam um princípio semelhante são os de NcAdams e AdamO.

O princípio é : Uma decisão para um número entre 1 e 7 é tomada após um certo número de caras e coroa. Após um número de inversões, para cada decisão que leva a um número existe uma decisão semelhante, igualmente provável, que leva a um número (o mesmo número de caras e coroa, mas apenas em uma ordem diferente). Algumas séries de cara e coroa podem levar a uma decisão de recomeçar.$x$$i$$j$

Para esse tipo de método, o método colocado aqui é o mais eficiente, porque toma as decisões o mais cedo possível (assim que houver a possibilidade de 7 sequências de probabilidade igual de cara e coroa, após o ésimo giro, podemos usar eles tomam uma decisão sobre um número e não precisamos mudar mais se encontrarmos um desses casos).$x$

Isso é demonstrado pela imagem e simulação abaixo:

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

outra imagem dimensionada por para melhor comparação:$p*(1-p)$

ampliar os métodos de comparação descritos neste post e comentários

o 'salto condicional do 7º passo' é uma ligeira melhora que pode ser feita na regra de parada antecipada. Nesse caso, você não seleciona grupos com probabilidades iguais após o sexto flips. Você tem 6 grupos com probabilidades iguais e 1 grupo com uma probabilidade ligeiramente diferente (para este último grupo, você precisa inverter mais um tempo extra quando tiver 6 caras ou coroa e porque você descarta as 7 caras ou 7 coroas) afinal, com a mesma probabilidade)

Escrito por StackExchangeStrike

Divida uma caixa em sete regiões de área igual, cada uma rotulada com um número inteiro. Jogue a moeda na caixa de maneira a ter igual probabilidade de aterrissagem em cada região.

Isso é apenas metade da brincadeira - é essencialmente o mesmo procedimento que estimar usando um procedimento físico de Monte Carlo, como jogar grãos de arroz no papel com um círculo desenhado nele.$\pi$

Essa é uma das únicas respostas que funcionam no caso de ou .$p = 1$$p=0$

EDIT: com base no feedback dos outros.

Aqui está um pensamento interessante:

defina a lista de {1,2,3,4,5,6,7}. Jogue a moeda para cada elemento da lista sequencialmente. Se cair de cabeça para cima para um elemento específico, remova o número da lista. Se todos os números de uma iteração específica da lista forem removidos, repita a amostragem. Faça isso até restar apenas um 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 dá uma distribuição 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 

É interessante notar (se não cometi um erro grave) que isso produz um resultado diferente do que gerar resultados binomiais de como a soma de 13 arremessos da moeda (contando 0 cabeças como resultado) e mapear o {0,1 , 2, ..., 12,13} indexe na lista anterior de {1,2,3, ..., 3,2,1}. Não sei como provar que meu método funciona.$N$

Avaliação do valor esperado para o número de lançamentos de moedas

O valor esperado para o número de lançamentos de moedas pode ser calculado usando a matriz de transição abaixo (respondendo à pergunta quando começamos com números não eliminados, qual é a probabilidade de obter números não eliminados)$x$$y$

O vetor próprio associado ao valor próprio 1 (que pode ser encontrado resolvendo ) mostra quanto tempo é gasto relativamente em qual estado. Então, o sétimo estado é a frequência com que você poderá desenhar um número de 1 a 7. Os outros estados dizem quantas moedas são lançadas.$(M-I)v=0$

Abaixo está a imagem que se compara à resposta de NcAdams, que tem valor esperado para lançamentos de moedas, sendo$E(n) = \frac{24}{7}p(1-p)$

Notável é que o método tem um desempenho melhor para . Mas também o desempenho não é simétrico. Um desempenho geral simétrico e melhor poderia ser feito quando uma regra de comutação probabilística fosse feita, que altera a regra de decisão de caudas para cabeças quando as cabeças são improváveis.$p>2/3$

Solução encontrada com 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 em 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))

A pergunta é um pouco ambígua, está perguntando "gerar um número inteiro aleatório igual ou menor que 7 com probabilidade igual" ou está perguntando "gerar 7 números inteiros aleatórios com probabilidade igual?" - mas qual é o espaço dos números inteiros?!?

Suponho que seja o primeiro, mas a mesma lógica que estou aplicando também pode ser estendida ao último caso, uma vez que o problema seja resolvido.

Com uma moeda tendenciosa, você pode produzir uma moeda justa seguindo o procedimento a seguir: https://en.wikipedia.org/wiki/Fair_coin#Fair_results_from_a_beased_coin

Um número 7 ou menos pode ser escrito em binário como três dígitos {0,1}. Portanto, basta seguir o procedimento acima três vezes e converter o número binário produzido novamente em decimal.

Uma solução que nunca desperdiça flips, o que ajuda muito em moedas muito tendenciosas.

A desvantagem desse algoritmo (como escrito, pelo menos) é que ele está usando aritmética de precisão arbitrária. Praticamente, você provavelmente deseja usar isso até o número inteiro exceder o limite e só então jogá-lo fora e começar de novo.

Além disso, você precisa saber o que o viés é ... que você não pode, por exemplo, se for como a maioria dos fenômenos físicos dependente da temperatura.

Supondo que a chance de cabeças seja, digamos, 30%.

• Comece com o intervalo [1, 8).
• Jogue sua moeda. Se tiver cara, use os 30% restantes, então seu novo alcance é [1, 3.1). Senão, use os 70% certos, então seu novo alcance é [3.1, 8).
• Repita até que todo o intervalo tenha a mesma parte inteira.

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 mencionado nos comentários anteriores, esse quebra-cabeça está relacionado ao artigo de John von Neumann, de 1951 , "Various Techniques Used in Connection With Random Digits", publicado na revista de pesquisa do National Bureau of Standards:

Existe uma literatura mais ampla sobre tais problemas que se chama “ problemas de fábrica de Bernoulli” , ou seja, dada uma moeda com probabilidade de cauda , como simular uma moeda com probabilidade de cauda . Se possível, uma vez que algumas funções não podem ser usadas como, por exemplo, . Nacu e Peres (2005) estudam algoritmos rápidos para resolver problemas de fábrica [solucionáveis] de Bernoulli, onde rápido significa decaimento exponencial da cauda da distribuição do número de ensaios.$p$$f(p)$$f$ $f(p)=\min\{1,2p\}$$N$

Isso também só funciona para e .$p \neq 1$$p \neq 0$

Primeiro, transformamos a moeda (possivelmente) injusta em uma moeda justa, usando o processo da resposta do NcAdams :

Jogue a moeda duas vezes. Se ele cair HHou TT, ignore-o e gire-o duas vezes novamente.

Agora, a moeda tem igual probabilidade de aparecer HTou TH. Se aparecer HT, ligue para isso H1. Se aparecer TH, ligue para isso T1.

Agora usamos a moeda justa para gerar um número real entre e em binário. Seja e . Comece com a corda , jogue a moeda e anexe o dígito resultante ao final da corda. Repita com a nova sequência. Por exemplo, a sequência forneceria o número .$0$$1$H1$= 1$T1 $= 0$0.H1 H1 T1$0.110$

$1/7$ é um decimal repetido e, com o lado direito na base 2, temos o seguinte:

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

Continue jogando a moeda correta para gerar os dígitos decimais até que os dígitos da sua sequência não correspondam a uma das seqüências acima e, em seguida, escolha o número que o número gerado seja menor que e maior que . Como cada número gerado é igualmente provável, escolhemos um número entre e com igual probabilidade.$n$$n/7$$(n-1)/7$$1$$7$

Inspirado na resposta do AdamO, aqui está uma solução Python que evita preconceitos:

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

Existem duas mudanças principais aqui: a principal é que, se todo o número for descartado em uma rodada, repita a rodada. Também mudo a escolha de se cara ou coroa significa descartar sempre. Isso reduz o número de inversões necessárias nos casos em que p é próximo de 0 ou 1 em ~ 70% quando p = 0,999

Parece que temos permissão para alterar o mapeamento do resultado de cada flip, toda vez que fazemos flip . Portanto, usando por conveniência os sete primeiros números inteiros positivos, damos as seguintes ordens:

1st Flip, mapear 2nd Flip, mapear ... 7th flip, mapear 8th flip, mapear$H \to 1$
$H \to 2$

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

etc

Repita, sempre em lotes de 7 movimentos. Mapeie os resultados para nada.$T$

ALGUMAS OBSERVAÇÕES SOBRE EFICIÊNCIA
Nosso RNG, indexado pelo , gerará zero resultados úteis em um lote de 7 flip se obtivermos em todos os 7 flips. assim$AP$$T$

À medida que executamos lotes 7 flip, o número total de inúteis tenderá a$N_b$

Considere agora o RNG do @DilipSarwate. Aqui, usamos um binômio e lotes de 5 flip. Os sete resultados que geram um número inteiro têm probabilidade de ocorrer , portanto, em um lote de 5 flip$B(p,n=5)$$p^3(1-p)^2$

A contagem de lançamentos inúteis aqui tenderá a

Para o RNG da tender a produzir lançamentos menos inúteis, deve ser o caso que$AP$

O exame numérico mostra que se , o RNG gera menos movimentos inúteis. $p>0.0467$$AP$

Também descobrimos que o número de inversões inúteis está diminuindo monotonicamente em para o RNG , enquanto que para o RNG ele tem um mínimo em torno de e depois aumenta novamente, enquanto em geral permanece alto. A proporçãoA P D S p ≈ $p$$AP$$DS$$p\approx 0.5967$

declina muito rapidamente. Por exemplo, é igual a para , igual a para , igual a para .p = 0,1 0,3 p = 0,2 0,127 p = $0.67$$p=0.1$$0.3$$p=0.2$$0.127$$p=0.4$