Menghasilkan angka acak dalam bahasa C. Menghasilkan nomor acak (semu) Gunakan satu contoh kelas Acak untuk beberapa panggilan

Kelas di bawah ini sepenuhnya statis dan hanya berisi satu metode publik (terbuka) GetThreadRandom. Metode ini dijadikan metode, bukan properti, terutama untuk kenyamanan: ini akan memastikan bahwa semua kelas yang memerlukan instance Random akan bergantung pada Func (delegasi yang menunjuk ke metode yang tidak mengambil parameter dan mengembalikan nilai bertipe Random), dan bukan dari kelas Random itu sendiri. Jika suatu tipe dimaksudkan untuk dijalankan pada satu thread, tipe tersebut dapat memanggil delegasi untuk mendapatkan satu instance Random dan kemudian menggunakannya secara keseluruhan; jika tipe tersebut perlu bekerja dalam skenario multi-utas, tipe tersebut dapat memanggil delegasi setiap kali memerlukan generator nomor acak. Kelas di bawah ini akan membuat instance kelas Random sebanyak jumlah thread, dan setiap instance akan dimulai dari nilai awal yang berbeda. Jika kita perlu menggunakan penyedia nomor acak sebagai ketergantungan pada tipe lain, kita dapat melakukan ini: new TypeThatNeedsRandom(RandomProvider.GetThreadRandom) . Nah, ini kodenya sendiri:
menggunakan Sistem; menggunakan Sistem.Threading; kelas statis publik RandomProvider ( private static int seed = Environment.TickCount; private static ThreadLocal randomWrapper = ThreadLocal baru (() => new Random(saling bertautan.Peningkatan(ref seed)));
getThreadRandom() statis publik statis ( return randomWrapper.Value; ) )

Cukup sederhana, bukan? Ini karena semua kode ditujukan untuk menghasilkan instance Random yang benar. Setelah sebuah instance dibuat dan dikembalikan, tidak masalah apa yang Anda lakukan selanjutnya: semua penerbitan instance selanjutnya sepenuhnya independen dari instance saat ini. Tentu saja, kode klien memiliki celah untuk penyalahgunaan yang berbahaya: kode tersebut dapat mengambil satu instance Random dan meneruskannya ke thread lain alih-alih memanggil RandomProvider kami di thread lain tersebut.

Akan sangat bagus jika penyedia RNG dalam kerangka tersebut memiliki “sumber keacakan” yang terpisah. Dalam hal ini, kita dapat memiliki API tunggal, sederhana dan nyaman yang akan didukung oleh implementasi yang tidak aman namun cepat dan implementasi yang aman namun lambat. Yah, tidak ada salahnya bermimpi. Mungkin fungsi serupa akan muncul di versi .NET Framework yang akan datang. Mungkin seseorang yang bukan dari Microsoft akan menawarkan implementasi adaptornya sendiri. (Sayangnya, saya tidak akan menjadi orang itu...mengimplementasikan sesuatu seperti ini dengan benar ternyata sangat rumit.) Anda juga dapat membuat kelas Anda sendiri dengan mengambil dari Random dan mengganti metode Sample dan NextBytes, tetapi tidak jelas bagaimana tepatnya mereka seharusnya pekerjaan, atau bahkan Contoh Penerapan Anda sendiri bisa jadi jauh lebih rumit daripada yang terlihat. Mungkin lain kali...

Harap tangguhkan AdBlock di situs ini.

Terkadang mungkin perlu untuk menghasilkan angka acak. Sebuah contoh sederhana.

Contoh: Penentuan pemenang dalam kompetisi repost.

Ada daftar 53 orang. Penting untuk memilih pemenang dari mereka. Jika Anda memilihnya sendiri, Anda mungkin dituduh bias. Jadi Anda memutuskan untuk menulis sebuah program. Ini akan bekerja sebagai berikut. Anda memasukkan jumlah peserta N, setelah itu program menampilkan satu nomor - nomor pemenang.

Anda sudah mengetahui cara mendapatkan nomor dari seorang pemain. Tapi bagaimana Anda bisa memaksa komputer memikirkan angka acak? Dalam pelajaran ini Anda akan belajar bagaimana melakukan hal ini.

fungsi Rand().

Fungsi ini mengembalikan bilangan bulat acak dalam rentang dari nol hingga RAND_MAX. RAND_MAX adalah konstanta C khusus yang menampung nilai integer maksimum yang dapat dikembalikan oleh fungsi rand().

