Data una funzione che produce un numero intero casuale nell'intervallo da 1 a 5, scrivere una funzione che produce un numero intero casuale nell'intervallo da 1 a 7.

1. Che cos'è una soluzione semplice?
2. Qual è una soluzione efficace per ridurre l'utilizzo della memoria o eseguire su una CPU più lenta?

Ciò equivale alla soluzione di Adam Rosenfield, ma potrebbe essere un po 'più chiaro per alcuni lettori. Presuppone che rand5 () sia una funzione che restituisce un numero intero statisticamente casuale nell'intervallo da 1 a 5 incluso.

int rand7()
{
    int vals[5][5] = {
        { 1, 2, 3, 4, 5 },
        { 6, 7, 1, 2, 3 },
        { 4, 5, 6, 7, 1 },
        { 2, 3, 4, 5, 6 },
        { 7, 0, 0, 0, 0 }
    };

    int result = 0;
    while (result == 0)
    {
        int i = rand5();
        int j = rand5();
        result = vals[i-1][j-1];
    }
    return result;
}

Come funziona? Pensala in questo modo: immagina di stampare su carta questo array a doppia dimensione, fissandolo a un bersaglio per le freccette e lanciandogli casualmente le freccette. Se colpisci un valore diverso da zero, è un valore statisticamente casuale compreso tra 1 e 7, poiché esiste un numero uguale di valori diversi da zero tra cui scegliere. Se colpisci uno zero, continua a lanciare il dardo finché non colpisci un zero. Ecco cosa sta facendo questo codice: gli indici iej selezionano casualmente una posizione sul bersaglio per le freccette e, se non otteniamo un buon risultato, continuiamo a lanciare freccette.

Come ha detto Adam, questo può durare per sempre nel caso peggiore, ma statisticamente il caso peggiore non si verifica mai. :)

Non esiste una soluzione (esattamente corretta) che verrà eseguita per un periodo di tempo costante, poiché 1/7 è un decimale infinito in base 5. Una soluzione semplice sarebbe quella di utilizzare il campionamento del rifiuto, ad esempio:

int i;
do
{
  i = 5 * (rand5() - 1) + rand5();  // i is now uniformly random between 1 and 25
} while(i > 21);
// i is now uniformly random between 1 and 21
return i % 7 + 1;  // result is now uniformly random between 1 and 7

Questo ha un tempo di esecuzione previsto di 25/21 = 1,19 iterazioni del loop, ma esiste una probabilità infinitamente piccola di loop per sempre.

Vorrei aggiungere un'altra risposta, oltre alla mia prima risposta . Questa risposta tenta di ridurre al minimo il numero di chiamate rand5()per chiamata rand7(), per massimizzare l'utilizzo della casualità. Cioè, se consideri la casualità come una risorsa preziosa, vogliamo usarne il più possibile, senza buttare via pezzi casuali. Questa risposta ha anche alcune somiglianze con la logica presentata nella risposta di Ivan .

L' entropia di una variabile casuale è una quantità ben definita. Per una variabile casuale che assume N stati con pari probabilità (una distribuzione uniforme), l'entropia è log ₂ N. Pertanto, rand5()ha circa 2.32193 bit di entropia e rand7()circa 2.80735 bit di entropia. Se speriamo di massimizzare il nostro uso della casualità, dobbiamo usare tutti i 2.32193 bit di entropia da ogni chiamata a rand5()e applicarli per generare 2.80735 bit di entropia necessari per ogni chiamata a rand7(). Il limite fondamentale, quindi, è che non possiamo fare di meglio che log (7) / log (5) = 1.20906 chiamate rand5()per chiamata a rand7().

Note a margine: tutti i logaritmi in questa risposta saranno base 2 se non diversamente specificato. rand5()si presume che restituiscano numeri nell'intervallo [0, 4] e rand7()che si presume restituisca numeri nell'intervallo [0, 6]. Regolare gli intervalli su [1, 5] e [1, 7] rispettivamente è banale.

Quindi come lo facciamo? Generiamo un numero reale casuale infinitamente preciso tra 0 e 1 (fingiamo per il momento che potremmo effettivamente calcolare e memorizzare un numero così infinitamente preciso - lo aggiusteremo in seguito). Possiamo generare un tale numero generando le sue cifre nella base 5: scegliamo il numero casuale 0. a₁ a₂ a₃ ..., dove ogni cifra a _iviene scelta da una chiamata a rand5(). Ad esempio, se il nostro RNG scegliesse a _i= 1 per tutti i, ignorando il fatto che non è molto casuale, corrisponderebbe al numero reale 1/5 + 1/5 ² + 1/5 ³ + ... = 1/4 (somma di una serie geometrica).

Ok, quindi abbiamo scelto un numero reale casuale compreso tra 0 e 1. Ora sostengo che tale numero casuale sia distribuito uniformemente. Intuitivamente, questo è facile da capire, poiché ogni cifra è stata selezionata in modo uniforme e il numero è infinitamente preciso. Tuttavia, una dimostrazione formale di questo è un po 'più implicata, poiché ora abbiamo a che fare con una distribuzione continua anziché una distribuzione discreta, quindi dobbiamo dimostrare che la probabilità che il nostro numero si trovi in ​​un intervallo [ a, b] è uguale alla lunghezza di tale intervallo, b - a. La prova è lasciata come esercizio per il lettore =).

Ora che abbiamo un numero reale casuale selezionato uniformemente nell'intervallo [0, 1], dobbiamo convertirlo in una serie di numeri uniformemente casuali nell'intervallo [0, 6] per generare l'output di rand7() . Come facciamo questo? Proprio il contrario di quello che abbiamo appena fatto: lo convertiamo in un decimale infinitamente preciso in base 7, e quindi ogni cifra in base 7 corrisponderà a un'uscita di rand7().

Prendendo l'esempio da prima, se nostro rand5() produce un flusso infinito di 1, il nostro numero reale casuale sarà 1/4. Convertendo 1/4 in base 7, otteniamo il decimale infinito 0,15151515 ..., quindi produrremo come output 1, 5, 1, 5, 1, 5, ecc.

Ok, quindi abbiamo l'idea principale, ma ci sono ancora due problemi: non possiamo effettivamente calcolare o memorizzare un numero reale infinitamente preciso, quindi come possiamo gestirne solo una parte finita? In secondo luogo, come possiamo effettivamente convertirlo in base 7?

