Équivalent à GRANDE.VALEUR(matrice,k) en C#

Version imprimable

19/06/2017, 14h51
shibo

Équivalent à GRANDE.VALEUR(matrice,k) en C#

Bonjour,

Existe t'il en C# une fonction qui fait l'équivalent du GRANDE.VALEUR d'excel ?

GRANDE.VALEUR(matrice,k) : Renvoie la k-ième plus grande valeur d’une série de données. Vous pouvez utiliser cette fonction pour sélectionner une valeur en fonction de son rang. Ainsi, vous pouvez utiliser la fonction GRANDE.VALEUR pour renvoyer le résultat le plus élevé, le deuxième résultat ou le troisième.

Merci d'avance
19/06/2017, 20h16
DotNetMatt

Il n'y a pas d'equivalent a ma connaissance. Que cherches-tu a faire precisement ? Comment est ta liste de donnees ? Poste ton code ca peut toujours aider.

Un truc du genre ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
using System;
 
namespace GrandeValeur
{
    static class Grande
    {
        public static T Valeur<T>(T[] liste, long indice = 1)
        {
            if (indice <= 0)
            {
                throw new IndexOutOfRangeException("L'indice doit être strictement positif");
            }
            else if (indice > liste.LongLength)
            {
                throw new IndexOutOfRangeException("L'indice doit être inférieur au nombre de valeurs");
            }
            else
            {
                Array.Sort<T>(liste);
                return liste[liste.LongLength - indice];
            }
        }
    }
}

Exemple d'utilisation :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
using System;
 
namespace GrandeValeur
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] entiers = new int[] { 17, 65, 89, 21, 2, 78, -50 };
            string[] chaines = new string[] { "voiture", "roue", "volant", "porte", "antenne", "capot", "vitre" };
            Personne[] personne = new Personne[] { new Personne() { Age = 12, Nom = "Aurélie" }, new Personne() { Age = 15, Nom = "André" }, new Personne() { Age = 20, Nom = "Anabelle" } };
 
            Console.WriteLine(Grande.Valeur(entiers));
            Console.WriteLine(Grande.Valeur(chaines));
            Console.WriteLine(Grande.Valeur(personne));
            Console.WriteLine(Grande.Valeur(entiers, 2));
            Console.WriteLine(Grande.Valeur(chaines, 2));
            Console.WriteLine(Grande.Valeur(personne, 2));
 
            Console.ReadKey(true);
        }
    }
 
    class Personne : IComparable
    {
        public string Nom;
        public int Age;
 
        public int CompareTo(object obj)
        {
            Personne autre = obj as Personne;
            if (autre == null)
            {
                throw new InvalidCastException("Une personne ne doit être comparée qu'à une autre personne");
            }
            else
            {
                return Age.CompareTo(autre.Age);
            }
        }
 
        public override string ToString()
        {
            return string.Format("{0} : {1}", Nom, Age);
        }
    }
}

Citation:

Envoyé par StringBuilder

Un truc du genre ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
using System;
 
namespace GrandeValeur
{
    static class Grande
    {
        public static T Valeur<T>(T[] liste, long indice = 1)
        {
            if (indice <= 0)
            {
                throw new IndexOutOfRangeException("L'indice doit être strictement positif");
            }
            else if (indice > liste.LongLength)
            {
                throw new IndexOutOfRangeException("L'indice doit être inférieur au nombre de valeurs");
            }
            else
            {
                Array.Sort<T>(liste);
                return liste[liste.LongLength - indice];
            }
        }
    }
}

J'ai une petite objection à formuler, à savoir que Array.Sort() affecte directement le tableau passé en paramètre, ce qui n'est pas forcément le comportement attendu d'une méthode qui fait une simple lecture. Il faudrait faire une copie et travailler dessus, ce qui n'est pas très difficile avec LinQ. Par ailleurs puisqu'il s'agit d'une lecture seule, on pourrait vouloir appliquer cet algorithme à n'importe quel IEnumerable et pas juste les tableaux.

Si je peux me permettre mon grain de sel :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
namespace GrandeValeur
{
    static class Grande
    {
        public static T Valeur<T>(IEnumerable<T> source, long indice = 1, Comparison<T> comparison = null)
        {
            if (indice <= 0) throw new IndexOutOfRangeException("L'indice doit être strictement positif");
            var copy = source.ToArray();
            if (indice > copy.LongLength) throw new IndexOutOfRangeException("L'indice doit être inférieur au nombre de valeurs");
            if (comparison != null) Array.Sort(copy, comparison); else Array.Sort(copy);
            return copy[copy.LongLength - indice];
        }
    }
}

L'usage est le même que précédemment si ce n'est qu'on peut fournir un delegate Comparison<T> pour spécifier le critère de tri. Par exemple :

Code:

1
2
3
4
5
6
7
8
9
var list = new List<Product>
{
  new Product {Id = 1, Price = 10.3},
  new Product {Id = 2, Price = 10.3},
  new Product {Id = 3, Price = 3.2}
};
 
var byId = Grande.Valeur(list, 1, (p1, p2) => p1.Id - p2.Id);
var byPrice = Grande.Valeur(list, 1, (p1, p2) => p1.Price > p2.Price ? 1 : p1.Price < p2.Price ? -1 : 0);