Generování náhodných čísel v jazyce C. Náhodná čísla ve standardním generátoru náhodných čísel C C

Níže uvedená třída je zcela statická a obsahuje pouze jednu veřejnou (otevřenou) metodu GetThreadRandom. Tato metoda je vytvořena spíše metodou než vlastností, hlavně pro pohodlí: to zajistí, že všechny třídy, které potřebují instanci Random, budou záviset na Func (delegát ukazující na metodu, která nebere žádné parametry a vrací hodnotu typu Random), a nikoli ze samotné třídy Random. Pokud je typ určen ke spuštění v jediném vláknu, může zavolat delegáta, aby získal jedinou instanci Random a poté ji mohl používat v celém průběhu; pokud typ potřebuje pracovat ve vícevláknových scénářích, může zavolat delegátovi pokaždé, když potřebuje generátor náhodných čísel. Níže uvedená třída vytvoří tolik instancí třídy Random, kolik je vláken, a každá instance bude začínat od jiné počáteční hodnoty. Pokud potřebujeme použít poskytovatele náhodných čísel jako závislost v jiných typech, můžeme udělat toto: new TypeThatNeedsRandom(RandomProvider.GetThreadRandom) . No, tady je samotný kód:
pomocí systému; pomocí System.Threading; public static class RandomProvider ( private static int seed = Environment.TickCount; private static ThreadLocal randomWrapper = nový ThreadLocal (() => new Random(Interlocked.Increment(ref seed))); public static Random GetThreadRandom() ( return randomWrapper.Value; ) )
Dost jednoduché, že? Je to proto, že veškerý kód je zaměřen na vytvoření správné instance Random. Jakmile je instance vytvořena a vrácena, nezáleží na tom, co s ní dále uděláte: všechna další vydání instancí jsou zcela nezávislá na aktuální. Klientský kód má samozřejmě mezeru pro škodlivé zneužití: může vzít jednu instanci Random a předat ji jiným vláknům namísto volání našeho RandomProvider v těchto jiných vláknech.

Problémy s návrhem rozhraní

Bylo by velmi hezké, kdyby poskytovatelé RNG v rámci měli samostatné „zdroje náhodnosti“. V tomto případě bychom mohli mít jediné, jednoduché a pohodlné API, které by podporovala jak nezabezpečená, ale rychlá implementace, tak zabezpečená, ale pomalá. No, není na škodu snít. Možná se podobná funkce objeví v budoucích verzích .NET Framework. Možná někdo mimo Microsoft nabídne vlastní implementaci adaptéru. (Bohužel tím člověkem nebudu...implementovat něco takového správně je překvapivě složité.) Můžete si také vytvořit vlastní třídu odvozením z Random a přepsáním metod Sample a NextBytes, ale není jasné, jak přesně by měly práce nebo dokonce váš vlastní Implementační vzorek může být mnohem složitější, než se zdá. Možná příště…

Velmi často je v programech potřeba používat náhodná čísla - od vyplňování pole až po kryptografii. Pro získání posloupnosti náhodných čísel má jazyk C# třídu Random. Tato třída poskytuje dva konstruktory:

• Náhodný()- inicializuje instanci třídy Random s počáteční hodnotou, která závisí na aktuálním čase. Jak je známo, čas může být reprezentován v klíšťata- 100 nanosekundových pulzů počínaje 1. lednem 0001. A časová hodnota v ticks je 64bitové celé číslo, které bude použito k inicializaci instance generátoru náhodných čísel.
• Náhodné (Int32)- inicializuje instanci třídy Random pomocí zadané počáteční hodnoty. Inicializace generátoru náhodných čísel tímto způsobem může být pohodlná při ladění programu, protože v tomto případě budou při každém spuštění programu generována stejná „náhodná“ čísla.

• Next() - vrací náhodné nezáporné celé číslo ve formátu Int32.
• Další( Int32)- vrátí náhodné nezáporné celé číslo, které je menší než zadaná hodnota.
• Další( Int32 min, Int32 max)- vrátí náhodné celé číslo v zadaném rozsahu. V tomto případě musí být splněna podmínka min

