दिलचस्प पोस्ट
मैं एक स्ट्रिंग को जावा में इनटस्टस्ट्रीम में कैसे रूपांतरित कर सकता हूं? प्रोग्रामेटिक एसएमएस कैसे JSON को विरासत में मिली वस्तुओं को तार करने के लिए? PHP में शुरू होता है () और समाप्त होता है () फ़ंक्शन लिबसी ++ में लघु स्ट्रिंग अनुकूलन के यांत्रिकी क्या हैं? दशमलव में द्विआधारी रूपांतरण के लिए # कैसे "जैसे" के साथ MongoDB क्वेरी करने के लिए? जावा से विशिष्ट कच्चे डेटा डिस्क पर कैसे पहुंचें अल्पविराम से पृथक स्ट्रिंग को int सरणी में कनवर्ट करें परम्परागत रूप से "System.Collections.Generic.IEnumerable" टाइप कर सकते हैं, नहीं करने के लिए: System.Collections.Generic.List <string> क्या प्रदर्शन के संदर्भ में std :: memcpy () या std :: copy () का उपयोग करना बेहतर है? प्रारंभिक आकार के बिना संग्रह आकार को सीतनिद्रा में होना जावा में (JTextField क्लास) कैसे कार्यान्वित करने के लिए केवल अंक दर्ज करने के लिए? क्या मैं सभी वस्तुओं की एक संकलन-सूची सूची प्राप्त कर सकता हूं जो स्काला में मुहरबंद माता-पिता से प्राप्त होती है? CPU प्रतिशत उपयोग प्राप्त करें

यादृच्छिक संख्या को समान रूप से पूरी रेंज पर जनरेट करें

मुझे एक निर्दिष्ट अंतराल के भीतर यादृच्छिक संख्या उत्पन्न करने की आवश्यकता है, [अधिकतम; मिनट]

इसके अलावा, यादृच्छिक संख्या एक समान रूप से अंतराल पर वितरित की जानी चाहिए, किसी विशिष्ट बिंदु के अनुसार नहीं।

सख्ती से मैं पैदा कर रहा हूँ:

for(int i=0; i<6; i++) { DWORD random = rand()%(max-min+1) + min; } 

मेरे परीक्षण से, यादृच्छिक संख्या केवल एक बिंदु के आसपास उत्पन्न होती है I

 Example min = 3604607; max = 7654607; 

यादृच्छिक संख्या उत्पन्न:

 3631594 3609293 3630000 3628441 3636376 3621404 

नीचे दिए गए उत्तर से: ठीक है, RAND_MAX 32767 है। मैं सी + + विंडोज प्लेटफॉर्म पर हूं। क्या समान वितरण के साथ यादृच्छिक संख्या उत्पन्न करने के लिए कोई अन्य तरीका है?

वेब के समाधान से एकत्रित समाधान "यादृच्छिक संख्या को समान रूप से पूरी रेंज पर जनरेट करें"

क्यों rand एक बुरा विचार है

आप यहां मिले अधिकांश उत्तर rand फंक्शन और मॉड्यूलस ऑपरेटर का उपयोग करते हैं। यह पद्धति संख्या समान रूप से नहीं उत्पन्न कर सकती है (यह सीमा पर निर्भर करती है और RAND_MAX का मूल्य), और इसलिए निराश हो जाता है।

सी ++ 11 और एक श्रेणी पर पीढ़ी

सी ++ 11 के साथ कई अन्य विकल्प बढ़ गए हैं। इनमें से एक आपकी आवश्यकताओं को फिट करता है, एक रेंज में यादृच्छिक संख्या उत्पन्न करने के लिए, बहुत अच्छी तरह से: std::uniform_int_distribution । यहां एक उदाहरण है:

 const int range_from = 0; const int range_to = 10; std::random_device rand_dev; std::mt19937 generator(rand_dev()); std::uniform_int_distribution<int> distr(range_from, range_to); std::cout << distr(generator) << '\n'; 

और यहाँ चलने का उदाहरण है

अन्य यादृच्छिक जनरेटर

<random> हेडर बेरनोली, पॉसॉन और सामान्य सहित विभिन्न प्रकार के वितरण के साथ असंख्य अन्य यादृच्छिक संख्या जनरेटर प्रदान करता है।

