Numeri casuali univoci (non ripetitivi) in O (1)?

Vorrei generare numeri casuali univoci tra 0 e 1000 che non si ripetono mai (cioè 6 non si presenta due volte), ma ciò non ricorre a qualcosa come una ricerca O (N) dei valori precedenti per farlo. È possibile?

Inizializza un array di 1001 numeri interi con i valori 0-1000 e imposta una variabile, max, sull'indice max corrente dell'array (a partire da 1000). Scegli un numero casuale, r, tra 0 e max, scambia il numero nella posizione r con il numero nella posizione max e restituisci il numero ora nella posizione max. Diminuisci max di 1 e continua. Quando max è 0, reimpostare max alla dimensione dell'array - 1 e ricominciare senza la necessità di reinizializzare l'array.

Aggiornamento: Anche se ho trovato questo metodo da solo quando ho risposto alla domanda, dopo alcune ricerche mi rendo conto che questa è una versione modificata di Fisher-Yates nota come Durstenfeld-Fisher-Yates o Knuth-Fisher-Yates. Poiché la descrizione può essere un po 'difficile da seguire, ho fornito un esempio di seguito (utilizzando 11 elementi anziché 1001):

L'array inizia con 11 elementi inizializzati nell'array [n] = n, il massimo inizia a 10:

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

Ad ogni iterazione, viene selezionato un numero casuale r tra 0 e max, l'array [r] e l'array [max] vengono scambiati, il nuovo array [max] viene restituito e il max viene diminuito:

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|
+--+--+--+--+--+--+--+--+--+--+--+

...

Dopo 11 iterazioni, tutti i numeri nell'array sono stati selezionati, max == 0 e gli elementi dell'array vengono mescolati:

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

A questo punto, max può essere resettato a 10 e il processo può continuare.

Puoi farlo:

1. Crea un elenco, 0..1000.
2. Mischia l'elenco. (Vedi Fisher-Yates shuffle per un buon modo per farlo.)
3. Restituisce i numeri in ordine dall'elenco mescolato.

Quindi questo non richiede una ricerca di vecchi valori ogni volta, ma richiede comunque O (N) per lo shuffle iniziale. Ma come sottolineato da Nils nei commenti, questo è ammortizzato O (1).

Usare un registro turni di feedback lineare massimo .

È implementabile in poche righe di C e in fase di esecuzione fa poco più di un paio di test / rami, una piccola aggiunta e un po 'di spostamento. Non è casuale, ma stupisce la maggior parte delle persone.

È possibile utilizzare un generatore congruenziale lineare . Dove m(il modulo) sarebbe il primo più vicino maggiore di 1000. Quando ottieni un numero fuori dall'intervallo, prendi solo quello successivo. La sequenza si ripeterà solo dopo che si sono verificati tutti gli elementi e non è necessario utilizzare una tabella. Sii consapevole degli svantaggi di questo generatore (inclusa la mancanza di casualità).

È possibile utilizzare la crittografia di conservazione del formato per crittografare un contatore. Il tuo contatore va da 0 in su e la crittografia utilizza una chiave di tua scelta per trasformarla in un valore apparentemente casuale di qualsiasi radix e larghezza desideri. Ad esempio per l'esempio in questa domanda: radix 10, larghezza 3.

I cifrari a blocchi hanno normalmente una dimensione di blocco fissa, ad esempio 64 o 128 bit. Ma la crittografia di conservazione del formato ti consente di prendere una cifra standard come AES e creare una cifra di larghezza inferiore, di qualsiasi radix e larghezza desideri, con un algoritmo che è ancora crittograficamente robusto.

È garantito che non si verificheranno mai collisioni (poiché gli algoritmi crittografici creano una mappatura 1: 1). È anche reversibile (una mappatura a 2 vie), quindi puoi prendere il numero risultante e tornare al valore del contatore con cui hai iniziato.

Questa tecnica non richiede memoria per archiviare un array mischiato, ecc., Che può essere un vantaggio su sistemi con memoria limitata.

AES-FFX è un metodo standard proposto per raggiungere questo obiettivo. Ho sperimentato un codice Python di base che si basa sull'idea AES-FFX, anche se non completamente conforme-- vedi il codice Python qui . Può ad esempio crittografare un contatore con un numero decimale di 7 cifre dall'aspetto casuale o un numero di 16 bit. Ecco un esempio di radix 10, larghezza 3 (per dare un numero compreso tra 0 e 999 incluso) come indicato nella domanda:

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
...   ...

Per ottenere diverse sequenze pseudo-casuali non ripetitive, modificare la chiave di crittografia. Ogni chiave di crittografia produce una diversa sequenza pseudo-casuale non ripetitiva.

