Bir gruptan N rastgele öğe seçmenin siparişle ilgisi olmamalıdır ! Rasgelelik öngörülemezlikle ilgilidir ve bir gruptaki pozisyonları karıştırmakla ilgili değildir. Biraz sıralama ile ilgili tüm cevaplar, yapmayanlardan daha az verimli olmak zorundadır. Verimlilik burada anahtar olduğundan, öğelerin sırasını çok fazla değiştirmeyen bir şey yayınlayacağım.
1) Gerçek rastgele değerlere ihtiyacınız varsa , hangi öğelerin seçileceği konusunda herhangi bir kısıtlama olmadığı anlamına gelir (yani, seçilen öğe yeniden seçildikten sonra):
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;
}
İstisna bayrağını kapatırsanız, rastgele öğeleri istediğiniz sayıda seçebilirsiniz.
{1, 2, 3, 4} ürününüz varsa, 3 öğe için {1, 4, 4}, {1, 4, 3} vb. 5 öğe!
Kontrol edilecek bir şey olmadığı için bu oldukça hızlı olmalıdır.
2) Tekrarlama olmayan gruptan bireysel üyelere ihtiyacınız varsa , o zaman bir sözlüğe güvenirim (birçok kişi daha önce işaret ettiği gibi).
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();
}
Kod, diğer sözlük yaklaşımlarından biraz daha uzundur çünkü ben sadece eklemekle kalmıyorum, aynı zamanda listeden de kaldırıyorum, bu yüzden iki döngü. Burada, eşit olunca hiçbir şeyi yeniden sıralamadığımı görebilirsiniz . Çünkü rastgeleliğin bir bütün olarak geri dönen sette olması gerektiğine inanıyorum . İstersen demek 5 rastgele ürün arasından , verilmemelidir olsun eğer onun veya ancak gerekirse 4 aynı kümesinden öğeleri, o zaman tahmin edilemeyecek içinde vermelidir , , gruptan öğe ekleyerek daha öğeler. Performans nedenleriyle kullanmak yerinecountsource.Count1, 2, 3, 4, 51, 3, 4, 2, 51, 2, 3, 4, 51, 2, 3, 41, 3, 5, 22, 3, 5, 4 vb İkincisi, rasgele öğelerin sayısı olmak ne zaman döndürülen orijinal grubun yarısından fazla, daha sonra kaldırmak daha kolaysource.Count - countcountsourcesourceDict Kaldır yönteminde rasgele dizin elde etmek için.
Dolayısıyla, {1, 2, 3, 4} varsa, bu, 3 öğe için {1, 2, 3}, {3, 4, 1} vb. İle sonuçlanabilir.
3) Orijinal gruptaki kopyaları dikkate alarak grubunuzdan gerçekten farklı rastgele değerlere ihtiyacınız varsa, yukarıdakiyle aynı yaklaşımı kullanabilirsiniz, ancak HashSetbir sözlükten daha açık olacaktır.
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();
}
randomsDeğişkeni yapılır HashSetçiftleri nadir durumlarda nadir ilave önlemek için Random.Nextgiriş listesi küçük olduğu durumlarda, aynı değeri verebilir.
Böylece {1, 2, 2, 4} => 3 rastgele öğe => {1, 2, 4} ve asla {1, 2, 2}
{1, 2, 2, 4} => 4 rastgele öğe => istisna !! veya ayarlanan işarete bağlı olarak {1, 2, 4}.
Kullandığım bazı uzantı yöntemleri:
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);
}
Listedeki öğelerin 1000'ler onlarca ile tüm ilgili performans 10000 kez tekrarlanır edilecek olan, o zaman olmasını isteyebilirsiniz hızlı rastgele sınıf daha System.Random, ama bunun büyük olasılıkla ikincisi dikkate büyük bir anlaşma asla düşünmüyorum darboğaz, yeterince hızlı ..
Düzenleme: Döndürülen öğelerin sırasını da yeniden düzenlemeniz gerekiyorsa, o zaman dhakim'in Fisher-Yates yaklaşımını yenebilecek hiçbir şey yok - kısa, tatlı ve basit ..