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:
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:
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:
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:
[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:
1
2
3
|
const newTab=[8,9,7],
const newTab2=[14,6,4] |
Un coup de pouce serait le bienvenu, merci à vous
Proposition de logigramme (à vérifier)
Citation:
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:
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 :
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 :
- 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 :
- 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:
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:
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:
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:
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:
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.
