दिलचस्प पोस्ट
स्टेटमेंट के साथ तैयार किए गए स्टेटमेंट। RETURN_GENERATED_KEYS जावा धागा को दूसरे थ्रेड के आउटपुट के लिए कैसे तैयार करना है? स्विफ्ट 3 URLSession.shared () सदस्य 'डेटाटस्क के साथ संदिग्ध संदर्भ (साथ: समापनहैण्डलर :) त्रुटि (बग) फाइल अपलोड करने के लिए fileReader.readAsBinaryString मुझे एक एमुलेटर -5554 डिस्कनेक्ट संदेश क्यों मिलता है Xticks निकालें, लेकिन MATLAB में xticklabels रखें अपवादित वर्ग स्थिर 'MYSQL_ATTR_INIT_COMMAND' पीडो के साथ जावा स्ट्रिंग चर का उपयोग .next () या .nextLine () जेएस string.split () सीमांकक को हटाने के बिना PHP विस्तार-विकास के साथ आरंभ करना पायथन मेमोइंग / आस्थगित खोज संपत्ति डेकोरेटर ASP.NET MVC में अनधिकृत नियंत्रक को पुनर्निर्देशित करना अजगर बनाम पायरेथॉन MySQL ग्रुप द्वारा और खाली पंक्ति भरें ये क्यों हैं == लेकिन `बराबर नहीं है (`)?

क्या "n * (रैंड (/ RAND_MAX)" एक विषम यादृच्छिक संख्या वितरण करना है?

मैं सी में यादृच्छिक संख्या पाने का एक अनपेक्षित रास्ता खोजना चाहता हूं (हालांकि अधिकतर मैं इसे 0-20 के मूल्यों के लिए उपयोग कर रहा हूं, और केवल 0-8 होने की संभावना)। मैंने यह फार्मूला देखा है लेकिन कुछ परीक्षण चलाने के बाद मुझे यकीन नहीं है कि यह पतला है या नहीं। कोई मदद?

यहां उपयोग किया जाने वाला पूर्ण कार्य है:

int randNum() { return 1 + (int) (10.0 * (rand() / (RAND_MAX + 1.0))); } 

मैं इसे का उपयोग कर की वरीयता प्राप्त:

 unsigned int iseed = (unsigned int)time(NULL); srand (iseed); 

नीचे सुझाए गए एक ने मेरे लिए काम करने से इनकार कर दिया, मैंने कोशिश की

 int greek; for (j=0; j<50000; j++) { greek =rand_lim(5); printf("%d, " greek); greek =(int) (NUM * (rand() / (RAND_MAX + 1.0))); int togo=number[greek]; number[greek]=togo+1; } 

और यह काम करना बंद कर देता है और मुझे उसी नंबर को 50000 बार मुहैया कराता है जब मैं printf को बाहर करता हूं

Solutions Collecting From Web of "क्या "n * (रैंड (/ RAND_MAX)" एक विषम यादृच्छिक संख्या वितरण करना है?"

हां, यह पतला है, जब तक आपका आरएआईटीएमएक्स 10 के एक से अधिक नहीं होता है

यदि आप संख्या 0 से लेकर RAND_MAX तक लेते हैं, और उन्हें 10 बवासीर में बांटते हैं, तो आपके पास केवल तीन संभावनाएं हैं:

  1. RAND_MAX 10 का एक बहुमूल्य है, और बवासीर भी बाहर आते हैं।
  2. RAND_MAX 10 के एक से अधिक नहीं है, और बवासीर असमान बाहर आते हैं।
  3. आप इसे शुरू करने के लिए असमान समूहों में विभाजित करते हैं, लेकिन सभी "अतिरिक्त" को फेंक देते हैं जो इसे असमान बनाते हैं।

आप शायद ही कभी RAND_MAX पर नियंत्रण रखते हैं, और यह वैसे भी एक प्रमुख संख्या है। वास्तव में केवल 2 और 3 को संभावनाओं के रूप में छोड़ देता है

तीसरा विकल्प मोटे तौर पर इस तरह दिखता है: [संपादित करें: कुछ सोचा के बाद, मैंने सी और सी ++ काम में सबसे अधिक चीजों के साथ फिट होने के लिए सीमा 0 … (सीमा -1) में संख्याओं को बनाने के लिए संशोधित किया है। यह कोड को सरल भी करता है (एक छोटा सा)

 int rand_lim(int limit) { /* return a random number in the range [0..limit) */ int divisor = RAND_MAX/limit; int retval; do { retval = rand() / divisor; } while (retval == limit); return retval; } 

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

 #include <stdlib.h> #include <stdio.h> #define MAX 1009 int next_val() { // just return consecutive numbers static int v=0; return v++; } int lim(int limit) { int divisor = MAX/limit; int retval; do { retval = next_val() / divisor; } while (retval == limit); return retval; } #define LIMIT 10 int main() { // we'll allocate extra space at the end of the array: int buckets[LIMIT+2] = {0}; int i; for (i=0; i<MAX; i++) ++buckets[lim(LIMIT)]; // and print one beyond what *should* be generated for (i=0; i<LIMIT+1; i++) printf("%2d: %d\n", i, buckets[i]); } 

इसलिए, हम 0 से 100 9 तक की संख्या से शुरू कर रहे हैं (100 9 प्रमुख है, इसलिए यह हमारे द्वारा चुने गए किसी भी सीमा का सटीक नहीं होगा)। इसलिए, हम 100 9 अंकों से शुरू कर रहे हैं, और इसे 10 बाल्टी में विभाजित कर रहे हैं। यह प्रत्येक बाल्टी में 100 देना चाहिए, और 9 बचे हुए (बोलने के लिए) do / लूप द्वारा "खाया" मिलता है। जैसा कि अभी लिखा गया है, यह एक अतिरिक्त बाल्टी को आवंटित करता है और प्रिंट करता है। जब मैं इसे चलाता हूं, तो प्रत्येक बाल्टी में 0. 0 और बाल्टी में 0 मिलता है। अगर मैं do / लूप में टिप्पणी करता do , तो मुझे 0. 9 में से प्रत्येक में 100 और बाल्टी में 9 ।

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

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

मुझे यह भी कहना चाहिए कि जनरेटर जो मोटे तौर पर विपरीत होते हैं – निचले बिट्स ऊपरी बिट्स की तुलना में अधिक यादृच्छिक होते हैं। कम से कम मेरे अनुभव में, ये काफी असामान्य हैं जिस के साथ ऊपरी बिट्स अधिक यादृच्छिक हैं वह काफी अधिक सामान्य हैं।