• NextBytes( Byte)- vyplní prvky zadaného bajtového pole náhodnými čísly.
• NextDouble() - vrací náhodné číslo s plovoucí desetinnou čárkou v rozsahu )
  přestávka ; // nalezena shoda, prvek se neshoduje
  }
  jestliže (j == i)
  { // žádná shoda nenalezena
  a[i] = num; // uložit prvek
  i++; // přejít na další prvek
  }
  }
  for (int i = 0; i< 100; i++)
  {
  
  if (i % 10 == 9)
  Console.WriteLine();
  }
  Konzole .ReadKey();
  }
  }
  }

  

  Čím blíže ke konci pole, tím více generací musí být provedeno, aby se získala neopakující se hodnota.
  Následující příklad zobrazuje počet volání metody Next() k získání každého prvku a také celkový počet náhodných čísel vygenerovaných k vyplnění pole 100 prvků neopakujícími se hodnotami.

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53

  pomocí systému;
  jmenný prostor MyProgram
  {
  třídní program
  {
  static void Main (string args)
  {
  Random rnd = new Random();
  int a = new int ; // pole prvků
  int pocet = new int ; // pole počtu generací
  a = rnd.Další(0, 101);
  int c = 0; // čítač počtu generací
  počet = 1; // a je generováno pouze jednou
  for (int i = 1; i< 100;)
  {
  int num = rnd.Next(0, 101);
  c++; // vygeneroval prvek ještě jednou
  int j;
  pro (j = 0; j< i; j++)
  {
  if (num == a[j])
  přestávka ;
  }
  jestliže (j == i)
  {
  a[i] = num; i++;
  počet[i] = c; c = 0; // uložit počet generací
  }
  }
  // Tisk hodnot prvků
  Konzole .WriteLine( "Hodnoty prvků");
  for (int i = 0; i< 100; i++)
  {
  Console .Write("(0,4) " , a[i]);
  if (i % 10 == 9)
  Console.WriteLine();
  }
  Console.WriteLine();
  // Zobrazení počtu generací
  Konzole .WriteLine( "Počet generace prvků");
  int součet = 0;
  for (int i = 0; i< 100; i++)
  {
  součet += počet[i];
  Console .Write("(0,4) " , count[i]);
  if (i % 10 == 9)
  Console.WriteLine();
  }
  Konzole .WriteLine( "Celkový počet generací - (0)", součet);
  Konzole .ReadKey();
  }
  }
  }
  

  void Main (string args)
  {
  Random rnd = new Random();
  int a = nový int ;
  for (int i = 0; i< 100; i++)
  a[i] = i;
  for (int i = 0; i< 50; i++)
  {
  int i1 = rnd.Next(0, 100); // první index
  int i2 = rnd.Next(0, 100); // druhý index
  // výměna hodnot prvků s indexy i1 a i2
  int temp = a;
  a = a;
  a = teplota;
  }
  Konzole .WriteLine( "Hodnoty prvků");
  for (int i = 0; i< 100; i++)
  {
  Console .Write("(0,4) " , a[i]);
  if (i % 10 == 9)
  Console.WriteLine();
  }
  Konzole .ReadKey();
  }
  }
  }

  

  Přesouvání hodnot je efektivnější, pokud se rozsah hodnot shoduje (nebo se blíží) počtu hodnot, protože v tomto případě je počet generování náhodných prvků výrazně snížen.

  Funkce, která generuje pseudonáhodná čísla, má prototyp v souboru knihovny stdlib.h:
  

  1
  2
  3
  4
  5
  6

  unsigned long int next = 1;
  int rand (neplatný)
  {
  další = další * 1103515245;
  return ((unsigned int )(další / 65536) * 2768);
  }
  

  
  Funkce rand() nebere žádné argumenty, ale pracuje s další proměnnou s globálním rozsahem.

  Pokud potřebujete vygenerovat sekvenci v rozsahu , pak se použije vzorec:

  Číslo = rand() % (M2-M1+1) + M1;

  Kde Číslo– vygenerované číslo. M2-M1+1– plný rozsah reprezentace čísel. M1– offset zadaného rozsahu vzhledem k 0; % - zbytek divize.

  Pokud například potřebujete vygenerovat sekvenci v rozsahu [-10;10], bude volání funkce vypadat

  Číslo = rand()%(10+10+1)-10

  Číslo = rand()%(21)-10

  V důsledku získání zbytku z dělení 21 máme číslo od 0 do 20. Odečtením 10 od výsledného čísla získáme číslo v požadovaném rozsahu [-10;10].

  Sekvence generovaná funkcí rand() však bude vypadat stejně při každém spuštění programu.

  Pro generování různých sekvencí při každém spuštění programu je nutné inicializovat globální proměnnou next s hodnotou jinou než 1. K tomuto účelu použijte funkci
  void srand (nepodepsané int seed)
  (další = semeno; )
  Aby bylo zajištěno, že inicializace next bude při každém spuštění programu jiná, je jako výchozí argument nejčastěji používán aktuální čas.

  Příklad Vyplňte pole 20 prvků náhodnými čísly v rozsahu od 0 do 99.
  

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15

  #zahrnout
  #zahrnout
  #zahrnout
  #definujte VELIKOST 20
  int main() (
  int a;
  srand(čas(NULL));
  for (int i = 0; i {
  a[i] = rand() % 100;
  printf("%d" , a[i]);
  }
  getchar();
  návrat 0;
  }
  

  
  Výsledek provedení
  

  Často vzniká úkol uspořádat existující sadu hodnot v náhodném pořadí. K tomuto účelu se také používá generátor pseudonáhodných čísel. Tím se vytvoří pole a naplní se hodnotami.
  Samotný postup míchání je následující. Dvě hodnoty indexu pole jsou generovány náhodně a hodnoty prvků s výslednými indexy jsou prohozeny. Postup se opakuje alespoň Nkrát, kde N je počet prvků pole.
  Jako příklad zvažte zamíchání 20 hodnot (od 1 do 20) a opakování postupu 20krát.

  Implementace v C
  

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30

  #zahrnout
  #zahrnout
  #zahrnout
  #definujte VELIKOST 20
  int main() (
  int a;
  srand(čas(NULL));
  
  for (int i = 0; i< SIZE; i++)
  {
  a[i] = i + 1;
  printf("%2d " , a[i]);
  }
  for (int i = 0; i< SIZE; i++)
  {
  // Náhodně vygeneruje dva indexy prvků
  int ind1 = rand() % 20;
  int ind2 = rand() % 20;
  // a zaměňte prvky s těmito indexy
  int temp = a;
  a = a;
  a = teplota;
  }
  printf("\n" );
  
  for (int i = 0; i< SIZE; i++)
  printf("%2d " , a[i]);
  getchar();
  návrat 0;
  }
  

  
  Výsledek provedení
  
  
  

  Často vyvstává úkol náhodného výběru dříve specifikovaných prvků pole. Navíc je nutné zajistit absenci opakování při výběru těchto prvků.
  Algoritmus pro tuto volbu je následující:

  • Náhodně vybereme index prvku pole
  • Pokud již byl vybrán prvek se stejným indexem, posuňte se doprava, dokud nedosáhneme dalšího nevybraného prvku. Zároveň dbáme na to, aby „pohyb doprava“ nepřesáhl hranice pole. Pokud je detekován přesah pole, začneme prvky pole prohlížet od začátku.
  • Výběr prvku
  • Oprava prvku podle výběru
  • Opakujte tyto kroky pro všechny ostatní prvky

  Implementace v C
  Výsledkem je nové pole b, vytvořené náhodným výběrem prvků pole a.
  

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33

  #zahrnout
  #zahrnout
  #zahrnout
  #definujte VELIKOST 20
  int main() (
  int a;
  int b; // výsledné pole
  srand(čas(NULL));
  // Vyplňte pole po sobě jdoucími hodnotami od 1 do 20
  for (int i = 0; i< SIZE; i++)
  {
  a[i] = i + 1;
  printf("%2d " , a[i]);
  }

  for (int i = 0; i< SIZE; i++)
  {
  int ind = rand() % 20; // vyberte libovolný index
  zatímco (a == -1) // když je prvek "vybraný"
  {
  ind++; // posun doprava
  ind %= 20; // pokud dosáhneme správné hranice, vrátíme se na začátek
  }
  b[i] = a; // zápis dalšího prvku pole b
  a = -1; // označte prvek pole a jako "vybraný"
  }
  printf("\n" );
  // Výstup výsledného pole
  for (int i = 0; i< SIZE; i++)
  printf("%2d " , b[i]);
  getchar();
  návrat 0;
  }
  

  
  Výsledek provedení
  
  

  Zdravím všechny, kteří se zastavili. Tato krátká poznámka bude obsahovat pár slov o generování pseudonáhodných čísel v C/C++. Zejména o tom, jak pracovat s nejjednodušší generovací funkcí - rand().

  funkce rand().

  Nalezeno ve standardní knihovně C++ (stdlib.h). Vygeneruje a vrátí pseudonáhodné číslo v rozsahu od 0 do RAND_MAX . Tato konstanta se může lišit v závislosti na architektuře kompilátoru nebo procesoru, ale obecně jde o maximální hodnotu datového typu unsigned int. Neakceptuje parametry a nikdy neakceptoval.

  Aby generování proběhlo, je potřeba nastavit seed pomocí pomocné funkce ze stejné knihovny - srand(). Vezme číslo a nastaví ho jako výchozí bod pro generování náhodného čísla. Pokud seed není nastaven, při každém spuštění programu obdržíme stejný náhodná čísla. Nejviditelnějším řešením je poslat tam aktuální systémový čas. To lze provést pomocí funkce time(NULL). Tato funkce je v knihovně time.h.

  Utřídili jsme teorii, našli všechny funkce pro generování náhodných čísel, teď je pojďme vygenerovat.

  Příklad použití funkce generování náhodných čísel rand().

  #zahrnout #zahrnout #zahrnout pomocí jmenného prostoru std; int main() ( srand(čas(NULL)); for(int i = 0; i< 10; i++) { cout << rand() << endl; } return 0; }

  Rand nám vygeneroval 10 náhodných čísel. Že jsou náhodné, můžete ověřit opakovaným spouštěním programu. Ale to nestačí, takže musíme mluvit o dosahu.

  Nastavit hranice rozsahu pro rand()

  Chcete-li vygenerovat číslo v rozsahu od A do B včetně, musíte napsat toto:

  A + rand() % ((B + 1) - A);

  Hraniční hodnoty mohou být také záporné, což vám umožňuje vygenerovat záporné náhodné číslo, podívejme se na příklad.

  #zahrnout #zahrnout #zahrnout pomocí jmenného prostoru std; int main() ( srand(čas(NULL)); int A = -2; int B = 8; for(int i = 0; i< 100; i++) { cout << A + rand() % ((B + 1) - A) << endl; } return 0; }