หมายเลขสุ่มที่ไม่ซ้ำ (ไม่ใช่ซ้ำ) ใน O (1)?

ฉันต้องการสร้างตัวเลขสุ่มที่ไม่ซ้ำกันระหว่าง 0 ถึง 1,000 ที่ไม่เคยทำซ้ำ (เช่น 6 ไม่ปรากฏขึ้นสองครั้ง) แต่นั่นไม่ได้หันไปหาสิ่งที่ต้องการการค้นหา O (N) ของค่าก่อนหน้า เป็นไปได้ไหม

เริ่มต้นอาร์เรย์ของจำนวนเต็ม 1001 ด้วยค่า 0-1000 และตั้งค่าตัวแปร max เป็นดัชนีสูงสุดปัจจุบันของอาร์เรย์ (เริ่มต้นด้วย 1,000) เลือกตัวเลขสุ่ม r ระหว่าง 0 ถึงสูงสุดสลับหมายเลขที่ตำแหน่ง r ด้วยหมายเลขที่ตำแหน่งสูงสุดและส่งกลับหมายเลขตอนนี้ที่ตำแหน่งสูงสุด ลดสูงสุด 1 และดำเนินการต่อ เมื่อ max เป็น 0 ให้ตั้งค่า max กลับเป็นขนาดของ array - 1 แล้วเริ่มต้นใหม่อีกครั้งโดยไม่ต้องกำหนดค่าเริ่มต้นใหม่

อัปเดต: แม้ว่าฉันจะใช้วิธีนี้ด้วยตัวเองเมื่อฉันตอบคำถามหลังจากการวิจัยบางอย่างฉันรู้ว่านี่เป็นรุ่นที่ได้รับการแก้ไขของFisher-Yatesหรือที่เรียกว่า Durstenfeld-Fisher-Yates หรือ Knuth-Fisher-Yates เนื่องจากคำอธิบายอาจเป็นเรื่องยากที่จะติดตามฉันได้ให้ตัวอย่างด้านล่าง (ใช้ 11 องค์ประกอบแทน 1001):

Array เริ่มต้นด้วยองค์ประกอบ 11 ค่าเริ่มต้นไปยังอาร์เรย์ [n] = n ค่าสูงสุดเริ่มต้นที่ 10:

+--+--+--+--+--+--+--+--+--+--+--+
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9|10|
+--+--+--+--+--+--+--+--+--+--+--+
                                ^
                               max    

ที่การวนซ้ำแต่ละครั้งสุ่มหมายเลข r ถูกเลือกระหว่าง 0 ถึงสูงสุดอาร์เรย์ [r] และอาร์เรย์ [max] จะถูกสลับกลับอาร์เรย์ใหม่ [สูงสุด] จะถูกส่งคืนและสูงสุดจะลดลง:

max = 10, r = 3
           +--------------------+
           v                    v
+--+--+--+--+--+--+--+--+--+--+--+
| 0| 1| 2|10| 4| 5| 6| 7| 8| 9| 3|
+--+--+--+--+--+--+--+--+--+--+--+

max = 9, r = 7
                       +-----+
                       v     v
+--+--+--+--+--+--+--+--+--+--+--+
| 0| 1| 2|10| 4| 5| 6| 9| 8| 7: 3|
+--+--+--+--+--+--+--+--+--+--+--+

max = 8, r = 1
     +--------------------+
     v                    v
+--+--+--+--+--+--+--+--+--+--+--+
| 0| 8| 2|10| 4| 5| 6| 9| 1: 7| 3|
+--+--+--+--+--+--+--+--+--+--+--+

max = 7, r = 5
                 +-----+
                 v     v
+--+--+--+--+--+--+--+--+--+--+--+
| 0| 8| 2|10| 4| 9| 6| 5: 1| 7| 3|
+--+--+--+--+--+--+--+--+--+--+--+

...

หลังจากการวนซ้ำ 11 ครั้งตัวเลขทั้งหมดในอาเรย์ได้ถูกเลือกสูงสุด == 0 และองค์ประกอบอาเรย์จะถูกสับ:

+--+--+--+--+--+--+--+--+--+--+--+
| 4|10| 8| 6| 2| 0| 9| 5| 1| 7| 3|
+--+--+--+--+--+--+--+--+--+--+--+

ณ จุดนี้สูงสุดสามารถรีเซ็ตเป็น 10 และกระบวนการสามารถดำเนินการต่อ

คุณสามารถทำได้:

1. สร้างรายการ 0..1000
2. สลับรายการ (ดูFisher-Yates shuffleเพื่อดูวิธีการทำเช่นนี้)
3. ส่งคืนตัวเลขตามลำดับจากรายการที่สับ

ดังนั้นสิ่งนี้ไม่ต้องการการค้นหาค่าเก่าในแต่ละครั้ง แต่ยังคงต้องใช้ O (N) สำหรับการสลับครั้งแรก แต่เมื่อนิลส์ชี้ให้เห็นในความคิดเห็นนี่เป็นค่าตัดจำหน่าย O (1)

ใช้สูงสุดเป็น Linear ข้อเสนอแนะกะสมัครสมาชิก

