З огляду на функцію, яка виробляє випадкове ціле число в діапазоні від 1 до 5, запишіть функцію, яка виробляє випадкове ціле число в діапазоні від 1 до 7.

1. Що таке просте рішення?
2. Що є ефективним рішенням для зменшення використання пам'яті або роботи на повільному процесорі?

Це еквівалентно рішенню Адама Розенфілда, але може бути дещо зрозумілішим для деяких читачів. Він передбачає, що rand5 () - це функція, яка повертає статистично випадкове ціле число в діапазоні від 1 до 5 включно.

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;
}

Як це працює? Подумайте про це так: уявіть собі, як роздрукувати цей двовимірний масив на папері, прив’язавши його до дошки з дартсом і випадково кидаючи на неї дротики. Якщо ви потрапили на ненульове значення, це статистично випадкове значення між 1 і 7, оскільки для вибору є рівне число ненульових значень. Якщо ви потрапили в нуль, просто продовжуйте кидати дротик, поки не потрапите на нуль. Ось що робить цей код: індекси i та j випадковим чином вибирають місце на дошці дартса, і якщо ми не отримаємо хорошого результату, ми продовжуємо кидати дартс.

Як сказав Адам, у гіршому випадку це може тривати вічно, але статистично найгірший випадок ніколи не буває. :)

Немає (точно правильного) рішення, яке працюватиме за постійну кількість часу, оскільки 1/7 - це нескінченний десятковий знак у базі 5. Одним простим рішенням буде використання вибірки відхилення, наприклад:

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

Це очікуване час виконання 25/21 = 1,19 ітерацій циклу, але існує нескінченно мало мала ймовірність циклу назавжди.

Я хотів би додати ще одну відповідь, окрім своєї першої відповіді . Ця відповідь намагається мінімізувати кількість дзвінків на rand5()один дзвінок rand7(), щоб максимально використовувати випадковість. Тобто, якщо ви розглядаєте випадковість як дорогоцінний ресурс, ми хочемо використовувати якомога більше його, не відкидаючи жодних випадкових біт. Ця відповідь також має деякі подібності з логікою, представленою в відповіді Івана .

Ентропія випадкової величини є добре визначеною величиною. Для випадкової змінної, яка приймає N станів з однаковими ймовірностями (рівномірний розподіл), ентропія являє собою log ₂ N. Таким чином, rand5()має приблизно 2.32193 біт ентропії та rand7()має приблизно 2.80735 біт ентропії. Якщо ми сподіваємося максимально використати випадковість, нам потрібно використовувати всі 2.32193 біти ентропії від кожного виклику до rand5()та застосувати їх для отримання 2.80735 біт ентропії, необхідних для кожного дзвінка rand7(). Принциповим обмеженням є те, що ми можемо робити не краще, ніж log (7) / log (5) = 1.20906 викликівrand5() один виклик rand7().

Бічні примітки: усі логарифми у цій відповіді будуть базою 2, якщо не вказано інше. rand5()буде прийнято повертати числа в діапазоні [0, 4], і rand7()буде прийнято повертати числа в діапазоні [0, 6]. Регулювання діапазонів у [1, 5] та [1, 7] відповідно тривіально.

То як нам це зробити? Ми генеруємо нескінченно точне випадкове дійсне число між 0 і 1 (зробимо вигляд, що ми могли насправді обчислити і зберегти таке нескінченно точне число - це ми виправимо пізніше). Ми можемо генерувати таке число, генеруючи його цифри в базі 5: ми вибираємо випадкове число 0. a₁ a₂ a₃ ..., де кожна цифра а _iвибирається викликом до rand5(). Наприклад, якщо наш RNG обрав a _i= 1 для всіх i, то ігноруючи той факт, що це не дуже випадково, це відповідало б дійсному номеру 1/5 + 1/5 ² + 1/5 ³ + ... = 1/4 (сума геометричного ряду).

