Discussion :

[novice12]

Bonjour,
J'aimerais savoir comment récupérer les minimum relatifs dans une séquence d'entiers. Bien que le côté algo ne soit pas mon fort, j'ai essayé différents codes mais sans résultat.
Voici le dernier en date qui me donne une série de valeurs fausses.
code en c:

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
#include <iostream>
using namespace std;
 
int main()
{
	const int taille = 10;
	int tabInt[taille] = {1,2,4,2,6,8,3,9,12,0};
	int min = tabInt[0];
	int tabMin[4];
 
	cout << "\ncontenu du tableau: ";
 
	for (int n = 0; n < taille; n++)
		cout << tabInt[n] << ' ';
 
	for (n = 0; n < taille; n++) 
	{
		if (min > tabInt[n]) 
		{
			min = tabInt[n];
			if ((min < tabInt[n+1]) && (min < tabInt[n]))
				tabMin[4]= min;
		}
	}
	cout << "\nvoici le minimum absolue: " << min << endl;
	cout << "\nvoici les minimum relatifs : ";
 
	for (n = 0; n < 4; n++)
		cout << tabMin[n] << ' '; 
                //  au lieu de me donner: 1, 2, 3, 0
                // il me donne:  -858993460 -858993460 -858993460   
                //                      -858993460
 
	cout << endl;
 
	return 0;
}

Voilà, si quelqu'un peut expliquer, ce serait sympa. Merci à tous.

Robert


[Balises CODE rajoutées par Loulou24, merci d'y penser à l'avenir]

[abelman]

Ce code n'est pas du C

Par contre tu ne remplis jamais le tableau tabMin et donc il est initialisé avec ce qui traîne en mémoire. Plutôt que

Code :

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

tabMin[4]= min;

je pense à qq chose comme :

Code :

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

tabMin[j++]=min

où j est initialisé à 0 avant ta boucle for.

Du temps qu'on y est tu déclares tabMin[4] donc pour les indices de 0..3 alors lors de l'affectation avec un indice de 4 tu as de la chance de ne pas avoir eu une erreur.

[abelman]

Sorry, c'est une erreur de ma part.
J'ai tellement chipoté à ce code que j'ai fait n'importe quoi.
Merci de ta réponse. Je vais essayer de corriger tout ça.

Robert

[abelman]

Il y a eu un message perdu et je n'ai pas pu le récuperer autrement qu'en faisant des citations.

[nicolas581]

abelman ce n'est pas grave "errare humanum est" et ceci même aux meilleurs.
De toute façon notre ami n'a pas l'air très pressé pour résoudre son problème.

[SKZ81]

Code :

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

1
2
3
4
5
6
7
8
9
 
...
int main()
{
...
			if ((min < tabInt[n+1]) && (min < tabInt[n]))
				tabMin[4]= min;
...
}

