गैर-दोहराव यादृच्छिक संख्या

Question

1- 20 से यादृच्छिक संख्याएं उत्पन्न करने के लिए मुझे चुनिंदा चुनना होगा और इसे दोहराया जाना चाहिए।

में यह करने के लिए कैसे सी #

नोट मैं सभी छोरों संख्या के लिए की तरह के रूप में इस

Random rnd = new Random() 
rnd.Next(1,20) 
for(int i =0; i<=20;i++) 
{ 

} 

के माध्यम से लूप करने की जरूरत किया जाना चाहिए 1 20

Answer 1

को वास्तव में क्या आप मतलब है "दोहराया नहीं जाना चाहिए"? यदि आपका मतलब है कि आप कोई डुप्लीकेट नहीं प्राप्त करना चाहते हैं, तो आपको मूल रूप से संख्या 1-20 की सूची लेनी चाहिए, उन्हें घुमाएं, और फिर सूची के शीर्ष से एक समय में एक को पकड़ लें। सूची को घुमाने के लिए एक कुशल तरीके से, this Stack Overflow answer देखें।

तुम सिर्फ मतलब है कि आपके वर्तमान प्रयास देता है 5, 5, 5, 5, 5, 5, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2 आदि तो संभावना है कि आप प्रत्येक बार जब कोई संख्या चुनते हैं तो Random का एक नया उदाहरण बना रहे हैं: ऐसा न करें। प्रत्येक बार जब आप एक उदाहरण बनाते हैं, तो यह वर्तमान समय का उपयोग यादृच्छिक संख्या जनरेटर के लिए "बीज" के रूप में करेगा (जब तक कि आप एक स्पष्ट रूप से निर्दिष्ट नहीं करते)। इसका मतलब है कि यदि आप त्वरित उत्तराधिकार में कई उदाहरण बनाते हैं, तो प्रत्येक को एक ही बीज मिल जाएगा और इसलिए संख्याओं का एक ही अनुक्रम दें।

इसके बजाय, Random के एक उदाहरण का उपयोग करें और इसका पुन: उपयोग करें। (ध्यान दें कि यह धागा सुरक्षित नहीं है, हालांकि, जो एक दर्द है।) उदाहरण के लिए:

private static readonly Random Rng = new Random(); 

public int NextNumber() 
{ 
    return Rng.Next(20) + 1; 
} 

कि धागे की सुरक्षित नहीं होगा, लेकिन हमें पता है कि अगर कोई समस्या है करते हैं। एक वैकल्पिक कभी कभी (बेशक, जो आम तौर पर और अधिक जटिल हो जाएगा) विधि में Random पारित करने के लिए है:

public int NextNumber(Random rng) 
{ 
    return rng.Next(20) + 1; 
} 

तो फोन करने वाले को उचित रूप से उदाहरण के पुन: उपयोग कर सकते हैं।

यदि आप यादृच्छिक संख्याएं उत्पन्न करने का थ्रेड-सुरक्षित तरीका चाहते हैं, तो आप कक्षा MiscUtil में देख सकते हैं।

(ध्यान दें कि rng.Next(1, 21) का उपयोग कर भी ठीक काम करेगा - मैं ऊपर के रूप में मुझे लगता है कि यह समावेशी/विशेष सीमाओं के बारे में अटकलबाजी कम कर देता है संस्करण को प्राथमिकता के लिए हो, लेकिन यह व्यक्तिगत स्वाद की बात है।)

Answer 2

MSDN

से

"यादृच्छिकता में सुधार करने का एक तरीका बीज मूल्य समय-निर्भर बनाना है।"

एक और तथ्य यह है

आप चाहिए "एक यादृच्छिक बनाने के समय के साथ कई यादृच्छिक संख्या उत्पन्न करने के लिए।" यह यादृच्छिक पीढ़ी

Answer 3

इस विधि सभी नंबरों को उत्पन्न करेगा में वृद्धि होगी, और कोई संख्या दोहराया जाएगा:

/// <summary> 
/// Returns all numbers, between min and max inclusive, once in a random sequence. 
/// </summary> 
IEnumerable<int> UniqueRandom(int minInclusive, int maxInclusive) 
{ 
    List<int> candidates = new List<int>(); 
    for (int i = minInclusive; i <= maxInclusive; i++) 
    { 
     candidates.Add(i); 
    } 
    Random rnd = new Random(); 
    while (candidates.Count > 0) 
    { 
     int index = rnd.Next(candidates.Count); 
     yield return candidates[index]; 
     candidates.RemoveAt(index); 
    } 
} 