มันสามารถใช้งานได้ในไม่กี่บรรทัดของ C และที่รันไทม์ทำมากกว่าสองสามทดสอบ / สาขาเพิ่มเล็กน้อยและขยับเล็กน้อย มันไม่ใช่การสุ่ม แต่มันคนโง่ที่สุด

คุณสามารถใช้เป็น Linear congruential ปั่นไฟ โดยที่m(โมดูลัส) จะเป็นนายกที่ใกล้เคียงที่สุดที่ใหญ่กว่า 1,000 เมื่อคุณได้รับตัวเลขจากช่วงเพียงแค่รับคนต่อไป ลำดับจะทำซ้ำเมื่อองค์ประกอบทั้งหมดเกิดขึ้นและคุณไม่จำเป็นต้องใช้ตาราง ระวังข้อเสียของเครื่องกำเนิดไฟฟ้านี้ด้วย (รวมถึงการขาดการสุ่ม)

คุณสามารถใช้การเข้ารหัสรูปแบบ - รักษาเพื่อเข้ารหัสตัวนับ ตัวนับของคุณเริ่มจาก 0 ขึ้นไปและการเข้ารหัสใช้คีย์ที่คุณเลือกเพื่อเปลี่ยนเป็นค่าสุ่มและความกว้างที่คุณต้องการ เช่นสำหรับตัวอย่างในคำถามนี้: radix 10, width 3

โดยทั่วไปยันต์บล็อกจะมีขนาดบล็อกคงที่เช่น 64 หรือ 128 บิต แต่การเข้ารหัส Format-Preserving Encryption ช่วยให้คุณใช้รหัสมาตรฐานเช่น AES และสร้างรหัสความกว้างขนาดเล็กลงได้ไม่ว่าคุณต้องการ Radix และ width ใดก็ตามด้วยอัลกอริทึมที่ยังคงแข็งแกร่งในการเข้ารหัส

ไม่รับประกันว่าจะไม่มีการชน (เนื่องจากอัลกอริธึมการเข้ารหัสสร้างการแมป 1: 1) นอกจากนี้ยังสามารถย้อนกลับได้ (การทำแผนที่สองทาง) ดังนั้นคุณสามารถใช้หมายเลขผลลัพธ์และกลับไปที่ค่าตัวนับที่คุณเริ่มต้นด้วย

เทคนิคนี้ไม่จำเป็นต้องมีหน่วยความจำในการจัดเก็บอาเรย์แบบสับเป็นต้นซึ่งสามารถเป็นประโยชน์ในระบบที่มีหน่วยความจำ จำกัด

AES-FFXเป็นหนึ่งในวิธีการมาตรฐานที่เสนอเพื่อบรรลุเป้าหมายนี้ ผมได้ทดลองกับบางรหัสหลามขั้นพื้นฐานซึ่งจะขึ้นอยู่กับความคิด AES-FFX ถึงแม้จะไม่ได้อย่างเต็มที่ conformant-- เห็นรหัสหลามที่นี่ เช่นสามารถเข้ารหัสตัวนับให้เป็นตัวเลขทศนิยม 7 หลักแบบสุ่มหรือตัวเลข 16 บิต นี่คือตัวอย่างของ radix 10 ความกว้าง 3 (เพื่อให้ตัวเลขระหว่าง 0 ถึง 999 รวม) ตามคำถามที่ระบุ:

000   733
001   374
002   882
003   684
004   593
005   578
006   233
007   811
008   072
009   337
010   119
011   103
012   797
013   257
014   932
015   433
...   ...

หากต้องการรับลำดับการสุ่มหลอกที่ไม่ซ้ำให้เปลี่ยนรหัสการเข้ารหัส แต่ละคีย์เข้ารหัสสร้างลำดับหลอกแบบไม่ซ้ำที่ไม่ซ้ำกัน

สำหรับตัวเลขที่ต่ำเช่น 0 ... 1,000 การสร้างรายการที่มีตัวเลขทั้งหมดและการสับเป็นแบบตรงไปข้างหน้า แต่ถ้าชุดตัวเลขที่จะดึงมีขนาดใหญ่มากก็มีอีกวิธีที่สวยงาม: คุณสามารถสร้างการเรียงสับเปลี่ยนหลอกเทียมโดยใช้คีย์และฟังก์ชันแฮชการเข้ารหัสลับ ดู C ++ ต่อไปนี้ - ตัวอย่างรหัสหลอก ish:

unsigned randperm(string key, unsigned bits, unsigned index) {
  unsigned half1 =  bits    / 2;
  unsigned half2 = (bits+1) / 2;
  unsigned mask1 = (1 << half1) - 1;
  unsigned mask2 = (1 << half2) - 1;
  for (int round=0; round<5; ++round) {
    unsigned temp = (index >> half1);
    temp = (temp << 4) + round;
    index ^= hash( key + "/" + int2str(temp) ) & mask1;
    index = ((index & mask2) << half1) | ((index >> half2) & mask1);
  }
  return index;
}

