PRNG สำหรับสร้างตัวเลขด้วย n บิตตั้งค่า

ฉันกำลังเขียนโค้ดบางส่วนเพื่อสร้างข้อมูลไบนารี ฉันต้องการสร้างหมายเลข 64 บิตด้วยจำนวนบิตที่กำหนดโดยเฉพาะ แม่นยำยิ่งขึ้นขั้นตอนควรใช้เวลาและส่งกลับตัวเลข 64 บิตหลอกเทียมด้วยบิตตั้งค่าเป็นและส่วนที่เหลือตั้งค่าเป็น 0$0 < n < 64$$n$$1$

แนวทางปัจจุบันของฉันเกี่ยวข้องกับสิ่งนี้:

1. สร้าง pseudorandom 64 บิตจำนวนk$k$
2. นับบิตในจัดเก็บผลในข$k$$b$
3. ถ้า , เอาต์พุต ; มิฉะนั้นไปที่ 1$b = n$$k$

ใช้งานได้ แต่ดูเหมือนไม่เหมาะสม มีอัลกอริธึม PRNG บางประเภทที่สามารถสร้างตัวเลขด้วยบิตเซตยิ่งกว่านี้หรือไม่?$n$

สิ่งที่คุณต้องเป็นตัวเลขสุ่มระหว่าง 0 และ 1 ปัญหาก็คือการทำให้สิ่งนี้เป็นรูปแบบบิต${ 64 \choose n } - 1$

สิ่งนี้เรียกว่าการเข้ารหัสแบบนับจำนวนและเป็นหนึ่งในอัลกอริธึมการบีบอัดที่เก่าแก่ที่สุดที่ปรับใช้ อาจเป็นอัลกอริทึมที่ง่ายที่สุดมาจาก Thomas Cover มันขึ้นอยู่กับการสังเกตอย่างง่าย ๆ ว่าถ้าคุณมีคำที่ยาวบิตโดยที่บิตที่ตั้งไว้คือตามลำดับบิตที่สำคัญที่สุดจากนั้นตำแหน่งของคำนี้ในการเรียงลำดับพจนานุกรมของคำทั้งหมดที่มีคุณสมบัตินี้ คือ:$n$$x_k \ldots x_1$

ตัวอย่างเช่นสำหรับคำ 7 บิต:

... และต่อไป

เพื่อให้ได้รูปแบบบิตจากลำดับคุณเพียงถอดรหัสแต่ละบิตในทางกลับกัน บางสิ่งเช่นนี้ในภาษาที่เหมือน 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 คุณจึงสามารถคำนวณล่วงหน้าได้

• หน้าปก, T. , การเข้ารหัสแหล่งที่มาแบบนับจำนวน ทฤษฎีการทำธุรกรรมเกี่ยวกับข้อมูลของ IEEE, Vol IT-19, No 1, Jan 1973

คล้ายกับคำตอบของนามแฝงที่ได้รับจากวิธีการอื่น

จำนวนรวมของการอยู่รวมกันพร้อมใช้งานเป็นเรื่องง่ายโดยดาวและบาร์วิธีจึงจะต้องมีการ{n} จำนวนรวมของตัวเลข 64- บิตที่คุณจะลองตัวอย่างตัวเลขของคุณจะสูงกว่านั้นอย่างเห็นได้ชัด$c=\binom{64}{n}$

สิ่งที่คุณต้องการแล้วเป็นฟังก์ชันที่สามารถนำคุณจากหมายเลข pseudorandomตั้งแต่เพื่อเพื่อการรวมกัน 64 บิตที่สอดคล้องกัน$k$$1$$c$

สามเหลี่ยมของปาสคาลสามารถช่วยคุณได้เพราะค่าของทุกโหนดแสดงถึงจำนวนเส้นทางที่แน่นอนจากโหนดนั้นไปยังรูทของสามเหลี่ยมและทุกเส้นทางสามารถทำเพื่อเป็นตัวแทนของหนึ่งในสตริงที่คุณกำลังมองหาหากเลี้ยวซ้ายทั้งหมด ที่มีป้ายกำกับด้วยและทุกเลี้ยวขวาด้วย0$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$

อีกวิธีที่ค่อนข้างหรูหราคือการใช้ bisection ตามที่อธิบายไว้ในคำตอบ 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) สร้างจำนวนสุ่มระหว่างและ64$k$$1$$64$

2) การตั้งค่า THที่จะ1$k$$0$$1$

3) ทำซ้ำขั้นตอนที่ 1 และ 2ครั้ง$n$

$A[]$คืออาร์เรย์บิตที่มีทั้งหมดวินาที$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;
}