Obteniendo una colección de valores de índice usando una consulta LINQ

Question

¿Hay una mejor manera de hacerlo?

string[] s = {"zero", "one", "two", "three", "four", "five"}; 

var x = 
s 
.Select((a,i) => new {Value = a, Index = i}) 
.Where(b => b.Value.StartsWith("t")) 
.Select(c => c.Index); 

es decir, estoy buscando una manera más eficiente o más elegante para obtener las posiciones de los elementos que coinciden con los criterios.

Answer 1

Desde aquí se puede añadir su propio método de extensión:

public static IEnumerable<int> IndexesWhere<T>(this IEnumerable<T> source, Func<T, bool> predicate) 
{ 
    int index=0; 
    foreach (T element in source) 
    { 
     if (predicate(element)) 
     { 
      yield return index; 
     } 
     index++; 
    } 
} 

Entonces usarlo con:

string[] s = {"zero", "one", "two", "three", "four", "five"}; 
var x = s.IndexesWhere(t => t.StartsWith("t")); 

Answer 2

Me parece bien. Es posible guardar un par de caracteres cambiando la selección para:

.Select((Value, Index) => new {Value, Index}) 

Answer 3

Si sólo está usando el ejemplo como una manera de aprender LINQ, ignorar este mensaje.

---

No es claro para mí que LINQ sea realmente la mejor manera de hacerlo. El siguiente código parece ser más eficiente ya que no es necesario crear un nuevo tipo anónimo. Por supuesto, su ejemplo puede ser ideado y la técnica podría ser más útil en un contexto diferente, por ejemplo, en una estructura de datos donde podría aprovechar un índice de valor, pero el código siguiente es razonablemente directo, comprensible (sin pensamiento). requerido) y posiblemente más eficiente.

string[] s = {"zero", "one", "two", "three", "four", "five"}; 
List<int> matchingIndices = new List<int>(); 

for (int i = 0; i < s.Length; ++i) 
{ 
    if (s[i].StartWith("t")) 
    { 
     matchingIndices.Add(i); 
    } 
} 

Answer 4

También hay método FindIndex en lista de colecciones para el que crea un método de eliminación que puede devolver el índice de la colección. Puede consultar el siguiente enlace en msdn http://msdn.microsoft.com/en-us/library/x1xzf2ca.aspx.

Answer 5

¿Qué tal esto? Es similar al póster original, pero primero selecciono los índices y luego construyo una colección que coincide con los criterios.

var x = s.Select((a, i) => i).Where(i => s[i].StartsWith("t")); 

Esto es un poco menos eficiente que algunas de las otras respuestas ya que la lista se itera por completo en dos ocasiones.

Answer 6

Discutí este problema interesante con un colega y al principio pensé que la solución de JonSkeet era genial, pero mi colega señaló un problema, a saber, que si la función es una extensión de IEnumerable<T>, entonces puede usarse donde una colección implementa eso.

Con una matriz, que es seguro decir que el orden producido con foreach será respetada (es decir foreach se repetirá desde el primero al último), pero no sería necesariamente el caso con otras colecciones (Lista, diccionario, etc.), donde foreach no reflejaría necesariamente "orden de entrada". Sin embargo, la función está ahí, y puede ser engañosa.

Al final, acabé con algo similar a la respuesta de tvanfosson, sino como un método de extensión, para las matrices:

public static int[] GetIndexes<T>(this T[]source, Func<T, bool> predicate) 
{ 
    List<int> matchingIndexes = new List<int>(); 

    for (int i = 0; i < source.Length; ++i) 
    { 
     if (predicate(source[i])) 
     { 
      matchingIndexes.Add(i); 
     } 
    } 
    return matchingIndexes.ToArray(); 
} 

Aquí está la esperanza List.ToArray respetará el orden de la última operación ...