นี่hashเป็นเพียงฟังก์ชั่นสุ่มหลอกโดยพลการที่แมปสตริงอักขระกับจำนวนเต็มที่ไม่ได้ลงนามขนาดใหญ่ ฟังก์ชั่นrandpermคือการเปลี่ยนแปลงของตัวเลขทั้งหมดภายใน 0 ... pow (2, บิต) -1 สมมติว่าเป็นคีย์คงที่ สิ่งนี้เกิดจากการก่อสร้างเพราะทุกขั้นตอนที่เปลี่ยนแปลงตัวแปรindexนั้นสามารถย้อนกลับได้ นี้เป็นแรงบันดาลใจจากตัวเลข Feistel

คุณสามารถใช้อัลกอริทึมของ Xincrol ของฉันอธิบายไว้ที่นี่:

http://openpatent.blogspot.co.il/2013/04/xincrol-unique-and-random-number.html

นี่เป็นวิธีอัลกอริทึมบริสุทธิ์ในการสร้างตัวเลขสุ่ม แต่ไม่ซ้ำใครโดยไม่ต้องมีอาร์เรย์รายการการเปลี่ยนลำดับหรือโหลดซีพียูจำนวนมาก

เวอร์ชันล่าสุดอนุญาตให้ตั้งช่วงของตัวเลขได้เช่นหากฉันต้องการตัวเลขสุ่มที่ไม่ซ้ำกันในช่วง 0-1073741821

ฉันใช้มันในทางปฏิบัติสำหรับ

• เครื่องเล่น MP3 ที่เล่นทุกเพลงแบบสุ่ม แต่เพียงครั้งเดียวต่ออัลบั้ม / ไดเรกทอรี
• เฟรมวิดีโอที่ชาญฉลาดพิกเซลละลายผล (รวดเร็วและราบรื่น)
• การสร้าง "เสียง" ที่เป็นความลับเหนือภาพสำหรับลายเซ็นและเครื่องหมาย (ซูรินาเม)
• Data Object IDs สำหรับซีเรียลไลซ์ชัน Java จำนวนมากผ่านฐานข้อมูล
• การป้องกันบิตหน่วยความจำส่วนใหญ่สามส่วน
• การเข้ารหัสที่อยู่ + ค่า (ทุกไบต์ไม่เพียงเข้ารหัส แต่ย้ายไปยังตำแหน่งเข้ารหัสใหม่ในบัฟเฟอร์) สิ่งนี้ทำให้เพื่อนคริปโตแนลไลเซชันเป็นบ้าจริง ๆ กับฉัน :-)
• การแปลงข้อความธรรมดาเป็นธรรมดาการเข้ารหัสข้อความสำหรับ SMS อีเมล ฯลฯ
• เครื่องคิดเลข Texas Hold'em Poker ของฉัน (THC)
• เกมของฉันหลายเกมสำหรับการจำลอง "การสับ" การจัดอันดับ
• มากกว่า

มันเปิดฟรี ให้มันลอง...

คุณไม่จำเป็นต้องมีอาร์เรย์เพื่อแก้ปัญหานี้

คุณต้องมี bitmask และตัวนับ

เริ่มต้นตัวนับเป็นศูนย์และเพิ่มขึ้นเมื่อมีการโทรติดต่อกัน แฮคเกอร์นับด้วย bitmask (สุ่มเลือกเมื่อเริ่มต้นหรือคงที่) เพื่อสร้างหมายเลข psuedorandom หากคุณไม่สามารถมีตัวเลขที่เกิน 1,000 อย่าใช้ bitmask ที่กว้างกว่า 9 บิต (กล่าวอีกนัยหนึ่ง bitmask เป็นจำนวนเต็มไม่สูงกว่า 511)

ตรวจสอบให้แน่ใจว่าเมื่อตัวนับผ่าน 1,000 คุณตั้งค่าใหม่เป็นศูนย์ ในเวลานี้คุณสามารถเลือก bitmask แบบสุ่ม - หากคุณต้องการ - เพื่อสร้างชุดหมายเลขเดียวกันในลำดับที่แตกต่างกัน

ฉันคิดว่าเครื่องกำเนิดเชิงเส้นตรงนั้นจะเป็นทางออกที่ง่ายที่สุด

และมีเพียง 3 ข้อ จำกัด ใน, คและมค่า

1. mและ cค่อนข้างดี
2. a-1สามารถหารได้ด้วยปัจจัยหลักทั้งหมดของ m
3. a-1หารด้วย 4ถ้า mหารด้วย 4

PSวิธีการที่ถูกกล่าวถึงแล้ว แต่โพสต์มีข้อสันนิษฐานผิดเกี่ยวกับค่าคงที่ ค่าคงที่ด้านล่างควรทำงานได้ดีสำหรับกรณีของคุณ

ในกรณีของคุณคุณอาจใช้a = 1002, c = 757,m = 1001

X = (1002 * X + 757) mod 1001

ต่อไปนี้เป็นโค้ดที่ฉันพิมพ์ขึ้นซึ่งใช้ตรรกะของโซลูชันแรก ฉันรู้ว่านี่คือ "ผู้ไม่เชื่อเรื่องภาษา" แต่ต้องการนำเสนอสิ่งนี้เป็นตัวอย่างใน C # ในกรณีที่ทุกคนกำลังมองหาวิธีแก้ปัญหาที่ใช้งานได้จริง