Гаразд, тому ми вибрали випадкове дійсне число між 0 і 1. Зараз я стверджую, що таке випадкове число розподілено рівномірно. Інтуїтивно це зрозуміти легко, оскільки кожна цифра була підібрана рівномірно, а число нескінченно точне. Однак формальне підтвердження цього дещо більше, оскільки зараз ми маємо справу з безперервним розподілом замість дискретного розподілу, тому нам потрібно довести, що ймовірність того, що наше число лежить в інтервалі [a , b], дорівнює довжині цей інтервал,b - a . Доведення залишається як вправа для читача =).

Тепер, коли у нас є випадкове дійсне число, вибране рівномірно з діапазону [0, 1], нам потрібно перетворити його в ряд рівномірно випадкових чисел у діапазоні [0, 6], щоб генерувати вихід rand7() . Як ми це робимо? Просто зворотний результат того, що ми тільки що зробили - ми перетворюємо його в нескінченно точний десятковий знак у базі 7, і тоді кожна 7-цифрова база буде відповідати одному виходуrand7() .

Беручи приклад з попереднього, якщо наш rand5() виробляють нескінченний потік 1, то наше випадкове дійсне число буде 1/4. Перетворивши 1/4 в базу 7, ми отримаємо нескінченний десятковий 0,15151515 ..., тому ми отримаємо як вихід 1, 5, 1, 5, 1, 5 і т.д.

Гаразд, у нас є основна ідея, але у нас залишилися дві проблеми: ми насправді не можемо обчислити або зберегти нескінченно точне дійсне число, так як ми маємо справу з лише кінцевою його частиною? По-друге, як насправді перетворити його на базу 7?

Один із способів перетворення числа між 0 і 1 в базу 7 полягає в наступному:

1. Помножте на 7
2. Невід’ємною частиною результату є наступна основна 7 цифра
3. Відніміть цілісну частину, залишивши лише дробову частину
4. Перехід до кроку 1

Для вирішення проблеми нескінченної точності ми обчислюємо частковий результат, а також зберігаємо верхню межу того, яким може бути результат. Тобто, припустимо, ми зателефонували rand5()двічі, і він повернувся 1 обидва рази. Поки що ми створили 0,11 (основа 5). Незалежно від решти нескінченних серій викликів, які ми rand5()виробляємо, випадкове дійсне число, яке ми генеруємо, ніколи не буде більшим за 0,12: завжди вірно, що 0,11 ≤ 0,11xyz ... <0,12.

Отже, відслідковуючи поточне число дотепер і максимальне значення, яке воно може колись прийняти, ми перетворюємо обидва числа в базові 7. Якщо вони погоджуються на перші kцифри, то ми можемо сміливо виводити наступні kцифри - незалежно від того, що нескінченний потік базових 5 цифр є, вони ніколи не впливатимуть на наступні kцифри представлення бази 7!

І ось алгоритм - щоб генерувати наступний висновок rand7(), ми генеруємо лише стільки цифр, rand5()скільки нам потрібно для того, щоб ми з певністю знали значення наступної цифри при перетворенні випадкового реального числа в базу 7. Ось реалізація Python із тестовим джгутом:

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)

Зверніть увагу, що rand7_gen()повертає генератор, оскільки він має внутрішній стан, що включає перетворення числа в базу 7. Тестовий джгут викликає next(r7)10000 разів для отримання 10000 випадкових чисел, а потім вимірює їх розподіл. Використовується лише ціла математика, тому результати точно правильні.

Також зауважте, що цифри тут стають дуже великими, дуже швидкими. Повноваження 5 і 7 швидко ростуть. Отже, продуктивність почне помітно погіршуватися після генерації безлічі випадкових чисел через арифметику біньюма. Але пам’ятайте тут, моя мета полягала в тому, щоб максимально використовувати випадкові біти, а не максимізувати продуктивність (хоча це вторинна мета).

