La sélection de N éléments aléatoires dans un groupe ne devrait rien avoir à voir avec l' ordre ! Le hasard est une question d'imprévisibilité et non de réorganisation des positions dans un groupe. Toutes les réponses qui traitent d'une sorte de commande sont forcément moins efficaces que celles qui ne le font pas. Puisque l'efficacité est la clé ici, je publierai quelque chose qui ne change pas trop l'ordre des éléments.
1) Si vous avez besoin de vraies valeurs aléatoires, ce qui signifie qu'il n'y a aucune restriction sur les éléments à choisir (c'est-à-dire qu'une fois que l'élément choisi peut être resélectionné):
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;
}
Si vous désactivez l'indicateur d'exception, vous pouvez choisir des éléments aléatoires un nombre illimité de fois.
Si vous avez {1, 2, 3, 4}, alors il peut donner {1, 4, 4}, {1, 4, 3} etc pour 3 éléments ou même {1, 4, 3, 2, 4} pour 5 éléments!
Cela devrait être assez rapide, car il n'y a rien à vérifier.
2) Si vous avez besoin de membres individuels du groupe sans répétition, alors je me fierais à un dictionnaire (comme beaucoup l'ont déjà souligné).
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();
}
Le code est un peu plus long que les autres approches de dictionnaire ici parce que je suis non seulement en train d'ajouter, mais aussi de supprimer de la liste, donc c'est un peu deux boucles. Vous pouvez voir ici que je n'ai rien réordonné du tout quand countdevient égal à source.Count. C'est parce que je pense que le hasard devrait être dans l' ensemble renvoyé dans son ensemble . Je veux dire si vous voulez 5 éléments aléatoires 1, 2, 3, 4, 5, il ne devrait pas question si son 1, 3, 4, 2, 5ou 1, 2, 3, 4, 5, mais si vous avez besoin de 4 articles de la même série, il devrait céder en imprévisiblement 1, 2, 3, 4, 1, 3, 5, 2, 2, 3, 5, 4etc. En second lieu , lorsque le nombre d'éléments aléatoires à renvoyé représente plus de la moitié du groupe d'origine, il est alors plus facile à supprimersource.Count - countéléments du groupe que d’ajouter des countéléments. Pour des raisons de performances, j'ai utilisé sourceau lieu de sourceDictpour obtenir un index aléatoire dans la méthode remove.
Donc, si vous avez {1, 2, 3, 4}, cela peut aboutir à {1, 2, 3}, {3, 4, 1} etc. pour 3 éléments.
3) Si vous avez besoin de valeurs aléatoires vraiment distinctes de votre groupe en prenant en compte les doublons dans le groupe d'origine, vous pouvez utiliser la même approche que ci-dessus, mais un HashSetsera plus léger qu'un dictionnaire.
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();
}
La randomsvariable est créée HashSetpour éviter l'ajout de doublons dans le plus rare des cas les plus rares où Random.Nextpeut produire la même valeur, en particulier lorsque la liste d'entrée est petite.
Donc {1, 2, 2, 4} => 3 éléments aléatoires => {1, 2, 4} et jamais {1, 2, 2}
{1, 2, 2, 4} => 4 éléments aléatoires => exception !! ou {1, 2, 4} selon le jeu d'indicateurs.
Certaines des méthodes d'extension que j'ai utilisées:
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);
}
Si tout est question de performances avec des dizaines de milliers d'éléments de la liste devant être répétés 10000 fois, vous voudrez peut-être avoir une classe aléatoire plus rapide que System.Random, mais je ne pense pas que ce soit un gros problème étant donné que ce dernier n'est probablement jamais un goulot d'étranglement, c'est assez rapide.
Edit: Si vous avez également besoin de réorganiser l'ordre des articles retournés, rien ne peut battre l' approche Fisher-Yates de Dhakim - bref, doux et simple.