// Initialize variables
Random RandomClass = new Random();
int RandArrayNum;
int MaxNumber = 10;
int LastNumInArray;
int PickedNumInArray;
int[] OrderedArray = new int[MaxNumber];      // Ordered Array - set
int[] ShuffledArray = new int[MaxNumber];     // Shuffled Array - not set

// Populate the Ordered Array
for (int i = 0; i < MaxNumber; i++)                  
{
    OrderedArray[i] = i;
    listBox1.Items.Add(OrderedArray[i]);
}

// Execute the Shuffle                
for (int i = MaxNumber - 1; i > 0; i--)
{
    RandArrayNum = RandomClass.Next(i + 1);         // Save random #
    ShuffledArray[i] = OrderedArray[RandArrayNum];  // Populting the array in reverse
    LastNumInArray = OrderedArray[i];               // Save Last Number in Test array
    PickedNumInArray = OrderedArray[RandArrayNum];  // Save Picked Random #
    OrderedArray[i] = PickedNumInArray;             // The number is now moved to the back end
    OrderedArray[RandArrayNum] = LastNumInArray;    // The picked number is moved into position
}

for (int i = 0; i < MaxNumber; i++)                  
{
    listBox2.Items.Add(ShuffledArray[i]);
}

วิธีการนี้ให้ผลที่ดีเมื่อขีด จำกัดสูงและคุณต้องการสร้างตัวเลขสุ่มเพียงไม่กี่ตัว

#!/usr/bin/perl

($top, $n) = @ARGV; # generate $n integer numbers in [0, $top)

$last = -1;
for $i (0 .. $n-1) {
    $range = $top - $n + $i - $last;
    $r = 1 - rand(1.0)**(1 / ($n - $i));
    $last += int($r * $range + 1);
    print "$last ($r)\n";
}

โปรดทราบว่าตัวเลขจะถูกสร้างตามลำดับจากน้อยไปมาก แต่คุณสามารถสลับได้หลังจากนั้น

คุณสามารถใช้ตัวสร้างตัวเลขสุ่มหลอกได้ดีด้วย 10 บิตและทิ้ง 1001 ถึง 1,023 ทิ้ง 0 ถึง 1,000

จากที่นี่เราได้รับการออกแบบสำหรับ PRNG 10 บิต ..

• 10 บิตข้อเสนอแนะพหุนาม x ^ 10 + x ^ 7 + 1 (ช่วง 1023)

• ใช้ Galois LFSR เพื่อรับรหัสที่รวดเร็ว

public static int[] randN(int n, int min, int max)
{
    if (max <= min)
        throw new ArgumentException("Max need to be greater than Min");
    if (max - min < n)
        throw new ArgumentException("Range needs to be longer than N");

    var r = new Random();

    HashSet<int> set = new HashSet<int>();

    while (set.Count < n)
    {
        var i = r.Next(max - min) + min;
        if (!set.Contains(i))
            set.Add(i);
    }

    return set.ToArray();
}

N ตัวเลขสุ่มที่ไม่ใช่การทำซ้ำจะมีความซับซ้อน O (n) ตามที่ต้องการ
หมายเหตุ: สุ่มควรเป็นแบบคงที่โดยใช้ความปลอดภัยของเธรด

สมมติว่าคุณต้องการดูรายการที่มีการสับซ้ำหลายครั้งโดยไม่O(n)ล่าช้าในแต่ละครั้งที่คุณเริ่มต้นเพื่อสลับอีกครั้งในกรณีนี้เราสามารถทำได้:

1. สร้าง 2 รายการ A และ B ที่มี 0 ถึง 1,000 ใช้2nพื้นที่

2. รายการสลับ A ที่ใช้ Fisher-Yates ใช้nเวลานาน

3. เมื่อวาดตัวเลขให้ทำแบบสุ่ม 1 ขั้นตอนกับ Fisher-Yates ในรายการอื่น

4. เมื่อเคอร์เซอร์อยู่ที่ท้ายรายการให้เปลี่ยนเป็นรายการอื่น

preprocess

cursor = 0

selector = A
other    = B

shuffle(A)

วาด

temp = selector[cursor]

swap(other[cursor], other[random])

if cursor == N
then swap(selector, other); cursor = 0
else cursor = cursor + 1

return temp

คำถามคุณสร้างรายการจำนวนเต็ม K ที่ไม่ซ้ำกันอย่างมีประสิทธิภาพระหว่าง 0 ถึงขีด จำกัด บนได้อย่างไรถูกลิงก์เป็นซ้ำได้อย่างไรและถ้าคุณต้องการบางสิ่งที่เป็น O (1) ต่อการสุ่มตัวเลขที่สร้างขึ้น (โดยไม่มี O (n) ราคาเริ่มต้น)) มีการบิดคำตอบที่ยอมรับได้ง่าย