За один проміжок цього я здійснив 12091 виклик rand5()для 10000 дзвінків rand7(), досягнувши мінімуму дзвінків журналу (7) / журналу (5) в середньому до 4 значущих цифр, і отриманий результат був рівномірним.

Щоб перенести цей код на мову, яка не має довільно великих цілих чисел, вам доведеться обмежувати значення pow5та pow7максимальне значення вашого рідного інтегрального типу - якщо вони занадто великі, то скиньте все і почніть спочатку. Це збільшить середню кількість дзвінків rand5()на виклик rand7()дуже незначно, але, сподіваємось, він не повинен надто збільшуватися навіть для 32- або 64-бітних цілих чисел.

(Я вкрав відповідь Адама Розенфельда і змусив його працювати приблизно на 7% швидше.)

Припустимо, що rand5 () повертає один із {0,1,2,3,4} з рівним розподілом, а мета - поверненням {0,1,2,3,4,5,6} з рівним розподілом.

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

Ми відслідковуємо найбільше значення, яке цикл може внести у змінну max. Якщо поки що результат відхилення від максимального% 7 до max-1, результат буде рівномірно розподілений у цьому діапазоні. Якщо ні, ми використовуємо залишок, який є випадковим значенням між 0 і макс.% 7-1, та інший виклик rand (), щоб створити нове число та новий макс. Тоді ми починаємо знову.

Редагувати: очікуйте, що кількість разів викликати rand5 () буде x у цьому рівнянні:

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()

Алгоритм:

7 може бути представлений у послідовності з 3 біт

Використовуйте rand (5), щоб випадковим чином заповнити кожен біт 0 або 1.
Наприклад: виклик rand (5) та

якщо результат 1 або 2, заповніть біт 0,
якщо результат 4 або 5, залийте біт 1,
якщо результат 3, ігноруйте і повторіть це (відмова)

Таким чином ми можемо заповнити 3 біти випадковим чином 0/1 і таким чином отримати число від 1-7.

EDIT: Це здається найпростішою та найефективнішою відповіддю, ось ось який код:

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

Правка: Це не зовсім працює. Він вимикається приблизно на 2 частини в 1000 (припускаючи ідеальний rand5). Відра отримують:

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

Перейшовши на суму

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

схоже, набирає порядку на кожен 2 додані

BTW: наведена вище таблиця помилок не була створена за допомогою вибірки, а за допомогою наступного відношення:

p[x,n]це кількість способів, за якими output=xможна nтелефонувати 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
     }
}

Далі виробляється рівномірний розподіл на {1, 2, 3, 4, 5, 6, 7} з використанням генератора випадкових чисел, що виробляє рівномірний розподіл на {1, 2, 3, 4, 5}. Код безладний, але логіка зрозуміла.

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;
}

На відміну від обраного рішення, алгоритм буде працювати в постійному часі. Однак він робить ще 2 виклики на rand5, ніж середній час роботи вибраного рішення.

Зауважте, що цей генератор не є ідеальним (число 0 має 0,0064% більше шансів, ніж будь-яке інше число), але для більшості практичних цілей гарантія постійного часу, ймовірно, переважає цю неточність.

Пояснення

Це рішення випливає з того, що число 15 624 ділиться на 7, і, якщо ми можемо випадково та рівномірно генерувати числа від 0 до 15 624, а потім взяти mod 7, ми можемо отримати майже рівномірний генератор rand7. Числа від 0 до 15 624 можна рівномірно генерувати прокручуванням rand5 6 разів та використовуючи їх для формування цифр базового числа 5 таким чином:

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

Однак властивості моди 7 дозволяють нам трохи спростити рівняння:

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

Тому

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

стає

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

Теорія

Число 15 624 було обрано не випадковим чином, але його можна виявити, використовуючи маленьку теорему Ферма, яка стверджує, що якщо p - просте число, то

a^(p-1) = 1 mod p

