PRNG для генерування чисел з п ять заданих бітів

В даний час я пишу код для створення двійкових даних. Мені спеціально потрібно генерувати 64-бітні числа з заданою кількістю встановлених бітів; точніше, процедура повинна приймати деяку і повертати псевдовипадкове 64-бітове число з точно яти бітами, встановленими на , а решта встановити на 0.n $0 < n < 64$$n$$1$

Мій сучасний підхід передбачає щось подібне:

1. Створити псевдовипадкове 64-розрядне число .$k$
2. Підраховуйте біти в , зберігаючи результат у .$k$$b$
3. Якщо , вихід ; інакше перейдіть до 1.$b = n$$k$

Це працює, але це здається неелегантним. Чи існує якийсь алгоритм PRNG, який може генерувати числа з заданих бітів більш елегантно, ніж цей?$n$

Вам потрібно випадкове число між 0 і . Проблема тоді полягає в тому, щоб перетворити це на бітовий зразок.${ 64 \choose n } - 1$

Це відомо як кодувальне кодування, і це один із найдавніших розгорнутих алгоритмів стиснення. Напевно, найпростіший алгоритм - від Thomas Cover. Він заснований на простому спостереженні, що якщо у вас є слово, яке має біт, де задані біти є у найбільш значущому порядку розрядів, то положення цього слова в лексикографічному упорядкуванні всіх слів із цією властивістю є:x k … x $n$$x_k \ldots x_1$

Так, наприклад, для 7-бітного слова:

i(0001011)= (

...і так далі.

Щоб отримати бітовий візерунок з порядкового порядку, ви просто розшифруєте кожен біт по черзі. Щось подібне, мовою, схожою на C:

uint64_t decode(uint64_t ones, uint64_t ordinal)
{
    uint64_t bits = 0;
    for (uint64_t bit = 63; ones > 0; --bit)
    {
        uint64_t nCk = choose(bit, ones);
        if (ordinal >= nCk)
        {
            ordinal -= nCk;
            bits |= 1 << bit;
            --ones;
        }
    }
    return bits;
}

Зауважте, що оскільки вам потрібні лише біноміальні коефіцієнти до 64, ви можете попередньо обчислити їх.

• Обкладинка, Т., Переліку кодувань джерел . Угоди IEEE з інформаційної теорії, т. ІТ-19, № 1, січ 1973.

Дуже схожа на відповідь псевдоніма, отриману іншими способами.

Загальна кількість доступних комбінацій доступна методом зірок і брусків , тому вона повинна бути . Загальна кількість 64-розрядних чисел, з яких ви намагаєтеся відібрати свій номер, було б, очевидно, набагато вищим за це.$c=\binom{64}{n}$

Тоді вам потрібна функція, яка може привести вас від псевдовипадкового числа , починаючи від до , до відповідної 64-бітної комбінації.1 $k$$1$$c$

Трикутник Паскаля може допомогти вам у цьому, тому що значення кожного вузла відображає саме кількість шляхів від цього вузла до кореня трикутника, і кожен шлях може бути зроблений таким чином, щоб він відображав один з рядків, який ви шукаєте, якщо всі ліві повороти є позначено позначкою , а кожен правий поворот .$1$$0$

Тож нехай - кількість бітів, що залишилися для визначення, а - кількість оставшихся для використання.$x$$y$

Ми знаємо, що , і ми можемо використовувати його, щоб правильно визначити наступний біт числа на кожному кроці:$\binom{x}{y}=\binom{x-1}{y}+\binom{x-1}{y-1}$

$\mathtt{while}\;\;\; x>0$

$\quad \mathtt{if}\;\;\; x>y$

$\qquad \mathtt{if}\;\;\;k>\binom{x-1}{y}: \;\;\;s \leftarrow s\; + \mathtt{"1"}, \;k\leftarrow k-\binom{x-1}{y}, \;y \leftarrow y-1$

$\qquad \mathtt{else}:\; \;s \leftarrow s\; + \mathtt{"0"}$

$\quad \mathtt{else}: \;\;s \leftarrow s\; + \mathtt{"1"}, \;y \leftarrow y-1$

$\quad x \leftarrow x-1$

Ще один досить елегантний метод - використовувати бісекцію, як описано в цій відповіді stackoverflow . Ідея полягає в тому, щоб зберегти два слова, в одному відомому, що має максимум k біт, а в одному відомому, що він має встановити принаймні k бітів, і використовувати випадковість для переміщення одного з цих напрямків до того, щоб мати рівно k біт. Ось декілька вихідних кодів для його ілюстрації:

word randomKBits(int k) {
    word min = 0;
    word max = word(~word(0)); // all 1s
    int n = 0;
    while (n != k) {
        word x = randomWord();
        x = min | (x & max);
        n = popcount(x);
        if (n > k)
            max = x;
        else
            min = x;
    }
    return min;
}

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

Ви можете зробити наступне:

1) Утворіть випадкове число, між і .$k$$1$$64$

2) Встановіть th до .$k$$0$$1$

3) Повторіть кроки 1 і 2 рази$n$

$A[]$ - це бітний масив з усіма s$64$$0$

for(i=1 to n)
{
    k=ran(1,65-i) % random number between 1 and 65-i
    for(x=1;x<65;x++)
    {
        if(A[x]==0)k--;
        if(k==0)break;
    }
    A[x]=1;
}