Fungsi rand() didefinisikan dalam file header stdlib.h. Oleh karena itu, jika Anda ingin menggunakan rand dalam program Anda, jangan lupa sertakan file header ini. Konstanta RAND_MAX juga didefinisikan dalam file ini. Anda dapat menemukan file ini di komputer Anda dan melihat artinya.

Mari kita lihat fitur ini beraksi. Mari kita jalankan kode berikut:

Daftar 1.

#termasuk // untuk menggunakan fungsi printf #include // untuk menggunakan fungsi rand int main(void) ( /* menghasilkan lima bilangan bulat acak */ printf("%d\n", rand()); printf("%d\n", rand()); printf ("%d\n", rand()); printf("%d\n", rand()); printf("%d\n", rand());

Seharusnya terlihat seperti ini.

Gbr.1 Lima angka acak yang dihasilkan oleh fungsi rand

Namun kami ingin mendapatkan angka dari 1 hingga 53, dan tidak semuanya berturut-turut. Berikut beberapa trik untuk membantu Anda membatasi fungsi rand().

Batasi angka acak dari atas.

Siapa pun yang menunggu di sekolah saat matematika berguna, bersiaplah. Saatnya telah tiba. Untuk membatasi bilangan acak di atas, Anda dapat menggunakan operasi memperoleh sisa pembagian yang telah Anda pelajari pada pelajaran terakhir. Anda mungkin tahu bahwa sisa pembagian dengan bilangan K selalu lebih kecil dari bilangan K. Misalnya membagi dengan 4 akan menghasilkan sisa 0, 1, 2, dan 3. Oleh karena itu, jika ingin membatasi bilangan acak dari atas ke bilangan K, maka cukup ambil sisa pembagiannya dengan K. Seperti ini:

Daftar 2.

#termasuk #termasuk int main(void) ( /* menghasilkan lima bilangan bulat acak kurang dari 100 */ printf("%d\n", rand()%100); printf("%d\n", rand()%100); printf ("%d\n", rand()%100); printf("%d\n", rand()%100);

Gbr.2 Lima bilangan acak kurang dari 100

Batasi angka di bawah ini.

Fungsi Rand mengembalikan angka acak dari interval. Bagaimana jika kita hanya membutuhkan angka yang lebih besar dari M (misalnya 1000)? Apa yang harus saya lakukan? Sederhana saja. Mari kita tambahkan nilai M kita ke fungsi rand yang dikembalikan. Kemudian jika fungsinya mengembalikan 0 maka jawaban akhirnya adalah M, jika 2394 maka jawaban akhirnya adalah M + 2394. Dengan tindakan ini kita seolah-olah menggeser semua bilangan ke depan sebanyak M satuan.

Tetapkan batas atas dan bawah fungsi Rand.

Misalnya, dapatkan angka dari 80 hingga 100. Sepertinya Anda hanya perlu menggabungkan kedua cara di atas. Kita akan mendapatkan sesuatu seperti ini:

Daftar 3.

#termasuk #termasuk int main(void) ( /* menghasilkan lima bilangan bulat acak yang lebih besar dari 80 dan kurang dari 100 */ printf("%d\n", 80 + rand()%100); printf("%d\n", 80 + nilai ()%100); printf("%d\n", 80 + nilai()%100); printf("%d\n", 80 + nilai()%100); 100);

Coba jalankan program ini. Terkejut?

Ya, cara ini tidak akan berhasil. Mari kita jalankan program ini secara manual untuk melihat apakah kita melakukan kesalahan. Katakanlah rand() mengembalikan nomor 143. Sisanya jika dibagi 100 adalah 43. Maka 80 + 43 = 123. Jadi cara ini tidak berhasil. Desain ini akan menghasilkan angka dari 80 hingga 179.

Mari kita uraikan ekspresi kita selangkah demi selangkah. rand()%100 dapat mengembalikan angka dari 0 hingga 99 inklusif. Itu. dari segmen tersebut.
Operasi + 80 menggeser segmen kami 80 unit ke kanan. Kami mengerti.
Seperti yang Anda lihat, masalah kita terletak pada batas kanan ruas; bergeser ke kanan sebanyak 79 unit. Ini angka asli kita 80 dikurangi 1. Mari kita bereskan dan pindahkan batas kanan kembali: 80 + rand()%(100 - 80 + 1) . Maka semuanya akan berjalan sebagaimana mestinya.

