Discussion :

[shibo]

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

[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.

[StringBuilder]

Un truc du genre ?

Code csharp :

Sélectionner tout - Visualiser dans une fenêtre à part

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 csharp :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
        }
    }
}

[Noxen]

Un truc du genre ?

Code csharp :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);