सी # में यादृच्छिक संख्या जनरेटर - अद्वितीय मान

Question

मैं एक सरणी कोडिंग के साथ सी # में व्यस्त हूं। मैं यादृच्छिक जनरेटर के साथ यह भरने लेकिन अब मेरा सवाल यह है कि मैं यह नहीं है, लेकिन इतना है कि मैं देख सकते हैं कि मान सरणी में पहले से ही है और कर सकते हैं यदि ऐसा है तो एक नया मान

अतिरिक्त जानकारी उत्पन्न:
अधिकतम मूल्य : 100
तत्वों की संख्या: 100

महत्वपूर्ण plz मुझे मेरी विचार पर आगे काम

मेरा विचार

public void FillArray(int[] A, int Range) 
{ 
    for (int I = 0; I < A.Length; I++) 
    { 
     A[I] = ValidNumber(T, I, Range); 
    } 
} /* Fill Array */ 

चयन का कार्यान्वयन तरह

public void SelectionSort(int[] A) 
{ 
    int K, X; 
    for (int I = 0; I < A.Length - 1; I++) 
    { 
     K = I; 
     X = A[K]; 
     for (int J = I + 1; J < A.Length; J++) 
     { 
      if (A[J] < X) 
      { 
       K = J; 
       X = A[K]; 
      } 
     } 
     A[K] = A[I]; 
     A[I] = X; 
    } 
} /* Selection sort */ 

ये सिर्फ कुछ विचार अब कर रहे हैं मुझे पता है कि कैसे मैं इसे तो मैं चयन प्रकार के साथ देख सकते हैं अगर वहाँ allread है ठीक कर सकते हैं चाहते हैं (fillarray) है कि एक ही है यदि ऐसा है तो इसे बदलना एक नया यादृच्छिक मूल्य के साथ। एक यादृच्छिक क्रम

Answer 1

निम्नलिखित संख्या 1-100 यादृच्छिक क्रम में साथ एक सरणी उत्पन्न होगा में 100 1 से - और इसलिए मैं ints के साथ एक यादृच्छिक सरणी बनाना चाहते हैं।

Random rnd = new Random(); 
    var randomNumbers = Enumerable.Range(1, 100).OrderBy(i => rnd.Next()).ToArray(); 

Answer 2

यहाँ एक अनुभवहीन कार्यान्वयन है:

int[] values = new int[100]; 
Random random = new Random(); 
for(int i = 0; i < values.Length; i++) 
{ 
    int v; 
    do 
    { 
     v = random.Next(100) + 1; 
    } while (Array.IndexOf(values, v) != -1) 
    values[i] = v; 
} 

लेकिन यह बहुत अक्षम, विशेष रूप से सरणी के अंत के पास होगा ...

एक बेहतर समाधान है कि विचार करने के लिए हो सकता है, के बाद से आप एक यादृच्छिक क्रम, अपने सरणी अंततः "फेरबदल" से 1 100 के लिए तो आप बस इन मूल्यों का एक दृश्य उत्पन्न करने के लिए की जरूरत है सभी संभव मूल्यों में शामिल होंगे, और उस में 1 से 100 के लिए 100 अलग-अलग मान हैं:

int[] values = Enumerable.Range(1, 100).ToArray(); 
Random random = new Random(); 
for(int i = values.Length - 1; i > 0; i--) 
{ 
    int j = random.Next(i + 1); 
    int tmp = values[i]; 
    values[i] = values[j]; 
    values[j] = tmp; 
} 

---

संपादित करें: एक बेहतर दृष्टिकोण है, जो कम विशिष्ट मामलों के लिए काम करना चाहिए: अपने विवरण से

int[] result = RandomCombinationWithNoRepeat(Enumerable.Range(1, 100), 100); 

Answer 3

:

T[] RandomCombinationWithNoRepeat<T>(IEnumerable<T> itemsToPickFrom, int numberOfItemsToPick) 
{ 
    // Copy original items to pick from, because we need to modify it 
    List<T> itemsCopy = new List<T>(itemsToPickFrom); 
    T[] array = new T[numberOfItemsToPick]; 
    Random random = new Random(); 
    for(int i = 0; i < numberOfItemsToPick; i++) 
    { 
     // Pick item and remove it from list 
     int index = random.Next(itemsCopy.Count); 
     array[i] = itemsCopy[index]; 
     itemsCopy.RemoveAt(index); 
    } 
    return array; 
} 

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