Un modo in cui possiamo convertire un numero compreso tra 0 e 1 in base 7 è il seguente:

1. Moltiplicare per 7
2. La parte integrante del risultato è la successiva cifra di 7 cifre
3. Sottrarre la parte integrale, lasciando solo la parte frazionaria
4. Vai al passaggio 1

Per affrontare il problema della precisione infinita, calcoliamo un risultato parziale e memorizziamo anche un limite superiore su quale potrebbe essere il risultato. Cioè, supponiamo che abbiamo chiamato rand5()due volte e che sia tornato 1 entrambe le volte. Il numero che abbiamo generato finora è 0,11 (base 5). Qualunque sia il resto della serie infinita di chiamate arand5() produrre, il numero reale casuale che stiamo generando non sarà mai maggiore di 0,12: è sempre vero che 0,11 ≤ 0,11xyz ... <0,12.

Quindi, tenendo traccia del numero corrente finora e del valore massimo che potrebbe mai assumere, convertiamo entrambi i numeri in base 7. Se sono d'accordo sulle prime kcifre, allora possiamo produrre in sicurezza le kcifre successive , indipendentemente da quale sia il il flusso infinito di cifre di base 5 sono, non influenzeranno mai le kcifre successive della rappresentazione di base 7!

E questo è l'algoritmo: per generare il prossimo output di rand7(), generiamo solo tutte le cifre di rand5()cui abbiamo bisogno per assicurarci di conoscere con certezza il valore della prossima cifra nella conversione del numero reale casuale in base 7. Ecco un'implementazione di Python, con un cablaggio di test:

import random

rand5_calls = 0
def rand5():
    global rand5_calls
    rand5_calls += 1
    return random.randint(0, 4)

def rand7_gen():
    state = 0
    pow5 = 1
    pow7 = 7
    while True:
        if state / pow5 == (state + pow7) / pow5:
            result = state / pow5
            state = (state - result * pow5) * 7
            pow7 *= 7
            yield result
        else:
            state = 5 * state + pow7 * rand5()
            pow5 *= 5

if __name__ == '__main__':
    r7 = rand7_gen()
    N = 10000
    x = list(next(r7) for i in range(N))
    distr = [x.count(i) for i in range(7)]
    expmean = N / 7.0
    expstddev = math.sqrt(N * (1.0/7.0) * (6.0/7.0))

    print '%d TRIALS' % N
    print 'Expected mean: %.1f' % expmean
    print 'Expected standard deviation: %.1f' % expstddev
    print
    print 'DISTRIBUTION:'
    for i in range(7):
        print '%d: %d   (%+.3f stddevs)' % (i, distr[i], (distr[i] - expmean) / expstddev)
    print
    print 'Calls to rand5: %d (average of %f per call to rand7)' % (rand5_calls, float(rand5_calls) / N)

Si noti che rand7_gen()restituisce un generatore, poiché ha uno stato interno che comporta la conversione del numero in base 7. Il cablaggio di test chiama next(r7)10000 volte per produrre 10000 numeri casuali, quindi misura la loro distribuzione. Viene utilizzata solo la matematica dei numeri interi, quindi i risultati sono esattamente corretti.

Si noti inoltre che i numeri qui diventano molto grandi, molto veloci. I poteri di 5 e 7 crescono rapidamente. Quindi, le prestazioni inizieranno a peggiorare notevolmente dopo aver generato molti numeri casuali, a causa dell'aritmetica del bignum. Ma ricorda qui, il mio obiettivo era quello di massimizzare l'uso di bit casuali, non di massimizzare le prestazioni (anche se questo è un obiettivo secondario).

In una sequenza di questo, ho effettuato 12091 chiamate a rand5()10000 chiamate a rand7(), ottenendo il minimo di log (7) / log (5) chiamate in media a 4 cifre significative e l'output risultante era uniforme.

Per eseguire il porting di questo codice in una lingua che non ha numeri interi arbitrariamente grandi integrati, dovrai limitare i valori pow5e pow7il valore massimo del tuo tipo integrale nativo - se diventano troppo grandi, quindi resetta tutto e ricominciare. Ciò aumenterà il numero medio di chiamate arand5()rand7() leggermente per chiamata , ma si spera che non aumenti troppo anche per numeri interi a 32 o 64 bit.

