Come posso ottenere ogni ennesimo elemento da un elenco ?

Sto usando .NET 3.5 e vorrei essere in grado di ottenere ogni * n * th elemento da un elenco. Non mi preoccupo se è raggiunto usando un’espressione lambda o LINQ.

modificare

Sembra che questa domanda abbia provocato un sacco di discussioni (che è una buona cosa, giusto?). La cosa principale che ho imparato è che quando pensi di sapere ogni modo di fare qualcosa (anche così semplice), ripensaci!

 return list.Where((x, i) => i % nStep == 0); 

So che è “vecchia scuola”, ma perché non usare solo un ciclo for con stepping = n?

Sembra

 IEnumerator GetNth(List list, int n) { for (int i=0; i 

farebbe il trucco Non vedo la necessità di usare Linq o espressioni lambda.

MODIFICARE:

Fallo

 public static class MyListExtensions { public static IEnumerable GetNth(this List list, int n) { for (int i=0; i 

e tu scrivi in ​​un modo LINQish

 from var element in MyList.GetNth(10) select element; 

2a modifica :

Per renderlo ancora più LINQish

 from var i in Range(0, ((myList.Length-1)/n)+1) select list[n*i]; 

È ansible utilizzare il sovraccarico Where che passa l’indice insieme all’elemento

 var everyFourth = list.Where((x,i) => i % 4 == 0); 

Per Loop

 for(int i = 0; i < list.Count; i += n) //Nth Item.. 

Non sono sicuro che sia ansible fare con un’espressione LINQ, ma so che è ansible utilizzare il metodo di estensione Where per farlo. Ad esempio per ottenere ogni quinto elemento:

 List list = originalList.Where((t,i) => (i % 5) == 0).ToList(); 

Questo otterrà il primo object e ogni cinque da lì. Se si desidera iniziare dal quinto elemento anziché dal primo, si confronta con 4 anziché con 0.

Penso che se fornisci un’estensione linq, dovresti essere in grado di operare sull’interfaccia meno specifica, quindi su IEnumerable. Ovviamente, se la velocità è elevata, specialmente per N di grandi dimensioni, è ansible che si verifichi un sovraccarico per l’accesso indicizzato. Quest’ultimo elimina la necessità di iterare su grandi quantità di dati non necessari e sarà molto più veloce della clausola Where. Fornire entrambi gli overload consente al compilatore di selezionare la variante più adatta.

 public static class LinqExtensions { public static IEnumerable GetNth(this IEnumerable list, int n) { if (n < 0) throw new ArgumentOutOfRangeException("n"); if (n > 0) { int c = 0; foreach (var e in list) { if (c % n == 0) yield return e; c++; } } } public static IEnumerable GetNth(this IList list, int n) { if (n < 0) throw new ArgumentOutOfRangeException("n"); if (n > 0) for (int c = 0; c < list.Count; c += n) yield return list[c]; } } 
 private static readonly string[] sequence = "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15".Split(','); static void Main(string[] args) { var every4thElement = sequence .Where((p, index) => index % 4 == 0); foreach (string p in every4thElement) { Console.WriteLine("{0}", p); } Console.ReadKey(); } 

produzione

inserisci la descrizione dell'immagine qui

Imho, nessuna risposta è giusta. Tutte le soluzioni iniziano da 0. Ma voglio avere il vero elemento ennesimo

 public static IEnumerable GetNth(this IList list, int n) { for (int i = n - 1; i < list.Count; i += n) yield return list[i]; }