Per numeri bassi come 0 ... 1000, la creazione di un elenco che contiene tutti i numeri e lo mescola è semplice. Ma se l'insieme di numeri da cui trarre è molto grande, c'è un altro modo elegante: puoi costruire una permutazione pseudocasuale usando un tasto e una funzione di hash crittografica. Vedi il seguente C ++ - pseudo codice esempio 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;
}

Qui, hashc'è solo una funzione pseudo casuale arbitraria che mappa una stringa di caratteri a un intero senza segno possibilmente enorme. La funzione randpermè una permutazione di tutti i numeri entro 0 ... pow (2, bit) -1 assumendo una chiave fissa. Ciò deriva dalla costruzione perché ogni passaggio che modifica la variabile indexè reversibile. Questo è ispirato a un codice Feistel .

Puoi usare il mio algoritmo Xincrol descritto qui:

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

Questo è un metodo algoritmico puro per generare numeri casuali ma univoci senza array, elenchi, permutazioni o carico pesante della CPU.

L'ultima versione consente anche di impostare l'intervallo di numeri, ad esempio, se voglio numeri casuali univoci nell'intervallo 0-1073741821.

L'ho praticamente usato per

• Lettore MP3 che riproduce ogni brano in modo casuale, ma solo una volta per album / directory
• Fotogrammi pixel saggi effetto dissolvenza (veloce e fluido)
• Creazione di una nebbia "rumore" segreta sull'immagine per firme e marcatori (steganografia)
• ID oggetto dati per la serializzazione di enormi quantità di oggetti Java tramite database
• Protezione dei bit di memoria a tripla maggioranza
• Crittografia indirizzo + valore (ogni byte non è solo crittografato, ma anche spostato in una nuova posizione crittografata nel buffer). Questo fatto ha fatto impazzire i compagni di crittoanalisi :-)
• Crittografia da testo semplice a semplice come Crypt Text per SMS, e-mail, ecc.
• My Texas Hold`em Poker Calculator (THC)
• Molti dei miei giochi per simulazioni, "mischiare", classifica
• Di Più

È aperto, gratuito. Provaci...

Non hai nemmeno bisogno di un array per risolvere questo.

Hai bisogno di una maschera di bit e un contatore.

Inizializza il contatore su zero e incrementalo nelle chiamate successive. XOR il contatore con la maschera di bit (selezionata casualmente all'avvio o fissa) per generare un numero psuedorandom. Se non puoi avere numeri che superano 1000, non usare una maschera di bit più larga di 9 bit. (In altre parole, la maschera di bit è un numero intero non superiore a 511.)

Assicurati che quando il contatore supera 1000, lo resetti a zero. In questo momento puoi selezionare un'altra maschera di bit casuale - se vuoi - per produrre lo stesso set di numeri in un ordine diverso.

Penso che il generatore congruenziale lineare sarebbe la soluzione più semplice.

e ci sono solo 3 restrizioni sui valori a , c e m

1. m e c sono relativamente primi,
2. a-1 è divisibile per tutti i fattori primi di m
3. a-1 è divisibile per 4 se m è divisibile per 4

PS il metodo è già stato menzionato ma il post ha ipotesi errate sui valori costanti. Le costanti di seguito dovrebbero funzionare bene per il tuo caso

Nel tuo caso si può utilizzare a = 1002, c = 757,m = 1001

X = (1002 * X + 757) mod 1001

Ecco un po 'di codice che ho scritto che utilizza la logica della prima soluzione. So che questo è "linguaggio agnostico" ma volevo solo presentarlo come esempio in C # nel caso in cui qualcuno fosse alla ricerca di una rapida soluzione pratica.

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

Questo metodo risulta appropriato quando il limite è alto e si desidera generare solo pochi numeri casuali.

#!/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";
}

Si noti che i numeri vengono generati in ordine crescente, ma è possibile mescolarli in seguito.

Potresti usare un buon generatore di numeri pseudo-casuali con 10 bit e buttare via da 1001 a 1023 lasciando da 0 a 1000.

Da qui otteniamo il design per un PRNG a 10 bit ..

• 10 bit, polinomio di feedback x ^ 10 + x ^ 7 + 1 (periodo 1023)

• usa un Galois LFSR per ottenere il codice veloce

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 I numeri casuali non ripetuti avranno una complessità O (n), come richiesto.
Nota: Casuale deve essere statico con la sicurezza della filettatura applicata.

Diciamo che vuoi ripassare più volte gli elenchi mescolati, senza avere il O(n)ritardo ogni volta che ricominciare a mescolarlo di nuovo, in tal caso possiamo fare questo:

1. Creare 2 elenchi A e B, da 0 a 1000, occupa 2nspazio.

2. L'elenco casuale A che utilizza Fisher-Yates richiede ntempo.

3. Quando si disegna un numero, eseguire Fisher-Yates shuffle in 1 passaggio sull'altro elenco.

4. Quando il cursore si trova alla fine dell'elenco, passare all'altro elenco.

preprocess

cursor = 0

selector = A
other    = B

shuffle(A)

Disegnare

temp = selector[cursor]

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

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

return temp

La domanda Come si genera in modo efficiente un elenco di K numeri interi non ripetitivi tra 0 e un limite superiore N è collegato come duplicato - e se si desidera qualcosa che è O (1) per numero casuale generato (senza O (n) costo di avvio)) c'è una semplice modifica della risposta accettata.

Crea una mappa vuota non ordinata (una mappa ordinata vuota prenderà O (log k) per elemento) da intero a intero, anziché utilizzare un array inizializzato. Impostare massimo su 1000 se questo è il massimo,

1. Scegli un numero casuale, r, tra 0 e max.
2. Assicurarsi che entrambi gli elementi della mappa r e max esistano nella mappa non ordinata. Se non esistono, crearli con un valore uguale al loro indice.
3. Scambia gli elementi re max
4. Restituisce max elemento e decrementa massimo di 1 (se max diventa negativo il gioco è fatto).
5. Torna al passaggio 1.

L'unica differenza rispetto all'utilizzo di un array inizializzato è che l'inizializzazione degli elementi è posticipata / ignorata, ma genererà gli stessi numeri esatti dallo stesso PRNG.

Un'altra possibilità:

È possibile utilizzare una serie di flag. E prendi il prossimo quando è già stato scelto.

Ma fai attenzione dopo 1000 chiamate, la funzione non finirà mai, quindi devi fare una protezione.

Ecco alcuni esempi di codice COBOL con cui puoi giocare.
Posso inviarti il ​​file RANDGEN.exe in modo da poter giocare con esso per vedere se lo desideri.

   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.

La maggior parte delle risposte qui non garantisce che non restituiranno lo stesso numero due volte. Ecco una soluzione corretta:

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

Non sono sicuro che il vincolo sia ben specificato. Si presume che dopo altre 1000 uscite sia consentito ripetere un valore, ma che consente ingenuamente a 0 di seguire immediatamente dopo 0 purché appaiano entrambi alla fine e all'inizio di set di 1000. Viceversa, mentre è possibile mantenere una distanza di 1000 altri valori tra le ripetizioni, in tal modo forza una situazione in cui la sequenza si riproduce esattamente nello stesso modo ogni volta perché non c'è altro valore che si è verificato al di fuori di quel limite.

Ecco un metodo che garantisce sempre almeno altri 500 valori prima di poter ripetere un valore:

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

Quando N è maggiore di 1000 e devi disegnare K campioni casuali, puoi usare un set che contiene i campioni finora. Per ogni sorteggio si utilizza il campionamento del rifiuto , che sarà un'operazione "quasi" O (1), quindi il tempo di esecuzione totale è quasi O (K) con memoria O (N).

Questo algoritmo si scontra quando K è "vicino" a N. Ciò significa che il tempo di esecuzione sarà molto peggio di O (K). Una semplice correzione è di invertire la logica in modo che, per K> N / 2, si tenga traccia di tutti i campioni che non sono stati ancora disegnati. Ogni estrazione rimuove un campione dal set di rifiuto.

L'altro ovvio problema con il campionamento del rifiuto è che si tratta di archiviazione O (N), che è una cattiva notizia se N è tra i miliardi o più. Tuttavia, esiste un algoritmo che risolve quel problema. Questo algoritmo si chiama algoritmo di Vitter dopo il suo inventore. L'algoritmo è descritto qui . L'essenza dell'algoritmo di Vitter è che dopo ogni estrazione, si calcola un salto casuale usando una certa distribuzione che garantisce un campionamento uniforme.

Fisher Yates

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

In realtà è O (n-1) in quanto è necessario solo uno scambio per gli ultimi due
Questo è 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;
}

Si prega di vedere la mia risposta a https://stackoverflow.com/a/46807110/8794687

Si tratta di uno degli algoritmi più semplici che hanno tempo medio di complessità O ( s log s ), s denota la dimensione del campione. Ci sono anche alcuni collegamenti lì agli algoritmi della tabella hash la cui complessità è dichiarata O ( s ).

Qualcuno ha pubblicato "la creazione di numeri casuali in Excel". Sto usando questo ideale. Crea una struttura con 2 parti, str.index e str.ran; Per 10 numeri casuali creare una matrice di 10 strutture. Impostare str.index da 0 a 9 e str.ran su un numero casuale diverso.

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

Ordinare l'array in base ai valori in arr [i] .ran. Str.index è ora in un ordine casuale. Di seguito è riportato il codice 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 );
}