सिस्टम क्यों है। यादृच्छिक पंक्ति में कई बार '1' दे रहा है, फिर थोड़ी देर के लिए नहीं, फिर फिर से?

Question

यह सुनिश्चित नहीं है कि इसे और कैसे समझाया जाए, इसलिए शीर्षक काफी समस्या का वर्णन करता है।

रैंडम को लूप के प्रत्येक भाग को फिर से शुरू नहीं किया जा रहा है। यह एक वर्ग का एक स्थिर सदस्य है जिसे मैं हमेशा अन्य वर्गों से बुलाता हूं।

मैं कस्टम बीज का उपयोग नहीं कर रहा हूं।

initialisation कोड है:

public static Random random = new Random(); 

     for (int x = 0; x < 75; x++) 
     { 
      if (main.random.Next(11) == 1) 
      { 
       tiles[heightMap[x] - 1][x] = 4; 
       tiles[heightMap[x] - 2][x] = 4; 
       tiles[heightMap[x] - 3][x] = 4; 
       tiles[heightMap[x] - 4][x] = 4; 
       tiles[heightMap[x] - 5][x] = 4; 
       tiles[heightMap[x] - 5][x - 1] = 5; 
       tiles[heightMap[x] - 6][x - 1] = 5; 
       tiles[heightMap[x] - 6][x] = 5; 
       tiles[heightMap[x] - 5][x + 1] = 5; 
       tiles[heightMap[x] - 6][x + 1] = 5; 
      } 
     } 

यह (मुझे पता है यह एक शानदार तरीका नहीं है हूँ - यह अल्पविकसित और अस्थायी है) एक पेड़ उत्पन्न करता है।

हालांकि मेरी इलाके अक्सर कुछ इस तरह, कई संकुल के पेड़ के साथ दिखता है:

☁☁☁☁☁☁☁☁☁☁

किसी को भी इस क्यों हो रहा है उसकी जानकारी दे सकते हैं? क्या System.Security.Cryptography.Random क्लास का उपयोग करने से बेहतर विकल्प है?

मैं प्रति पेड़ के औसत 9 अंतर की अपेक्षा करता हूं, लेकिन यह 7 की तरह अधिक है और फिर 3 पेड़ बारीकी से क्लस्टर किए गए हैं।

Answer 1

यह एक संभावना गलतफहमी है, आप सभी जानते हैं कि किसी भी बिंदु पर, अगले स्लॉट में एक पेड़ के होने की संभावना है, समान वितरण, 1 11.

में यह सोचते हैं 0 के अंतराल होने की संभावना इस प्रकार 1/11

है

1 के अंतराल होने की संभावना इस प्रकार 10/11 * 1/11

है 2 के अंतराल होने की संभावना इस प्रकार 10/11 * 10/11 * 1/11

आदि

है

उन सभी 10/11 जोड़ें (अच्छी तरह से, गुणा करें) ऊपर! तो चलो एक उपयोगिता लिखने करते हैं:

decimal accountedFor = 0M; 
for (int i = 0; i <= 20; i++) 
{ 
    decimal chance = 1M/11M; 
    for (int j = 0; j < i; j++) chance *= 10M/11M; 
    accountedFor += chance; 
    Console.WriteLine("{0:00}: {1:00.0%}\t({2:00.0%})", i, chance, accountedFor); 
} 

कौन देता है:

00: 09.1%  (09.1%) 
01: 08.3%  (17.4%) 
02: 07.5%  (24.9%) 
03: 06.8%  (31.7%) 
04: 06.2%  (37.9%) 
05: 05.6%  (43.6%) 
06: 05.1%  (48.7%) 
07: 04.7%  (53.3%) 
08: 04.2%  (57.6%) 
09: 03.9%  (61.4%) 
10: 03.5%  (65.0%) 
11: 03.2%  (68.1%) 
12: 02.9%  (71.0%) 
13: 02.6%  (73.7%) 
14: 02.4%  (76.1%) 
15: 02.2%  (78.2%) 
16: 02.0%  (80.2%) 
17: 01.8%  (82.0%) 
18: 01.6%  (83.6%) 
19: 01.5%  (85.1%) 
20: 01.4%  (86.5%) 

जो छोटे अंतराल के लिए पूर्वाग्रह बताते हैं। ध्यान दें; जब तक हम आकार 20 के अंतराल तक पहुंच जाते हैं, हम 1.5% मौके क्षेत्र से नीचे हैं, और सभी संभावित परिणामों के 85% के लिए जिम्मेदार हैं - शेष 15% बाकी अनंतता (यानी एक अंतर आकार 13212 संभव है, लेकिन बहुत ही असंभव)।

तो यहाँ अनुकरण है:

int[] gapCounts = new int[21]; 

int gap = 0; 
// simulate a few gaps using your algo 
var random = new Random(); 
for (int x = 0; x < 100000; x++) 
{ 
    if (random.Next(11) == 1) 
    { // count that gap 
     gapCounts[gap]++; 
     gap = 0; 
    } 
    else 
    { 
     gap++; 
     if(gap >= gapCounts.Length) 
     { // just skip anything too large, sorry 
      gap = 0; 
     } 
    } 
} 

decimal total = gapCounts.Sum(); 
for(int i = 0 ; i < gapCounts.Length ; i++) 
{ 
    Console.WriteLine("{0:00}: {1:00.0%}", i, gapCounts[i]/total); 
} 

उत्पादन के साथ

कुछ भी नहीं है कि इन मूल्यों को हर रन बदल जाएगा:

00: 11.0% 
01: 09.4% 
02: 08.6% 
03: 07.9% 
04: 07.3% 
05: 06.5% 
06: 05.4% 
07: 05.4% 
08: 04.7% 
09: 04.5% 
10: 04.4% 
11: 03.4% 
12: 03.5% 
13: 03.0% 
14: 02.9% 
15: 02.4% 
16: 02.5% 
17: 02.2% 
18: 01.9% 
19: 01.5% 
20: 01.7%