एक समूह से एन यादृच्छिक आइटम का चयन करने के लिए ऑर्डर के साथ कुछ भी नहीं होना चाहिए ! यादृच्छिकता अप्रत्याशितता के बारे में है न कि किसी समूह में फेरबदल की स्थिति के बारे में। सभी जवाब जो थोड़े ऑर्डर के साथ सौदा करते हैं, वह उन लोगों की तुलना में कम कुशल है जो ऐसा नहीं करते हैं। चूंकि दक्षता यहां कुंजी है, इसलिए मैं कुछ ऐसा पोस्ट करूंगा जो वस्तुओं के क्रम को बहुत अधिक नहीं बदलता है।
1) यदि आपको सच्चे यादृच्छिक मूल्यों की आवश्यकता है, जिसका अर्थ है कि किन तत्वों पर कोई प्रतिबंध नहीं है (यानी, एक बार चुने गए आइटम को फिर से चुना जा सकता है):
public static List<T> GetTrueRandom<T>(this IList<T> source, int count,
bool throwArgumentOutOfRangeException = true)
{
if (throwArgumentOutOfRangeException && count > source.Count)
throw new ArgumentOutOfRangeException();
var randoms = new List<T>(count);
randoms.AddRandomly(source, count);
return randoms;
}
यदि आप अपवाद ध्वज को बंद करते हैं, तो आप किसी भी समय यादृच्छिक आइटम चुन सकते हैं।
यदि आपके पास {1, 2, 3, 4} है, तो यह 3 आइटम के लिए {1, 4, 4}, {1, 4, 3} आदि दे सकता है या {1, 4, 3, 2, 4} के लिए भी दे सकता है। 5 आइटम!
यह बहुत तेज़ होना चाहिए, क्योंकि इसमें कुछ भी नहीं है।
2) यदि आपको पुनरावृत्ति वाले समूह से अलग-अलग सदस्यों की आवश्यकता है , तो मैं एक शब्दकोश पर भरोसा करूंगा (जैसा कि कई पहले ही बता चुके हैं)।
public static List<T> GetDistinctRandom<T>(this IList<T> source, int count)
{
if (count > source.Count)
throw new ArgumentOutOfRangeException();
if (count == source.Count)
return new List<T>(source);
var sourceDict = source.ToIndexedDictionary();
if (count > source.Count / 2)
{
while (sourceDict.Count > count)
sourceDict.Remove(source.GetRandomIndex());
return sourceDict.Select(kvp => kvp.Value).ToList();
}
var randomDict = new Dictionary<int, T>(count);
while (randomDict.Count < count)
{
int key = source.GetRandomIndex();
if (!randomDict.ContainsKey(key))
randomDict.Add(key, sourceDict[key]);
}
return randomDict.Select(kvp => kvp.Value).ToList();
}
कोड अन्य शब्दकोश दृष्टिकोणों की तुलना में थोड़ा लंबा है, क्योंकि मैं न केवल जोड़ रहा हूं, बल्कि सूची से भी हटा रहा हूं, इसलिए इसकी थोड़े दो छोरें। आप यहाँ देख सकते हैं कि मैंने कुछ भी नहीं लिखा है जब countसमान हो जाता है source.Count। ऐसा इसलिए है क्योंकि मेरा मानना है कि पूरे सेट के रूप में बेतरतीब वापसी होनी चाहिए । मेरा मतलब है अगर आप चाहते हैं 5 यादृच्छिक वस्तुओं से 1, 2, 3, 4, 5है, यह बात अगर इसकी नहीं करना चाहिए 1, 3, 4, 2, 5या 1, 2, 3, 4, 5, लेकिन अगर आप की जरूरत है 4 एक ही सेट से आइटम है, तो यह अप्रत्याशित रूप में उपज चाहिए 1, 2, 3, 4, 1, 3, 5, 2, 2, 3, 5, 4आदि दूसरे, जब यादृच्छिक आइटम की गणना होने के लिए लौटा मूल समूह के आधे से अधिक है, तो इसे हटाने के लिए आसान हैsource.Count - countआइटम जोड़ने से समूह से countआइटम। प्रदर्शन कारणों के लिए मैंने हटाने की विधि में यादृच्छिक सूचकांक प्राप्त करने के sourceबजाय उपयोग किया है sourceDict।
इसलिए यदि आपके पास {1, 2, 3, 4} है, तो यह 3 आइटम के लिए {1, 2, 3}, {3, 4, 1} आदि में समाप्त हो सकता है।
3) यदि आपको मूल समूह में डुप्लिकेट को ध्यान में रखते हुए अपने समूह से वास्तव में अलग-अलग यादृच्छिक मूल्यों की आवश्यकता है, तो आप ऊपर के समान दृष्टिकोण का उपयोग कर सकते हैं, लेकिन HashSetएक शब्दकोश की तुलना में हल्का होगा।
public static List<T> GetTrueDistinctRandom<T>(this IList<T> source, int count,
bool throwArgumentOutOfRangeException = true)
{
if (count > source.Count)
throw new ArgumentOutOfRangeException();
var set = new HashSet<T>(source);
if (throwArgumentOutOfRangeException && count > set.Count)
throw new ArgumentOutOfRangeException();
List<T> list = hash.ToList();
if (count >= set.Count)
return list;
if (count > set.Count / 2)
{
while (set.Count > count)
set.Remove(list.GetRandom());
return set.ToList();
}
var randoms = new HashSet<T>();
randoms.AddRandomly(list, count);
return randoms.ToList();
}
randomsचर एक बना है HashSetसे बचने के लिए डुप्लिकेट नायाब मामलों में जहां के नायाब में जोड़ा जा रहा है Random.Nextएक ही मूल्य प्राप्त हो सकते हैं, खासकर जब इनपुट सूची छोटा है।
तो {1, 2, 2, 4} => 3 यादृच्छिक आइटम => {1, 2, 4} और कभी नहीं {1, 2, 2}
{, 2, 2, 4} => 4 यादृच्छिक आइटम => अपवाद !! या {1, 2, 4} ध्वज सेट पर निर्भर करता है।
मेरे द्वारा उपयोग की जाने वाली कुछ विस्तार विधियाँ:
static Random rnd = new Random();
public static int GetRandomIndex<T>(this ICollection<T> source)
{
return rnd.Next(source.Count);
}
public static T GetRandom<T>(this IList<T> source)
{
return source[source.GetRandomIndex()];
}
static void AddRandomly<T>(this ICollection<T> toCol, IList<T> fromList, int count)
{
while (toCol.Count < count)
toCol.Add(fromList.GetRandom());
}
public static Dictionary<int, T> ToIndexedDictionary<T>(this IEnumerable<T> lst)
{
return lst.ToIndexedDictionary(t => t);
}
public static Dictionary<int, T> ToIndexedDictionary<S, T>(this IEnumerable<S> lst,
Func<S, T> valueSelector)
{
int index = -1;
return lst.ToDictionary(t => ++index, valueSelector);
}
यदि इसकी सभी वस्तुओं के प्रदर्शन के बारे में 10000 से अधिक बार होने वाली सूची में इसके प्रदर्शन के बारे में है, तो आप शायद इसकी तुलना में तेजी से यादृच्छिक वर्ग चाहते हैं System.Random, लेकिन मुझे नहीं लगता कि बाद में सबसे अधिक विचार करने वाला एक बड़ा सौदा शायद कभी नहीं है अड़चन, इसके काफी तेजी से पर्याप्त ..
संपादित करें: यदि आपको लौटे हुए सामान के ऑर्डर को फिर से व्यवस्थित करने की आवश्यकता है, तो ऐसा कुछ भी नहीं है जो ढकीम के फिशर-येट्स के दृष्टिकोण को हरा सकता है - लघु, मीठा और सरल ।।