आप इसे इस तरह उपयोग कर सकते हैं:

Console.WriteLine("All numbers between 0 and 20 in random order:"); 
foreach (int i in UniqueRandom(0, 20)) { 
    Console.WriteLine(i); 
} 

Answer 4

मैं एक किया थोड़ी देर पहले इस तरह से। मुझे नहीं पता कि यह दक्षता, यादृच्छिकता आदि के रूप में प्रस्तुत अन्य तरीकों से कैसे तुलना करता है।लेकिन यह काम करने के लिए लगता है:

List<int> integers = new List<int>() { 1, 2, 3, 4, 5, 6,7, 8, 9, 10, 11, 12 }; 

Random rnd = new Random(); 

var ints = from i in integers 
      orderby rnd.Next(integers.Count) 
      select i; 

Answer 5

एक IEnumerable कार्यान्वयन, Hallgrim's उत्तर के आधार पर:

public class UniqueRandoms : IEnumerable<int> 
{ 
    Random _rand = new Random(); 
    List<int> _candidates; 

    public UniqueRandoms(int maxInclusive) 
     : this(1, maxInclusive) 
    { } 

    public UniqueRandoms(int minInclusive, int maxInclusive) 
    { 
     _candidates = 
      Enumerable.Range(minInclusive, maxInclusive - minInclusive + 1).ToList(); 
    } 

    public IEnumerator<int> GetEnumerator() 
    { 
     while (_candidates.Count > 0) 
     { 
      int index = _rand.Next(_candidates.Count); 
      yield return _candidates[index]; 
      _candidates.RemoveAt(index); 
     } 
    } 

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    { 
     return GetEnumerator(); 
    } 
} 

Answer 6

class Program 
{ 
    static void Main(string[] args) 
    {   
     List<int> list = new List<int>(); 
     int val; 
     Random r; 
     int IntialCount = 1; 
     int count = 7 ; 
     int maxRandomValue = 8; 

     while (IntialCount <= count) 
     { 
      r = new Random(); 
      val = r.Next(maxRandomValue); 
      if (!list.Contains(val)) 
      { 
       list.Add(val); 
       IntialCount++; 
      } 

     } 
    } 
} 

Answer 7

निम्नलिखित तरीके से बहुत अच्छा तरीका है, मैं यहाँ पर एक स्ट्रिंग का उपयोग कर रहा है, तो आप जो कुछ भी आप चाहते हैं करने के लिए सूची का प्रकार बदल सकते हैं ..., यह प्रयास करें:

  List<string> NamesList = new List<string>() { "Name1", "Name2", "Name3", "Name4", "Name5" }; 
      Random rnd = new Random(); 
      //Now to get random of the above "Without Repeating.." 
      for (int i = 0; i <= NamesList.Count - 1; i++) 
      { 
       int TheSelectedRand = rnd.Next(NamesList.Count); 
       string MyRandNumber = NamesList[TheSelectedRand]; 

       //Print or use your item here 

       NamesList.Remove(NamesList[TheSelectedRand]); 
      } 

Answer 8

झटका कोड 0 - 9 2 के बीच 65 अद्वितीय यादृच्छिक संख्या उत्पन्न करता है और एक सरणी में उस अद्वितीय यादृच्छिक संख्या को वापस करता है।

public static int[] RandomNumbers_Supplier() 
     { 
      Random R = new Random(); 
      int[] RandomNumbers = new int[65]; 
      int k = 0, Temp; 
      bool IsRepetitive = false; 
      while (k < 65) 
      { 
       Temp = R.Next(0, 92); 
       for (int i = 0; i < 65; i++) 
       { 
        IsRepetitive = false; 
        if (RandomNumbers[i] == Temp) 
        { 
         IsRepetitive = true; 
         break; 
        }      
       } 
       if (!IsRepetitive) 
       { 
        RandomNumbers[k] = Temp; 
        k++; 
       } 
      } 
      return(RandomNumbers) 
     } 

Answer 9

static void Main(string[] args) 
{ 
    //Randomize 15 numbers out of 25 - from 1 to 25 - in ascending order 
    var randomNumbers = new List<int>(); 
    var randomGenerator = new Random(); 
    int initialCount = 1; 

    for (int i = 1; i <= 15; i++) 
    { 
     while (initialCount <= 15) 
     { 
      int num = randomGenerator.Next(1, 26); 
      if (!randomNumbers.Contains(num)) 
      { 
       randomNumbers.Add(num); 
       initialCount++; 
      } 
     } 
    } 
    randomNumbers.Sort(); 
    randomNumbers.ForEach(x => Console.WriteLine(x)); 
}