Отже, це дає нам,

(5^6)-1 = 0 mod 7

(5 ^ 6) -1 дорівнює

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

Це число в базовій формі 5, і тому ми можемо бачити, що цей метод може бути використаний для переходу від будь-якого генератора випадкових чисел до будь-якого іншого генератора випадкових чисел. Хоча при використанні експонента p-1 завжди вводиться невеликий ухил до 0.

Щоб узагальнити цей підхід і бути більш точним, ми можемо мати таку функцію:

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)

Чи дозволені проблеми домашнього завдання тут?

Ця функція виконує неочищену математику "5 базових", щоб генерувати число між 0 і 6.

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

Якщо ми розглянемо додаткове обмеження спроби дати найбільш ефективну відповідь, тобто таку, яка задала вхідний потік, Iз рівномірно розподілених цілих чисел довжиною mвід 1-5 виводить потік O, рівномірно розподілених цілих чисел від 1-7 найдовшої відносної довжини до m, скажімо L(m).

Найпростіший спосіб проаналізувати це - трактувати потоки I та O5-арійні та 7-арі числа відповідно. Це досягається ідеєю основної відповіді взяти потік a1, a2, a3,... -> a1+5*a2+5^2*a3+..і аналогічно для потоку O.

Тоді, якщо ми візьмемо ділянку вхідного потоку довжиною, m choose n s.t. 5^m-7^n=cде c>0і як можна менше. Тоді є рівномірна карта від вхідного потоку довжиною m до цілих чисел від 1до 5^mта ще одна рівномірна карта від цілих чисел від 1 до 7^nвихідного потоку довжини n, де нам, можливо, доведеться втратити кілька випадків із вхідного потоку, коли відображене ціле число перевищує 7^n.

Таким чином, це дає значення, L(m)навколо m (log5/log7)якого приблизно .82m.

Труднощі наведеного вище аналізу є рівняння , 5^m-7^n=cяке так легко вирішити точно і випадок , коли однорідне значення від 1до 5^mперевищує 7^nі ми втрачаємо ефективність.

Питання полягає в тому, наскільки близьким до найкращого можливого значення m (log5 / log7) можна досягти. Наприклад, коли це число наближається до цілого числа, чи можемо ми знайти спосіб досягти цього точного інтегрального числа вихідних значень?

Якщо 5^m-7^n=cтоді з вхідного потоку ми ефективно генеруємо рівномірне випадкове число від 0до (5^m)-1та не використовуємо значення, що перевищує значення 7^n. Однак ці значення можна врятувати і використовувати знову. Вони ефективно генерують єдину послідовність чисел від 1 до 5^m-7^n. Тоді ми можемо спробувати використовувати їх і перетворити їх у 7-річні числа, щоб ми могли створити більше вихідних значень.

Якщо допустимо T7(X)середню довжину вихідної послідовності random(1-7)цілих чисел, отриману з рівномірного введення розміру X, і припускаючи це 5^m=7^n0+7^n1+7^n2+...+7^nr+s, s<7.

Тоді T7(5^m)=n0x7^n0/5^m + ((5^m-7^n0)/5^m) T7(5^m-7^n0)оскільки у нас немає довжини без послідовності з ймовірністю 7 ^ n0 / 5 ^ m з залишком довжини 5^m-7^n0з ймовірністю (5^m-7^n0)/5^m).

Якщо ми просто продовжуємо замінювати, ми отримуємо:

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

Звідси

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

Ще один спосіб цього:

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)

Найкращий можливий випадок - мій оригінал вище, де 5^m=7^n+s, де s<7.

Тоді T7(5^m) = nx(7^n)/(7^n+s) = n+o(1) = m (Log5/Log7)+o(1)як і раніше.

Найгірший випадок, коли ми можемо знайти лише k і st 5 ^ m = kx7 + s.

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

Інші випадки десь між ними. Було б цікаво побачити, наскільки добре ми можемо зробити для дуже великих m, тобто наскільки добре ми можемо отримати термін помилки:

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

e(m) = o(1)Загалом це здається неможливим, але, сподіваємось, ми зможемо довести e(m)=o(m).

Потім вся річ спирається на розподіл 7-річних цифр 5^mдля різних значень m.

Я впевнений, що існує багато теорії, яка висвітлює це, я можу поглянути і доповісти в якийсь момент.

Ось робоча реалізація відповіді Адама на Python .

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

Мені подобається кидати алгоритми, на які я дивлюся в Python, щоб я міг пограти з ними, подумав, що опублікую його тут, сподіваючись, що комусь це корисно, а не тому, що спіткати потрібно багато часу.

Чому б не зробити це просто?

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

Шанси отримати 1 і 7 у цьому рішенні нижчі через модуль, однак, якщо ви просто хочете швидкого та читаного рішення, це шлях.

Якщо припустити, що rand (n) тут означає "випадкове ціле число в рівномірному розподілі від 0 до n-1 ", ось зразок коду з використанням рандінта Python, який має такий ефект. Він використовує лише randint (5) та константи для отримання ефекту randint (7) . Насправді трохи нерозумно

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

Припущення за правильною відповіддю Адама Розенфілда:

• x = 5 ^ n (у його випадку: n = 2)
• маніпулювати n rand5-дзвінками, щоб отримати число y в межах [1, x]
• z = ((int) (x / 7)) * 7
• якщо y> z, спробуйте ще раз. інше повернути y% 7 + 1

Коли n дорівнює 2, у вас є 4 можливості викидання: y = {22, 23, 24, 25}. Якщо ви використовуєте n дорівнює 6, у вас є лише 1 викид: y = {15625}.

5 ^ 6 = 15625
7 * 2232 = 15624

Ви дзвоните rand5 більше разів. Однак у вас є набагато менший шанс отримати значення викидання (або нескінченну петлю). Якщо є спосіб отримати неможливе значення викидання для y, я його ще не знайшов.

Ось моя відповідь:

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

Це трохи складніше, ніж інші, але я вважаю, що це мінімізує виклики до rand5. Як і в інших рішеннях, є невелика ймовірність, що це може тривалий час циклічно.

Простий та ефективний:

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

(Натхненний Вашим улюбленим мультфільмом "програміст"? ).

Поки на вибір не залишилося семи можливостей, намалюйте ще одне випадкове число, яке помножить число можливостей на п'ять. У 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;
}

Мені не подобаються діапазони починаючи з 1, тому я почну з 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;
}

Там ви їдете, рівномірний розподіл і нульові дзвінки rand5.

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

Потрібно заздалегідь встановити насіння.

Я знаю, що на нього відповіли, але це здається, що це нормально, але я не можу сказати, чи має він упередженість. Моє "тестування" припускає, що принаймні розумне.

Можливо, Адам Розенфілд був би добрим, щоб прокоментувати?

Моя (наївна?) Ідея така:

Накопичуйте rand5, поки не буде достатньо випадкових біт, щоб зробити rand7. Це займає максимум 2 rand5. Для отримання числа rand7 я використовую накопичене значення mod 7.

Щоб уникнути переповнення акумулятора, а оскільки акумулятор моди 7, я беру мод 7 акумулятора:

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

Функція rand7 () наступна:

(Я дозволяю діапазону rand5 бути 0-4, а rand7 - так само 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;
}

Редагувати: додано результати для 100 мільйонів випробувань.

'Реальні' функції rand mod 5 або 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

Мій rand7

Середнє виглядає нормально, і кількість розподілів також виглядає нормально.

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

Наведені вище елегантні алгоритми, але ось один із способів наблизитись до цього, хоча це може бути круговим. Я припускаю значення, породжені від 0.

