Memilih N item acak dari grup seharusnya tidak ada hubungannya dengan pesanan ! Keacakan adalah tentang ketidakpastian dan bukan tentang pengacakan posisi dalam suatu grup. Semua jawaban yang berhubungan dengan pemesanan agak pasti kurang efisien daripada yang tidak. Karena efisiensi adalah kuncinya di sini, saya akan memposting sesuatu yang tidak mengubah urutan item terlalu banyak.
1) Jika Anda membutuhkan nilai acak sejati yang berarti tidak ada batasan pada elemen mana yang harus dipilih (yaitu, item yang dipilih dapat dipilih kembali):
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;
}
Jika Anda menonaktifkan flag pengecualian, maka Anda dapat memilih item acak berapa kali.
Jika Anda memiliki {1, 2, 3, 4}, maka ia dapat memberikan {1, 4, 4}, {1, 4, 3} dll untuk 3 item atau bahkan {1, 4, 3, 2, 4} untuk 5 item!
Ini harusnya cukup cepat, karena tidak ada yang perlu diperiksa.
2) Jika Anda memerlukan anggota individu dari grup tanpa pengulangan, maka saya akan mengandalkan kamus (seperti yang sudah ditunjukkan banyak orang).
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();
}
Kode ini sedikit lebih panjang daripada pendekatan kamus lain di sini karena saya tidak hanya menambahkan, tetapi juga menghapus dari daftar, jadi itu agak dua loop. Anda dapat melihat di sini bahwa saya belum memesan ulang apa pun ketika countmenjadi sama dengan source.Count. Itu karena saya percaya keacakan harus di set kembali secara keseluruhan . Maksudku jika Anda ingin 5 item acak dari 1, 2, 3, 4, 5, seharusnya tidak peduli jika 1, 3, 4, 2, 5atau 1, 2, 3, 4, 5, tapi jika Anda membutuhkan 4 item dari set yang sama, maka harus tak terduga menghasilkan di 1, 2, 3, 4, 1, 3, 5, 2, 2, 3, 5, 4dll Kedua, ketika jumlah item acak menjadi dikembalikan lebih dari setengah dari grup asli, maka lebih mudah untuk dihapussource.Count - countitem dari grup daripada menambahkan countitem. Untuk alasan kinerja, saya menggunakan sourcealih-alih sourceDictmendapatkan indeks acak dalam metode hapus.
Jadi jika Anda memiliki {1, 2, 3, 4}, ini bisa berakhir pada {1, 2, 3}, {3, 4, 1} dll untuk 3 item.
3) Jika Anda membutuhkan nilai acak yang benar-benar berbeda dari grup Anda dengan mempertimbangkan duplikat dalam grup asli, maka Anda dapat menggunakan pendekatan yang sama seperti di atas, tetapi HashSetakan lebih ringan daripada kamus.
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();
}
The randomsvariabel membuat HashSetuntuk menghindari duplikasi yang ditambahkan dalam yang paling langka kasus yang paling langka di mana Random.Nextdapat menghasilkan nilai yang sama, terutama ketika daftar masukan kecil.
Jadi {1, 2, 2, 4} => 3 item acak => {1, 2, 4} dan tidak pernah {1, 2, 2}
{1, 2, 2, 4} => 4 item acak => pengecualian !! atau {1, 2, 4} tergantung pada set bendera.
Beberapa metode ekstensi yang saya gunakan:
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);
}
Jika itu semua tentang kinerja dengan puluhan item 1000s dalam daftar harus diulang 10.000 kali, maka Anda mungkin ingin memiliki kelas acak lebih cepat daripada System.Random, tapi saya tidak berpikir itu masalah besar mengingat yang terakhir kemungkinan besar tidak pernah menjadi bottleneck, itu cukup cepat ..
Sunting: Jika Anda perlu mengatur ulang pesanan barang yang dikembalikan juga, maka tidak ada yang dapat mengalahkan pendekatan Fisher-Yates dhakim - pendek, manis dan sederhana ..