मैं एक कंटेनर कैसे फेर सकता हूँ?

मानक std::random_shuffle प्रदान करता है, जिसका उपयोग निम्न प्रकार से किया जा सकता है:

 std::vector<int> vec = {4, 8, 15, 16, 23, 42}; std::random_device random_dev; std::mt19937 generator(random_dev()); std::shuffle(vec.begin(), vec.end(), generator); 

एल्गोरिथ्म तत्वों को एक क्रमबद्ध जटिलता के साथ क्रम में पुन: क्रमित करेगा।

Boost.Random

एक अन्य विकल्प, यदि आपके पास C + + 11 + कंपाइलर तक पहुंच नहीं है, तो बूस्ट का उपयोग करें । यादृच्छिक इसका इंटरफ़ेस सी ++ 11 के समान है।

[संपादित करें] चेतावनी: सांख्यिकी, सिमुलेशन, क्रिप्टोग्राफी या कुछ गंभीर rand() लिए rand() उपयोग न करें।

यह एक अच्छा इंसान के लिए जल्दबाजी में नंबर यादृच्छिक बनाने के लिए पर्याप्त है, और नहीं।

बेहतर विकल्पों के लिए @ जेफफ्रे का उत्तर देखें, या क्रिप्टो-सुरक्षित यादृच्छिक संख्या के लिए यह उत्तर ।


आम तौर पर, उच्च बिट्स कम बिट्स की तुलना में बेहतर वितरण दिखाती हैं, इसलिए सरल उद्देश्यों के लिए एक रेंज के यादृच्छिक संख्या उत्पन्न करने का अनुशंसित तरीका है:

 ((double) rand() / (RAND_MAX+1)) * (max-min+1) + min 

नोट : सुनिश्चित करें कि RAND_MAX + 1 अतिप्रवाह नहीं है (धन्यवाद डेमी)!

विभाजन अंतराल [0, 1] में एक यादृच्छिक संख्या उत्पन्न करता है; यह आवश्यक श्रेणी में "खिंचाव" जब अधिकतम-मिनट + 1 को RAND_MAX के करीब हो तो आपको "बिगरेण्ड ()" फ़ंक्शन की आवश्यकता होती है जैसे कि मार्क रोटोम द्वारा पोस्ट किया गया

यह मॉडुलो के कारण कुछ टुकड़ों की समस्याओं को भी टाल जाता है, जो आपके नंबरों को और भी खराब कर सकता है।


अंतर्निर्मित यादृच्छिक संख्या जनरेटर को सांख्यिकीय सिमुलेशन के लिए आवश्यक गुणवत्ता रखने की गारंटी नहीं है। संख्याओं के लिए "यादृच्छिक" दिखने के लिए ठीक है, लेकिन एक गंभीर आवेदन के लिए, आपको कुछ बेहतर करना चाहिए – या कम से कम इसकी संपत्तियों की जांच करें (समान वितरण आमतौर पर अच्छा है, लेकिन मूल्यों को सहसंबंधित करना होता है, और अनुक्रम निर्धारक )। Knuth यादृच्छिक संख्या जनरेटर पर एक उत्कृष्ट (यदि मुश्किल से पढ़ा हुआ) ग्रंथ है, और मैंने हाल ही में एलएफएसआर को उत्कृष्ट और आसान बनाने के लिए पाया है, क्योंकि इसके गुण आपके लिए ठीक हैं।

यदि RAND_MAX 32767 है, तो आप आसानी से बिट्स की संख्या को दोहरा सकते हैं।

 int BigRand() { assert(INT_MAX/(RAND_MAX+1) > RAND_MAX); return rand() * (RAND_MAX+1) + rand(); } 

यदि आप सक्षम हैं, बूस्ट का उपयोग करें। मेरे पास यादृच्छिक पुस्तकालय के साथ अच्छे भाग्य हैं।

uniform_int को आप क्या करना चाहिए।

यदि आप यादृच्छिकता के बारे में चिंतित हैं और गति के बारे में नहीं हैं, तो आपको एक सुरक्षित यादृच्छिक संख्या पीढ़ी विधि का उपयोग करना चाहिए। ऐसा करने के कई तरीके हैं … सबसे आसान तरीका है ओपनएसएसएल का रैंडम नंबर जेनरेटर का उपयोग करना।

