दिलचस्प पोस्ट
बूलियन, सशर्त ऑपरेटर्स और ऑटोबॉक्सिंग स्ट्रिंग को किसी तारीख को सी ++ में कनवर्ट करें वैश्विक चर का उपयोग किए बिना अन्य कार्यों से चर तक पहुंच यह निर्धारित करने के लिए कि क्या कोई पोर्ट एक विंडोज सर्वर पर खुला है? सी – एक मिश्रित-केस स्ट्रिंग को सभी लोअर केस में परिवर्तित करें सी गैर-अवरुद्ध कुंजीपटल इनपुट प्रारंभिक गतिविधि पर एक बंडल पास करना ()? "चेतावनी: आईफ़ोन एप में बिल्ड वर्कचर भी शामिल होना चाहिए" यहां तक ​​कि बिल्ड कॉन्फ़िग सेट के साथ अजगर के साथ Win32 API का उपयोग कैसे करें? जावा एम्बेडेड डेटाबेस तुलना जावा से पर्यावरण चर कैसे सेट करूं? SQLite को CSV आयात करें आर पैकेज के विकास संस्करण को कैसे स्थापित करें github repository? जावास्क्रिप्ट पद्धति श्रृंखला में इनपुट पैरामीटर कैसे भरा जाता है? यूआरएल_ के लिए फ्लास्क स्टैटिक फाइल्स से लिंक करें

कैसे सी में एक यादृच्छिक संख्या उत्पन्न करने के लिए?

सी में एक यादृच्छिक संख्या उत्पन्न करने के लिए कोई फ़ंक्शन है? या मुझे एक तीसरी पार्टी लाइब्रेरी का उपयोग करना होगा?

वेब के समाधान से एकत्रित समाधान "कैसे सी में एक यादृच्छिक संख्या उत्पन्न करने के लिए?"

नोट : सुरक्षा के लिए rand() उपयोग न करें यदि आपको क्रिप्टोग्राफ़िक रूप से सुरक्षित नंबर की आवश्यकता है, तो इसके बजाय इस उत्तर देखें ।

 #include <time.h> #include <stdlib.h> srand(time(NULL)); // should only be called once int r = rand(); // returns a pseudo-random integer between 0 and RAND_MAX 

<stdlib.h> में rand() फ़ंक्शन एक छद्म यादृच्छिक पूर्णांक 0 और RAND_MAX बीच RAND_MAX । आप एक बीज सेट करने के लिए srand(unsigned int seed) का उपयोग कर सकते हैं

