दिलचस्प पोस्ट
क्यों strtok () अनिर्धारित माना जाता है? एंज्युलर 2.0 के साथ गतिशील घटक को संकलित करने के लिए मैं गतिशील टेम्पलेट कैसे बना सकता हूं? StringBuilder क्यों स्ट्रिंग है जब? कैसे जावास्क्रिप्ट में खिड़की के आकार परिवर्तन घटना ट्रिगर करने के लिए? एंड्रॉइड कैप्चर वीडियो फ़्रेम लुआ के लिए मानक (या सर्वश्रेष्ठ समर्थित) बड़ी संख्या (मनमानी सटीक) पुस्तकालय क्या है? एचटीएमएल 5 फॉर्म आवश्यक विशेषता कस्टम सत्यापन संदेश सेट करें? एक इनपुट फ़ील्ड का मान सेट करें सामग्रीयुक्त डिवीज़ में चयनित पाठ की जगह पीआईपी: कई पायथन संस्करणों से निपटने के लिए? फ़ाइलों के साथ पोस्ट डेटा अपलोड करने के लिए कर्ल का उपयोग करना जावा में समय बीतने के लिए मैं कैसे मापूं? MySQL में डेटा कैसे उत्पन्न करें? एंड्रॉइड: किसी गतिविधि में अस्थायी रूप से अभिविन्यास परिवर्तन अक्षम करें अनुरोध इकाई बहुत बड़ा PHP

रैंड () से मैं संख्याओं को कैसे मापूं?

निम्न कोड प्रत्येक सेकंड में एक यादृच्छिक संख्या दिखाता है:

