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

Algorithmes et structures de données Discussion :

Comparer un élément d'un tableau à tous les autres


Sujet :

Algorithmes et structures de données

  1. #1
    Membre actif
    Homme Profil pro
    Reconversion
    Inscrit en
    novembre 2018
    Messages
    499
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : Reconversion
    Secteur : Santé

    Informations forums :
    Inscription : novembre 2018
    Messages : 499
    Points : 296
    Points
    296
    Par défaut Comparer un élément d'un tableau à tous les autres
    Bonjour,

    Je fais des révisions en algo et je vois que j'en ai bien besoin. Mon problème, j'aimerais comparer une valeur d'un tableau de nombres entiers à toutes les autres de ce même tableau selon le schéma suivant .
    Soit le tableau :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    const tabInt=[10,8,9,7,15,14,6,4]
    Tant que le 1er élement (10) est supérieur à tous les autres éléments qui suivent dans le tableau, alors je stocke ces éléments dans un autre tableau et je stoppe dès le premier élément supérieur à 10 (15 ici). Ainsi je devrais récupérer le tableau qui suit :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    //10 étant supérieur à 8,9 et 7 je récupère ces éléments 
    const newTab=[8,9,7]
    Je voudrais appliquer ce test à tous les autres éléments du tableau tabInt : "tant que le 2ème élement est supérieur (8)...même démarche.

    Je pensais m'en sortir comme ceci avec une imbrication (code js) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
     for(let i=0; i<tabInt.length;i++) {
            	let  sliceTab=tabInt.slice(i+1);
     
             	for(let j = 0; j<sliceTab.length; j++) {
                        if(tabInt[i]>sliceTab[j]) {
                            newTab.push(sliceTab[i]])
                  }
                  break;
               }
            }
    Ce code a l'inconvénient de ne pas stopper à la valeur 15 au 1er tour et de retourner le tableau :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    [8, 9, 7, 6, 4, 7, 6, 4, 7, 6, 4, 6, 4, 14, 6, 4, 6, 4, 4]
    Normal me direz-vous le if reprend sa course dès lors que le test de comparaison est à nouveau vérifié...Je pourrais utiliser un break, mais cela créé d'autres inconvénients :
    je ne récupère par la valeur 9 au 1er tour vu que le breqk doit casser à la comparaison entre 8et 9.

    In fine je voudrais obtenir ceci :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    const newTab=[8,9,7],
    const newTab2=[14,6,4]
    Un coup de pouce serait le bienvenu, merci à vous

  2. #2
    Rédacteur/Modérateur

    Homme Profil pro
    Ingénieur qualité méthodes
    Inscrit en
    décembre 2013
    Messages
    3 577
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur qualité méthodes
    Secteur : Conseil

    Informations forums :
    Inscription : décembre 2013
    Messages : 3 577
    Points : 8 270
    Points
    8 270
    Par défaut
    Je n'ai pas tout suivi, mais voici ce que je fais parfois :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    for (k=0 ; k<n ; k++)
      if test_reussi() then
         afficher(k)
         k=n+1
      end if
    end for
    En mettant k=n+1, ça fait le même effet que ce que tu veux faire avec Break
    C'est du bricolage, mais ça me convient parfaitement.

    Une autre piste c'est de faire quelque chose comme ça :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    k=0
    traitement_en_cours = True
    While ( k < n  and  traitement_en_cours = True ) LOOP
       if test_reussi() then
         afficher(k)
         traitement_en_cours = False
      end if
       k++
    END LOOP
    Tu évites l'utilisation de break.
    Moi je n'aime pas ces instructions comme break ou continue. S'il y a plusieurs niveaux de boucle imbriqués, je ne sais jamais si ça s'applique au niveau le plus fin, ou à un autre niveau. Donc je contourne systématiquement, et c'est toujours très simple de trouver des contournements.
    N'oubliez pas le bouton Résolu si vous avez obtenu une réponse à votre question.

  3. #3
    Expert éminent sénior Avatar de Flodelarab
    Homme Profil pro
    Inscrit en
    septembre 2005
    Messages
    4 907
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Charente (Poitou Charente)

    Informations forums :
    Inscription : septembre 2005
    Messages : 4 907
    Points : 12 419
    Points
    12 419
    Par défaut
    Bonjour

    La double boucle est une mauvaise idée car elle ne rend pas compte de ce que tu fais vraiment. Tu ne parcours qu'une seule fois ton tableau, en changeant la valeur de référence.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    const tabInt=[10,8,9,7,15,14,6,4]
    en
    en
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    const tabInt1=[8,9,7]
    const tabInt2=[14,6,4]
    En clair, tu parcours ton tableau, si ta valeur est inférieure à ta référence, tu ne fais rien. Si ta valeur est supérieure à ta référence, elle devient ta nouvelle référence.

    Cela devient plus une question de langage qu'une question algorithmique.
    Cette réponse vous apporte quelque chose ? Cliquez sur en bas à droite du message.

  4. #4
    Membre éclairé
    Avatar de APL-AML
    Homme Profil pro
    Développeur Gestion (Retraité)
    Inscrit en
    juin 2020
    Messages
    40
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Côtes d'Armor (Bretagne)

    Informations professionnelles :
    Activité : Développeur Gestion (Retraité)
    Secteur : Administration - Collectivité locale

    Informations forums :
    Inscription : juin 2020
    Messages : 40
    Points : 768
    Points
    768
    Billets dans le blog
    69
    Par défaut Proposition de logigramme (à vérifier)
    ATTENTION ! La fonctionnalité DVP « Visualiser dans une fenêtre à part » ne reconnaît pas les caractères semi-graphiques.

    Pour lire facilement les logigrammes :

    Copier/coller le Code (Sélectionner le Code, Ctrl/C puis Ctrl/V dans un fichier Word Orientation Paysage, les 4 Marges à 1 cm, puis tout mettre en Police Courrier New, Taille de police 8, Interligne simple).
    Énoncé

    Si j’ai bien tout compris, j’ai reformulé l’énoncé ainsi :

    Comparer une valeur d'un tableau de nombres entiers à toutes les autres de ce même tableau selon le schéma suivant...

    Soit le tableau :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    const TabInt=[10,8,9,7,15,14,6,4]
    Tant que le 1er élément [10] est supérieur à tous les autres éléments qui suivent dans le tableau, stocker ces éléments dans un autre tableau et arrêter dès le premier élément supérieur à 10 (15 ici) ou la fin du tableau atteinte. Ainsi on devrait récupérer le tableau qui suit :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    const NewTab=[8,9,7]
    Appliquer ce test à tous les autres éléments du tableau TabInt :

    • Tant que le 2ème élément [8] est supérieur à tous les autres éléments qui suivent dans le tableau, ...même démarche. Sauf qu’il n’y aura rien à stocker car l’élément suivant est déjà supérieur au 2ème élément référent.
    • Idem 3ème et 4ème élément : rien à stocker.
    • Tant que le 5ème élément [15] est supérieur à tous les autres éléments qui suivent dans le tableau, stocker ces éléments dans un autre tableau et arrêter dès le premier élément supérieur à 15 ou la fin du tableau atteinte. Ainsi on devrait récupérer le tableau qui suit :

      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
       
      const NewTab=[14,6,4]
    • Tant que le 6ème élément [14] est supérieur à tous les autres éléments qui suivent dans le tableau, stocker ces éléments dans un autre tableau et arrêter dès le premier élément supérieur à 14 ou la fin du tableau atteinte. Ainsi on devrait récupérer le tableau qui suit :

      Code : Sélectionner tout - Visualiser dans une fenêtre à part
      1
      2
       
      const NewTab=[6,4]
    • Tant que le 7ème élément [6] est supérieur à tous les autres éléments qui suivent dans le tableau, stocker ces éléments dans un autre tableau et arrêter dès le premier élément supérieur à 6 ou la fin du tableau atteinte. Ainsi on devrait récupérer le tableau qui suit :


    In fine on devrait obtenir ceci :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    const NewTab1=[8,9,7]
    const NewTab2=[14,6,4]
    const NewTab3=[6,4]
    const NewTab4=[4]


    LOGIGRAMME (Itération 1er élément de TabInt)

    Code : 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
    49
    50
    51
    52
    53
    54
    55
    56
    const TabInt=[10,8,9,7,15,14,6,4]
    
    Itération 1er élément de TabInt
    
    i-ti = indice courant    (= 2, 3, 4, 5)
    j-ti = indice borne mini (= 1)
    k-ti = indice borne maxi (= 8)
    
                               ┌───────────────────────────┐
                        D-PROG │        j-ti = 1           │
                               │        k-ti = 8           │
                               │      AIG-tn = 0           │
                               └─────────────┬─────────────┘
                                             ├──────────────────────────────────────────────────┐
                               ┌─────────────┴─────────────┐                                    │
                      D-TabNew │       i-tn  = 0           │                                    │
                               │       i-ti  = j-ti + 1    │                                    │
                               │       Init  TabNew        │                                    │
                               └─────────────┬─────────────┘                                    │  ┌───────────────┬───────────────┬───────────────┬───────────────┐
                                             ├─────────────────────────────────────────────┐    │  │1ère itération │2ème itération │3ème itération │4ème itération │
                               ┌─────────────┴─────────────┐                               │    │  ├───────────────┼───────────────┼───────────────┼───────────────┤
                      D-TabInt │TabInt(i-ti)::TabInt(j-ti) │                               │    │  │j-ti = 1       │               │               │               │
                               │                           │                               │    │  │i-ti = 2       │i-ti = 3       │i-ti = 4       │               │
                   >=          └─────────────┬─────────────┘          <                    │    │  └───────────────┴───────────────┴───────────────┴───────────────┘
                  ┌──────────────────────────◊──────────────────────────┐                  │    │
    ┌─────────────┴─────────────┐                         ┌─────────────┴─────────────┐    │    │  ┌───────────────┬───────────────┬───────────────┬───────────────┐
    │                           │                T-TabNew │       i-tn  = i-tn + 1    │    │    │  │TabInt(j-ti)=10│               │               │               │
    │        i-ti = 0           │                         │TabNew(i-tn) = TabInt(i-ti)│    │    │  │TabInt(i-ti)= 8│TabInt(i-ti)= 9│TabInt(i-ti)= 7│               │  
    │                           │                         │       i-ti  = i-ti + 1    │    │    │  │i-ti = 3       │i-ti = 4       │i-ti = 5       │i-ti = 0       │
    └─────────────┬─────────────┘                         └─────────────┬─────────────┘    │    │  └───────────────┴───────────────┴───────────────┴───────────────┘
                  └──────────────────────────┬──────────────────────────┘                  │    │
                               ┌─────────────┴─────────────┐                               │    │
                      F-TabInt │  i-ti > 0 et i-ti <= k-ti │                               │    │
                               └─────────────┬─────────────┘ oui                           │    │  ┌───────────────┬───────────────┬───────────────┬───────────────┐
                                             ◊─────────────────────────────────────────────┘    │  │1ère itération │5ème itération │6ème itération │7ème itération │
                               ┌─────────────┴─────────────┐                                    │  ├───────────────┼───────────────┼───────────────┼───────────────┤
                         INTER │       j-ti = j-ti + 1     │                                    │  │j-ti = 2       │               │               │               │
                               │       i-tn :: 0           │                                    │  └───────────────┴───────────────┴───────────────┴───────────────┘
                   = 0         └─────────────┬─────────────┘        > 0                         │
                  ┌──────────────────────────◊─────────────────────────┐                        │
    ┌─────────────┴─────────────┐                        ┌─────────────┴─────────────┐          │
    │                           │            T-TabNew(n) │      AIG-tn = AIG-tn + 1  │          │
    │             Ø             │                        │AIG-tn=1 => TabNew1=TabNew │          │   const NewTab1=[8,9,7]
    │                           │                        │AIG-tn=2 => TabNew2=TabNew │          │
    │                           │                        │AIG-tn=3 => TabNew3=TabNew │          │
    │                           │                        │AIG-tn=4 => TabNew4=TabNew │          │
    └─────────────┬─────────────┘                        └─────────────┬─────────────┘          │
                  └──────────────────────────┬─────────────────────────┘                        │
                               ┌─────────────┴─────────────┐                                    │
                      F-TabNew │        j-ti < k-ti        │                                    │
                               └─────────────┬─────────────┘ <                                  │
                                             ◊──────────────────────────────────────────────────┘
                               ┌─────────────┴─────────────┐
                        F-PROG │             Ø             │
                               └───────────────────────────┘


    LOGIGRAMME (Itération 5ème élément de TabInt)

    Code : 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
    49
    50
    51
    52
    53
    54
    55
    56
    const TabInt=[10,8,9,7,15,14,6,4]
    
    LOGIGRAMME (Itération 5ème élément de TabInt)
    
    i-ti = indice courant    (= 6, 7, 8, 9)
    j-ti = indice borne mini (= 5)
    k-ti = indice borne maxi (= 8)
    
                               ┌───────────────────────────┐
                        D-PROG │        j-ti = 1           │
                               │        k-ti = 8           │
                               │      AIG-tn = 0           │
                               └─────────────┬─────────────┘
                                             ├──────────────────────────────────────────────────┐
                               ┌─────────────┴─────────────┐                                    │
                      D-TabNew │       i-tn  = 0           │                                    │
                               │       i-ti  = j-ti + 1    │                                    │
                               │       Init  TabNew        │                                    │ 
                               └─────────────┬─────────────┘                                    │  ┌───────────────┬───────────────┬───────────────┬───────────────┐
                                             ├─────────────────────────────────────────────┐    │  │1ère itération │2ème itération │3ème itération │               │
                               ┌─────────────┴─────────────┐                               │    │  ├───────────────┼───────────────┼───────────────┼───────────────┤
                      D-TabInt │TabInt(i-ti)::TabInt(j-ti) │                               │    │  │j-ti = 5       │               │               │               │
                               │                           │                               │    │  │i-ti = 6       │i-ti = 7       │i-ti = 8       │               │
                   >=          └─────────────┬─────────────┘           <                   │    │  └───────────────┴───────────────┴───────────────┴───────────────┘
                  ┌──────────────────────────◊──────────────────────────┐                  │    │
    ┌─────────────┴─────────────┐                         ┌─────────────┴─────────────┐    │    │  ┌───────────────┬───────────────┬───────────────┬───────────────┐
    │                           │                T-TabNew │       i-tn  = i-tn + 1    │    │    │  │TabInt(j-ti)=15│               │               │               │
    │        i-ti = 0           │                         │TabNew(i-tn) = TabInt(i-ti)│    │    │  │TabInt(i-ti)=14│TabInt(i-ti)= 6│TabInt(i-ti)= 4│               │  
    │                           │                         │       i-ti  = i-ti + 1    │    │    │  │i-ti = 7       │i-ti = 8       │i-ti = 9       │               │
    └─────────────┬─────────────┘                         └─────────────┬─────────────┘    │    │  └───────────────┴───────────────┴───────────────┴───────────────┘
                  └──────────────────────────┬──────────────────────────┘                  │    │
                               ┌─────────────┴─────────────┐                               │    │
                      F-TabInt │  i-ti > 0 et i-ti <= k-ti │                               │    │
                               └─────────────┬─────────────┘ oui                           │    │  ┌───────────────┬───────────────┬───────────────┬───────────────┐
                                             ◊─────────────────────────────────────────────┘    │  │1ère itération │5ème itération │6ème itération │7ème itération │
                               ┌─────────────┴─────────────┐                                    │  ├───────────────┼───────────────┼───────────────┼───────────────┤
                         INTER │       j-ti = j-ti + 1     │                                    │  │j-ti = 2       │j-ti = 6       │               │               │
                               │       i-tn :: 0           │                                    │  └───────────────┴───────────────┴───────────────┴───────────────┘
                   = 0         └─────────────┬─────────────┘        > 0                         │
                  ┌──────────────────────────◊─────────────────────────┐                        │
    ┌─────────────┴─────────────┐                        ┌─────────────┴─────────────┐          │
    │                           │            T-TabNew(n) │      AIG-tn = AIG-tn + 1  │          │
    │             Ø             │                        │AIG-tn=1 => TabNew1=TabNew │          │   const NewTab1=[8,9,7]
    │                           │                        │AIG-tn=2 => TabNew2=TabNew │          │   const NewTab2=[14,6,4]
    │                           │                        │AIG-tn=3 => TabNew3=TabNew │          │
    │                           │                        │AIG-tn=4 => TabNew4=TabNew │          │
    └─────────────┬─────────────┘                        └─────────────┬─────────────┘          │
                  └──────────────────────────┬─────────────────────────┘                        │
                               ┌─────────────┴─────────────┐                                    │
                      F-TabNew │        j-ti < k-ti        │                                    │
                               └─────────────┬─────────────┘ <                                  │
                                             ◊──────────────────────────────────────────────────┘
                               ┌─────────────┴─────────────┐
                        F-PROG │             Ø             │
                               └───────────────────────────┘


    LOGIGRAMME (Itération 6ème élément de TabInt)

    Code : 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
    49
    50
    51
    52
    53
    54
    55
    56
    const TabInt=[10,8,9,7,15,14,6,4]
    
    LOGIGRAMME 6ème élément de TabInt
    	
    i-ti = indice courant    (= 7, 8, 9)
    j-ti = indice borne mini (= 6)
    k-ti = indice borne maxi (= 8)
    
                               ┌───────────────────────────┐
                        D-PROG │        j-ti = 1           │
                               │        k-ti = 8           │
                               │      AIG-tn = 0           │
                               └─────────────┬─────────────┘
                                             ├──────────────────────────────────────────────────┐
                               ┌─────────────┴─────────────┐                                    │
                      D-TabNew │       i-tn  = 0           │                                    │
                               │       i-ti  = j-ti + 1    │                                    │
                               │       Init  TabNew        │                                    │
                               └─────────────┬─────────────┘                                    │  ┌───────────────┬───────────────┬───────────────┬───────────────┐
                                             ├─────────────────────────────────────────────┐    │  │1ère itération │2ème itération │               │               │
                               ┌─────────────┴─────────────┐                               │    │  ├───────────────┼───────────────┼───────────────┼───────────────┤
                      D-TabInt │TabInt(i-ti)::TabInt(j-ti) │                               │    │  │j-ti = 6       │               │               │               │
                               │                           │                               │    │  │i-ti = 7       │i-ti = 8       │               │               │
                   >=          └─────────────┬─────────────┘           <                   │    │  └───────────────┴───────────────┴───────────────┴───────────────┘
                  ┌──────────────────────────◊──────────────────────────┐                  │    │
    ┌─────────────┴─────────────┐                         ┌─────────────┴─────────────┐    │    │  ┌───────────────┬───────────────┬───────────────┬───────────────┐
    │                           │                T-TabNew │       i-tn  = i-tn + 1    │    │    │  │TabInt(j-ti)=14│               │               │               │
    │        i-ti = 0           │                         │TabNew(i-tn) = TabInt(i-ti)│    │    │  │TabInt(i-ti)= 6│TabInt(i-ti)= 4│               │               │  
    │                           │                         │       i-ti  = i-ti + 1    │    │    │  │i-ti = 8       │i-ti = 9       │               │               │
    └─────────────┬─────────────┘                         └─────────────┬─────────────┘    │    │  └───────────────┴───────────────┴───────────────┴───────────────┘
                  └──────────────────────────┬──────────────────────────┘                  │    │
                               ┌─────────────┴─────────────┐                               │    │
                      F-TabInt │  i-ti > 0 et i-ti <= k-ti │                               │    │
                               └─────────────┬─────────────┘ oui                           │    │  ┌───────────────┬───────────────┬───────────────┬───────────────┐
                                             ◊─────────────────────────────────────────────┘    │  │1ère itération │5ème itération │6ème itération │7ème itération │
                               ┌─────────────┴─────────────┐                                    │  ├───────────────┼───────────────┼───────────────┼───────────────┤
                         INTER │       j-ti = j-ti + 1     │                                    │  │j-ti = 2       │j-ti = 6       │j-ti = 7       │               │
                               │       i-tn :: 0           │                                    │  └───────────────┴───────────────┴───────────────┴───────────────┘
                   = 0         └─────────────┬─────────────┘        > 0                         │
                  ┌──────────────────────────◊─────────────────────────┐                        │
    ┌─────────────┴─────────────┐                        ┌─────────────┴─────────────┐          │
    │                           │            T-TabNew(n) │      AIG-tn = AIG-tn + 1  │          │
    │             Ø             │                        │AIG-tn=1 => TabNew1=TabNew │          │   const NewTab1=[8,9,7]
    │                           │                        │AIG-tn=2 => TabNew2=TabNew │          │   const NewTab2=[14,6,4]
    │                           │                        │AIG-tn=3 => TabNew3=TabNew │          │   const NewTab3=[6,4]
    │                           │                        │AIG-tn=4 => TabNew4=TabNew │          │ 
    └─────────────┬─────────────┘                        └─────────────┬─────────────┘          │
                  └──────────────────────────┬─────────────────────────┘                        │
                               ┌─────────────┴─────────────┐                                    │
                      F-TabNew │        j-ti < k-ti        │                                    │
                               └─────────────┬─────────────┘ <                                  │
                                             ◊──────────────────────────────────────────────────┘
                               ┌─────────────┴─────────────┐
                        F-PROG │             Ø             │
                               └───────────────────────────┘



    LOGIGRAMME (Itération 7ème élément de TabInt)

    Code : 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
    49
    50
    51
    52
    53
    54
    55
    56
    const TabInt=[10,8,9,7,15,14,6,4]
    
    LOGIGRAMME 7ème élément de TabInt
    
    i-ti = indice courant    (= 8, 9)
    j-ti = indice borne mini (= 7)
    k-ti = indice borne maxi (= 8)
    
                               ┌───────────────────────────┐
                        D-PROG │        j-ti = 1           │
                               │        k-ti = 8           │
                               │      AIG-tn = 0           │
                               └─────────────┬─────────────┘
                                             ├──────────────────────────────────────────────────┐
                               ┌─────────────┴─────────────┐                                    │
                      D-TabNew │       i-tn  = 0           │                                    │
                               │       i-ti  = j-ti + 1    │                                    │
                               │       Init  TabNew        │                                    │
                               └─────────────┬─────────────┘                                    │  ┌───────────────┬───────────────┬───────────────┬───────────────┐
                                             ├─────────────────────────────────────────────┐    │  │1ère itération │               │               │               │
                               ┌─────────────┴─────────────┐                               │    │  ├───────────────┼───────────────┼───────────────┼───────────────┤
                      D-TabInt │TabInt(i-ti)::TabInt(j-ti) │                               │    │  │j-ti = 7       │               │               │               │
                               │                           │                               │    │  │i-ti = 8       │               │               │               │
                   >=          └─────────────┬─────────────┘           <                   │    │  └───────────────┴───────────────┴───────────────┴───────────────┘
                  ┌──────────────────────────◊──────────────────────────┐                  │    │
    ┌─────────────┴─────────────┐                         ┌─────────────┴─────────────┐    │    │  ┌───────────────┬───────────────┬───────────────┬───────────────┐
    │                           │                T-TabNew │       i-tn  = i-tn + 1    │    │    │  │TabInt(j-ti)= 6│               │               │               │
    │        i-ti = 0           │                         │TabNew(i-tn) = TabInt(i-ti)│    │    │  │TabInt(i-ti)= 4│               │               │               │
    │                           │                         │       i-ti  = i-ti + 1    │    │    │  │i-ti = 9       │               │               │               │
    └─────────────┬─────────────┘                         └─────────────┬─────────────┘    │    │  └───────────────┴───────────────┴───────────────┴───────────────┘
                  └──────────────────────────┬──────────────────────────┘                  │    │
                               ┌─────────────┴─────────────┐                               │    │
                      F-TabInt │  i-ti > 0 et i-ti <= k-ti │                               │    │
                               └─────────────┬─────────────┘ oui                           │    │  ┌───────────────┬───────────────┬───────────────┬───────────────┐
                                             ◊─────────────────────────────────────────────┘    │  │1ère itération │5ème itération │6ème itération │7ème itération │
                               ┌─────────────┴─────────────┐                                    │  ├───────────────┼───────────────┼───────────────┼───────────────┤
                         INTER │       j-ti = j-ti + 1     │                                    │  │j-ti = 2       │j-ti = 6       │j-ti = 7       │j-ti = 8       │
                               │       i-tn :: 0           │                                    │  └───────────────┴───────────────┴───────────────┴───────────────┘
                   = 0         └─────────────┬─────────────┘        > 0                         │
                  ┌──────────────────────────◊─────────────────────────┐                        │
    ┌─────────────┴─────────────┐                        ┌─────────────┴─────────────┐          │
    │                           │            T-TabNew(n) │      AIG-tn = AIG-tn + 1  │          │
    │             Ø             │                        │AIG-tn=1 => TabNew1=TabNew │          │   const NewTab1=[8,9,7]
    │                           │                        │AIG-tn=2 => TabNew2=TabNew │          │   const NewTab2=[14,6,4]
    │                           │                        │AIG-tn=3 => TabNew3=TabNew │          │   const NewTab3=[6,4]
    │                           │                        │AIG-tn=4 => TabNew4=TabNew │          │   const NewTab4=[4]
    └─────────────┬─────────────┘                        └─────────────┬─────────────┘          │
                  └──────────────────────────┬─────────────────────────┘                        │
                               ┌─────────────┴─────────────┐                                    │
                      F-TabNew │        j-ti < k-ti        │                                    │
                               └─────────────┬─────────────┘ <                                  │
                                             ◊──────────────────────────────────────────────────┘
                               ┌─────────────┴─────────────┐
                        F-PROG │             Ø             │
                               └───────────────────────────┘



    Si j’ai bien compris l’énoncé mon logigramme devrait fonctionner.

    Pour le codage, je laisse faire les actifs.
    La situation étant désespérée, tout est maintenant possible. John Cage

Discussions similaires

  1. [XL-2016] Sélectionner des éléments dans un tableau et les transposer
    Par danny76 dans le forum Excel
    Réponses: 27
    Dernier message: 20/10/2018, 11h03
  2. Réponses: 10
    Dernier message: 22/07/2014, 13h55
  3. [XSLT 2.0] Comparer la valeur d'un attribut avec tous les autres
    Par VforVincent dans le forum XSL/XSLT/XPATH
    Réponses: 4
    Dernier message: 02/09/2011, 17h26
  4. Lister dans un tableau tous les fichiers d'un répertoire ?
    Par The Molo dans le forum Général JavaScript
    Réponses: 4
    Dernier message: 17/10/2007, 12h22
  5. Sélectionner un champ et tous les autres s'affichent
    Par 512banque dans le forum Access
    Réponses: 20
    Dernier message: 05/07/2006, 10h06

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