Obtiene la posición del elemento List en c # usando LINQ

Tengo una lista con números, me gustaría encontrar la posición del mínimo (sin valor) usando LINQ

Ej .: {3,1,0,5} salida = 2

var list = new List { 3, 1, 0, 5 }; int pos = list.IndexOf(list.Min()); // returns 2 

Como solicitó específicamente una solución LINQ, y todo lo que obtuvo fueron soluciones que no son LINQ, aquí hay una solución LINQ:

 List values = new List { 3, 1, 0, 5 }; int index = values .Select((n, i) => new { Value = n, Index = i }) .OrderBy(n=>n.Value) .First() .Index; 

Sin embargo, eso no significa que LINQ sea la mejor solución para este problema …

Editar:

Con un código un poco más complejo esto funciona un poco mejor:

 int index = values .Select((n, i) => new { Value = n, Index = i }) .Aggregate((a,b) => a.Value < b.Value ? a : b) .Index; 

Para obtener el mejor rendimiento, usaría un bucle simple para ver los elementos, mientras realiza un seguimiento de los más bajos:

 int index = 0, value = values[0]; for (int i = 1; i < values.Length; i++) { if (values[i] < value) { value = values[i]; index = i; } } 

La mejor forma de atrapar la posición es mediante FindIndex Esta función está disponible solo para List <>

Ejemplo

 int id = listMyObject.FindIndex(x => x.Id == 15); 

Si tiene enumerador o matriz, use de esta manera

 int id = myEnumerator.ToList().FindIndex(x => x.Id == 15); 

o

  int id = myArray.ToList().FindIndex(x => x.Id == 15); 

Estoy de acuerdo en que LINQ no es la mejor solución para este problema, pero aquí hay otra variación que es O (n). No ordena y solo cruza la lista una vez.

 var list = new List { 3, 1, 0, 5 }; int pos = Enumerable.Range(0, list.Count) .Aggregate((a, b) => (list[a] < list[b]) ? a : b); // returns 2 
 var data = new List { 3, 1, 0, 5 }; var result = Enumerable.Range(0, data.Count).OrderBy(n => data[n]).First(); 
 List data = new List(); data.AddRange(new[] { 3, 1, 0, 5 }); Console.WriteLine(data.IndexOf(data.Min())); 
 int min = 0; bool minIsSet = false; var result = ints .Select( (x, i) => new {x, i} .OrderBy(z => zx) .Select(z => { if (!minIsSet) { min = zx; minIsSet = true; } return z; } .TakeWhile(z => zx == min) .Select(z => zi); 

No recomiendo necesariamente este código de estilo CPS, pero funciona y es O (n), a diferencia de las soluciones que usan OrderBy:

 var minIndex = list.Aggregate( new { i = 0, mini = -1, minv = int.MaxValue }, (min, x) => (min.minv > x) ? new { i = min.i + 1, mini = min.i, minv = x } : new { i = min.i + 1, mini = min.mini, minv = min.minv }) .mini; 

Cambie> a> = si quiere el último mínimo duplicado, no el primero.

Use .minv para obtener el valor mínimo o ninguno para obtener una 2-tupla con el índice y el valor mínimo.

No puedo esperar a que .NET obtenga tuplas en 4.0.

 List.Enumerator e = l.GetEnumerator(); int p = 0, min = int.MaxValue, pos = -1; while (e.MoveNext()) { if (e.Current < min) { min = e.Current; pos = p; } ++p; }