สร้างแผนที่ที่ไม่มีการเรียงลำดับว่างเปล่า (แผนที่ที่ว่างเปล่าที่สั่งจะใช้ O (ล็อก k) ต่อองค์ประกอบ) จากจำนวนเต็มถึงจำนวนเต็ม - แทนที่จะใช้อาร์เรย์ที่กำหนดค่าเริ่มต้น ตั้งค่าสูงสุดเป็น 1,000 หากนั่นคือค่าสูงสุด

1. เลือกตัวเลขสุ่ม r ระหว่าง 0 ถึงสูงสุด
2. ตรวจสอบให้แน่ใจว่าทั้งองค์ประกอบของแผนที่ r และ max มีอยู่ในแผนที่ที่ไม่ได้เรียงลำดับ หากไม่มีอยู่ให้สร้างด้วยค่าเท่ากับดัชนี
3. สลับองค์ประกอบ r และสูงสุด
4. ส่งคืนองค์ประกอบสูงสุดและค่าลดลงสูงสุด 1 (ถ้าค่าสูงสุดเป็นลบคุณก็ทำเสร็จแล้ว)
5. กลับไปที่ขั้นตอนที่ 1

ความแตกต่างเพียงอย่างเดียวเมื่อเทียบกับการใช้อาเรย์เริ่มต้นคือการเริ่มต้นขององค์ประกอบถูกเลื่อน / ข้าม - แต่มันจะสร้างตัวเลขเดียวกันแน่นอนจาก PRNG เดียวกัน

ตำแหน่งอื่น:

คุณสามารถใช้อาร์เรย์ของธง และเลือกอันถัดไปเมื่อเลือกแล้ว

แต่ระวังหลังจากโทร 1,000 ครั้งฟังก์ชั่นจะไม่สิ้นสุดดังนั้นคุณต้องป้องกัน

นี่คือตัวอย่างโค้ดโคบอลที่คุณสามารถเล่นได้
ฉันสามารถส่งไฟล์ RANDGEN.exe ให้คุณเพื่อให้คุณสามารถเล่นกับมันเพื่อดูว่ามันต้องการหรือไม่

   IDENTIFICATION DIVISION.
   PROGRAM-ID.  RANDGEN as "ConsoleApplication2.RANDGEN".
   AUTHOR.  Myron D Denson.
   DATE-COMPILED.
  * ************************************************************** 
  *  SUBROUTINE TO GENERATE RANDOM NUMBERS THAT ARE GREATER THAN
  *    ZERO AND LESS OR EQUAL TO THE RANDOM NUMBERS NEEDED WITH NO
  *    DUPLICATIONS.  (CALL "RANDGEN" USING RANDGEN-AREA.)
  *     
  *  CALLING PROGRAM MUST HAVE A COMPARABLE LINKAGE SECTION
  *    AND SET 3 VARIABLES PRIOR TO THE FIRST CALL IN RANDGEN-AREA     
  *
  *    FORMULA CYCLES THROUGH EVERY NUMBER OF 2X2 ONLY ONCE. 
  *    RANDOM-NUMBERS FROM 1 TO RANDOM-NUMBERS-NEEDED ARE CREATED 
  *    AND PASSED BACK TO YOU.
  *
  *  RULES TO USE RANDGEN:
  *
  *    RANDOM-NUMBERS-NEEDED > ZERO 
  *     
  *    COUNT-OF-ACCESSES MUST = ZERO FIRST TIME CALLED.
  *         
  *    RANDOM-NUMBER = ZERO, WILL BUILD A SEED FOR YOU
  *    WHEN COUNT-OF-ACCESSES IS ALSO = 0 
  *     
  *    RANDOM-NUMBER NOT = ZERO, WILL BE NEXT SEED FOR RANDGEN
  *    (RANDOM-NUMBER MUST BE <= RANDOM-NUMBERS-NEEDED)       
  *     
  *    YOU CAN PASS RANDGEN YOUR OWN RANDOM-NUMBER SEED
  *     THE FIRST TIME YOU USE RANDGEN.
  *     
  *    BY PLACING A NUMBER IN RANDOM-NUMBER FIELD
  *      THAT FOLLOWES THESE SIMPLE RULES:
  *        IF COUNT-OF-ACCESSES = ZERO AND 
  *        RANDOM-NUMBER > ZERO AND 
  *        RANDOM-NUMBER <= RANDOM-NUMBERS-NEEDED
  *       
  *    YOU CAN LET RANDGEN BUILD A SEED FOR YOU
  *     
  *      THAT FOLLOWES THESE SIMPLE RULES:
  *        IF COUNT-OF-ACCESSES = ZERO AND 
  *        RANDOM-NUMBER = ZERO AND 
  *        RANDOM-NUMBER-NEEDED > ZERO  
  *         
  *     TO INSURING A DIFFERENT PATTERN OF RANDOM NUMBERS
  *        A LOW-RANGE AND HIGH-RANGE IS USED TO BUILD
  *        RANDOM NUMBERS.
  *        COMPUTE LOW-RANGE =
  *             ((SECONDS * HOURS * MINUTES * MS) / 3).         
  *        A HIGH-RANGE = RANDOM-NUMBERS-NEEDED + LOW-RANGE
  *        AFTER RANDOM-NUMBER-BUILT IS CREATED 
  *        AND IS BETWEEN LOW AND HIGH RANGE
  *        RANDUM-NUMBER = RANDOM-NUMBER-BUILT - LOW-RANGE
  *               
  * **************************************************************         
   ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   DATA DIVISION.
   FILE SECTION.
   WORKING-STORAGE SECTION.
   01  WORK-AREA.
       05  X2-POWER                     PIC 9      VALUE 2. 
       05  2X2                          PIC 9(12)  VALUE 2 COMP-3.
       05  RANDOM-NUMBER-BUILT          PIC 9(12)  COMP.
       05  FIRST-PART                   PIC 9(12)  COMP.
       05  WORKING-NUMBER               PIC 9(12)  COMP.
       05  LOW-RANGE                    PIC 9(12)  VALUE ZERO.
       05  HIGH-RANGE                   PIC 9(12)  VALUE ZERO.
       05  YOU-PROVIDE-SEED             PIC X      VALUE SPACE.
       05  RUN-AGAIN                    PIC X      VALUE SPACE.
       05  PAUSE-FOR-A-SECOND           PIC X      VALUE SPACE.   
   01  SEED-TIME.
       05  HOURS                        PIC 99.
       05  MINUTES                      PIC 99.
       05  SECONDS                      PIC 99.
       05  MS                           PIC 99. 
  *
  * LINKAGE SECTION.
  *  Not used during testing  
   01  RANDGEN-AREA.
       05  COUNT-OF-ACCESSES            PIC 9(12) VALUE ZERO.
       05  RANDOM-NUMBERS-NEEDED        PIC 9(12) VALUE ZERO.
       05  RANDOM-NUMBER                PIC 9(12) VALUE ZERO.
       05  RANDOM-MSG                   PIC X(60) VALUE SPACE.
  *    
  * PROCEDURE DIVISION USING RANDGEN-AREA.
  * Not used during testing 
  *  
   PROCEDURE DIVISION.
   100-RANDGEN-EDIT-HOUSEKEEPING.
       MOVE SPACE TO RANDOM-MSG. 
       IF RANDOM-NUMBERS-NEEDED = ZERO
         DISPLAY 'RANDOM-NUMBERS-NEEDED ' NO ADVANCING
         ACCEPT RANDOM-NUMBERS-NEEDED.
       IF RANDOM-NUMBERS-NEEDED NOT NUMERIC 
         MOVE 'RANDOM-NUMBERS-NEEDED NOT NUMERIC' TO RANDOM-MSG
           GO TO 900-EXIT-RANDGEN.
       IF RANDOM-NUMBERS-NEEDED = ZERO
         MOVE 'RANDOM-NUMBERS-NEEDED = ZERO' TO RANDOM-MSG
           GO TO 900-EXIT-RANDGEN.
       IF COUNT-OF-ACCESSES NOT NUMERIC
         MOVE 'COUNT-OF-ACCESSES NOT NUMERIC' TO RANDOM-MSG
           GO TO 900-EXIT-RANDGEN.
       IF COUNT-OF-ACCESSES GREATER THAN RANDOM-NUMBERS-NEEDED
         MOVE 'COUNT-OF-ACCESSES > THAT RANDOM-NUMBERS-NEEDED'
           TO RANDOM-MSG
           GO TO 900-EXIT-RANDGEN.
       IF YOU-PROVIDE-SEED = SPACE AND RANDOM-NUMBER = ZERO
         DISPLAY 'DO YOU WANT TO PROVIDE SEED  Y OR N: '
           NO ADVANCING
           ACCEPT YOU-PROVIDE-SEED.  
       IF RANDOM-NUMBER = ZERO AND
          (YOU-PROVIDE-SEED = 'Y' OR 'y')
         DISPLAY 'ENTER SEED ' NO ADVANCING
         ACCEPT RANDOM-NUMBER. 
       IF RANDOM-NUMBER NOT NUMERIC
         MOVE 'RANDOM-NUMBER NOT NUMERIC' TO RANDOM-MSG
         GO TO 900-EXIT-RANDGEN.
   200-RANDGEN-DATA-HOUSEKEEPING.      
       MOVE FUNCTION CURRENT-DATE (9:8) TO SEED-TIME.
       IF COUNT-OF-ACCESSES = ZERO
         COMPUTE LOW-RANGE =
                ((SECONDS * HOURS * MINUTES * MS) / 3).
       COMPUTE RANDOM-NUMBER-BUILT = RANDOM-NUMBER + LOW-RANGE.  
       COMPUTE HIGH-RANGE = RANDOM-NUMBERS-NEEDED + LOW-RANGE.
       MOVE X2-POWER TO 2X2.             
   300-SET-2X2-DIVISOR.
       IF 2X2 < (HIGH-RANGE + 1) 
          COMPUTE 2X2 = 2X2 * X2-POWER
           GO TO 300-SET-2X2-DIVISOR.    
  * *********************************************************         
  *  IF FIRST TIME THROUGH AND YOU WANT TO BUILD A SEED.    *
  * ********************************************************* 
       IF COUNT-OF-ACCESSES = ZERO AND RANDOM-NUMBER = ZERO
          COMPUTE RANDOM-NUMBER-BUILT =
                ((SECONDS * HOURS * MINUTES * MS) + HIGH-RANGE).
       IF COUNT-OF-ACCESSES = ZERO        
         DISPLAY 'SEED TIME ' SEED-TIME 
               ' RANDOM-NUMBER-BUILT ' RANDOM-NUMBER-BUILT 
               ' LOW-RANGE  ' LOW-RANGE.          
  * *********************************************     
  *    END OF BUILDING A SEED IF YOU WANTED TO  * 
  * *********************************************               
  * ***************************************************
  * THIS PROCESS IS WHERE THE RANDOM-NUMBER IS BUILT  *  
  * ***************************************************   
   400-RANDGEN-FORMULA.
       COMPUTE FIRST-PART = (5 * RANDOM-NUMBER-BUILT) + 7.
       DIVIDE FIRST-PART BY 2X2 GIVING WORKING-NUMBER 
         REMAINDER RANDOM-NUMBER-BUILT. 
       IF RANDOM-NUMBER-BUILT > LOW-RANGE AND
          RANDOM-NUMBER-BUILT < (HIGH-RANGE + 1)
         GO TO 600-RANDGEN-CLEANUP.
       GO TO 400-RANDGEN-FORMULA.
  * *********************************************     
  *    GOOD RANDOM NUMBER HAS BEEN BUILT        *               
  * *********************************************
   600-RANDGEN-CLEANUP.
       ADD 1 TO COUNT-OF-ACCESSES.
       COMPUTE RANDOM-NUMBER = 
            RANDOM-NUMBER-BUILT - LOW-RANGE. 
  * *******************************************************
  * THE NEXT 3 LINE OF CODE ARE FOR TESTING  ON CONSOLE   *  
  * *******************************************************
       DISPLAY RANDOM-NUMBER.
       IF COUNT-OF-ACCESSES < RANDOM-NUMBERS-NEEDED
        GO TO 100-RANDGEN-EDIT-HOUSEKEEPING.     
   900-EXIT-RANDGEN.
       IF RANDOM-MSG NOT = SPACE
        DISPLAY 'RANDOM-MSG: ' RANDOM-MSG.
        MOVE ZERO TO COUNT-OF-ACCESSES RANDOM-NUMBERS-NEEDED RANDOM-NUMBER. 
        MOVE SPACE TO YOU-PROVIDE-SEED RUN-AGAIN.
       DISPLAY 'RUN AGAIN Y OR N '
         NO ADVANCING.
       ACCEPT RUN-AGAIN.
       IF (RUN-AGAIN = 'Y' OR 'y')
         GO TO 100-RANDGEN-EDIT-HOUSEKEEPING.
       ACCEPT PAUSE-FOR-A-SECOND.
       GOBACK.

คำตอบส่วนใหญ่ที่นี่ไม่สามารถรับประกันได้ว่าพวกเขาจะไม่ส่งคืนหมายเลขเดิมสองครั้ง นี่คือทางออกที่ถูกต้อง:

int nrrand(void) {
  static int s = 1;
  static int start = -1;
  do {
    s = (s * 1103515245 + 12345) & 1023;
  } while (s >= 1001);
  if (start < 0) start = s;
  else if (s == start) abort();

  return s;
}

ฉันไม่แน่ใจว่ามีการระบุข้อ จำกัด ไว้อย่างดี หนึ่งสมมติว่าหลังจาก 1000 เอาต์พุตอื่น ๆ ค่าจะได้รับอนุญาตให้ทำซ้ำ แต่ที่ไร้เดียงสาอนุญาตให้ 0 ติดตามทันทีหลังจาก 0 ตราบใดที่พวกเขาทั้งสองปรากฏในตอนท้ายและเริ่มชุด 1,000 ในทางกลับกันในขณะที่เป็นไปได้ที่จะรักษาระยะห่าง 1,000 ค่าอื่น ๆ ระหว่างการทำซ้ำการทำเช่นนั้นบังคับให้สถานการณ์ที่ลำดับไกลตัวเองในลักษณะเดียวกันทุกครั้งเพราะไม่มีค่าอื่น ๆ ที่เกิดขึ้นนอกขีด จำกัด นั้น

ต่อไปนี้เป็นวิธีการที่รับประกันอย่างน้อย 500 ค่าอื่น ๆ ก่อนที่จะทำซ้ำค่า:

int nrrand(void) {
  static int h[1001];
  static int n = -1;

  if (n < 0) {
    int s = 1;
    for (int i = 0; i < 1001; i++) {
      do {
        s = (s * 1103515245 + 12345) & 1023;
      } while (s >= 1001);
      /* If we used `i` rather than `s` then our early results would be poorly distributed. */
      h[i] = s;
    }
    n = 0;
  }

  int i = rand(500);
  if (i != 0) {
      i = (n + i) % 1001;
      int t = h[i];
      h[i] = h[n];
      h[n] = t;
  }
  i = h[n];
  n = (n + 1) % 1001;

  return i;
}