Secara umum, jika kita perlu mendapatkan nomor dari segmen tersebut, maka kita perlu menggunakan konstruksi berikut:
A + Rand()%(B-A+1) .

Berdasarkan rumus ini, kami akan menulis ulang program terakhir kami:

Daftar 4.

#termasuk #termasuk int main(void) ( /* menghasilkan lima bilangan bulat acak dari segmen */ printf("%d\n", 80 + rand()%(100 - 80 + 1)); printf("%d\n", 80 + rand()%(100 - 79)); printf("%d\n", 80 + rand()%21); printf("%d\n", 80 + rand()%21); "%d\n", 80 + rand()%21 )

Hasil:

Gbr.3 Angka acak dari suatu rentang

Nah, sekarang Anda bisa menyelesaikan masalah awal pelajaran. Hasilkan nomor dari segmen. Atau tidak bisa?

Tapi pertama-tama, beberapa informasi berguna. Jalankan program terakhir tiga kali berturut-turut dan tuliskan angka acak yang dihasilkannya. Apakah Anda memperhatikan?

fungsi srand().

Ya, nomor identik yang sama muncul setiap saat. “Generator biasa-biasa saja!” - katamu. Dan Anda tidak sepenuhnya benar. Memang, angka yang sama dihasilkan setiap saat. Namun kita dapat memengaruhinya dengan menggunakan fungsi srand(), yang juga didefinisikan dalam file header stdlib.h. Ini menginisialisasi generator nomor acak dengan nomor benih.

Kompilasi dan jalankan program ini beberapa kali:

Daftar 5.

#termasuk #termasuk int main(void) ( srand(2); /* menghasilkan lima bilangan bulat acak dari segmen */ printf("%d\n", 80 + rand()%(100 - 80 + 1)); printf("% d\n", 80 + rand()%(100 - 79)); printf("%d\n", 80 + rand()%21); printf("%d\n", 80 + rand() %21); printf("%d\n", 80 + nilai()%21);

Sekarang ubah argumen fungsi srand() ke angka lain (saya harap Anda tidak lupa apa itu argumen fungsi?) lalu kompilasi dan jalankan program lagi. Urutan angka harus berubah. Segera setelah kita mengubah argumen dalam fungsi srand, urutannya berubah. Sangat tidak praktis, bukan? Untuk mengubah urutannya, Anda perlu mengkompilasi ulang program. Andai saja nomor ini dimasukkan di sana secara otomatis.

Dan itu bisa dilakukan. Misalnya, mari kita gunakan fungsi time(), yang didefinisikan dalam file header time.h. Fungsi ini, jika NULL dilewatkan sebagai argumen, mengembalikan jumlah detik yang telah berlalu sejak 1 Januari 1970. Berikut ini cara melakukannya.

Daftar 6.

#termasuk #termasuk #termasuk // untuk menggunakan fungsi time() int main(void) ( srand(time(NULL)); /* menghasilkan lima bilangan bulat acak dari segmen */ printf("%d\n", 80 + rand()%( 100 - 80 + 1)); printf("%d\n", 80 + rand()%(100 - 79)); printf("%d\n", 80 + rand()%21); \n", 80 + rand()%21); printf("%d\n", 80 + rand()%21); )

Anda mungkin bertanya, apa itu NULL? Sebuah pertanyaan yang masuk akal. Sementara itu, saya akan memberi tahu Anda apa kata khusus yang dilindungi undang-undang ini. Saya juga bisa mengatakan apa arti pointer nol, tapi... Ini tidak memberi Anda informasi apa pun, jadi saya sarankan untuk tidak memikirkannya saat ini. Dan ingatlah itu sebagai semacam trik cerdas. Dalam pelajaran selanjutnya kita akan melihat hal ini secara lebih rinci.

Sangat sering dalam program ada kebutuhan untuk menggunakan nomor acak - mulai dari mengisi array hingga kriptografi. Untuk memperoleh barisan bilangan acak, bahasa C# memiliki kelas Random. Kelas ini menyediakan dua konstruktor:

• Acak()- menginisialisasi instance kelas Random dengan nilai awal yang bergantung pada waktu saat ini. Seperti diketahui, waktu dapat direpresentasikan dalam kutu- Pulsa 100 nanodetik mulai 1 Januari 0001. Dan nilai waktu dalam tick adalah bilangan bulat 64-bit, yang akan digunakan untuk menginisialisasi instance penghasil angka acak.
• Acak (Int32)- menginisialisasi instance kelas Random menggunakan nilai awal yang ditentukan. Menginisialisasi generator angka acak dengan cara ini dapat memudahkan saat men-debug suatu program, karena dalam hal ini angka “acak” yang sama akan dihasilkan setiap kali program diluncurkan.

