Query LINQ ottimale per ottenere una sottocartella casuale - Shuffle

Question

Si prega di suggerire un modo più semplice per ottenere una raccolta casualmente casuale del conteggio "n" da una raccolta con elementi "N". dove n < = N

Answer 1

Un'altra opzione è quella di utilizzare OrderBy e per ordinare su un valore GUID, che è possibile farlo utilizzando:

var result = sequence.OrderBy(elem => Guid.NewGuid()); 

Ho fatto alcuni test empirici per convincermi che quanto sopra in realtà genera una distribuzione casuale (che appare fare). Puoi vedere i miei risultati allo Techniques for Randomly Reordering an Array.

Answer 2

Shuffle la raccolta in un ordine casuale e prendere i primi articoli n dal risultato.

Answer 3

seguito alla risposta del mquander e il commento di Dan Blanchard, ecco un metodo di estensione LINQ-friendly che esegue una Fisher-Yates-Durstenfeld shuffle:

// take n random items from yourCollection 
var randomItems = yourCollection.Shuffle().Take(n); 

// ... 

public static class EnumerableExtensions 
{ 
    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source) 
    { 
     return source.Shuffle(new Random()); 
    } 

    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source, Random rng) 
    { 
     if (source == null) throw new ArgumentNullException("source"); 
     if (rng == null) throw new ArgumentNullException("rng"); 

     return source.ShuffleIterator(rng); 
    } 

    private static IEnumerable<T> ShuffleIterator<T>(
     this IEnumerable<T> source, Random rng) 
    { 
     var buffer = source.ToList(); 
     for (int i = 0; i < buffer.Count; i++) 
     { 
      int j = rng.Next(i, buffer.Count); 
      yield return buffer[j]; 

      buffer[j] = buffer[i]; 
     } 
    } 
} 

Answer 4

Ci scusiamo per il codice brutto :-), ma

 

var result =yourCollection.OrderBy(p => (p.GetHashCode().ToString() + Guid.NewGuid().ToString()).GetHashCode()).Take(n); 
 

Answer 5

Questo ha alcuni problemi con "bias casuale" e sono sicuro che non è ottimale, questa è un'altra possibilità:

var r = new Random(); 
l.OrderBy(x => r.NextDouble()).Take(n); 

Answer 6

Scrivo questo sovrascrive il metodo:

public static IEnumerable<T> Randomize<T>(this IEnumerable<T> items) where T : class 
{ 
    int max = items.Count(); 
    var secuencia = Enumerable.Range(1, max).OrderBy(n => n * n * (new Random()).Next()); 

    return ListOrder<T>(items, secuencia.ToArray()); 
} 

private static IEnumerable<T> ListOrder<T>(IEnumerable<T> items, int[] secuencia) where T : class 
     { 
      List<T> newList = new List<T>(); 
      int count = 0; 
      foreach (var seed in count > 0 ? secuencia.Skip(1) : secuencia.Skip(0)) 
      { 
       newList.Add(items.ElementAt(seed - 1)); 
       count++; 
      } 
      return newList.AsEnumerable<T>(); 
     } 

Poi, io ho la mia lista sorgente (tutte le voci)

var listSource = p.Session.QueryOver<Listado>(() => pl) 
         .Where(...); 

Infine, mi chiamano "Randomize" e ottengo un sub-raccolta casuale di articoli, nel mio caso, 5 articoli:

var SubCollection = Randomize(listSource.List()).Take(5).ToList(); 

Answer 7

Un po 'meno casuale, ma efficiente:

var rnd = new Random(); 
var toSkip = list.Count()-n; 

if (toSkip > 0) 
    toSkip = rnd.Next(toSkip); 
else 
    toSkip=0; 

var randomlySelectedSequence = list.Skip(toSkip).Take(n);