R2 = генератор випадкових чисел, що дає значення менше 2 (простір вибірки = {0, 1})
R8 = генератор випадкових чисел, що дає значення менше 8 (простір вибірки = {0, 1, 2, 3, 4, 5, 6, 7 })

Для того, щоб генерувати R8 з R2, ви будете запускати R2 тричі і використовувати комбінований результат усіх 3 прогонів як двійкове число з 3 цифрами. Ось діапазон значень, коли R2 проводиться тричі:

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

Тепер для генерації R7 з R8 ми просто запускаємо R7 знову, якщо він повертає 7:

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

Рішення навколо кола - генерувати R2 з R5 (так само, як ми генерували R7 з R8), потім R8 з R2, а потім R7 з R8.

Ось рішення, яке повністю вписується в цілі числа і знаходиться в межах приблизно 4% від оптимальних (тобто використовує 1,26 випадкових чисел у {0..4} для кожного з {0..6}). Код в Scala, але математика повинна бути чітко зрозумілою будь-якою мовою: ви скористаєтеся тим, що 7 ^ 9 + 7 ^ 8 дуже близький до 5 ^ 11. Таким чином, ви вибираєте 11-значне число в базі 5, а потім інтерпретуєте його як 9-значний номер у базі 7, якщо він знаходиться в діапазоні (даючи 9 базових 7 чисел), або як 8-значний номер, якщо він перевищує 9-значний номер тощо. .:

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

Якщо вставити тест в інтерпретатор (фактично REPL), ви отримаєте:

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

Розподіл є приємним і рівним (у межах приблизно 10 к 1/7 від 10 ^ 8 у кожному відро, як і очікувалося від приблизно-гаусського розподілу).

За допомогою загальної сукупності , ви можете обидва

• підтримувати рівний розподіл; і
• не доведеться жертвувати жодним елементом у випадковій послідовності.

Обидві ці проблеми є проблемою із спрощеним rand(5)+rand(5)...типом рішення. У наступному коді Python показано, як його реалізувати (більшість із них доводить розподіл).

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)

І цей результат показує результати:

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%)

Спрощений rand(5)+rand(5), ігнорування тих випадків, коли цей показник повертає більше 6, має типову відхилення в 18%, в 100 разів більше, ніж метод, показаний вище:

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%)

І за порадою Nixuz я очистив сценарій, щоб ви могли просто витягнути та використати rand7...речі:

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)

Ця відповідь є скоріше експериментом із отримання максимально можливої ​​ентропії за допомогою функції Rand5. Отже, t дещо незрозуміло і майже напевно набагато повільніше, ніж інші реалізації.

Припускаючи рівномірний розподіл від 0-4 і результуючий рівномірний розподіл від 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;
  }
}

Кількість бітів, доданих до буфера за виклик до Rand5, наразі становить 4/5 * 2, так що 1.6. Якщо включено значення ймовірності 1/5, що збільшується на 0,05, тому 1,65, але дивіться коментар у коді, де мені довелося це відключити.

