IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C# Discussion :

calcul du rapport de deux entiers , chacun d'une liste d'entiers et ayant le même index


Sujet :

C#

  1. #1
    Membre à l'essai
    Homme Profil pro
    Administrateur systèmes et réseaux
    Inscrit en
    Janvier 2014
    Messages
    14
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Algérie

    Informations professionnelles :
    Activité : Administrateur systèmes et réseaux
    Secteur : Enseignement

    Informations forums :
    Inscription : Janvier 2014
    Messages : 14
    Points : 12
    Points
    12
    Par défaut calcul du rapport de deux entiers , chacun d'une liste d'entiers et ayant le même index
    Bonjour à tous
    Voici un simple programme, pour débutant, qui calcule le rapport de deux éléments, chacun d'une liste et ayant le même index :
    public static List<int> Lst_01 = new List<int> { 14, 11, 32, 15 };
    public static List<int> Lst_02 = new List<int> { 36, 17, 2, 3 };
    foreach (int i in Lst_01)
    {
    foreach (int j in Lst_02)
    {

    if(Lst_01.IndexOf(i) == Lst_02.IndexOf(j) && j!=0)
    {
    int k = i / j;
    Lst_Rp.Add(k);
    }
    }
    }
    for (int x = 0; x < Lst_Rp.Count; x++)
    {
    Console.WriteLine(Lst_Rp[x]);
    }
    Le résultat est le suivant :
    ****************************
    Liste 01 :
    14
    11
    32
    15
    ****************************
    Liste 02 :
    36
    17
    2
    3
    ****************************
    0
    0
    16
    5
    ****************************
    Tout se passe bien, mais si j'ai par exemple ce qui suit :
    public static List<int> Lst_03 = new List<int> { 1, 1, 1, 1 };
    public static List<int> Lst_04 = new List<int> { 1, 1, 1, 1 };
    foreach (int i in Lst_03)
    {
    foreach (int j in Lst_04)
    {

    if(Lst_03.IndexOf(i) == Lst_04.IndexOf(j) && j!=0)
    {
    int k = i / j;
    Lst_Rp.Add(k);
    }
    }
    }
    for (int x = 0; x < Lst_Rp.Count; x++)
    {
    Console.WriteLine(Lst_Rp[x]);
    }
    Le résultat est :
    ****************************
    Liste 01 :
    1
    1
    1
    1
    ****************************
    Liste 02 :
    1
    1
    1
    1
    ****************************
    1
    1
    1
    1
    1
    1
    1
    1
    1
    1
    1
    1
    1
    1
    1
    1
    Alors que normalement doit me donner :
    1
    1
    1
    1
    càd 16 éléments au lieu de 4 éléments .
    ****************************
    et je n'arrive pas à cerné mon erreur , de l'aide Svp et merci d'avance

  2. #2
    Expert éminent sénior
    Homme Profil pro
    Responsable Données
    Inscrit en
    Janvier 2009
    Messages
    5 228
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Responsable Données

    Informations forums :
    Inscription : Janvier 2009
    Messages : 5 228
    Points : 12 838
    Points
    12 838
    Par défaut
    Bonjour,
    Dans ta boucle tu cherches l'indice des éléments dans tes listes.
    Or dans le deuxième code, les listes ne contiennent qu'une seule valeur, mais répétée. Donc à chaque itération, la recherche de l'indice renvoie 1.
    En gros ton algo ne fonctionne que s'il n'y a pas d'élément dupliqué dans une des listes.

    Pour t'en convaincre, met un point d'arrêt et regarde ce que renvoie IndexOf().

    Ici il ne faut pas 2 boucles imbriquées, une seule qui parcourt la première suffit, avec un compteur pour récupérer l'élément correspondant dans la seconde.

    Tatayo.

  3. #3
    Membre à l'essai
    Homme Profil pro
    Administrateur systèmes et réseaux
    Inscrit en
    Janvier 2014
    Messages
    14
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Algérie

    Informations professionnelles :
    Activité : Administrateur systèmes et réseaux
    Secteur : Enseignement

    Informations forums :
    Inscription : Janvier 2014
    Messages : 14
    Points : 12
    Points
    12
    Par défaut
    Bonjour Tatayo
    Bravo j'ai essayé ce qui suit :
    foreach (int i in Lst_01)
    {
    for (int j = 0; j < Lst_01.Count; j++)
    {
    if (Lst_01.IndexOf(i) == j && Lst_02.IndexOf(j)!=0)
    {
    int k =i/Lst_02[j];
    Lst_Rp.Add(k);
    }
    }
    }
    for (int x = 0; x < Lst_Rp.Count; x++)
    {
    Console.WriteLine(Lst_Rp[x]);
    }

    en utilisant un compteur et ça a marché et voici le résultat recherché :
    ****************************
    Liste 01 :
    1
    1
    1
    1
    ****************************
    Liste 02 :
    1
    1
    1
    1
    ****************************
    1
    1
    1
    1


    Merci beaucoup de m'avoir aider

  4. #4
    Membre expérimenté
    Profil pro
    Inscrit en
    Septembre 2010
    Messages
    1 187
    Détails du profil
    Informations personnelles :
    Âge : 45
    Localisation : France

    Informations forums :
    Inscription : Septembre 2010
    Messages : 1 187
    Points : 1 731
    Points
    1 731
    Par défaut
    Dans ton cas, tu n'as pas besoin de 2 boucles imbriquées, une seule suffit (il faut s'assurer que les 2 listes soient de même taille ou s'arrêter à la taille la plus petite des 2 listes

  5. #5
    Membre chevronné
    Homme Profil pro
    edi
    Inscrit en
    Juin 2007
    Messages
    903
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : edi

    Informations forums :
    Inscription : Juin 2007
    Messages : 903
    Points : 1 922
    Points
    1 922
    Par défaut
    Malgré son approche un peu alambiquée, ce que ton code essaie manifestement de faire est le rapprochement entre les éléments de deux listes. Ce n'est pas vraiment nouveau comme algorithme et on appelle parfois cela un zip.

    Comme il a été dit, pas besoin de deux boucles imbriquées, juste une qui accède aux éléments de chaque liste. Avec des tableaux ou des listes, un simple index suffit. Cela ammène cependant un première question : que doit-on faire si les deux listes n'ont pas la même longueur ? On peut s'arrêter à la plus courte, généralement l'approche par défaut. S'il est impératif que les deux listes soint de la même longueur, alors il faut déclencher une erreur.

    Ensuite sur la combinaison elle-même, un autre problème se présente. Tu fais une division d'un entier par un entier. Or l'entier diviseur peut être égal à 0, ce qui est une opération illégale et lèvera une exception. Il faut donc savoir comment tu veux gérer ce potentiel problème :
    - laisser tel quel, la division par 0 lèvera une exception ;
    - contrôler et lever une exception spécifique portant sur le jeu données lui-même plutôt que sur l'opération mathématique if(right[i] == 0) throw new ArgumentException($"Unexpected 0 value at index {i} in divisor data source"); ;
    - contrôler et ignorer le calcul si le diviseur vaut 0 ;
    - contrôler et renvoyer null, ce qui implique que toutes les valeurs renvoyées seront des Nullable<int> et donc que l'utilisateur de la fonction devra lui-même faire le tri dans les valeurs acceptables ;
    - contraindre les valeurs en entrée en utilisant un type de donnée sur le second tableau qui garantit l'absence de valeur 0 (approche commune en programmation fonctionnelle).

    En prenant le parti suivant :
    - on limite le résultat à la plus petite des deux listes ;
    - on renvoie des Nullable<int> avec null si l'opération est interdite.

    Méthode visant à combiner deux entiers, en l'occurrence la division du premier par le second, avec en retour null si le diviseur vaut 0 :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    static int? Combine(int left, int right) => right == 0 ? null : left / right;
    Méthode qui prend deux listes en entrée et applique une fonction de combinaison pour produire un résultat :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    static List<int?> Combine(List<int> left, List<int> right, Func<int, int, int?> combiner)
    {
    	int limit = Math.Min(left.Length, right.Length);
    	var result = new List<int>(limit);
     
    	for(int i = 0; i < limit; i++)
    		result[i] = combiner(left[i], right[i]);
     
    	return result;
    }
    Exemple d'appel :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    List<int> List_01 = new List<int> { 14, 11, 32, 15 };
    List<int> List_02 = new List<int> { 36, 17, 2, 3 };
     
    List<int> result = Combine(List_01, List_02, Combine);
    Il est a noter que ce coode sera fonctionnellement similaire avec ce que l'on peut obtenir avec la méthode LinQ Enumerable.Zip :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    List<int> List_01 = new List<int> { 14, 11, 32, 15 };
    List<int> List_02 = new List<int> { 36, 17, 2, 3 };
     
    List<int> result = List_01.Zip(List_02, Combine).ToList();

Discussions similaires

  1. Réponses: 16
    Dernier message: 18/01/2016, 18h54
  2. Problème de l'affichage de deux colonnes filtrés dans une liste box
    Par Dr walid dans le forum Macros et VBA Excel
    Réponses: 1
    Dernier message: 09/06/2014, 02h35
  3. [AC-2002] attribuer deux requêtes différentes à une liste
    Par Jean-Luc80 dans le forum VBA Access
    Réponses: 2
    Dernier message: 26/09/2010, 12h36
  4. Réponses: 4
    Dernier message: 03/07/2009, 09h45
  5. Deux iterators pour obtenir une liste
    Par Jere3110 dans le forum Struts 2
    Réponses: 1
    Dernier message: 26/06/2009, 11h08

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo