Наиболее эффективный алгоритм печати 1-100 с использованием заданного генератора случайных чисел

Нам дан генератор случайных чисел, RandNum50который генерирует случайное целое число равномерно в диапазоне 1–50. Мы можем использовать только этот генератор случайных чисел для генерации и печати всех целых чисел от 1 до 100 в случайном порядке. Каждое число должно приходить ровно один раз, и вероятность появления любого числа в любом месте должна быть одинаковой.

Какой алгоритм для этого наиболее эффективен?

Я думал (так что может быть неправильно :-) этого решение , которое использует перетасовать Fisher-Yates . Для того , чтобы поддерживать равномерное распределение с хорошим приближением (смотрите раздел EDIT ниже) на каждой итерации вы можете использовать этот трюк , чтобы получить значение между и :0 k - $O(N^2)$krand$0$$k-1$

 // return a random number in [0..k-1] with uniform distribution
 // using a uniform random generator in [1..50]
 funtion krand(k) {    
   sum = 0
   for i = 1 to k do sum = sum + RandNum50() - 1
   krand = sum mod k
 }

Алгоритм Фишера-Йейтса становится:

arr : array[0..99]
for i = 0  to 99 do arr[i] = i+1; // store 1..100 in the array
for i = 99 downto 1 {
  r = krand(i+1)  // random value in [0..i]
  exchange the values of arr[i] and arr[r]
}
for i = 0 to 99 do print arr[i]

РЕДАКТИРОВАТЬ:

Как указал Эрик, krandвышеприведенная функция не возвращает действительно равномерное распределение. Есть и другие методы, которые можно использовать для получения лучшего (произвольно лучшего) и более быстрого приближения; но (насколько мне известно) единственный способ получить действительно равномерное распределение - это использовать выборку отклонения : выберите случайные биты и, если полученное число меньше верните его, в противном случае создайте другое случайное число; Возможная реализация:r $m = \lceil \log_2(k) \rceil$$r$$k$

function trulyrand(k) {
    if (k <= 1) return 0
    while (true) { // ... if you're really unlucky ...
      m = ceil(log_2 (k) ) // calculate m such that k < 2^m
      r = 0  // will hold the random value
      while (m >= 0) {  // ... will add m bits        
        if ( rand50() > 25 ) then b = 1 else b = 0   // random bit
        r = r * 2 + b  // shift and add the random bit
        m = m - 1
      }      
      if (r < k) then return r  // we have 0<=r<2^m ; accept it, if r < k
    }
}

Поскольку другие люди дали приблизительные решения и решения, включающие получение неопределенного числа отклонений, как насчет доказательства того, что не существует такого алгоритма, который гарантированно требует только конечного числа RandNum50()вызовов?

Как отмечали другие, печать чисел от 1 до 100 в случайном порядке эквивалентна печати случайной перестановки этих чисел; Есть 100! из этих перестановок, и поэтому любая конкретная перестановка должна быть выведена с вероятностью .$\frac{1}{100!}$

Но если бы мы знали, что наш алгоритм использовал не более вызовов для некоторого , то мы могли бы рассуждать следующим образом: во-первых, выделите те вычислительные пути, которые делают меньше вызовов, чтобы сделать дополнительные фиктивные вызовы (то есть вызовы, где возвращаемое значение не имеет значения), так что все пути вычислений делают ровно вызовов. Любая заданная последовательность результатов наших вызовов должна приводить к некоторой выходной перестановке, и поэтому мы можем построить «таблицу результатов», которая отображает любую данную последовательность результатов наших вызовов в конкретный выходная перестановка. Так как каждый из этих результатов одинаково вероятен (каждый из них имеет вероятностьk k k k ( r 1 , r 2 , … , r k ) $k$RandNum50$k$$k$RandNum50$k$$k$RandNum50$(r_1, r_2, \ldots, r_k)$$\displaystyle\frac{1}{50^k}$ ), тогда вероятность получения какой-либо конкретной перестановки из нашего алгоритма должна иметь вид для некоторого . Но может быть такой формы, потому чтоне делит для любого (например, 3 делит но не может делить любое число формы ). Это означает, что никакое возможное распределение результатов для вызовов случайных чисел не может привести к равномерной перестановке. с$\displaystyle\frac{c}{50^k}$$c$100! 50кк100! 50$\displaystyle\frac{1}{100!}$$100!$$50^k$$k$$100!$$50^k$

Предыдущие решения не являются оптимальными. Сложность точно равна в вызовах RandNum50 и подробно описана здесь с использованием в качестве источника случайного бита (как предложено Vor):$n\log n + O(1)$

if ( rand50() > 25 ) then b = 1 else b = 0   // random bit

Основная идея заключается в том, что вы экономите много битов, если генерируете униформу от дои затем, используя факториальную базовую декомпозицию , вместо генерации последовательности униформ в диапазоне до , затем , затем и т. д., . Это на самом деле, как я уже упоминал в посте, тема статьи, которую я представил!п ! 1 2 3 $1$$n!$$1$$2$$3$$n$

Если вы не знаете, как сгенерировать униформу, как предлагается в этом посте, из случайного бита, вы также можете сгенерировать аппроксимацию униформы напрямую, таким образом (что эквивалентно «истинно» Вора, но быстрее):

P = (RandNum50()-1) + (RandNum50()-1)*50^1 + (RandNum50()-1)*50^2 + ...

идти так далеко, как вам нужно пойти. Это развивается в базе . Тогда просто усеченный , т.е. , в вашем случае, Это значение не является полностью случайным, но это мера однородности, которая часто используется. Или, как говорит Вор, вы можете отказаться , если . Затем с этим значением, вы можете сделать расширение факторных баз , как описаны в посте .50 P Q = $P$$50$$P$$Q=P\mod n$$n=100!$$P>n$

Я не сделал анализ , чтобы подтвердить , как равномерная (или нет) , это было бы, и она может быть скорректирована , чтобы быть истинным перетасовка, но вы могли бы просто выбрать из исходного массива из iго индекса = i + 1, в (k + RandNum50() + RandNum50() - 1) mod (100 - k)индекс, с удаление, для k= 0..99?

Это «толкает» пик в RandNum50() + RandNum50()распределении вперед равномерно.

_{Я уверен, что это не совсем верно, как я сказал это, потому что 0 индекс (1) не получается из первого выбора, и я не могу быстро увидеть альтернативную настройку 1..50 + 1..50, который производит 0 ..99.}

Обновить

Чтобы устранить эту проблему , я отметил, я эффективно использовать RandNum100как уже упоминалось в комментариях вопрос к randomally Инициализируем первого kсмещения.

Это создает распределение со значительной волной на фронте.

Вместо того, чтобы продвигаться на 1, я использовал другой, RandNum50чтобы увеличить это первым k. Это дает достаточно случайный для меня результат, но все же он не является «действительно» случайным, что можно легко увидеть, если изменить K на 2.

Тестирование кода VB.NET где я обслужены любой даже K. Примечание оно представляет собой О (К), 6К + 2 в самом деле.