เมื่อ N มากกว่า 1,000 และคุณต้องวาดตัวอย่างสุ่ม K คุณสามารถใช้ชุดที่มีตัวอย่างจนถึง สำหรับการจับแต่ละครั้งคุณใช้การสุ่มตัวอย่างการปฏิเสธซึ่งจะเป็นการดำเนินการ "เกือบ" O (1) ดังนั้นเวลาการทำงานทั้งหมดคือเกือบ O (K) พร้อมที่เก็บ O (N)

อัลกอริธึมนี้เกิดการชนกันเมื่อ K ใกล้เคียงกับ N ซึ่งหมายความว่าเวลาทำงานจะแย่กว่า O (K) มาก การแก้ไขอย่างง่ายคือการย้อนกลับตรรกะเพื่อที่ K> N / 2 คุณจะเก็บบันทึกตัวอย่างทั้งหมดที่ยังไม่ถูกดึงออกมา การจับแต่ละครั้งจะลบตัวอย่างออกจากชุดการปฏิเสธ

ปัญหาที่ชัดเจนอื่น ๆ ที่มีการสุ่มตัวอย่างการปฏิเสธคือมันเป็นที่เก็บ O (N) ซึ่งเป็นข่าวร้ายถ้า N อยู่ในพันล้านหรือมากกว่านั้น อย่างไรก็ตามมีอัลกอริทึมที่แก้ปัญหานั้นได้ อัลกอริทึมนี้เรียกว่าอัลกอริทึมของ Vitter หลังจากเป็นนักประดิษฐ์ ขั้นตอนวิธีการอธิบายไว้ที่นี่ ส่วนสำคัญของอัลกอริธึมของ Vitter คือหลังจากการจับสลากแต่ละครั้งคุณคำนวณการข้ามแบบสุ่มโดยใช้การแจกแจงบางตัวซึ่งรับประกันการสุ่มตัวอย่างแบบสม่ำเสมอ

ฟิชเชอร์เยตส์

for i from n−1 downto 1 do
     j ← random integer such that 0 ≤ j ≤ i
     exchange a[j] and a[i]

จริงๆแล้วมันเป็น O (n-1) เนื่องจากคุณต้องการเพียงหนึ่ง swap สำหรับสองอันสุดท้าย
นี่คือ C #

public static List<int> FisherYates(int n)
{
    List<int> list = new List<int>(Enumerable.Range(0, n));
    Random rand = new Random();
    int swap;
    int temp;
    for (int i = n - 1; i > 0; i--)
    {
        swap = rand.Next(i + 1);  //.net rand is not inclusive
        if(swap != i)  // it can stay in place - if you force a move it is not a uniform shuffle
        {
            temp = list[i];
            list[i] = list[swap];
            list[swap] = temp;
        }
    }
    return list;
}

โปรดดูคำตอบของฉันที่ https://stackoverflow.com/a/46807110/8794687

มันเป็นหนึ่งในอัลกอริทึมที่ง่ายที่สุดที่มีความซับซ้อนของเวลาเฉลี่ยO ( s log s ) sแสดงถึงขนาดตัวอย่าง นอกจากนี้ยังมีการเชื่อมโยงบางอย่างไปยังอัลกอริทึมตารางแฮชที่ซับซ้อนอ้างว่าเป็นO ( s )

มีคนโพสต์ "สร้างตัวเลขสุ่มใน excel" ฉันกำลังใช้อุดมคตินี้ สร้างโครงสร้างที่มี 2 ส่วนคือ str.index และ str.ran สำหรับ 10 ตัวเลขสุ่มสร้างอาร์เรย์ของ 10 โครงสร้าง ตั้ง str.index จาก 0 ถึง 9 และ str.ran เป็นจำนวนสุ่มที่แตกต่างกัน

for(i=0;i<10; ++i) {
      arr[i].index = i;
      arr[i].ran   = rand();
}

เรียงลำดับอาร์เรย์ตามค่าใน arr [i] .ran str.index ขณะนี้อยู่ในลำดับแบบสุ่ม ด้านล่างคือรหัส c:

#include <stdio.h>
#include <stdlib.h>

struct RanStr { int index; int ran;};
struct RanStr arr[10];

int sort_function(const void *a, const void *b);

int main(int argc, char *argv[])
{
   int cnt, i;

   //seed(125);

   for(i=0;i<10; ++i)
   {
      arr[i].ran   = rand();
      arr[i].index = i;
      printf("arr[%d] Initial Order=%2d, random=%d\n", i, arr[i].index, arr[i].ran);
   }

   qsort( (void *)arr, 10, sizeof(arr[0]), sort_function);
   printf("\n===================\n");
   for(i=0;i<10; ++i)
   {
      printf("arr[%d] Random  Order=%2d, random=%d\n", i, arr[i].index, arr[i].ran);
   }

   return 0;
}

int sort_function(const void *a, const void *b)
{
   struct RanStr *a1, *b1;

   a1=(struct RanStr *) a;
   b1=(struct RanStr *) b;

   return( a1->ran - b1->ran );
}