आप एक एन्क्रिप्शन एल्गोरिदम (जैसे एईएस ) का उपयोग करके अपना खुद भी लिख सकते हैं। एक बीज और एक चतुर्थ चयन करके और फिर एन्क्रिप्शन समारोह के उत्पादन को लगातार पुन: एन्क्रिप्ट किया जा रहा है। OpenSSL का उपयोग करना आसान है, लेकिन कम मर्दाना

मैं 2015 में कला की स्थिति के एक संक्षिप्त अवलोकन के साथ एन्जैड जूता और पीटरबेन के उत्कृष्ट उत्तर देना चाहता हूं:

कुछ अच्छे विकल्प

randutils

randutils लाइब्रेरी (प्रस्तुति) एक दिलचस्प नवीनता है, एक सरल इंटरफ़ेस प्रदान करती है और (घोषित) मजबूत यादृच्छिक क्षमताएं। इसका नुकसान यह है कि यह आपकी परियोजना पर निर्भरता जोड़ता है और नए होने के कारण इसे बड़े पैमाने पर परीक्षण नहीं किया गया है। वैसे भी, मुक्त (एमआईटी लाइसेंस) और हेडर-केवल होने के नाते, मुझे लगता है कि यह एक कोशिश के लायक है

न्यूनतम नमूना: एक मरने वाला रोल

 #include <iostream> #include "randutils.hpp" int main() { randutils::mt19937_rng rng; std::cout << rng.uniform(1,6) << "\n"; } 