एक अलग श्रेणी प्राप्त करने के लिए (हालांकि यह ध्यान में रखें कि यह एकरूपता से कुछ फेंकता है rand() के साथ संयोजन के साथ % ऑपरेटर का उपयोग करने के लिए सामान्य अभ्यास है उदाहरण के लिए:

 /* random int between 0 and 19 */ int r = rand() % 20; 

यदि आप वास्तव में समानता की देखभाल करते हैं तो आप ऐसा कुछ कर सकते हैं:

 /* Returns an integer in the range [0, n). * * Uses rand(), and so is affected-by/affects the same seed. */ int randint(int n) { if ((n - 1) == RAND_MAX) { return rand(); } else { // Chop off all of the values that would cause skew... long end = RAND_MAX / n; // truncate skew assert (end > 0L); end *= n; // ... and ignore results from rand() that fall above that limit. // (Worst case the loop condition should succeed 50% of the time, // so we can expect to bail out of this loop pretty quickly.) int r; while ((r = rand()) >= end); return r % n; } } 

यदि आपको सुरक्षित यादृच्छिक वर्ण या पूर्णांक की आवश्यकता है:

जैसा कि विभिन्न प्रोग्रामिंग भाषाओं में सुरक्षित रूप से यादृच्छिक संख्या उत्पन्न करने के तरीके में बताया गया है , आप निम्न में से कोई एक करना चाहते हैं:

  • लिबोडियम के randombytes एपीआई का प्रयोग करें
  • लिब्सोडियम के sysrandom क्रियान्वयन से आप को क्या जरूरत है, इसे पुन: लागू करें, बहुत सावधानी से
  • मोटे तौर पर, /dev/urandom उपयोग करें , नहीं /dev/random ओपनएसएसएल (या अन्य यूज़रस्पेस पीआरएनजीएस) नहीं।

उदाहरण के लिए:

 #include "sodium.h" int foo() { char myString[32]; uint32_t myInt; /* myString will be an array of 32 random bytes, not null-terminated */ randombytes_buf(myString, 32); /* myInt will be a random number between 0 and 9 */ myInt = randombytes_uniform(10); } 

randombytes_uniform() cryptographically सुरक्षित और निष्पक्ष है।

यदि आपको बेहतर गुणवत्ता वाले छद्म यादृच्छिक संख्या की तुलना में क्या stdlib है, तो stdlib ट्विस्टर की जांच करें यह तेज भी है नमूना कार्यान्वयन बहुतायत से हैं, उदाहरण के लिए यहां ।

इस के माध्यम से चलें। सबसे पहले हम randomizer के बीज को srand () फ़ंक्शन का उपयोग करते हैं असल में, कंप्यूटर संख्या के आधार पर यादृच्छिक संख्या उत्पन्न कर सकता है जो कि srand () को खिलाया जाता है। यदि आप समान बीज मान देते हैं, तो हर बार समान यादृच्छिक संख्या उत्पन्न होती है।

इसलिए, हमें हमेशा एक मूल्य के साथ यादृच्छिक बीज बोना पड़ता है जो हमेशा बदलता रहता है। हम इसे समय () फ़ंक्शन के साथ वर्तमान समय के मूल्य को खिला कर करते हैं।

अब, जब हम रैंड () कहते हैं, तो हर बार एक नया यादृच्छिक संख्या उत्पन्न होगी।

 #include <stdio.h> int random_number(int min_num, int max_num); int main(void) { printf("Min : 1 Max : 40 %d\n", random_number(1,40)); printf("Min : 100 Max : 1000 %d\n",random_number(100,1000)); return 0; } int random_number(int min_num, int max_num) { int result = 0, low_num = 0, hi_num = 0; if (min_num < max_num) { low_num = min_num; hi_num = max_num + 1; // include max_num in output } else { low_num = max_num + 1; // include max_num in output hi_num = min_num; } srand(time(NULL)); result = (rand() % (hi_num - low_num)) + low_num; return result; } 

मानक सी फ़ंक्शन rand() त्यागी के लिए कार्ड सौदा करने के लिए पर्याप्त है, लेकिन यह भयानक है। संख्याओं की एक छोटी सूची के माध्यम से rand() चक्र के कई कार्यान्वयन, और कम बिट्स में छोटे चक्र होते हैं। जिस तरह से कुछ प्रोग्राम rand() को कॉल करते हैं, वह भयानक है, और एक अच्छे बीज की गणना करने के लिए srand() कठिन है

सी में यादृच्छिक संख्या उत्पन्न करने का सबसे अच्छा तरीका है एक तृतीय-पक्ष लायब्रेरी जैसे ओपनएसएसएल का उपयोग करना। उदाहरण के लिए,

 #include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <openssl/rand.h> /* Random integer in [0, limit) */ unsigned int random_uint(unsigned int limit) { union { unsigned int i; unsigned char c[sizeof(unsigned int)]; } u; do { if (!RAND_bytes(uc, sizeof(uc))) { fprintf(stderr, "Can't get random bytes!\n"); exit(1); } } while (ui < (-limit % limit)); /* ui < (2**size % limit) */ return ui % limit; } /* Random double in [0.0, 1.0) */ double random_double() { union { uint64_t i; unsigned char c[sizeof(uint64_t)]; } u; if (!RAND_bytes(uc, sizeof(uc))) { fprintf(stderr, "Can't get random bytes!\n"); exit(1); } /* 53 bits / 2**53 */ return (ui >> 11) * (1.0/9007199254740992.0); } int main() { printf("Dice: %d\n", (int)(random_uint(6) + 1)); printf("Double: %f\n", random_double()); return 0; } 

इतना कोड क्यों? अन्य भाषाओं जैसे जावा और रूबी में यादृच्छिक पूर्णांक या फ़्लोट्स के लिए कार्य किया जाता है। ओपनएसएसएल केवल यादृच्छिक बाइट्स देता है, इसलिए मैं नकल करने की कोशिश करता हूं कि कैसे जावा या रूबी उन्हें पूर्णांक या फ्लोट में बदलते हैं।

पूर्णांक के लिए, हम माड्यूलो पूर्वाग्रह से बचना चाहते हैं। मान लीजिए कि हमें rand() % 10000 से कुछ यादृच्छिक 4 अंकों वाले पूर्णांक प्राप्त हुए हैं, लेकिन rand() केवल 0 से 32767 (जैसे कि माइक्रोसॉफ्ट विंडोज में करता है rand() वापस कर सकते हैं। 0 से 2767 तक प्रत्येक संख्या 2768 से 99 99 तक प्रत्येक संख्या की तुलना में अधिक बार प्रकट हो जाएगी। पूर्वाग्रह को दूर करने के लिए, हम rand() पुनः प्रयास कर सकते हैं, जबकि मूल्य 2768 से नीचे है, क्योंकि 2768 से 32767 के 30000 मूल्य 10000 मूल्यों पर समान रूप से मानचित्रित होते हैं 0 से 99 99 तक

फ्लोट्स के लिए, हम 53 यादृच्छिक बिट्स चाहते हैं, क्योंकि एक double बास्केट 53 बिट सटीकता (यह मानते हुए कि यह आईईईई डबल है)। यदि हम 53 बिट्स से अधिक का उपयोग करते हैं, तो हम गोल पूर्वाग्रह प्राप्त करते हैं। कुछ प्रोग्रामर कोड लिखते हैं जैसे rand() / (double)RAND_MAX , लेकिन rand() केवल 31 बिट्स या Windows में केवल 15 बिट्स लौटा सकते हैं।

ओपनएसएसएल का RAND_bytes() बीज, शायद लिनक्स में /dev/urandom को पढ़कर। अगर हमें कई यादृच्छिक संख्या की आवश्यकता होती है, तो उन्हें /dev/urandom से सभी को पढ़ने में बहुत धीमी गति होगी, क्योंकि उन्हें कर्नेल से कॉपी करना होगा ओपनएसएसएल को बीज से अधिक यादृच्छिक संख्या उत्पन्न करने की अनुमति देने के लिए यह तेज़ है।

यादृच्छिक संख्या के बारे में अधिक:

  • पर्ल के पर्ल_सीड () एक उदाहरण है कि कैसे सी के लिए सी के लिए सीआरएंड () की गणना करें। यह वर्तमान समय, प्रक्रिया आईडी और कुछ पॉइंटर्स से बिट्स को घोषित करता है, यदि वह /dev/urandom पढ़ नहीं सकता है।
  • ओपनबीएसडी के एआरसी 4आरएंड_एनिफ़ॉर्म () मॉड्यूलो बायस को बताता है।
  • Java.util.Random के लिए जावा एपीआई यादृच्छिक पूर्णांक से पूर्वाग्रह को हटाने के लिए एल्गोरिदम का वर्णन करता है, और 53 बिट्स को यादृच्छिक फ्लोट में पैक कर रहा है।

यदि आपका सिस्टम फ़ंक्शन के arc4random परिवार का समर्थन करता है तो मैं मानक rand फ़ंक्शन के बजाय उन का उपयोग करने की सलाह देता हूं।

arc4random परिवार में शामिल हैं:

 uint32_t arc4random(void) void arc4random_buf(void *buf, size_t bytes) uint32_t arc4random_uniform(uint32_t limit) void arc4random_stir(void) void arc4random_addrandom(unsigned char *dat, int datlen) 

arc4random एक यादृच्छिक 32-बिट हस्ताक्षरित पूर्णांक देता है।

arc4random_buf यादृच्छिक सामग्री में इसके पैरामीटर buf : void * डालता है सामग्री की मात्रा bytes : size_t द्वारा निर्धारित की जाती है bytes : size_t पैरामीटर

arc4random_uniform एक यादृच्छिक 32-बिट अहस्ताक्षरित पूर्णांक देता है जो नियम का अनुसरण करता है: 0 <= arc4random_uniform(limit) < limit , जहां सीमा भी एक अहस्ताक्षरित 32-बिट पूर्णांक है

arc4random_stir /dev/urandom से डेटा पढ़ता है और डेटा को arc4random_addrandom को इसके अतिरिक्त आंतरिक रैंडम नंबर पूल को यादृच्छिक रूप से यादृच्छिक रूप से पास करता है।

arc4random_addrandom को arc4random_addrandom द्वारा इसे करने के लिए पारित डेटा के अनुसार आंतरिक रैंडम संख्या पूल को पॉप्युलेट करने के लिए उपयोग किया जाता है।

यदि आपके पास इन फ़ंक्शन नहीं है, लेकिन आप यूनिक्स पर हैं, तो आप इस कोड का उपयोग कर सकते हैं:

 /* This is C, not C++ */ #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <errno.h> #include <unistd.h> #include <stdlib.h> /* exit */ #include <stdio.h> /* printf */ int urandom_fd = -2; void urandom_init() { urandom_fd = open("/dev/urandom", O_RDONLY); if (urandom_fd == -1) { int errsv = urandom_fd; printf("Error opening [/dev/urandom]: %i\n", errsv); exit(1); } } unsigned long urandom() { unsigned long buf_impl; unsigned long *buf = &buf_impl; if (urandom_fd == -2) { urandom_init(); } /* Read 4 bytes, or 32 bits into *buf, which points to buf_impl */ read(urandom_fd, buf, sizeof(long)); return buf_impl; } 

urandom_init फ़ंक्शन /dev/urandom डिवाइस को खोलता है, और urandom_fd में फ़ाइल डिस्क्रिप्टर डालता है।

urandom फ़ंक्शन मूल रूप से rand कॉल के समान है, और अधिक सुरक्षित है, और यह एक long (आसानी से अस्थिरता) रिटर्न देता है।

हालांकि, /dev/urandom थोड़ा धीमा हो सकता है, इसलिए यह अनुशंसा की जाती है कि आप इसे एक अलग यादृच्छिक संख्या जनरेटर के लिए बीज के रूप में प्रयोग करें।

यदि आपके सिस्टम में /dev/urandom , लेकिन एक /dev/random या समान फ़ाइल है, तो आप केवल urandom_init open लिए पास किए गए पथ को बदल सकते हैं। urandom_init और urandom में प्रयुक्त कॉल और एपीआई (मुझे विश्वास है) POSIX- संगत है, और इस तरह, सबसे अधिक काम करना चाहिए, यदि सभी POSIX आज्ञाकारी सिस्टम नहीं हैं

नोट्स: यदि कोई अपर्याप्त एन्ट्रोपी उपलब्ध नहीं है तो /dev/urandom से पढ़ा नहीं जा सकेगा, इसलिए ऐसी परिस्थितियों में उत्पन्न मान क्रिप्टोग्राफ़िक असुरक्षित हो सकते हैं। यदि आप इसके बारे में चिंतित हैं, तो /dev/random उपयोग करें, जो हमेशा अवरुद्ध होगा यदि अपर्याप्त एन्ट्रापी है

यदि आप किसी अन्य सिस्टम (यानी विंडोज) पर हैं, तो rand उपयोग करें या कुछ आंतरिक विंडोज विशिष्ट मंच-आधारित गैर-पोर्टेबल एपीआई

arc4random , rand , या arc4random कॉल के लिए रैपर फ़ंक्शन:

 #define RAND_IMPL /* urandom(see large code block) | rand | arc4random */ int myRandom(int bottom, int top){ return (RAND_IMPL() % (top - bottom)) + bottom; } 

सीटी के लिए एसटीएल मौजूद नहीं है। आपको rand को कॉल करना है, या बेहतर अभी तक random । इन्हें मानक पुस्तकालय शीर्षलेख stdlib.h घोषित किया stdlib.hrand POSIX है, random एक बीएसडी युक्ति समारोह है।

rand और random बीच का अंतर यह है कि random अधिक उपयोगी 32-बिट यादृच्छिक संख्या देता है, और rand आमतौर पर एक 16-बिट संख्या देता है बीएसडी मैनपेज दिखाते हैं कि rand के निचले बिट्स चक्रीय और अनुमान लगाते हैं, इसलिए rand संभवतः छोटी संख्या के लिए बेकार है।

ISAAC (इंडिरेक्शन, शिफ्ट, संचित, जोड़ें, और गणना) पर एक नज़र डालें। इसकी समान रूप से वितरित की गई है और इसकी औसत चक्र लंबाई 2 ^ 8295 है

आप rand() का उपयोग करना चाहते हैं rand() नोट ( बहुत महत्वपूर्ण ): रेंड फ़ंक्शन के लिए बीज सेट करना सुनिश्चित करें यदि आप नहीं करते हैं, तो आपके यादृच्छिक संख्या वास्तव में यादृच्छिक नहीं हैं। यह बहुत, बहुत, बहुत महत्वपूर्ण है शुक्र है, आप आम तौर पर सिस्टम के कुछ संयोजन का प्रयोग टाइमर और एक अच्छा बीज प्राप्त करने की तारीख का उपयोग कर सकते हैं।

एफडब्ल्यूआईडब्ल्यू, इसका उत्तर यह है कि हाँ, वहाँ एक stdlib.h rand नामक समारोह है; यह फ़ंक्शन मुख्यतः गति और वितरण के लिए है, न कि अनिश्चितता के लिए। विभिन्न भाषाओं और चौखटे के लिए लगभग सभी अंतर्निहित यादृच्छिक कार्य डिफ़ॉल्ट रूप से इस फ़ंक्शन का उपयोग करते हैं। वहाँ भी "क्रिप्टोग्राफिक" यादृच्छिक संख्या जनरेटर है जो बहुत कम उम्मीद के मुताबिक हैं, लेकिन बहुत धीमी गति से चलते हैं। इन्हें किसी भी तरह की सुरक्षा से संबंधित आवेदन में इस्तेमाल किया जाना चाहिए।

खैर, सीटीएल सी ++ है, सी नहीं है, इसलिए मुझे नहीं पता कि आप क्या चाहते हैं। यदि आप सी चाहते हैं, तो rand() और srand() फ़ंक्शंस हैं:

 int rand(void); void srand(unsigned seed); 

ये दोनों एएनएसआई सी का हिस्सा हैं। random() फ़ंक्शन भी है:

 long random(void); 

लेकिन जहां तक ​​मैं बता सकता हूं, random() एएनएसआई सी मानक नहीं है। तीसरी पार्टी की लाइब्रेरी शायद एक बुरा विचार नहीं हो सकती है, लेकिन यह सब इस बात पर निर्भर करती है कि आप कितनी संख्या में उत्पन्न होनी चाहिए

यह उम्मीद है कि सिर्फ srand(time(NULL)) का उपयोग करने से थोड़ा अधिक यादृच्छिक होगा।

 #include <time.h> #include <stdio.h> #include <stdlib.h> int main(int argc, char **argv) { srand((unsigned int)**main + (unsigned int)&argc + (unsigned int)time(NULL)); srand(rand()); for (int i = 0; i < 10; i++) printf("%d\n", rand()); } 

rand() रैंडम संख्या उत्पन्न करने का सबसे सुविधाजनक तरीका है।

आप random.org जैसी किसी भी ऑनलाइन सेवा से भी यादृच्छिक नंबर पकड़ सकते हैं।

यह आपकी पसंद के दो नंबरों के बीच यादृच्छिक संख्या पाने का एक अच्छा तरीका है।

 #include <stdio.h> #include <stdlib.h> #include <time.h> #define randnum(min, max) \ ((rand() % (int)(((max) + 1) - (min))) + (min)) int main() { srand(time(NULL)); printf("%d\n", randnum(1, 70)); } 

पहली बार आउटपुट: 39

दूसरी बार आउटपुट: 61

आउटपुट तीसरी बार: 65

randnum बाद आप जो भी नंबर चुनते हैं, उसके बाद आप मूल्य बदल सकते हैं, और यह उन दोनों नंबरों के बीच आपके लिए एक यादृच्छिक संख्या उत्पन्न करेगा।

 #include <stdio.h> #include <dos.h> int random(int range); int main(void) { printf("%d", random(10)); return 0; } int random(int range) { struct time t; int r; gettime(&t); r = t.ti_sec % range; return r; } 
 #include <stdio.h> #include <stdlib.h> void main() { int visited[100]; int randValue, a, b, vindex = 0; randValue = (rand() % 100) + 1; while (vindex < 100) { for (b = 0; b < vindex; b++) { if (visited[b] == randValue) { randValue = (rand() % 100) + 1; b = 0; } } visited[vindex++] = randValue; } for (a = 0; a < 100; a++) printf("%d ", visited[a]); } 

सी प्रोग्राम 9 और 50 के बीच यादृच्छिक संख्या उत्पन्न करने के लिए

 #include <time.h> #include <stdlib.h> int main() { srand(time(NULL)); int lowerLimit = 10, upperLimit = 50; int r = lowerLimit + rand() % (upperLimit - lowerLimit); printf("%d", r); } 

सामान्य तौर पर हम निम्न लिमिट और ऊपरी लिमिट -1 के बीच एक यादृच्छिक संख्या उत्पन्न कर सकते हैं

यानी कम लिमिट इंसुलेंसर है या कहें r ∈ [कम लिमिट, ऊपरी लिमिट]

एक अच्छा विवरण सुनकर rand() का उपयोग करके किसी दी गई श्रेणी में समान रूप से वितरित रैंडम संख्याओं का उपयोग करना बुरा विचार है, मैंने यह तय करने का निर्णय लिया कि वास्तव में आउटपुट कितना छोटा है। मेरा परीक्षण का मामला निष्पक्ष पासा फेंक रहा था। यहां सी कोड है:

 #include <stdio.h> #include <stdlib.h> #include <time.h> int main(int argc, char *argv[]) { int i; int dice[6]; for (i = 0; i < 6; i++) dice[i] = 0; srand(time(NULL)); const int TOTAL = 10000000; for (i = 0; i < TOTAL; i++) dice[(rand() % 6)] += 1; double pers = 0.0, tpers = 0.0; for (i = 0; i < 6; i++) { pers = (dice[i] * 100.0) / TOTAL; printf("\t%1d %5.2f%%\n", dice[i], pers); tpers += pers; } printf("\ttotal: %6.2f%%\n", tpers); } 

और यहां इसका उत्पादन है:

  $ gcc -o t3 t3.c $ ./t3 1666598 16.67% 1668630 16.69% 1667682 16.68% 1666049 16.66% 1665948 16.66% 1665093 16.65% total: 100.00% $ ./t3 1667634 16.68% 1665914 16.66% 1665542 16.66% 1667828 16.68% 1663649 16.64% 1669433 16.69% total: 100.00% 

मैं नहीं जानता कि वर्दी के लिए आपको अपनी यादृच्छिक संख्या की आवश्यकता है, लेकिन उपरोक्त सभी जरूरतों के लिए समान रूप से एक समान दिखता है।

संपादित करें: time(NULL) से बेहतर कुछ के साथ पीआरएनजी को प्रारंभ करने के लिए एक अच्छा विचार होगा time(NULL)

मेरे हालिया आवेदन में छद्म यादृच्छिक संख्या जनरेटर के साथ मेरे पास एक गंभीर मुद्दा था: मैंने एक पयहटन स्क्रिप्ट के माध्यम से अपने सी प्रोग्राम को बार-बार बुलाया और मैं निम्नलिखित कोड के बीज का प्रयोग कर रहा था:

 srand(time(NULL)) 

हालांकि, चूंकि:

  • रैंड एक ही छद्म यादृच्छिक अनुक्रम उत्पन्न करेगा, जो एक ही वंश को एसआरएंड में दे देंगे (देखें man srand );
  • जैसा कि पहले ही कहा गया है, समय कार्य केवल दूसरे से दूसरे स्थान पर होता है: यदि आपका आवेदन एक ही सेकंड में कई बार चलाया जाता है, तो time हर बार एक ही मान वापस करेगा।

मेरे कार्यक्रम ने संख्याओं का एक ही क्रम उत्पन्न किया इस समस्या को हल करने के लिए आप 3 चीजें कर सकते हैं:

  1. कुछ अन्य जानकारी रनों पर बदलते समय (मेरे आवेदन में, आउटपुट नाम) के साथ समय के आउटपुट को मिलाएं:

     srand(time(NULL) | getHashOfString(outputName)) 

    मैंने अपने हैश फ़ंक्शन के रूप में डीजेबी 2 का इस्तेमाल किया।

  2. समय संकल्प बढ़ाएं मेरे मंच पर, clock_gettime उपलब्ध था, इसलिए मैं इसका उपयोग करता हूं:

     #include<time.h> struct timespec nanos; clock_gettime(CLOCK_MONOTONIC, &nanos) srand(nanos.tv_nsec); 
  3. दोनों विधियों का एक साथ प्रयोग करें:

     #include<time.h> struct timespec nanos; clock_gettime(CLOCK_MONOTONIC, &nanos) srand(nanos.tv_nsec | getHashOfString(outputName)); 

विकल्प 3 आपको (जहां तक ​​मुझे पता है) सबसे अच्छी बीज रैंडैडिटी सुनिश्चित करता है, लेकिन यह केवल तेज़ आवेदन पर एक अंतर पैदा कर सकता है। मेरी राय विकल्प 2 में एक सुरक्षित शर्त है

आधुनिक x86_64 CPU पर आप _rdrand64_step() द्वारा हार्डवेयर यादृच्छिक संख्या जनरेटर का उपयोग कर सकते हैं

उदाहरण कोड:

 #include <immintrin.h> uint64_t randVal; if(!_rdrand64_step(&randVal)) { // Report an error here: random number generation has failed! } // If no error occured, randVal contains a random 64-bit number 

सभी लोगों के सुझाव rand() बावजूद, आप rand() का उपयोग नहीं करना चाहते हैं rand() जब तक आपको नहीं करना है! rand() की यादृच्छिक संख्या अक्सर बहुत खराब होती है। लिनक्स मैन पेज से उद्धृत करने के लिए:

लिनक्स सी लाइब्रेरी में rand() और srand() संस्करणों को random(3) और srandom(3) रूप में एक ही यादृच्छिक संख्या जनरेटर का इस्तेमाल किया जाता है, इसलिए निचले क्रम के बिट्स को उच्च-क्रम बिट्स के रूप में यादृच्छिक होना चाहिए। हालांकि, पुराने रैंड () कार्यान्वयन पर, और विभिन्न प्रणालियों पर वर्तमान कार्यान्वयन पर, कम-आदेश बिट्स उच्च-आदेश बिट्स की तुलना में बहुत कम यादृच्छिक हैं । इस फंक्शन में उपयोग करने के लिए पोर्टेबल होने का इरादा रखिए, जब अच्छी यादृच्छिकता की आवश्यकता होती है। ( इसके बजाय random(3) प्रयोग करें। )

पोर्टेबिलिटी के बारे में, random() भी कुछ समय के लिए POSIX मानक द्वारा भी परिभाषित किया गया है। rand() पुराना है, यह पहले पॉसिक्स 1 स्पेक (आईईईई एसटीडी 1003.1-19 88) में पहले से ही प्रकट हुआ था, जबकि random() पहले POSIX.1-2001 (आईईईई एसटीडी 1003.1-2001) में प्रकाशित हुआ था, फिर भी वर्तमान पीओएसआईएसआईएस मानक पहले से ही POSIX.1-2008 (आईईईई एसटीडी 1003.1-2008), जिसे सिर्फ एक साल पहले अपडेट मिला (आईईईई एसटीडी 1003.1-2008, 2016 संस्करण)। इसलिए मैं random() को बहुत पोर्टेबल मानता हूं।

POSIX.1-2001 ने भी lrand48() और mrand48() कार्यों की शुरुआत की, यहां देखें :

फ़ंक्शन के यह परिवार एक रेखीय congraential एल्गोरिथ्म और 48-बिट पूर्णांक अंकगणितीय का उपयोग कर छद्म यादृच्छिक संख्या उत्पन्न करेगा।

और बहुत अच्छा छद्म यादृच्छिक स्रोत है arc4random() फ़ंक्शन जो कई सिस्टमों पर उपलब्ध है। किसी भी आधिकारिक मानक का कोई हिस्सा नहीं है, जो 1997 के आसपास बीएसडी में प्रकाशित हुआ था लेकिन आप इसे लिनक्स और मैक ओएस / आईओएस जैसे सिस्टम पर पा सकते हैं।

मेरी न्यूनतर समाधान को रेंज में यादृच्छिक संख्या [न्यूनतम, अधिकतम] के लिए काम करना चाहिए। प्रयोग करें srand (समय (नल)) पहले

 int range_rand(int min_num, int max_num) { if(min_num >= max_num) { fprintf(stderr, "min_num is greater or equal than max_num!\n"); } return min_num + (rand() % (max_num - min_num)); } 

इसे आज़माएं, मैंने इसे पहले से ही संदर्भित कुछ अवधारणाओं से एक साथ रखा है:

 /* Uses the srand() function to seed the random number generator based on time value, then returns an integer in the range 1 to max. Call this with random(n) where n is an integer, and you get an integer as a return value. */ int random(int max) { srand((unsigned) time(NULL)); return (rand() % max) + 1; }