• Next() - mengembalikan bilangan bulat non-negatif acak dalam format Int32.
• Berikutnya( Int32)- mengembalikan bilangan bulat non-negatif acak yang kurang dari nilai yang ditentukan.
• Berikutnya( Int32 mnt, Int32 maks)- mengembalikan bilangan bulat acak dalam rentang yang ditentukan. Dalam hal ini, kondisi min harus dipenuhi

• Byte Berikutnya( byte)- mengisi elemen array byte yang ditentukan dengan angka acak.
• NextDouble() - mengembalikan angka floating point acak, dalam rentang )
  merusak ; // kecocokan ditemukan, elemen tidak cocok
  }
  jika (j == saya)
  { // tidak ditemukan kecocokan
  a[i] = angka; // simpan elemennya
  saya++; // pergi ke elemen berikutnya
  }
  }
  untuk (int saya = 0; saya< 100; i++)
  {
  
  jika (saya % 10 == 9)
  Konsol.WriteLine();
  }
  Konsol .ReadKey();
  }
  }
  }

  

  Namun, semakin dekat ke akhir array, semakin banyak generasi yang harus dilakukan untuk mendapatkan nilai yang tidak berulang.
  Contoh berikut menampilkan jumlah panggilan ke metode Next() untuk mendapatkan setiap elemen, serta jumlah total angka acak yang dihasilkan untuk mengisi array 100 elemen dengan nilai yang tidak berulang.

  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

  menggunakan Sistem;
  namespace Program Saya
  {
  Program kelas
  {
  kekosongan statis Utama (argumen string)
  {
  Rnd acak = baru Acak();
  int a = int baru; // susunan elemen
  int hitungan = int baru; // array jumlah generasi
  a = rnd.Berikutnya(0, 101);
  ke dalam c = 0; // penghitung jumlah generasi
  hitungan = 1; // a hanya dihasilkan satu kali
  untuk (int saya = 1; saya< 100;)
  {
  int angka = rnd.Berikutnya(0, 101);
  c++; // membuat elemen sekali lagi
  ke dalam j;
  untuk (j = 0; j< i; j++)
  {
  jika (angka == a[j])
  merusak ;
  }
  jika (j == saya)
  {
  a[i] = angka; saya++;
  hitung[i] = c; c = 0; // simpan jumlah generasi
  }
  }
  // Mencetak nilai elemen
  Konsol .WriteLine( "Nilai Elemen");
  untuk (int saya = 0; saya< 100; i++)
  {
  Konsol .Write("(0,4) " , a[i]);
  jika (saya % 10 == 9)
  Konsol.WriteLine();
  }
  Konsol.WriteLine();
  // Menampilkan jumlah generasi
  Konsol .WriteLine( "Jumlah pembuatan elemen");
  int jumlah = 0;
  untuk (int saya = 0; saya< 100; i++)
  {
  jumlah += hitungan[i];
  Konsol .Write("(0,4) " , hitung[i]);
  jika (saya % 10 == 9)
  Konsol.WriteLine();
  }
  Konsol .WriteLine( "Jumlah total generasi - (0)", jumlah);
  Konsol .ReadKey();
  }
  }
  }
  

  kekosongan Utama (argumen string)
  {
  Rnd acak = baru Acak();
  int a = int baru;
  untuk (int saya = 0; saya< 100; i++)
  a[saya] = saya;
  untuk (int saya = 0; saya< 50; i++)
  {
  int i1 = rnd.Berikutnya(0, 100); // indeks pertama
  int i2 = rnd.Berikutnya(0, 100); // indeks kedua
  // pertukaran nilai elemen dengan indeks i1 dan i2
  int suhu = a;
  sebuah = sebuah;
  a = suhu;
  }
  Konsol .WriteLine( "Nilai Elemen");
  untuk (int saya = 0; saya< 100; i++)
  {
  Konsol .Write("(0,4) " , a[i]);
  jika (saya % 10 == 9)
  Konsol.WriteLine();
  }
  Konsol .ReadKey();
  }
  }
  }

  

  Pengacakan nilai lebih efektif jika rentang nilai cocok (atau mendekati) jumlah nilai, karena dalam hal ini jumlah pembuatan elemen acak berkurang secara signifikan.