यहां तक ​​कि अगर पुस्तकालय में कोई दिलचस्पी नहीं है, तो वेबसाइट ( http://www.pcg-random.org/ ) विशेष रूप से यादृच्छिक संख्या पीढ़ी के विषय और सी ++ लाइब्रेरी के विषय के बारे में कई रोचक लेख प्रदान करती है

Boost.Random

बूस्ट। रैंडम (प्रलेखन) लाइब्रेरी है जो सी ++ 11 के <random> प्रेरित करती है, जिसके साथ इंटरफ़ेस के बहुत से शेयर होते हैं। सैद्धांतिक रूप से भी बाहरी निर्भरता होने पर, बूस्ट ने अब "अर्ध-मानक" पुस्तकालय का दर्जा दिया है, और इसके रैंडम मॉड्यूल को अच्छी गुणवत्ता वाले यादृच्छिक संख्या पीढ़ी के लिए शास्त्रीय पसंद के रूप में माना जा सकता है। इसमें C ++ 11 समाधान के संबंध में दो फायदे हैं:

  • यह अधिक पोर्टेबल है, बस सी ++ 03 के लिए कंपाइलर समर्थन की ज़रूरत है
  • इसकी random_device अच्छी गुणवत्ता के बीज बोने की पेशकश करने के लिए सिस्टम-विशिष्ट तरीकों का उपयोग करती है

केवल एक छोटी सी random_device यह है कि मॉड्यूल को random_device करना हेडर-केवल नहीं है, किसी को भी boost_random संकलित और लिंक boost_random

न्यूनतम नमूना: एक मरने वाला रोल

 #include <iostream> #include <boost/random.hpp> #include <boost/nondet_random.hpp> int main() { boost::random::random_device rand_dev; boost::random::mt19937 generator(rand_dev()); boost::random::uniform_int_distribution<> distr(1, 6); std::cout << distr(generator) << '\n'; } 

जबकि न्यूनतम नमूना अपने काम को अच्छी तरह से करते हैं, असली कार्यक्रमों में सुधार की एक जोड़ी का उपयोग करना चाहिए:

  • mt19937 एक thread_local : जनरेटर काफी मोटा (> 2 KB) है और स्टैक पर बेहतर आवंटित नहीं किया गया है
  • एक से अधिक पूर्णांक वाले mt19937 : मेर्सन ट्विस्टर का एक बड़ा राज्य है और आरंभीकरण के दौरान अधिक एंट्रोपी का लाभ ले सकता है

कुछ ना-तो-अच्छे विकल्प

सी ++ 11 लाइब्रेरी

जबकि सबसे मुहावरेदार समाधान होने के नाते, <random> पुस्तकालय मूलभूत जरूरतों के लिए भी इसके इंटरफेस की जटिलता के बदले बहुत कुछ नहीं प्रदान करता है दोष std::random_device : मानक अपने आउटपुट के लिए किसी भी न्यूनतम गुणवत्ता को जनादेश नहीं देता (जब तक कि entropy() रिटर्न 0 ) और, 2015 तक, मिनग्यू (सबसे अधिक इस्तेमाल किया संकलक नहीं है, लेकिन शायद ही कोई विशिष्ट पसंद) हमेशा न्यूनतम नमूने पर 4 प्रिंट करेगा।

न्यूनतम नमूना: एक मरने वाला रोल

 #include <iostream> #include <random> int main() { std::random_device rand_dev; std::mt19937 generator(rand_dev()); std::uniform_int_distribution<int> distr(1, 6); std::cout << distr(generator) << '\n'; } 

यदि कार्यान्वयन सड़ा हुआ नहीं है, तो यह समाधान बूस्ट के समान होना चाहिए, और एक ही सुझाव लागू होंगे।

गोडोट का समाधान

न्यूनतम नमूना: एक मरने वाला रोल

 #include <iostream> #include <random> int main() { std::cout << std::randint(1,6); } 

यह एक सरल, प्रभावी और साफ समाधान है केवल दोष, इसे संकलन करने में कुछ समय लगेगा – लगभग दो वर्षों में, सी ++ 17 प्रदान करने के समय पर जारी किया जाता है और प्रायोगिक randint फ़ंक्शन को नए मानक में अनुमोदित किया जाता है। हो सकता है कि उस समय तक भी बोने की गुणवत्ता पर गिनती में सुधार होगा।

खराब-बेहतर समाधान

न्यूनतम नमूना: एक मरने वाला रोल

 #include <cstdlib> #include <ctime> #include <iostream> int main() { std::srand(std::time(nullptr)); std::cout << (std::rand() % 6 + 1); } 

पुरानी सी समाधान हानिकारक माना जाता है, और अच्छे कारणों के लिए (अन्य उत्तरों यहां या इस विस्तृत विश्लेषण को देखें )। फिर भी, इसके फायदे हैं: सरल, पोर्टेबल, तेज और ईमानदार है, अर्थात् यह ज्ञात है कि यादृच्छिक संख्याएं शायद ही अच्छे लगती हैं, और इसलिए एक गंभीर उद्देश्यों के लिए उन्हें इस्तेमाल करने का प्रयास नहीं करता है

लेखा ट्रोल समाधान

न्यूनतम नमूना: एक मरने वाला रोल

 #include <iostream> int main() { std::cout << 9; // http://dilbert.com/strip/2001-10-25 } 

जबकि 9 नियमित रूप से डाय रोल के लिए कुछ असामान्य परिणाम है, इसलिए इस समाधान में अच्छे गुणों का उत्कृष्ट संयोजन प्रशंसा करना है, जो सबसे तेज़, सबसे सरल, सबसे कैश-अनुकूल और सबसे पोर्टेबल एक है। 4 के साथ 9 में प्रतिस्थापन करके किसी को किसी भी प्रकार की डिनगॉन्स और ड्रेगन मरने के लिए एक आदर्श जनरेटर मिल जाता है, जबकि अभी भी 1, 2 और 3 के प्रतीक प्रतीकों से बचा जाता है। केवल छोटे दोष यह है कि, दिलबर्ट के लेखांकन ट्रोल के बुरे स्वभाव के कारण, इस कार्यक्रम वास्तव में उत्प्रेरक व्यवहार अनिर्धारित

आपको अपने विशिष्ट कंपाइलर / पर्यावरण के लिए RAND_MAX को देखना चाहिए। मुझे लगता है कि आप इन परिणामों को देखेंगे यदि रैंड () एक यादृच्छिक 16-बिट संख्या का उत्पादन कर रहा है। (आप मानते हैं कि यह एक 32-बिट संख्या होगी)।

मैं यह जवाब नहीं दे सकता, लेकिन कृपया अपने मूल्य RAND_MAX के बारे में बताएं, और अपने पर्यावरण पर थोड़ी अधिक जानकारी दें।

जांचें कि आपके सिस्टम पर RAND_MAX क्या है – मुझे लगता है कि यह केवल 16 बिट्स है, और आपकी सीमा इसके लिए बहुत बड़ी है

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

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

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

यह कोड नहीं है, लेकिन यह तर्क आपकी सहायता कर सकता है।

 static double rnd(void) { return (1.0/(RAND_MAX+1.0)*((double)(rand())) ); } static void InitBetterRnd(unsigned int seed) { register int i; srand( seed ); for( i=0; i<POOLSIZE; i++){ pool[i]= rnd(); } } static double rnd0_1(void) { // This function returns a number between 0 and 1 static int i=POOLSIZE-1; double r; i = (int)(POOLSIZE*pool[i]); r=pool[i]; pool[i]=rnd(); return (r); } 

यह फ्लोटों का उपयोग किए बिना श्रेणी [low, high) पर एक समान वितरण प्रदान करना चाहिए, जब तक कि समग्र सीमा आरएए IDM से कम नहीं है।

 uint32_t rand_range_low(uint32_t low, uint32_t high) { uint32_t val; // only for 0 < range <= RAND_MAX assert(low < high); assert(high - low <= RAND_MAX); uint32_t range = high-low; uint32_t scale = RAND_MAX/range; do { val = rand(); } while (val >= scale * range); // since scale is truncated, pick a new val until it's lower than scale*range return val/scale + low; } 

और RAND_MAX से अधिक मूल्य के लिए आप ऐसा कुछ चाहते हैं

 uint32_t rand_range(uint32_t low, uint32_t high) { assert(high>low); uint32_t val; uint32_t range = high-low; if (range < RAND_MAX) return rand_range_low(low, high); uint32_t scale = range/RAND_MAX; do { val = rand() + rand_range(0, scale) * RAND_MAX; // scale the initial range in RAND_MAX steps, then add an offset to get a uniform interval } while (val >= range); return val + low; } 

यह मोटे तौर पर है कि कैसे std :: uniform_int_distribution कुछ चीज़ें करता है।

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

लेकिन ध्यान रखें कि यादृच्छिकता एक समान नहीं है।

संपादित करें: मैंने स्पष्ट करने के लिए "छोटा नमूना" जोड़ा।

1 और 10 के बीच एक नंबर के लिए मैन 3 रैंड द्वारा दिए गए समाधान शामिल है:

 j = 1 + (int) (10.0 * (rand() / (RAND_MAX + 1.0))); 

आपके मामले में, यह होगा:

 j = min + (int) ((max-min+1) * (rand() / (RAND_MAX + 1.0))); 

बेशक, यह सही यादृच्छिकता या एकरूपता नहीं है क्योंकि कुछ अन्य संदेश ओर इशारा करते हैं, लेकिन ज्यादातर मामलों में यह पर्याप्त है।

@ सॉल्यूशन ((double) rand() / (RAND_MAX+1)) * (max-min+1) + min

चेतावनी : खींचने और संभावित सटीक त्रुटियों के कारण मत भूलें (भले ही RAND_MAX काफी बड़ा हो), आप केवल समान रूप से वितरित "डिब्बे" बनाने में सक्षम होंगे और सभी नंबरों में [न्यूनतम, अधिकतम] नहीं।


@ सॉल्यूशन: बिगोरैंड

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


जानकारी : रैंड की रेंज () आपकी अंतराल रेंज और रैंड () "वर्दी" से अधिक हो जाने तक आपके दृष्टिकोण (मॉड्यूल) "ठीक" हैं। अधिकतम अधिकतम संख्या के लिए त्रुटि – न्यूनतम संख्या 1 / (RAND_MAX +1) है।

इसके अलावा, मैं नए यादृच्छिक पैकेज और सी ++ 11 में भी स्विच करने का सुझाव देता हूं, जो रैंड से बेहतर और अधिक किस्मों को लागू करता है I

मैं सिर्फ इंटरनेट पर यह पाया यह काम करना चाहिए:

 DWORD random = ((min) + rand()/(RAND_MAX + 1.0) * ((max) - (min) + 1));