Linq और जेस्पर पाम के दृष्टिकोण का उपयोग करना - थॉमस लेवेस्क की निम्न कथन से आप सरणी आप की जरूरत दे देंगे।

Random rnd = new Random(); 
var randomNumbers = Enumerable.Range(1, 100) 
           .Select(x => new { val = x, order = rnd.Next() }) 
           .OrderBy(i => i.order) 
           .Select(x => x.val) 
           .ToArray(); 

विधि किसी भी तुलना संचालन की तुलना में काफी तेज, निश्चित रूप से अधिक कुशल है।

मूल पोस्टर के लिए ऊपर समझाने के लिए, नीचे टिप्पणी देखें:

• Enumerable.Range(1, 100) 1 से शुरू होकर 100 पर समाप्त पूर्णांकों की एक श्रृंखला पैदा करता है।
• .Select(x => new { val = x, order = rnd.Next() }) मूल्य और व्यवस्था की स्थिति है, जो एक यादृच्छिक संख्या द्वारा निर्धारित किया जाता पकड़े एक नए अस्थायी वस्तु बनाता है।
• .OrderBy(i => i.order) अस्थायी वस्तुओं को इसकी ऑर्डर स्थिति से टाइप करता है।
• .Select(x => x.val) अस्थायी वस्तु का मान चुनता है, इस प्रकार वापस int में परिवर्तित होता है।
• .ToArray() पूरी चीज को फिर से एक सरणी में बदल देता है।

इस्तेमाल किया गया वाक्यविन्यास LINQ है जो .NET 3.5 में उपलब्ध है। पुराने संस्करणों के साथ आपको इसे स्वयं लागू करना होगा, जो कि बहुत जटिल और काफी लंबा है।

एरिक की टिप्पणी के बाद: के रूप में

var list = myInputList; 
var result = list.Select(x => new { val = x, order = rnd.Next() }) 
       .OrderBy(i => i.order) 
       .Select(x => x.val) 
       .ToArray(); 

Answer 4

मैं क्या समझ है, वहां से

का अनुसरण करती है shuffeling requried है आप कोड कर सकते हैं। आपको यादृच्छिक संख्याओं के साथ पूर्णांक के संग्रह की आवश्यकता है। मैं int सरणी का उपयोग कर मानता हूं या int की सूची कोई फर्क नहीं पड़ता। यहां एक सरल पूर्ण दृष्टिकोण है जिसे आपने वर्णित किया है।
using System; using System.Collections.Generic; using System.Text;

namespace FillRandom { class Program { static void Main(string[] args) { int minValue = 1; int maxValue = 100; //create a list of int with capacity set as 100 List array = new List(100);

 FillArray(array, minValue, maxValue, array.Capacity); 

     //print out all values in the array 
     foreach (int i in array) 
     { 
      Console.WriteLine(i); 
     } 
    } 

    private static void FillArray(List<int> array, int minValue, int maxValue, int capacity) 
    { 
     int count = 0; 
     while (array.Count != capacity - 1) 
     { 
      Random rnd = new Random(); 
      int value = rnd.Next(minValue, maxValue); 
      if (!array.Contains(value)) 
      { 
       array.Add(value); 
      } 
      count++; 
     } 
     //print out the number of times the looping occurs 
     Console.WriteLine("count: "+count); 
    }   
} 

}

आप एक कंसोल प्रोजेक्ट बना सकते हैं और इसे आज़मा सकते हैं।

Answer 5

मैं कैसे करते हो यह इतना लेकिन मैं जांच कर सकते हैं कि अगर मूल्य कभी, सरणी में पहले से ही है और यदि ऐसा है तो एक नया मान

उत्पन्न आप ऐसा नहीं करते हैं, क्योंकि कि एक बहुत बुरा विचार है।

इसे समझने के लिए क्यों यह एक भयानक विचार है, एक ही समस्या का एक और संस्करण पर विचार करें: निम्नलिखित प्रक्रिया द्वारा एक यादृच्छिक क्रम में एक लाख संख्या क्रमबद्ध करें:

1. एक लाख एक से एक नंबर का चयन करें।
2. यह देखने के लिए जांचें कि यह पहले से ही सूची में है या नहीं।
3. यदि यह है, तो चरण 1
4. पर वापस जाएं अन्यथा, सूची में संख्या जोड़ें।
5. क्या इस सूची में दस लाख आइटम हैं? यदि हां, तो आप कर चुके हैं। यदि नहीं, तो चरण 1 पर वापस जाएं।

स्पष्ट रूप से यह काम करता है। क्या यह एक अच्छा विचार है? मान लीजिए कि आप लगभग पूरा कर चुके हैं। इस सूची में 99 99 99 आइटम हैं। एकमात्र गायब वस्तु 857313 है। आप क्या करते हैं? आप एक यादृच्छिक संख्या चुनते हैं, कहें, 12. अब आप सूची में 99 99 99 आइटम देख सकते हैं कि उनमें से कोई भी 12 है या नहीं। 12 शायद आपके द्वारा चुने गए पहले नंबरों में से एक हो सकता है, इसलिए इसे ढूंढना तेज़ हो सकता है। या यह आखिरी में से एक हो सकता है, इसलिए इसमें काफी समय लगेगा। औसतन 500000 चेक लेते हैं यह देखने के लिए कि सूची में 12 है या नहीं। और ऐसा इसलिए है, क्योंकि सूची में केवल एक नंबर गुम है।

12 काम नहीं किया। शुरुआत में वापस जाओ। 53259 कहें, एक और यादृच्छिक संख्या चुनें। क्या यह सूची में है? एक और आधे मिलियन चेक।

कर रखें कि जब तक आप 857,313 उत्पन्न करते हैं जो एक हर दस लाख की कोशिश करता होता है।

तो औसतन, सूची में अंतिम आइटम डालने के लिए 500000 x 1000000 = पांच सौ अरब तुलनाएं होती हैं। यह और अधिक रास्ता ले सकता है। इसमें कई ट्रिलियन तुलना हो सकती है। या आप भाग्यशाली हो सकते हैं और यह एक लेता है। लेकिन औसतन, आधा ट्रिलियन तुलना।

यह एक भयानक एक सूची का यादृच्छिक क्रम बनाने के लिए है।

सूची के यादृच्छिक क्रम बनाने के दो अच्छे तरीके हैं।

(1) एक उपकरण बनाएं जो ऑर्डरिंग फ़ंक्शन दिए गए सूची को सॉर्ट कर सकता है। स्थिर ऑर्डर करना जो यादृच्छिक बीज पर आधारित है प्रदान करें।

ध्यान दें कि आपको एक ऐसी विधि बनाकर यादृच्छिक क्रम उत्पन्न करना चाहिए जो "बी से बड़ा है?" यह एक अस्थिर आदेश है; कई प्रकार के एल्गोरिदम एक स्थिर सॉर्ट ऑर्डरिंग पर अनुमानित होते हैं और अस्थिर सॉर्ट ऑर्डर देने पर अनंत लूप में जाते हैं या अन्य खराब व्यवहार करते हैं।

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

(2) यादृच्छिक रूप से को स्रोत सूची से इंडेक्स द्वारा एक आइटम चुनें, इसे स्रोत सूची से हटाकर, और गंतव्य सूची पर डालें।

उत्तरार्द्ध को Knuth Shuffle या फिशर-येट्स शफल के रूप में जाना जाता है, और यह एक बहुत तेज़ एल्गोरिदम है। आप इसे "जगह में" कर सकते हैं, एक मौजूदा सरणी को शफल क्रम में बदल सकते हैं, या एक नई सूची बनाकर कर सकते हैं। इसमें अच्छी संपत्ति भी है जिसे आप "प्ले के लिए भुगतान" कर सकते हैं, जिसकी आपको आवश्यकता है, सूची के "शीर्ष" को घुमाएं। यदि आपके पास शफल करने के लिए लाखों आइटम हैं लेकिन आपको केवल पहले सौ की आवश्यकता है, तो आप पहले सौ के लिए सॉर्ट ऑर्डर कर सकते हैं और इसे अच्छा कह सकते हैं।