(Ho rubato la risposta di Adam Rosenfeld e l'ho fatta correre circa il 7% più veloce.)

Supponiamo che rand5 () restituisca uno di {0,1,2,3,4} con uguale distribuzione e l'obiettivo è di ritorno {0,1,2,3,4,5,6} con uguale distribuzione.

int rand7() {
  i = 5 * rand5() + rand5();
  max = 25;
  //i is uniform among {0 ... max-1}
  while(i < max%7) {
    //i is uniform among {0 ... (max%7 - 1)}
    i *= 5;
    i += rand5(); //i is uniform {0 ... (((max%7)*5) - 1)}
    max %= 7;
    max *= 5; //once again, i is uniform among {0 ... max-1}
  }
  return(i%7);
}

Stiamo tenendo traccia del valore più grande che il ciclo può fare nella variabile max . Se il risultato finora è compreso tra max% 7 e max-1, il risultato sarà uniformemente distribuito in quell'intervallo. In caso contrario, utilizziamo il resto, che è casuale tra 0 e max% 7-1 e un'altra chiamata a rand () per creare un nuovo numero e un nuovo max. Quindi ricominciamo.

Modifica: il numero di volte in cui si chiama rand5 () è x in questa equazione:

x =  2     * 21/25
   + 3     *  4/25 * 14/20
   + 4     *  4/25 *  6/20 * 28/30
   + 5     *  4/25 *  6/20 *  2/30 * 7/10
   + 6     *  4/25 *  6/20 *  2/30 * 3/10 * 14/15
   + (6+x) *  4/25 *  6/20 *  2/30 * 3/10 *  1/15
x = about 2.21 calls to rand5()

Algoritmo:

7 possono essere rappresentati in una sequenza di 3 bit

Utilizzare rand (5) per riempire casualmente ogni bit con 0 o 1.
Ad esempio: call rand (5) e

se il risultato è 1 o 2, riempire il bit con 0
se il risultato è 4 o 5, riempire il bit con 1
se il risultato è 3, quindi ignorare e ripetere l'operazione (rifiuto)

In questo modo possiamo riempire 3 bit casualmente con 0/1 e quindi ottenere un numero da 1-7.

EDIT: questa sembra la risposta più semplice ed efficiente, quindi ecco un po 'di codice:

public static int random_7() {
    int returnValue = 0;
    while (returnValue == 0) {
        for (int i = 1; i <= 3; i++) {
            returnValue = (returnValue << 1) + random_5_output_2();
        }
    }
    return returnValue;
}

private static int random_5_output_2() {
    while (true) {
        int flip = random_5();

        if (flip < 3) {
            return 0;
        }
        else if (flip > 3) {
            return 1;
        }
    }
}

int randbit( void )
{
    while( 1 )
    {
        int r = rand5();
        if( r <= 4 ) return(r & 1);
    }
}

int randint( int nbits )
{
    int result = 0;
    while( nbits-- )
    {
        result = (result<<1) | randbit();
    }
    return( result );
}

int rand7( void )
{
    while( 1 )
    {
        int r = randint( 3 ) + 1;
        if( r <= 7 ) return( r );
    }
}

rand7() = (rand5()+rand5()+rand5()+rand5()+rand5()+rand5()+rand5())%7+1

Modifica: non funziona del tutto. È spento di circa 2 parti su 1000 (supponendo un perfetto rand5). I secchi ottengono:

value   Count  Error%
1       11158  -0.0035
2       11144  -0.0214
3       11144  -0.0214
4       11158  -0.0035
5       11172  +0.0144
6       11177  +0.0208
7       11172  +0.0144

Passando a una somma di

n   Error%
10  +/- 1e-3,
12  +/- 1e-4,
14  +/- 1e-5,
16  +/- 1e-6,
...
28  +/- 3e-11

sembra ottenere un ordine di grandezza per ogni 2 aggiunti

A proposito: la tabella degli errori sopra non è stata generata tramite campionamento ma dalla seguente relazione di ricorrenza:

p[x,n]è il numero di modi in cui output=xpossono accadere determinate nchiamate rand5.

  p[1,1] ... p[5,1] = 1
  p[6,1] ... p[7,1] = 0

  p[1,n] = p[7,n-1] + p[6,n-1] + p[5,n-1] + p[4,n-1] + p[3,n-1]
  p[2,n] = p[1,n-1] + p[7,n-1] + p[6,n-1] + p[5,n-1] + p[4,n-1]
  p[3,n] = p[2,n-1] + p[1,n-1] + p[7,n-1] + p[6,n-1] + p[5,n-1]
  p[4,n] = p[3,n-1] + p[2,n-1] + p[1,n-1] + p[7,n-1] + p[6,n-1]
  p[5,n] = p[4,n-1] + p[3,n-1] + p[2,n-1] + p[1,n-1] + p[7,n-1]
  p[6,n] = p[5,n-1] + p[4,n-1] + p[3,n-1] + p[2,n-1] + p[1,n-1]
  p[7,n] = p[6,n-1] + p[5,n-1] + p[4,n-1] + p[3,n-1] + p[2,n-1]

int ans = 0;
while (ans == 0) 
{
     for (int i=0; i<3; i++) 
     {
          while ((r = rand5()) == 3){};
          ans += (r < 3) >> i
     }
}

Quanto segue produce una distribuzione uniforme su {1, 2, 3, 4, 5, 6, 7} utilizzando un generatore di numeri casuali che produce una distribuzione uniforme su {1, 2, 3, 4, 5}. Il codice è disordinato, ma la logica è chiara.

public static int random_7(Random rg) {
    int returnValue = 0;
    while (returnValue == 0) {
        for (int i = 1; i <= 3; i++) {
            returnValue = (returnValue << 1) + SimulateFairCoin(rg);
        }
    }
    return returnValue;
}

private static int SimulateFairCoin(Random rg) {
    while (true) {
        int flipOne = random_5_mod_2(rg);
        int flipTwo = random_5_mod_2(rg);

        if (flipOne == 0 && flipTwo == 1) {
            return 0;
        }
        else if (flipOne == 1 && flipTwo == 0) {
            return 1;
        }
    }
}

private static int random_5_mod_2(Random rg) {
    return random_5(rg) % 2;
}

private static int random_5(Random rg) {
    return rg.Next(5) + 1;
}    

int rand7() {
    int value = rand5()
              + rand5() * 2
              + rand5() * 3
              + rand5() * 4
              + rand5() * 5
              + rand5() * 6;
    return value%7;
}

A differenza della soluzione scelta, l'algoritmo verrà eseguito in tempo costante. Effettua tuttavia 2 chiamate in più a rand5 rispetto al tempo medio di esecuzione della soluzione scelta.

Si noti che questo generatore non è perfetto (il numero 0 ha una probabilità dello 0,0064% in più rispetto a qualsiasi altro numero), ma per la maggior parte degli scopi pratici la garanzia del tempo costante probabilmente supera questa inesattezza.

Spiegazione

Questa soluzione deriva dal fatto che il numero 15.624 è divisibile per 7 e quindi se possiamo generare casualmente e uniformemente numeri da 0 a 15.624 e quindi prendere il mod 7 possiamo ottenere un generatore rand7 quasi uniforme. I numeri da 0 a 15.624 possono essere generati uniformemente ruotando rand5 6 volte e utilizzandoli per formare le cifre di un numero di base 5 come segue:

rand5 * 5^5 + rand5 * 5^4 + rand5 * 5^3 + rand5 * 5^2 + rand5 * 5 + rand5

Le proprietà di mod 7 ci consentono tuttavia di semplificare un po 'l'equazione:

5^5 = 3 mod 7
5^4 = 2 mod 7
5^3 = 6 mod 7
5^2 = 4 mod 7
5^1 = 5 mod 7

Così

rand5 * 5^5 + rand5 * 5^4 + rand5 * 5^3 + rand5 * 5^2 + rand5 * 5 + rand5

diventa

rand5 * 3 + rand5 * 2 + rand5 * 6 + rand5 * 4 + rand5 * 5 + rand5

Teoria

Il numero 15.624 non è stato scelto a caso, ma può essere scoperto usando il piccolo teorema di fermat, che afferma che se p è un numero primo allora

a^(p-1) = 1 mod p

Quindi questo ci dà

(5^6)-1 = 0 mod 7

(5 ^ 6) -1 è uguale a

4 * 5^5 + 4 * 5^4 + 4 * 5^3 + 4 * 5^2 + 4 * 5 + 4

Questo è un numero in forma base 5 e quindi possiamo vedere che questo metodo può essere usato per passare da qualsiasi generatore di numeri casuali a qualsiasi altro generatore di numeri casuali. Anche se viene sempre introdotto un piccolo orientamento verso 0 quando si usa l'esponente p-1.

Per generalizzare questo approccio e per essere più precisi possiamo avere una funzione come questa:

def getRandomconverted(frm, to):
    s = 0
    for i in range(to):
        s += getRandomUniform(frm)*frm**i
    mx = 0
    for i in range(to):
        mx = (to-1)*frm**i 
    mx = int(mx/to)*to # maximum value till which we can take mod
    if s < mx:
        return s%to
    else:
        return getRandomconverted(frm, to)

Qui sono ammessi problemi con i compiti?

Questa funzione esegue la matematica "base 5" per generare un numero compreso tra 0 e 6.

function rnd7() {
    do {
        r1 = rnd5() - 1;
        do {
            r2=rnd5() - 1;
        } while (r2 > 1);
        result = r2 * 5 + r1;
    } while (result > 6);
    return result + 1;
}

Se consideriamo il vincolo aggiuntivo del tentativo di dare la risposta più efficiente, ovvero quella che ha dato un flusso di input I, di interi distribuiti uniformemente di lunghezza mda 1-5 output a stream O, di numeri interi distribuiti uniformemente da 1-7 del relativo più lungo a mdire L(m).

Il modo più semplice per analizzarlo è trattare i flussi I e Orispettivamente i numeri 5-ary e 7-ary. Ciò è ottenuto dall'idea della risposta principale di prendere lo stream a1, a2, a3,... -> a1+5*a2+5^2*a3+..e allo stesso modo per lo stream O.

Quindi se prendiamo una sezione del flusso di input di lunghezza m choose n s.t. 5^m-7^n=cdove c>0ed è il più piccolo possibile. Quindi c'è una mappa uniforme dal flusso di input di lunghezza m agli interi da 1a 5^me un'altra mappa uniforme da interi da 1 a 7^nal flusso di output di lunghezza n dove potremmo dover perdere alcuni casi dal flusso di input quando l'intero mappato supera 7^n.

Quindi questo dà un valore L(m)di circa m (log5/log7)che è approssimativamente .82m.

La difficoltà con l'analisi di cui sopra è l'equazione 5^m-7^n=cche non è di facile soluzione e esattamente il caso in cui il valore di uniforme da 1al 5^msupera 7^ne perdiamo efficienza.

La domanda è: quanto vicino può essere raggiunto il miglior valore possibile di m (log5 / log7). Ad esempio, quando questo numero si avvicina a un numero intero, possiamo trovare un modo per ottenere questo numero integrale esatto di valori di output?

Se 5^m-7^n=cquindi dal flusso di input generiamo effettivamente un numero casuale uniforme da 0a (5^m)-1e non utilizziamo valori superiori a 7^n. Tuttavia, questi valori possono essere salvati e riutilizzati. Generano effettivamente una sequenza uniforme di numeri da 1 a 5^m-7^n. Quindi possiamo quindi provare a usarli e convertirli in numeri 7-ary in modo da poter creare più valori di output.

Se lasciamo T7(X)essere la lunghezza media della sequenza di output di random(1-7)numeri interi derivati ​​da un input uniforme di dimensione X, e supponendo che 5^m=7^n0+7^n1+7^n2+...+7^nr+s, s<7.

Quindi T7(5^m)=n0x7^n0/5^m + ((5^m-7^n0)/5^m) T7(5^m-7^n0)poiché non abbiamo una lunghezza nessuna sequenza con probabilità 7 ^ n0 / 5 ^ m con un residuo di lunghezza 5^m-7^n0con probabilità (5^m-7^n0)/5^m).