Біти, спожиті при виклику до Rand7 = 3 + 1/8 * (3 + 1/8 * (3 + 1/8 * (...
Це 3 + 3/8 + 3/64 + 3/512 ... так приблизно 3,42

Витягуючи інформацію із сімки, я повертаю 1/8 * 1/7 біт за виклик, тобто приблизно 0,018

Це дає чисте споживання 3,4 біта на виклик, тобто коефіцієнт становить 2,125 викликів до Rand5 за кожен Rand7. Оптимум повинен бути 2,1.

Я думаю, що цей підхід значно повільніше, ніж у багатьох інших тут, якщо вартість дзвінка до Rand5 не є надзвичайно дорогою (скажімо, виклик до якогось зовнішнього джерела ентропії).

в 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);
}

циклів для отримання випадкового числа між 16 і 127, ділиться на шістнадцять, щоб створити поплавок між 1 і 7.9375, потім обводиться вниз, щоб отримати int між 1 і 7. Якщо я не помиляюся, є шанс отримати 16/112 будь-який із 7 результатів.

extern int r5();

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

Я думаю, що у мене є чотири відповіді, два дають точні рішення, як рішення @Adam Rosenfield, але без нескінченної проблеми циклу, а інші два з майже ідеальним рішенням, але швидше реалізуються, ніж перший.

Найкраще точне рішення вимагає 7 дзвінків rand5, але давайте продовжуємо, щоб зрозуміти.

Спосіб 1 - Точний

Сила відповіді Адама полягає в тому, що він дає ідеальний рівномірний розподіл, і існує дуже висока ймовірність (21/25), що будуть потрібні лише два дзвінки на rand5 (). Однак найгірший випадок - нескінченна петля.

Перше рішення нижче також забезпечує ідеальний рівномірний розподіл, але вимагає в цілому 42 дзвінки rand5. Немає нескінченних петель.

Ось реалізація 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

Для людей, які не знайомі з R, ось спрощена версія:

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
}

Поширення rand5буде збережено. Якщо ми робимо математику, кожна з 7 ітерацій циклу має 5 ^ 6 можливих комбінацій, таким чином, загальна кількість можливих комбінацій є (7 * 5^6) %% 7 = 0. Таким чином, ми можемо розділити випадкові числа, згенеровані на рівні групи 7. Дивіться метод другий для більшого обговорення цього питання.

Ось всі можливі комбінації:

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 

Я думаю, що прямо вперед показати, що метод Адама буде працювати набагато швидше. Ймовірність наявності rand5у рішенні Адама 42 або більше дзвінків дуже мала ( (4/25)^21 ~ 10^(-17)).

Спосіб 2 - Неточний

Тепер другий метод, майже однорідний, але вимагає 6 дзвінків rand5:

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

Ось спрощена версія:

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

Це по суті одна ітерація методу 1. Якщо ми генеруємо всі можливі комбінації, тут підраховується підрахунок:

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

Одне число з’явиться ще раз у 5^6 = 15625випробуваннях.

Тепер у способі 1, додавши 1 до 6, переносимо число 2233 до кожної послідовної точки. Таким чином, загальна кількість комбінацій збігатиметься. Це працює тому, що 5 ^ 6 %% 7 = 1, а потім робимо 7 відповідних варіацій, тому (7 * 5 ^ 6 %% 7 = 0).

Спосіб 3 - Точний

Якщо аргументи методів 1 і 2 зрозумілі, слід метод 3 і вимагає лише 7 викликів до rand5. На даний момент я відчуваю, що це мінімальна кількість дзвінків, необхідних для точного рішення.

Ось реалізація R:

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

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

Для людей, які не знайомі з R, ось спрощена версія:

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

Поширення rand5буде збережено. Якщо ми робимо математику, кожна з 7 ітерацій циклу має 5 можливих результатів, тому загальна кількість можливих комбінацій є (7 * 5) %% 7 = 0. Таким чином, ми можемо розділити випадкові числа, згенеровані на рівні групи 7. Дивіться метод один і два для більшого обговорення цього питання.

Ось всі можливі комбінації:

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 

Я думаю, що прямо вперед показати, що метод Адама все одно буде працювати швидше. Ймовірність наявності rand5у рішенні Адама 7 або більше дзвінків все ще невелика ( (4/25)^3 ~ 0.004).

Метод 4 - Неточний

Це незначна варіація другого способу. Він майже рівномірний, але вимагає 7 дзвінків rand5, тобто один із додаткових методів 2:

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

Ось спрощена версія:

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

Якщо ми генеруємо всі можливі комбінації, ось такі підрахунки:

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

Два числа з’являться один раз менше у 5^7 = 78125випробуваннях. Для більшості цілей я можу з цим жити.

Вам потрібна функція rand1_7 () , я написав rand1_5 (), щоб ви могли її протестувати та побудувати.

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