Amigas del foro.

En primer lugar me disculpo por mi inglés

Cómo recorrer una matriz y crear una lista para contar la cantidad de veces que se repite un número y se ordena por elemento2 de mayor a menor.

Tengo la siguiente matriz:

int[] arrayNumeros= new int[10] {1,2,3,4,5,6,1,1,2,3}

Tengo la siguiente lista:

List<Tuple<int, int>> contadorNumerosTotal = new List<Tuple<int, int>>();

Este es mi código:

for (int i = 0; i < arrayNumeros.Length; i++)
    {
         if (contadorNumerosTotal.Any(t => t.Item1 == arrayNumeros[i]))                    
         {
             //if the number exists I want item2 to be incremented by 1.
         }else{
              contadorNumerosTotal.Add(new Tuple<int, int>(arrayNumeros[i], 1));
         }
}



    for (int i = 0; i < contadorNumerosTotal.Count; i++)
    {
      System.Diagnostics.Debug.WriteLine(contadorNumerosTotal[i].Item1 +" -> "+ contadorNumerosTotal[i].Item2);                   
    }

Como resultado, debería mostrar:

1 -> 3
3 -> 3
2 -> 2
4 -> 1
5 -> 1
6 -> 1

Muchas gracias por tu tiempo

0
Alonso 18 jun. 2017 a las 14:14

3 respuestas

La mejor respuesta

Lo siguiente debería producir los resultados deseados:

int[] numbers = new int[] {1,2,3,4,5,6,1,1,2,3};

Dictionary<int, int> numberCount = new Dictionary<int, int>();

int len = numbers.Length;
for(int i = 0; i < len; i++)
{
    if (numberCount.ContainsKey(numbers[i]))
    {
        numberCount[numbers[i]]++;
    }
    else
    {
        numberCount[numbers[i]] = 1;
    }
}

// Sort by value if necessary. Otherwise loop through numberCount.
var sortednumberCount = numberCount.OrderByDescending(pair => pair.Value);
foreach (var number in sortednumberCount)
{
    Console.WriteLine("{0} -> {1}", number.Key, number.Value);
}

Salida:

1 -> 3
2 -> 2
3 -> 2
4 -> 1
5 -> 1
6 -> 1
0
Tristan Gibson 18 jun. 2017 a las 11:43
int[] arrayNumeros= new int[10] {1,2,3,4,5,6,1,1,2,3};

var result = arrayNumeros
    .GroupBy( e => e )
    .ToDictionary( e => e.Key, e => e.Count() )
    .OrderByDescending( e => e.Value )
    .ThenBy( e => e.Key )
    .Select( e => Tuple.Create( e.Key, e.Value ) )
    .ToList();

Muestra de violín .net

0
Sir Rufo 18 jun. 2017 a las 11:51

Te vendría bien algo como esto:

List<Tuple<int, int>> contadorNumerosTotal =
    arrayNumeros.GroupBy (i => i).Select (ints => new Tuple<int, int> (ints.Key, ints.Count ())).ToList ();
contadorNumerosTotal.Sort ((tuple, tuple1) => tuple1.Item2.CompareTo (tuple.Item2));

Esto toma los elementos, grupos arrayNumeros por el valor de los números y transforma la lista, de modo que contiene el valor (esta es la clave del grupo) y el recuento del valor (este es el recuento de grupo). Por último, ordena los elementos de la lista descendiendo del recuento (puede ordenarlos ascendiendo comparando el Elemento2 de tuple con el Elemento2 de tuple1 en lugar de al revés.

Puede imprimir los resultados de esta manera:

int [] arrayNumeros = new int[10] {1, 2, 3, 4, 5, 6, 1, 1, 2, 3};
List<Tuple<int, int>> contadorNumerosTotal =
    arrayNumeros.GroupBy (i => i).Select (ints => new Tuple<int, int> (ints.Key, ints.Count ())).ToList ();
contadorNumerosTotal.Sort ((tuple, tuple1) => tuple1.Item2.CompareTo (tuple.Item2));
foreach (var count in contadorNumerosTotal)
    Console.WriteLine ($"{count.Item1} -> {count.Item2}");
Console.ReadLine ();

Lo que resulta en lo siguiente:

1 -> 3
2 -> 2
3 -> 2
4 -> 1
5 -> 1
6 -> 1

Lea más sobre groupBy aquí.

0
MetaColon 18 jun. 2017 a las 11:39