int main () { srand(time(NULL)); // Seeds number generator with execution time. while (true) { int rawRand = rand(); std::cout << rawRand << std::endl; sleep(1); } } 

मैं इन नंबरों को कैसे आकार दे सकता हूं ताकि वे हमेशा 0-100 की सीमा में रहें?

Solutions Collecting From Web of "रैंड () से मैं संख्याओं को कैसे मापूं?"

यदि आप सी ++ का उपयोग कर रहे हैं और अच्छा वितरण के बारे में चिंतित हैं तो आप TR1 C ++ 11 <random> उपयोग कर सकते हैं।

 #include <random> std::random_device rseed; std::mt19937 rgen(rseed()); // mersenne_twister std::uniform_int_distribution<int> idist(0,100); // [0,100] std::cout << idist(rgen) << std::endl; 

अभी तक पोस्ट किए गए सभी उदाहरणों में वास्तव में बुरी तरह वितरित परिणाम दिए गए हैं। अक्सर कोड को निष्पादित करें और यह देखने के लिए एक आंकड़ा बनाएं कि कैसे मान बन जाते हैं।

किसी भी श्रेणी [0, एन ] में एक वास्तविक समान यादृच्छिक संख्या वितरण उत्पन्न करने का एक बेहतर तरीका यह है (यह मानते हुए कि वास्तव में एक समान वितरण होता है, जो स्पष्ट रूप से दूर है):

 unsigned result; do { result = rand(); } while (result > N); 

बेशक, यह विधि धीमी है लेकिन यह एक अच्छी वितरण का उत्पादन करती है । ऐसा करने का एक छोटा सा तरीका यह है कि एन का सबसे बड़ा RAND_MAX जो कि RAND_MAX से छोटा होता है और इसका उपयोग ऊपरी बाउंड के रूप में होता है। उसके बाद, कोई भी सुरक्षित रूप से result % (N + 1) ले सकता है

स्पष्टीकरण के लिए, भोलेदार मापांक पद्धति खराब क्यों है और ऊपर क्यों बेहतर है, rand का उपयोग करने के बारे में जुलिएन का बेहतरीन लेख देखें

 int rawRand = rand() % 101; 

देखें (अधिक जानकारी के लिए):

रैंड – सी ++ संदर्भ

दूसरों ने यह भी बताया है कि यह आपको यादृच्छिक संख्याओं का सबसे अच्छा वितरण संभव नहीं दे रहा है। यदि आपके कोड में उस प्रकार की बात महत्वपूर्ण है, तो आपको करना होगा:

 int rawRand = (rand() * 1.0 / RAND_MAX) * 100; 

संपादित करें

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

रैंड () माना जाता है हानिकारक | GoingNative 2013

man 3 rand देखें – आपको [0, 1] की सीमा प्राप्त करने के लिए RAND_MAX द्वारा विभाजित करके RAND_MAX करना होगा जिसके बाद आप अपने लक्ष्य सीमा के लिए 100 से गुणा कर सकते हैं।

तुम कर सकते हो

 cout << rawRand % 100 << endl; // Outputs between 0 and 99 cout << rawRand % 101 << endl; // outputs between 0 and 100 

लोगों के लिए downvoting; मूल रूप से पोस्ट किए जाने के एक मिनट के बाद मैं टिप्पणी छोड़ देता हूं:

http://www.cplusplus.com/reference/clibrary/cstdlib/rand "से ध्यान दें, हालांकि यह मॉड्यूलो ऑपरेशन अवधि में वास्तव में एक समान रूप से वितरित यादृच्छिक संख्या उत्पन्न नहीं करता है (क्योंकि ज्यादातर मामलों में कम संख्या में थोड़ा अधिक संभावना है), लेकिन यह आमतौर पर छोटे स्पेन्स के लिए एक अच्छा सन्निकटन है। "

64-बिट इनट्स के साथ और आउटपुट के रूप में 100 नंबरों का उपयोग करते हुए, 0-16 नंबरों की संख्या 1.00000000000000000455% के साथ दर्शायी जाती है (एक रिश्तेदार सटीकता को समान रूप से 1% से 10 -18 तक वितरित की जाती है), जबकि संख्या 17-99 का प्रतिनिधित्व किया जाता है संख्या के साथ 0.9999999999999999999913%। हां, पूरी तरह से वितरित नहीं, लेकिन छोटे spans के लिए एक बहुत अच्छा अनुमान।

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

संपादित करें – उन लोगों के लिए जो वास्तव में यादृच्छिक संख्या का एक समान वितरण रखने के लिए संबंधित हैं, निम्न कोड काम करता है नोट यह जरूरी नहीं कि 64-बिट यादृच्छिक इनट्स के रूप में इष्टतम हो, इसके लिए प्रत्येक 10 ^ 18 कॉलों के बाद दो कॉल rand()

 unsigned N = 100; // want numbers 0-99 unsigned long randTruncation = (RAND_MAX / N) * N; // include every number the N times by ensuring rawRand is between 0 and randTruncation - 1 or regenerate. unsigned long rawRand = rand(); while (rawRand >= randTruncation) { rawRand = rand(); // with 64-bit int and range of 0-99 will need to generate two random numbers // about 1 in every (2^63)/16 ~ 10^18 times (1 million million times) // with 32-bit int and range of 0-99 will need to generate two random numbers // once every 46 million times. } cout << rawRand % N << stdl::endl; 

सीमा न्यूनतम अधिकतम (समावेशी) के लिए, उपयोग करें: int result = rand() % (max - min + 1) + min;

कच्चे रैंड% 101 दे देंगे [0-100], समावेशी।

आप कितनी देर तक उत्तर देंगे

सरलतम 101 से विभाजित शेष का उपयोग करने के लिए परिवर्तित करना है:

 int value = rawRand % 101; 

एक सेमिटीलिस्ट युगल का उपयोग करते हुए पुन: सहेजेगा:

 double dbl = 100 * ((double)rawRand / RAND_MAX); int ivalue = (int)(dbl + 0.5); // round up for above 0.5 

और एक प्योरिस्ट कहेंगे कि रैंड यादृच्छिक संख्या उत्पन्न नहीं करता है।

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

कुछ लोगों ने निम्नलिखित कोड को एक उदाहरण के रूप में पोस्ट किया है:

 int rawRand = (rand() / RAND_MAX) * 100; 

यह समस्या को सुलझाने का एक अमान्य तरीका है, क्योंकि दोनों रैंड () और आरएआई आईडीएएमएक्स पूर्णांक हैं सी ++ में, यह अभिन्न विभाजन में परिणाम है, जो परिणाम दशमलव अंक को छोटा करेगा। जैसा RAND_MAX> = रैंड (), उस ऑपरेशन का परिणाम या तो 1 या 0 है, जिसका अर्थ है कि कच्चे रैंड केवल 0 या 100 हो सकता है। ऐसा करने का सही तरीका निम्न होगा:

 int rawRand = (rand() / static_cast<double>(RAND_MAX)) * 100; 

चूंकि एक ऑपरेंड अब एक डबल है, फ्लोटिंग प्वाइंट डिविजन का उपयोग किया जाता है, जो 0 और 1 के बीच उचित मान वापस करेगा।