Se continuiamo a sostituire, otteniamo:

T7(5^m) = n0x7^n0/5^m + n1x7^n1/5^m + ... + nrx7^nr/5^m  = (n0x7^n0 + n1x7^n1 + ... + nrx7^nr)/5^m

Quindi

L(m)=T7(5^m)=(n0x7^n0 + n1x7^n1 + ... + nrx7^nr)/(7^n0+7^n1+7^n2+...+7^nr+s)

Un altro modo per dirlo è:

If 5^m has 7-ary representation `a0+a1*7 + a2*7^2 + a3*7^3+...+ar*7^r
Then L(m) = (a1*7 + 2a2*7^2 + 3a3*7^3+...+rar*7^r)/(a0+a1*7 + a2*7^2 + a3*7^3+...+ar*7^r)

Il miglior caso possibile è il mio originale sopra dove 5^m=7^n+s, doves<7 .

Quindi T7(5^m) = nx(7^n)/(7^n+s) = n+o(1) = m (Log5/Log7)+o(1)come prima.

Il caso peggiore è quando possiamo trovare solo k e st 5 ^ m = kx7 + s.

Then T7(5^m) = 1x(k.7)/(k.7+s) = 1+o(1)

Altri casi sono da qualche parte nel mezzo. Sarebbe interessante vedere quanto bene possiamo fare per m molto grandi, cioè quanto possiamo ottenere il termine di errore:

T7(5^m) = m (Log5/Log7)+e(m)

Sembra impossibile da raggiungere e(m) = o(1)in generale, ma speriamo di poterlo dimostrare e(m)=o(m).

Il tutto si basa quindi sulla distribuzione delle cifre 7-ary di 5^mvari valori di m.

Sono sicuro che ci sia molta teoria là fuori che copre questo, potrei dare un'occhiata e riferire ad un certo punto.

Ecco un'implementazione Python funzionante della risposta di Adam .

import random

def rand5():
    return random.randint(1, 5)

def rand7():
    while True:
        r = 5 * (rand5() - 1) + rand5()
        #r is now uniformly random between 1 and 25
        if (r <= 21):
            break
    #result is now uniformly random between 1 and 7
    return r % 7 + 1

Mi piace lanciare algoritmi che sto esaminando in Python in modo da poter giocare con loro, ho pensato di pubblicarlo qui nella speranza che sia utile a qualcuno là fuori, non che ci sia voluto molto tempo per metterli insieme.

Perché non farlo semplice?

int random7() {
  return random5() + (random5() % 3);
}

Le possibilità di ottenere 1 e 7 in questa soluzione sono inferiori a causa del modulo, tuttavia, se si desidera solo una soluzione rapida e leggibile, questa è la strada da percorrere.

Supponendo che rand (n) qui significhi "intero casuale in una distribuzione uniforme da 0 a n-1 ", ecco un esempio di codice che usa il randint di Python, che ha quell'effetto. Usa solo randint (5) e costanti per produrre l'effetto di randint (7) . Un po 'sciocco, in realtà

from random import randint
sum = 7
while sum >= 7:
    first = randint(0,5)   
    toadd = 9999
    while toadd>1:
        toadd = randint(0,5)
    if toadd:
        sum = first+5
    else:
        sum = first

assert 7>sum>=0 
print sum

La premessa alla base della risposta corretta di Adam Rosenfield è:

• x = 5 ^ n (nel suo caso: n = 2)
• manipola n rand5 chiamate per ottenere un numero y entro l'intervallo [1, x]
• z = ((int) (x / 7)) * 7
• se y> z, riprova. altrimenti restituisce y% 7 + 1

Quando n è uguale a 2, hai 4 possibilità di eliminazione: y = {22, 23, 24, 25}. Se usi n uguale a 6, hai solo 1 lancio: y = {15625}.

5 ^ 6 = 15625
7 * 2232 = 15624

Chiami rand5 più volte. Tuttavia, hai una probabilità molto più bassa di ottenere un valore di lancio (o un ciclo infinito). Se c'è un modo per non ottenere alcun valore da buttare via per y, non l'ho ancora trovato.

Ecco la mia risposta:

static struct rand_buffer {
  unsigned v, count;
} buf2, buf3;

void push (struct rand_buffer *buf, unsigned n, unsigned v)
{
  buf->v = buf->v * n + v;
  ++buf->count;
}

#define PUSH(n, v)  push (&buf##n, n, v)

int rand16 (void)
{
  int v = buf2.v & 0xf;
  buf2.v >>= 4;
  buf2.count -= 4;
  return v;
}

int rand9 (void)
{
  int v = buf3.v % 9;
  buf3.v /= 9;
  buf3.count -= 2;
  return v;
}

int rand7 (void)
{
  if (buf3.count >= 2) {
    int v = rand9 ();

    if (v < 7)
      return v % 7 + 1;

    PUSH (2, v - 7);
  }

  for (;;) {
    if (buf2.count >= 4) {
      int v = rand16 ();

      if (v < 14) {
        PUSH (2, v / 7);
        return v % 7 + 1;
      }

      PUSH (2, v - 14);
    }

    // Get a number between 0 & 25
    int v = 5 * (rand5 () - 1) + rand5 () - 1;

    if (v < 21) {
      PUSH (3, v / 7);
      return v % 7 + 1;
    }

    v -= 21;
    PUSH (2, v & 1);
    PUSH (2, v >> 1);
  }
}

È un po 'più complicato di altri, ma credo che minimizzi le chiamate a rand5. Come con altre soluzioni, c'è una piccola probabilità che possa essere ripetuta a lungo.

Semplice ed efficiente:

int rand7 ( void )
{
    return 4; // this number has been calculated using
              // rand5() and is in the range 1..7
}

(Ispirato da Qual è il tuo cartone animato preferito "programmatore"? ).

Finché non ci sono sette possibilità tra cui scegliere, disegna un altro numero casuale, che moltiplica il numero di possibilità per cinque. In Perl:

$num = 0;
$possibilities = 1;

sub rand7
{
  while( $possibilities < 7 )
  {
    $num = $num * 5 + int(rand(5));
    $possibilities *= 5;
  }
  my $result = $num % 7;
  $num = int( $num / 7 );
  $possibilities /= 7;
  return $result;
}

Non mi piacciono gli intervalli a partire da 1, quindi inizierò da 0 :-)

unsigned rand5()
{
    return rand() % 5;
}

unsigned rand7()
{
    int r;

    do
    {
        r =         rand5();
        r = r * 5 + rand5();
        r = r * 5 + rand5();
        r = r * 5 + rand5();
        r = r * 5 + rand5();
        r = r * 5 + rand5();
    } while (r > 15623);

    return r / 2232;
}

Ecco fatto, distribuzione uniforme e zero chiamate rand5.

def rand7:
    seed += 1
    if seed >= 7:
        seed = 0
    yield seed

È necessario impostare il seme in anticipo.

So che ha avuto una risposta, ma sembra che funzioni bene, ma non posso dirti se ha una propensione. Il mio "test" suggerisce che è, almeno, ragionevole.

Forse Adam Rosenfield sarebbe così gentile da commentare?

La mia (ingenua?) Idea è questa:

Accumula rand5 finché non ci sono abbastanza bit casuali per creare un rand7. Questo richiede al massimo 2 rand5. Per ottenere il numero Rand7 uso il valore accumulato mod 7.

Per evitare che l'accumulatore trabocchi, e poiché l'accumulatore è mod 7, prendo il mod 7 dell'accumulatore:

(5a + rand5) % 7 = (k*7 + (5a%7) + rand5) % 7 = ( (5a%7) + rand5) % 7

La funzione rand7 () segue:

(Lascio che l'intervallo di rand5 sia 0-4 e anche rand7 sia 0-6.)

int rand7(){
  static int    a=0;
  static int    e=0;
  int       r;
  a = a * 5 + rand5();
  e = e + 5;        // added 5/7ths of a rand7 number
  if ( e<7 ){
    a = a * 5 + rand5();
    e = e + 5;  // another 5/7ths
  }
  r = a % 7;
  e = e - 7;        // removed a rand7 number
  a = a % 7;
  return r;
}

Modifica: aggiunti risultati per 100 milioni di prove.

Le funzioni "reali" del mod 5 o 7

rand5: avg = 1.999802 0: 20003944 1: 19999889 2: 20003690 3: 19996938 4: 19995539 rand7: avg = 3.000111 0: 14282851 1: 14282879 2: 14284554 3: 14288546 4: 14292388 5: 14288736 6: 14280046

My rand7

La media sembra ok e anche le distribuzioni di numeri sembrano ok.

randt: avg = 3.000080 0: 14288793 1: 14280135 2: 14287848 3: 14285277 4: 14286341 5: 14278663 6: 14292943

Esistono algoritmi eleganti citati sopra, ma ecco un modo per affrontarlo, anche se potrebbe essere una rotonda. Sto assumendo valori generati da 0.

R2 = generatore di numeri casuali che fornisce valori inferiori a 2 (spazio campione = {0, 1})
R8 = generatore di numeri casuali che fornisce valori inferiori a 8 (spazio campione = {0, 1, 2, 3, 4, 5, 6, 7 })

Per generare R8 da R2, eseguirai R2 tre volte e utilizzerai il risultato combinato di tutte e 3 le esecuzioni come numero binario con 3 cifre. Ecco l'intervallo di valori quando R2 viene eseguito tre volte:

0 0 0 -> 0
.
.
1 1 1 -> 7

Ora per generare R7 da R8, eseguiamo nuovamente R7 se restituisce 7:

int R7() {
  do {
    x = R8();
  } while (x > 6)
  return x;
}

La soluzione rotonda è quella di generare R2 da R5 (proprio come abbiamo generato R7 da R8), quindi R8 da R2 e quindi R7 da R8.

Ecco una soluzione che si adatta interamente ai numeri interi e si trova a circa il 4% dell'ottimale (ovvero utilizza 1,26 numeri casuali in {0..4} per ognuno in {0..6}). Il codice è in Scala, ma la matematica dovrebbe essere ragionevolmente chiara in qualsiasi lingua: approfitti del fatto che 7 ^ 9 + 7 ^ 8 è molto vicino a 5 ^ 11. Quindi scegli un numero di 11 cifre nella base 5 e poi lo interpreti come un numero di 9 cifre nella base 7 se è nell'intervallo (fornendo 9 numeri di base 7) o come un numero di 8 cifre se si trova sopra il numero di 9 cifre, ecc. .:

abstract class RNG {
  def apply(): Int
}

class Random5 extends RNG {
  val rng = new scala.util.Random
  var count = 0
  def apply() = { count += 1 ; rng.nextInt(5) }
}

class FiveSevener(five: RNG) {
  val sevens = new Array[Int](9)
  var nsevens = 0
  val to9 = 40353607;
  val to8 = 5764801;
  val to7 = 823543;
  def loadSevens(value: Int, count: Int) {
    nsevens = 0;
    var remaining = value;
    while (nsevens < count) {
      sevens(nsevens) = remaining % 7
      remaining /= 7
      nsevens += 1
    }
  }
  def loadSevens {
    var fivepow11 = 0;
    var i=0
    while (i<11) { i+=1 ; fivepow11 = five() + fivepow11*5 }
    if (fivepow11 < to9) { loadSevens(fivepow11 , 9) ; return }
    fivepow11 -= to9
    if (fivepow11 < to8) { loadSevens(fivepow11 , 8) ; return }
    fivepow11 -= to8
    if (fivepow11 < 3*to7) loadSevens(fivepow11 % to7 , 7)
    else loadSevens
  }
  def apply() = {
    if (nsevens==0) loadSevens
    nsevens -= 1
    sevens(nsevens)
  }
}

Se si incolla un test nell'interprete (REPL effettivamente), si ottiene:

scala> val five = new Random5
five: Random5 = Random5@e9c592

scala> val seven = new FiveSevener(five)
seven: FiveSevener = FiveSevener@143c423

scala> val counts = new Array[Int](7)
counts: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0)

scala> var i=0 ; while (i < 100000000) { counts( seven() ) += 1 ; i += 1 }
i: Int = 100000000

scala> counts
res0: Array[Int] = Array(14280662, 14293012, 14281286, 14284836, 14287188,
14289332, 14283684)

scala> five.count
res1: Int = 125902876

La distribuzione è piacevole e piatta (entro circa 10k di 1/7 di 10 ^ 8 in ciascun cestino, come previsto da una distribuzione approssimativamente gaussiana).

Utilizzando un totale parziale , è possibile entrambi

• mantenere una distribuzione equa; e
• non è necessario sacrificare alcun elemento nella sequenza casuale.

Entrambi questi problemi sono un problema con le rand(5)+rand(5)...soluzioni di tipo semplice . Il seguente codice Python mostra come implementarlo (la maggior parte di questo sta provando la distribuzione).

import random
x = []
for i in range (0,7):
    x.append (0)
t = 0
tt = 0
for i in range (0,700000):
    ########################################
    #####            qq.py             #####
    r = int (random.random () * 5)
    t = (t + r) % 7
    ########################################
    #####       qq_notsogood.py        #####
    #r = 20
    #while r > 6:
        #r =     int (random.random () * 5)
        #r = r + int (random.random () * 5)
    #t = r
    ########################################
    x[t] = x[t] + 1
    tt = tt + 1
high = x[0]
low = x[0]
for i in range (0,7):
    print "%d: %7d %.5f" % (i, x[i], 100.0 * x[i] / tt)
    if x[i] < low:
        low = x[i]
    if x[i] > high:
        high = x[i]
diff = high - low
print "Variation = %d (%.5f%%)" % (diff, 100.0 * diff / tt)

E questo output mostra i risultati:

pax$ python qq.py
0:   99908 14.27257
1:  100029 14.28986
2:  100327 14.33243
3:  100395 14.34214
4:   99104 14.15771
5:   99829 14.26129
6:  100408 14.34400
Variation = 1304 (0.18629%)

pax$ python qq.py
0:   99547 14.22100
1:  100229 14.31843
2:  100078 14.29686
3:   99451 14.20729
4:  100284 14.32629
5:  100038 14.29114
6:  100373 14.33900
Variation = 922 (0.13171%)

pax$ python qq.py
0:  100481 14.35443
1:   99188 14.16971
2:  100284 14.32629
3:  100222 14.31743
4:   99960 14.28000
5:   99426 14.20371
6:  100439 14.34843
Variation = 1293 (0.18471%)

Un semplicistico rand(5)+rand(5), ignorando quei casi in cui questo restituisce più di 6 ha una variazione tipica del 18%, 100 volte quella del metodo mostrato sopra:

pax$ python qq_notsogood.py
0:   31756 4.53657
1:   63304 9.04343
2:   95507 13.64386
3:  127825 18.26071
4:  158851 22.69300
5:  127567 18.22386
6:   95190 13.59857
Variation = 127095 (18.15643%)

pax$ python qq_notsogood.py
0:   31792 4.54171
1:   63637 9.09100
2:   95641 13.66300
3:  127627 18.23243
4:  158751 22.67871
5:  126782 18.11171
6:   95770 13.68143
Variation = 126959 (18.13700%)

pax$ python qq_notsogood.py
0:   31955 4.56500
1:   63485 9.06929
2:   94849 13.54986
3:  127737 18.24814
4:  159687 22.81243
5:  127391 18.19871
6:   94896 13.55657
Variation = 127732 (18.24743%)

E, su consiglio di Nixuz, ho ripulito lo script in modo da poter estrarre e usare le rand7...cose:

import random

# rand5() returns 0 through 4 inclusive.

def rand5():
    return int (random.random () * 5)

# rand7() generator returns 0 through 6 inclusive (using rand5()).

def rand7():
    rand7ret = 0
    while True:
        rand7ret = (rand7ret + rand5()) % 7
        yield rand7ret

# Number of test runs.

count = 700000

# Work out distribution.

distrib = [0,0,0,0,0,0,0]
rgen =rand7()
for i in range (0,count):
    r = rgen.next()
    distrib[r] = distrib[r] + 1

# Print distributions and calculate variation.

high = distrib[0]
low = distrib[0]
for i in range (0,7):
    print "%d: %7d %.5f" % (i, distrib[i], 100.0 * distrib[i] / count)
    if distrib[i] < low:
        low = distrib[i]
    if distrib[i] > high:
        high = distrib[i]
diff = high - low
print "Variation = %d (%.5f%%)" % (diff, 100.0 * diff / count)

Questa risposta è più un esperimento per ottenere la massima entropia dalla funzione Rand5. È quindi un po 'poco chiaro e quasi sicuramente molto più lento di altre implementazioni.

Supponendo la distribuzione uniforme da 0-4 e la distribuzione uniforme risultante da 0-6:

public class SevenFromFive
{
  public SevenFromFive()
  {
    // this outputs a uniform ditribution but for some reason including it 
    // screws up the output distribution
    // open question Why?
    this.fifth = new ProbabilityCondensor(5, b => {});
    this.eigth = new ProbabilityCondensor(8, AddEntropy);
  } 

  private static Random r = new Random();
  private static uint Rand5()
  {
    return (uint)r.Next(0,5);
  }

  private class ProbabilityCondensor
  {
    private readonly int samples;
    private int counter;
    private int store;
    private readonly Action<bool> output;

    public ProbabilityCondensor(int chanceOfTrueReciprocal,
      Action<bool> output)
    {
      this.output = output;
      this.samples = chanceOfTrueReciprocal - 1;  
    }

    public void Add(bool bit)
    {
      this.counter++;
      if (bit)
        this.store++;   
      if (counter == samples)
      {
        bool? e;
        if (store == 0)
          e = false;
        else if (store == 1)
          e = true;
        else
          e = null;// discard for now       
        counter = 0;
        store = 0;
        if (e.HasValue)
          output(e.Value);
      }
    }
  }

  ulong buffer = 0;
  const ulong Mask = 7UL;
  int bitsAvail = 0;
  private readonly ProbabilityCondensor fifth;
  private readonly ProbabilityCondensor eigth;

  private void AddEntropy(bool bit)
  {
    buffer <<= 1;
    if (bit)
      buffer |= 1;      
    bitsAvail++;
  }

  private void AddTwoBitsEntropy(uint u)
  {
    buffer <<= 2;
    buffer |= (u & 3UL);    
    bitsAvail += 2;
  }

  public uint Rand7()
  {
    uint selection;   
    do
    {
      while (bitsAvail < 3)
      {
        var x = Rand5();
        if (x < 4)
        {
          // put the two low order bits straight in
          AddTwoBitsEntropy(x);
          fifth.Add(false);
        }
        else
        { 
          fifth.Add(true);
        }
      }
      // read 3 bits
      selection = (uint)((buffer & Mask));
      bitsAvail -= 3;     
      buffer >>= 3;
      if (selection == 7)
        eigth.Add(true);
      else
        eigth.Add(false);
    }
    while (selection == 7);   
    return selection;
  }
}

Il numero di bit aggiunti al buffer per chiamata a Rand5 è attualmente 4/5 * 2, quindi 1.6. Se viene incluso il valore di probabilità 1/5 che aumenta di 0,05, quindi 1,65, ma vedere il commento nel codice in cui ho dovuto disabilitare questo.

Bit consumati per chiamata a Rand7 = 3 + 1/8 * (3 + 1/8 * (3 + 1/8 * (...
Questo è 3 + 3/8 + 3/64 + 3/512 ... quindi circa 3,42

Estraendo le informazioni dai sette richiedo 1/8 * 1/7 bit per chiamata, quindi circa 0,018

Ciò fornisce un consumo netto di 3,4 bit per chiamata, il che significa che il rapporto è 2,125 chiamate a Rand5 per ogni Rand7. L'ottimale dovrebbe essere 2.1.

Immagino che questo approccio sia significativamente più lento di molti altri qui a meno che il costo della chiamata a Rand5 non sia estremamente costoso (diciamo che chiamare una fonte esterna di entropia).

in php

function rand1to7() {
    do {
        $output_value = 0;
        for ($i = 0; $i < 28; $i++) {
            $output_value += rand1to5();
        }
    while ($output_value != 140);
    $output_value -= 12;
    return floor($output_value / 16);
}

esegue un ciclo per produrre un numero casuale compreso tra 16 e 127, si divide per sedici per creare un float tra 1 e 7,9375, quindi arrotonda per ottenere un int tra 1 e 7. Se non sbaglio, c'è una possibilità 16/112 di ottenere uno dei 7 risultati.

extern int r5();

int r7() {
    return ((r5() & 0x01) << 2 ) | ((r5() & 0x01) << 1 ) | (r5() & 0x01);
}

Penso di avere quattro risposte, due che danno soluzioni esatte come quella di @Adam Rosenfield ma senza il problema del loop infinito, e altre due con una soluzione quasi perfetta ma un'implementazione più veloce della prima.

La migliore soluzione esatta richiede 7 chiamate a rand5, ma consente di procedere per capire.

Metodo 1 - Esatto

Il punto di forza della risposta di Adam è che fornisce una distribuzione uniforme perfetta, e c'è un'altissima probabilità (21/25) che saranno necessarie solo due chiamate a rand5 (). Tuttavia, il caso peggiore è loop infinito.

La prima soluzione di seguito fornisce anche una distribuzione uniforme perfetta, ma richiede un totale di 42 chiamate rand5. Nessun loop infinito.

Ecco un'implementazione R:

rand5 <- function() sample(1:5,1)

rand7 <- function()  (sum(sapply(0:6, function(i) i + rand5() + rand5()*2 + rand5()*3 + rand5()*4 + rand5()*5 + rand5()*6)) %% 7) + 1

Per le persone che non hanno familiarità con R, ecco una versione semplificata:

rand7 = function(){
  r = 0 
  for(i in 0:6){
    r = r + i + rand5() + rand5()*2 + rand5()*3 + rand5()*4 + rand5()*5 + rand5()*6
  }
  return r %% 7 + 1
}

La distribuzione di rand5sarà preservata. Se facciamo la matematica, ognuna delle 7 iterazioni del loop ha 5 ^ 6 possibili combinazioni, quindi il numero totale di possibili combinazioni sono (7 * 5^6) %% 7 = 0. Quindi possiamo dividere i numeri casuali generati in gruppi uguali di 7. Vedi il metodo due per ulteriori discussioni su questo.

Ecco tutte le possibili combinazioni:

table(apply(expand.grid(c(outer(1:5,0:6,"+")),(1:5)*2,(1:5)*3,(1:5)*4,(1:5)*5,(1:5)*6),1,sum) %% 7 + 1)

    1     2     3     4     5     6     7 
15625 15625 15625 15625 15625 15625 15625 

Penso che sia semplice dimostrare che il metodo di Adam verrà eseguito molto più velocemente. La probabilità che ci siano 42 o più chiamate a rand5nella soluzione di Adam è molto piccola ( (4/25)^21 ~ 10^(-17)).

Metodo 2 - Non Esatto

Ora il secondo metodo, che è quasi uniforme, ma richiede 6 chiamate a rand5:

rand7 <- function() (sum(sapply(1:6,function(i) i*rand5())) %% 7) + 1

Ecco una versione semplificata:

rand7 = function(){
  r = 0 
  for(i in 1:6){
    r = r + i*rand5()
  }
  return r %% 7 + 1
}

Questa è essenzialmente un'iterazione del metodo 1. Se generiamo tutte le possibili combinazioni, ecco i conteggi risultanti:

table(apply(expand.grid(1:5,(1:5)*2,(1:5)*3,(1:5)*4,(1:5)*5,(1:5)*6),1,sum) %% 7 + 1)

   1    2    3    4    5    6    7 
2233 2232 2232 2232 2232 2232 2232

Un numero apparirà ancora una volta nelle 5^6 = 15625prove.

Ora, nel Metodo 1, aggiungendo da 1 a 6, spostiamo il numero 2233 in ciascuno dei punti successivi. Pertanto, il numero totale di combinazioni corrisponderà. Questo funziona perché 5 ^ 6 %% 7 = 1, e quindi facciamo 7 variazioni appropriate, quindi (7 * 5 ^ 6 %% 7 = 0).

Metodo 3 - Esatto

Se l'argomento del metodo 1 e 2 è compreso, il metodo 3 segue e richiede solo 7 chiamate rand5. A questo punto, ritengo che questo sia il numero minimo di chiamate necessarie per una soluzione esatta.

Ecco un'implementazione R:

rand5 <- function() sample(1:5,1)

rand7 <- function()  (sum(sapply(1:7, function(i) i * rand5())) %% 7) + 1

Per le persone che non hanno familiarità con R, ecco una versione semplificata:

rand7 = function(){
  r = 0 
  for(i in 1:7){
    r = r + i * rand5()
  }
  return r %% 7 + 1
}

La distribuzione di rand5sarà preservata. Se facciamo la matematica, ognuna delle 7 iterazioni del ciclo ha 5 possibili esiti, quindi il numero totale di possibili combinazioni lo sono (7 * 5) %% 7 = 0. Quindi possiamo dividere i numeri casuali generati in gruppi uguali di 7. Vedi il metodo uno e due per ulteriori discussioni su questo.

Ecco tutte le possibili combinazioni:

table(apply(expand.grid(0:6,(1:5)),1,sum) %% 7 + 1)

1 2 3 4 5 6 7  
5 5 5 5 5 5 5 

Penso che sia semplice dimostrare che il metodo di Adam sarà ancora più veloce. La probabilità che ci siano 7 o più chiamate a rand5nella soluzione di Adam è ancora piccola ( (4/25)^3 ~ 0.004).

Metodo 4 - Non esatto

Questa è una variante minore del secondo metodo. È quasi uniforme, ma richiede 7 chiamate a rand5, che è un'ulteriore al metodo 2:

rand7 <- function() (rand5() + sum(sapply(1:6,function(i) i*rand5())) %% 7) + 1

Ecco una versione semplificata:

rand7 = function(){
  r = 0 
  for(i in 1:6){
    r = r + i*rand5()
  }
  return (r+rand5()) %% 7 + 1
}

Se generiamo tutte le possibili combinazioni, ecco i conteggi risultanti:

table(apply(expand.grid(1:5,(1:5)*2,(1:5)*3,(1:5)*4,(1:5)*5,(1:5)*6,1:5),1,sum) %% 7 + 1)

    1     2     3     4     5     6     7 
11160 11161 11161 11161 11161 11161 11160

Due numeri appariranno una volta in meno nelle 5^7 = 78125prove. Per molti scopi, posso conviverci.

La funzione di cui hai bisogno è rand1_7 () , ho scritto rand1_5 () in modo che tu possa testarlo e tracciarlo.

import numpy
def rand1_5():
    return numpy.random.randint(5)+1

def rand1_7():
    q = 0
    for i in xrange(7):  q+= rand1_5()
    return q%7 + 1