C'est là que ça pêche... Et que les bactéries attaquent
Ce que tu doit faire c'est initialiser les valeurs de ton tableau de min à INT_MAX (ou qqchose dans le genre. Si tu trouve rien, utilise 0x8FFFFFFF qui est le plus grand entier sur 32bits, mais c'est sâle...)
Ensuite, au lieu du code incriminé :
* Tu teste, à partir du premier (#0) si min est inférieur.
* Si oui, il faut au préalable recopier 2 dans 3, 1 dans 2 et 0 dans 1. Puis écrire min dans 0. Je te conseille d'écrire une boucle pour laquelle '3' et '0' sont des paramètres de l'exemple que je viens de te donner. Ainsi tu ne l'écrit qu'une seule fois pour les 4 étape, mais tu peux aussi augmenter la taille de tabMin.
(Les numéros représente le numéro des cases).
* On passe au suivant.
* Recommencer à partir du test

Voilà je te laisse coder... Si je suis pas clair demande.

[edit]
... perseverare diabolicum ...
[/edit]

[novice12]

Bonjour SKZ81,

Je suis vraiment désolé de t'embêter avec ça mais je n'ai pas tout compris.

Pourquoi initialiser le tableau de min à INT_MAX (d'où il vient)?

Et pourrais-tu me donner plus de renseignement sur ta méthode?

Personnellement, ce que j'ai essayé de faire, c'est de parcourrir le tableau en testant si l'élément courant est à la fois plus petit que le précédent et le suivant, et si oui, on le stocke dans tabMin.

Merci de ton aide.

Robert

[Shaud7]

Personnellement, je parcourerai le tableau (la première valeur je la stokerai dans une variable MIN) et je testerai si la valeur courante est plus petite que MIN. Si oui alors MIN prend la valeur courante et on poursuit, si non on passe a la suivante. et ainsi de suite jusqu'a la fin du tableau.

[SKZ81]

Je suis vraiment désolé de t'embêter avec ça mais je n'ai pas tout compris.

Si tu m'embêtait avec ça, je ne traînerais pas sur le forum !!!
Dzol, j'avais pas vu que tu avait reposé une question, je poste un peu partout parfois

Pourquoi initialiser le tableau de min à INT_MAX (d'où il vient)?
Et pourrais-tu me donner plus de renseignement sur ta méthode?

INT_MAX est une valeur symbolique représentant le plus grand entier positif possible (avec des int 32bits, sur 4 octets, c'est 2^31-1 (deux puissance 31 moins un) soit en hexadécimal 8FFFFFFF, soit 2 millards et qques). Mais en fait tu n'en as pas besoin en l'occurence( pour moi), j'y reviens.

L'idée est la suivante : min doit être un tableau trié d'éléments. Ainsi, à chaque fois que tu trouve un nouveau min, tu dois l'insérer dans le tableau.
Ce que je proposais, c'est de faire en sorte que le tableau soit trié. Bon je t'avoue que je devais être fatigué, j'ai compliqué les choses inutilement, en fait le nouveau min trouvé est forcément inférieur à tout les éléments de tabMin, puisque min est dans tabMin. Si tabMin est trié, on a min=tabMin[0]. Sauf pour simplifier l'écriture, on n'a pas besoin de min, en fait.
J'avais perdu cette hypothèse de vue...

Donc à l'initialisation, le premier élément du tableau à trier est supposé être le min.
On initialise min et tabMin[0] avec cette valeur.

Ensuite on boucle.
Si on trouve un nouveau minimum, il faut l'inserer en position zéro (sans écraser la valeur précédente!!!).
DECALAGE [ La dernière valeur sera "expulsée" du tableau. La méthode est de recopier l'avant dernière valeur dans la dernière (on l'écrase mais pas grave, cette dernière valeur est expulsée).
Ensuite l'avant-avant dernière dans l'avant-dernière (qu'on écrase, mais elle a déjà été recopiée).
Ect... Jusqu'à recopier la première valeur dans la deuxième.
On peut enfin écraser la valeur de tabMin[0] par le nouveau min (puisque l'ancien à été décalé en position "2" (ou 1, suivant comment on voit les choses (première=0)).
]
Fin de la boucle.

Ce que je disant à propos d coder l'opération de décalage par une boucle reste valable, mais non-obligatoire.

Personnellement, ce que j'ai essayé de faire, c'est de parcourrir le tableau en testant si l'élément courant est à la fois plus petit que le précédent et le suivant, et si oui, on le stocke dans tabMin.

Edàxi, le soucis est que tu le stocke dans une case bien précise, et toujours celle là, donc tu l'écrase à chaque fois. Les autres valeurs ne sont pas initialisée, d'où les résultats abérents.
Ce sont bien les deux lignes de codes que je t'ai indiqué qui sont foireuses :
D'une tu fait le test sur "min < tabInt[n+1]) && (min < tabInt[n])", alors que n varie entre 0 et taille-1, ce qui dépasse largement de ton tableau "tabMin". Erreur grave, avec de grande valeurs, tu sort de l'espace mémoire alloué à ton programme, et c'est le crash !!!
De deux, tu écrase systématiquement tabMin[4], il n'y a que cette valeur à être modifiée.

Merci de ton aide.

De rien !!