Chọn N mục ngẫu nhiên từ một nhóm không nên có bất cứ điều gì liên quan đến đơn hàng ! Sự ngẫu nhiên là về sự khó lường và không phải là về các vị trí xáo trộn trong một nhóm. Tất cả các câu trả lời liên quan đến một số loại đặt hàng chắc chắn là kém hiệu quả hơn so với những câu trả lời không. Vì hiệu quả là chìa khóa ở đây, tôi sẽ đăng một cái gì đó không thay đổi thứ tự của các mặt hàng quá nhiều.
1) Nếu bạn cần các giá trị ngẫu nhiên thực sự , điều đó có nghĩa là không có hạn chế nào về việc lựa chọn các yếu tố nào (nghĩa là, một khi mục được chọn có thể được chọn lại):
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;
}
Nếu bạn đặt cờ ngoại lệ, thì bạn có thể chọn các mục ngẫu nhiên bất kỳ số lần.
Nếu bạn có {1, 2, 3, 4}, thì nó có thể cung cấp {1, 4, 4}, {1, 4, 3} vv cho 3 mục hoặc thậm chí {1, 4, 3, 2, 4} cho 5 món!
Điều này sẽ khá nhanh, vì nó không có gì để kiểm tra.
2) Nếu bạn cần các thành viên riêng lẻ trong nhóm mà không lặp lại, thì tôi sẽ dựa vào một từ điển (như nhiều người đã chỉ ra).
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();
}
Mã này dài hơn một chút so với các cách tiếp cận từ điển khác ở đây vì tôi không chỉ thêm, mà còn xóa khỏi danh sách, do đó, đây là hai vòng lặp. Bạn có thể thấy ở đây tôi chưa sắp xếp lại bất cứ thứ gì khi counttrở nên ngang bằng source.Count. Đó là bởi vì tôi tin rằng ngẫu nhiên phải ở trong bộ trở lại như một toàn thể . Ý tôi là nếu bạn muốn 5 mục ngẫu nhiên từ 1, 2, 3, 4, 5đó, thì không quan trọng nếu nó 1, 3, 4, 2, 5hay 1, 2, 3, 4, 5, nhưng nếu bạn cần 4 mục từ cùng một tập hợp, sau đó nó không thể lường trước nên năng suất trong 1, 2, 3, 4, 1, 3, 5, 2, 2, 3, 5, 4, vv Thứ hai, khi số lượng các mặt hàng ngẫu nhiên để được trả lại là hơn một nửa của nhóm ban đầu, sau đó dễ dàng hơn để loại bỏsource.Count - countcác mục từ nhóm hơn là thêm countcác mục. Vì lý do hiệu suất, tôi đã sử dụng sourcethay vì sourceDictlấy chỉ số ngẫu nhiên trong phương thức remove.
Vì vậy, nếu bạn có {1, 2, 3, 4}, điều này có thể kết thúc bằng {1, 2, 3}, {3, 4, 1}, v.v. cho 3 mục.
3) Nếu bạn cần các giá trị ngẫu nhiên thực sự khác biệt với nhóm của mình bằng cách tính đến các bản sao trong nhóm ban đầu, thì bạn có thể sử dụng cùng một cách tiếp cận như trên, nhưng HashSetsẽ nhẹ hơn từ điển.
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();
}
Các randomsbiến được làm một HashSetđể tránh trùng lặp được thêm vào trong hiếm các trường hợp hiếm nhất nơi Random.Nextcó thể mang lại giá trị như nhau, đặc biệt là khi danh sách đầu vào là nhỏ.
Vậy {1, 2, 2, 4} => 3 mục ngẫu nhiên => {1, 2, 4} và không bao giờ {1, 2, 2}
{1, 2, 2, 4} => 4 mục ngẫu nhiên => ngoại lệ !! hoặc {1, 2, 4} tùy thuộc vào bộ cờ.
Một số phương pháp mở rộng tôi đã sử dụng:
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);
}
Nếu tất cả chỉ là về hiệu suất với hàng chục 1000 mặt hàng trong danh sách phải lặp đi lặp lại 10000 lần, thì bạn có thể muốn có lớp ngẫu nhiên nhanh hơn System.Random, nhưng tôi không nghĩ rằng đó là vấn đề lớn có lẽ không bao giờ là một nút cổ chai, nó khá đủ nhanh ..
Chỉnh sửa: Nếu bạn cũng cần sắp xếp lại thứ tự các mặt hàng được trả lại, thì không có gì có thể vượt qua cách tiếp cận Fisher-Yates của dhakim - ngắn gọn, ngọt ngào và đơn giản ..