Mediane d'une suite de nombres
Résolu
alexey27
Messages postés
18
Date d'inscription
samedi 22 novembre 2008
Statut
Membre
Dernière intervention
11 janvier 2009
-
1 déc. 2008 à 23:59
alexey27 Messages postés 18 Date d'inscription samedi 22 novembre 2008 Statut Membre Dernière intervention 11 janvier 2009 - 9 déc. 2008 à 13:04
alexey27 Messages postés 18 Date d'inscription samedi 22 novembre 2008 Statut Membre Dernière intervention 11 janvier 2009 - 9 déc. 2008 à 13:04
A voir également:
- Comment calculer une médiane dans un tableau
- Comment calculer la médiane - Meilleures réponses
- Comment calculer une mediane - Meilleures réponses
- Afficher un tableau php en html - Conseils pratiques -PHP
- Retourner un tableau en c ✓ - Forum C# / .NET
- Tableau de turbo 2 - Forum C / C++ / C++.NET
- Tableau decimal ✓ - Forum Java
- Comment calculer l aire d un trapèze - Forum Visual Basic 6
9 réponses
cs_stephane57
Messages postés
12
Date d'inscription
lundi 17 décembre 2007
Statut
Membre
Dernière intervention
6 janvier 2009
9 déc. 2008 à 09:14
9 déc. 2008 à 09:14
La solution est ici.
Je n'ai utilisé ni pointeur, ni constructeur, ni destructeur.... c'est basique mais ça fonctionne.
Je crée un tableau de 10 éléments correspondant aux 10 nombres différents possibles.
Je me sers d'une variable TailleUtile qui me permet de faire ensuite le tri uniquement sur les premiers éléments du tableau, dans lesquels j'aurai stocké les nombres différents.
Schématiquement:
tu déclares ton Tableau[0] à Tableau[9]
tu entres tes 10 valeurs au clavier par exemple 2,1,5,5,4,4,4,1,3,8
après chaque saisie, je compare avec les éléments déjà existants dans le tableau, pour voir si ce nombre existe déjà ou non.
s'il n'existe pas, je le mets dans le tableau à l'élément suivant et j'augmente TailleUtile de 1.
à la fin en mémoire il y a ceci
Tableau[0] = 2
Tableau[1]=1
Tableau[2]=5
Tableau[3]=4
Tableau[4]=3
Tableau[5]=8
et les éléments Tableau[6] à Tableau[9] ??? On s'en fout lol... on ne s'en préoccupe plus car grâce à notre variable TailleUtile
on sait maintenant qu'il ne faudra travailler (pour le tri) que sur les 6 premiers éléments de notre tableau!
Le source:
#include
using namespace std ; // permet d'éviter la lourdeur de std::cout et std::cin, remplacés par cout et cin
int main ()
{
const unsigned short int TAILLE=10; // taille totale du tableau, correspond aux 10 nombres à entrer au maximum
unsigned short int Tableau[TAILLE];
unsigned short int TailleUtile = 0 ; // permettra de comptabiliser combien il y a effectivement et réellement
// de nombres différents dans ce tableau
bool NombreEstIdentique = false; // servira pour des tests de comparaison avec les nombres déjà existants
// indiquer que la médiane sera calculée à partir de ... nombres à saisir au clavier
cout<<"Entrez " <<TAILLE <<" nombres" <<endl ;
//*********************************************************************************************************************
// l'utilisateur entre successivement les dix nombres, qui sont mis à tour de rôle dans le tableau
// si et uniquement si un nombre identique n'existe pas déjà dans le tableau.
// Si le nombre n'existe pas déjà, on incrémente aussi TailleUtile
// ce qui permettra de faire plus tard un tri parmi les éléments du tableau qui nous intéressent.
unsigned short int ValeurSaisie ;
for (int Iteration=0; Iteration<TAILLE ;Iteration++) // saisie successive de 10 nombres
{
cin >> ValeurSaisie ;
if (Iteration==0) // aucun intérêt de tester la premiere valeur saisie, elle est forcément unique
{
Tableau[0]=ValeurSaisie ; // stocke la valeur saisie au clavier, dans Tableau[0]
TailleUtile ++ ; // on a 1 élément utile dans le tableau
}
else // pour les valeurs suivantes saisies, c'est ici qu'on compare
{
NombreEstIdentique = false ;
for (int Iteration2=0 ; Iteration2<TailleUtile ; Iteration2++) // teste tous les nombres existants déjà
{
if ( ValeurSaisie == Tableau[Iteration2] ) // et compare les successivement à la valeur saisie
NombreEstIdentique = true ;
}
if (NombreEstIdentique == false) // si la valeur saisie n'est pas un nombre existant déjà
{
Tableau[TailleUtile]=ValeurSaisie ; // stocke la valeur saisie , dans Tableau[1] ou Tableau[2...]
TailleUtile++ ; // et on a un nouvel élément utile dans le tableau
}
}
}
//**************************************************************************************************
//affiche le résultat des comparaisons qui viennent d'être effectuées.
cout <<"sont retenus les nombres suivants:" << endl ;
for (int Iteration=0 ; Iteration<TailleUtile ; Iteration++)
{
cout << Tableau[Iteration] <<" " ;
}
cout <<endl;
cout <<"il y a "<< TailleUtile <<" nombres differents parmi les " << TAILLE << " nombres saisis" ;
cout << endl <<endl;
//**************************************************************************************************
// on va maintenant trier par ordre croissant les premiers éléments du tableau
// qui sont tous des nombres différents les uns des autres.
// on sait grâce à la variable TailleUtile éléments, sur combien d'éléments se fera le tri.
unsigned short int Element_A_Comparer=1 ;
unsigned short int swap=0 ; // sera utile pour échanger deux variables
//prendre successivement pour référence l'élément 0 puis 1 puis 2 puis 3.... jusqu'à (TailleUtile-1)
for (unsigned short int Element_De_Reference=0; Element_De_Reference< TailleUtile-1 ; Element_De_Reference ++)
{
while (Element_A_Comparer < (TailleUtile)) // Compare successivement cet élément de référence
// avec tous les éléments suivants du tableau (1 puis 2 puis 3 puis 4 ...)
{
if ( Tableau[Element_A_Comparer] < Tableau[Element_De_Reference] ) // Si un élément suivant
// est plus petit que l'élément de référence
{
//echange les deux valeurs
swap = Tableau[Element_De_Reference] ;
Tableau[Element_De_Reference] = Tableau [Element_A_Comparer];
Tableau[Element_A_Comparer] = swap ;
}
else // sinon teste l'élément suivant
{
Element_A_Comparer ++ ;
}
}
Element_A_Comparer = Element_De_Reference + 1 ; // et compare le uniquement avec les éléments qui le suivent
}
//*************************************************************************************************
// affiche le résultat du tri qui vient d'être réalisé
cout << "voici la suite en ordre croissant: " ;
for (int Iteration=0; Iteration<TailleUtile ;Iteration++)
{
cout << Tableau[Iteration] << " ";
}
cout << endl <<endl;
//*************************************************************************************************
// il est très simple maintenant de trouver la médiane des nombres différents
// ou l'intervalle médian des nombres differents.
if (TailleUtile%2 == 0) // si la taille de la suite est en nombre pair (car la division par 2 n'a pas de reste)
{
cout << "les valeurs differentes sont en nombre pair" << endl <<endl ;
cout << "intervalle median de la suite de nombres differents est" << endl ;
cout << "compris entre: "<< Tableau[(TailleUtile/2)-1] <<" et " << Tableau[TailleUtile/2] << endl;
}
else // sinon c'est que la suite est impaire
{
cout <<"les valeurs differentes sont en nombre impair" << endl << endl;
cout << "la mediane des nombres differents vaut: "<< Tableau[TailleUtile/2] ;
}
cout << endl ;
return 0;
}
Je n'ai utilisé ni pointeur, ni constructeur, ni destructeur.... c'est basique mais ça fonctionne.
Je crée un tableau de 10 éléments correspondant aux 10 nombres différents possibles.
Je me sers d'une variable TailleUtile qui me permet de faire ensuite le tri uniquement sur les premiers éléments du tableau, dans lesquels j'aurai stocké les nombres différents.
Schématiquement:
tu déclares ton Tableau[0] à Tableau[9]
tu entres tes 10 valeurs au clavier par exemple 2,1,5,5,4,4,4,1,3,8
après chaque saisie, je compare avec les éléments déjà existants dans le tableau, pour voir si ce nombre existe déjà ou non.
s'il n'existe pas, je le mets dans le tableau à l'élément suivant et j'augmente TailleUtile de 1.
à la fin en mémoire il y a ceci
Tableau[0] = 2
Tableau[1]=1
Tableau[2]=5
Tableau[3]=4
Tableau[4]=3
Tableau[5]=8
et les éléments Tableau[6] à Tableau[9] ??? On s'en fout lol... on ne s'en préoccupe plus car grâce à notre variable TailleUtile
on sait maintenant qu'il ne faudra travailler (pour le tri) que sur les 6 premiers éléments de notre tableau!
Le source:
#include
using namespace std ; // permet d'éviter la lourdeur de std::cout et std::cin, remplacés par cout et cin
int main ()
{
const unsigned short int TAILLE=10; // taille totale du tableau, correspond aux 10 nombres à entrer au maximum
unsigned short int Tableau[TAILLE];
unsigned short int TailleUtile = 0 ; // permettra de comptabiliser combien il y a effectivement et réellement
// de nombres différents dans ce tableau
bool NombreEstIdentique = false; // servira pour des tests de comparaison avec les nombres déjà existants
// indiquer que la médiane sera calculée à partir de ... nombres à saisir au clavier
cout<<"Entrez " <<TAILLE <<" nombres" <<endl ;
//*********************************************************************************************************************
// l'utilisateur entre successivement les dix nombres, qui sont mis à tour de rôle dans le tableau
// si et uniquement si un nombre identique n'existe pas déjà dans le tableau.
// Si le nombre n'existe pas déjà, on incrémente aussi TailleUtile
// ce qui permettra de faire plus tard un tri parmi les éléments du tableau qui nous intéressent.
unsigned short int ValeurSaisie ;
for (int Iteration=0; Iteration<TAILLE ;Iteration++) // saisie successive de 10 nombres
{
cin >> ValeurSaisie ;
if (Iteration==0) // aucun intérêt de tester la premiere valeur saisie, elle est forcément unique
{
Tableau[0]=ValeurSaisie ; // stocke la valeur saisie au clavier, dans Tableau[0]
TailleUtile ++ ; // on a 1 élément utile dans le tableau
}
else // pour les valeurs suivantes saisies, c'est ici qu'on compare
{
NombreEstIdentique = false ;
for (int Iteration2=0 ; Iteration2<TailleUtile ; Iteration2++) // teste tous les nombres existants déjà
{
if ( ValeurSaisie == Tableau[Iteration2] ) // et compare les successivement à la valeur saisie
NombreEstIdentique = true ;
}
if (NombreEstIdentique == false) // si la valeur saisie n'est pas un nombre existant déjà
{
Tableau[TailleUtile]=ValeurSaisie ; // stocke la valeur saisie , dans Tableau[1] ou Tableau[2...]
TailleUtile++ ; // et on a un nouvel élément utile dans le tableau
}
}
}
//**************************************************************************************************
//affiche le résultat des comparaisons qui viennent d'être effectuées.
cout <<"sont retenus les nombres suivants:" << endl ;
for (int Iteration=0 ; Iteration<TailleUtile ; Iteration++)
{
cout << Tableau[Iteration] <<" " ;
}
cout <<endl;
cout <<"il y a "<< TailleUtile <<" nombres differents parmi les " << TAILLE << " nombres saisis" ;
cout << endl <<endl;
//**************************************************************************************************
// on va maintenant trier par ordre croissant les premiers éléments du tableau
// qui sont tous des nombres différents les uns des autres.
// on sait grâce à la variable TailleUtile éléments, sur combien d'éléments se fera le tri.
unsigned short int Element_A_Comparer=1 ;
unsigned short int swap=0 ; // sera utile pour échanger deux variables
//prendre successivement pour référence l'élément 0 puis 1 puis 2 puis 3.... jusqu'à (TailleUtile-1)
for (unsigned short int Element_De_Reference=0; Element_De_Reference< TailleUtile-1 ; Element_De_Reference ++)
{
while (Element_A_Comparer < (TailleUtile)) // Compare successivement cet élément de référence
// avec tous les éléments suivants du tableau (1 puis 2 puis 3 puis 4 ...)
{
if ( Tableau[Element_A_Comparer] < Tableau[Element_De_Reference] ) // Si un élément suivant
// est plus petit que l'élément de référence
{
//echange les deux valeurs
swap = Tableau[Element_De_Reference] ;
Tableau[Element_De_Reference] = Tableau [Element_A_Comparer];
Tableau[Element_A_Comparer] = swap ;
}
else // sinon teste l'élément suivant
{
Element_A_Comparer ++ ;
}
}
Element_A_Comparer = Element_De_Reference + 1 ; // et compare le uniquement avec les éléments qui le suivent
}
//*************************************************************************************************
// affiche le résultat du tri qui vient d'être réalisé
cout << "voici la suite en ordre croissant: " ;
for (int Iteration=0; Iteration<TailleUtile ;Iteration++)
{
cout << Tableau[Iteration] << " ";
}
cout << endl <<endl;
//*************************************************************************************************
// il est très simple maintenant de trouver la médiane des nombres différents
// ou l'intervalle médian des nombres differents.
if (TailleUtile%2 == 0) // si la taille de la suite est en nombre pair (car la division par 2 n'a pas de reste)
{
cout << "les valeurs differentes sont en nombre pair" << endl <<endl ;
cout << "intervalle median de la suite de nombres differents est" << endl ;
cout << "compris entre: "<< Tableau[(TailleUtile/2)-1] <<" et " << Tableau[TailleUtile/2] << endl;
}
else // sinon c'est que la suite est impaire
{
cout <<"les valeurs differentes sont en nombre impair" << endl << endl;
cout << "la mediane des nombres differents vaut: "<< Tableau[TailleUtile/2] ;
}
cout << endl ;
return 0;
}
alexey27
Messages postés
18
Date d'inscription
samedi 22 novembre 2008
Statut
Membre
Dernière intervention
11 janvier 2009
1
6 déc. 2008 à 17:19
6 déc. 2008 à 17:19
Merci pour vos reponses alors je m'explique l'exercice demande justement de trouver le nombre pour lequel le nombre de valeurs superieures a lui est egale au nombre de valeurs inferieures a lui. Ce n'est pas vraiment la definition de la mediane.
C'est pour cela que j'ai donné l'exemple precedant:
Si l'utilisateur entre cette suite de nombres:
{2,2,4,3,1,6,7,5,9,8} .
Le programme devra afficher le nombre 5 car il existe 4 valeurs inferieures a 5 et 4 valeurs sperieures a 5.
Or 2 apparait deux fois dans la suite de nombres c'est bien cela le probleme et je ne sais pas comment faire pour ne le prendre en compte qu'une seule fois.
5>1>2>3>4 (5 est plus grand que 4 nombres)
5<6<7<8<9 (5 est plus petit que 4 nombres)
C'est pour cela que j'ai donné l'exemple precedant:
Si l'utilisateur entre cette suite de nombres:
{2,2,4,3,1,6,7,5,9,8} .
Le programme devra afficher le nombre 5 car il existe 4 valeurs inferieures a 5 et 4 valeurs sperieures a 5.
Or 2 apparait deux fois dans la suite de nombres c'est bien cela le probleme et je ne sais pas comment faire pour ne le prendre en compte qu'une seule fois.
5>1>2>3>4 (5 est plus grand que 4 nombres)
5<6<7<8<9 (5 est plus petit que 4 nombres)
coucou747
Messages postés
12303
Date d'inscription
mardi 10 février 2004
Statut
Membre
Dernière intervention
30 juillet 2012
44
2 déc. 2008 à 01:04
2 déc. 2008 à 01:04
salut
ton if (a == b) n'est pas dans ta boucle :
#include
int main ()
{
const int SIZE=10;
int num[SIZE];
int med,key,j,a,b;
std::cout<<"Enter "<<SIZE<<" numbers"<<std::endl;
for (int counter=0; counter<SIZE ;counter++)
{
std::cin >> num[counter];
}
for (int i=0; i<SIZE ; i++)
{
key=num[i];
j=0;
a=0;
b=0;
for (int j=0; j<SIZE ; j++)
{
if (num[j]>key)
{
a++;
}
if (num[j]<key)
{
b++;
}
}
if (a==b)
{
med=key;
std::cout<<med;
}
}
return 0;
}
ton if (a == b) n'est pas dans ta boucle :
#include
int main ()
{
const int SIZE=10;
int num[SIZE];
int med,key,j,a,b;
std::cout<<"Enter "<<SIZE<<" numbers"<<std::endl;
for (int counter=0; counter<SIZE ;counter++)
{
std::cin >> num[counter];
}
for (int i=0; i<SIZE ; i++)
{
key=num[i];
j=0;
a=0;
b=0;
for (int j=0; j<SIZE ; j++)
{
if (num[j]>key)
{
a++;
}
if (num[j]<key)
{
b++;
}
}
if (a==b)
{
med=key;
std::cout<<med;
}
}
return 0;
}
coucou747
Messages postés
12303
Date d'inscription
mardi 10 février 2004
Statut
Membre
Dernière intervention
30 juillet 2012
44
2 déc. 2008 à 01:12
2 déc. 2008 à 01:12
hum... j'oubliais un detail : si t'as a = b-1, ou b = a-1 alors c'est aussi une mediane.
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
alexey27
Messages postés
18
Date d'inscription
samedi 22 novembre 2008
Statut
Membre
Dernière intervention
11 janvier 2009
1
2 déc. 2008 à 13:32
2 déc. 2008 à 13:32
Oui mais selon l'exercice la mediane est la valeur pour laquelle le nombre de valeur superieurs a elle est egale au nombre de valeurs inferieurs a elle (a la mediane).
Comme l'exemple que j'ai donne plus haut .
Or je ne sais pas comment m'y prendre lorsque j'ai des valeurs qui se repetent plusieurs fois dans la suite de nombres....
Comme l'exemple que j'ai donne plus haut .
Or je ne sais pas comment m'y prendre lorsque j'ai des valeurs qui se repetent plusieurs fois dans la suite de nombres....
coucou747
Messages postés
12303
Date d'inscription
mardi 10 février 2004
Statut
Membre
Dernière intervention
30 juillet 2012
44
2 déc. 2008 à 17:06
2 déc. 2008 à 17:06
t'ajoutes un break apres l'affichage.
cs_stephane57
Messages postés
12
Date d'inscription
lundi 17 décembre 2007
Statut
Membre
Dernière intervention
6 janvier 2009
4 déc. 2008 à 15:57
4 déc. 2008 à 15:57
Quelques petites remarques d'ordre général...
Merci d'avoir mis ton source, c'est plus simple pour t'aider.
Mais.... il pourrait être utile que tu ajoutes un ou deux petits commentaires dans ton source, pour séparer les parties (//ici on entre les valeurs //début de l'algorithme de calcul ....)
D'autre part, essaie stp de mettre des noms évocateurs à tes variables : j ,a , b .... désolé mais ça demande un petit effort supplémentaire pour lire ton source et le comprendre.
Voilà, ceci étant dit, je crois qu'avant de commencer à programmer, il faut déjà bien définir sur papier ce qu'est la médiane de nombres...
Je suis donc allé voir sur plusieurs sites internet car j'avais un doute sur ta façon de concevoir la médiane de nombres.
Je pense que l'erreur vient de là au départ: la médiane de 10 nombres ce n'est pas possible...
En effet, si tu as un nombre qui est la médiane, il te reste 9 autres nombres. Soit 5 nombres au-dessus de la mediane et 4 nombres au-dessous de la mediane, soit l'inverse.
Dur,dur de trouver la médiane dans ce cas, entre 5 nombres d'un côté et 4 nombres de l'autre!
Tu expliques que:
" Or lorsque je rentre la suite de nombres suivante:
{2,2,4,3,1,6,7,5,9,8} je n'obtiens pas de mediane alors que celle ci vaut normalement 5.
Selon l'exercice la definition de la mediane est 5 puisque:
5>1>2>3>4 (5 est plus grand que 4 nombres)
5<6<7<8<9 (5 est plus petit que 4 nombres) "
Et bien en fait tu as deux fois le nombre 2 !!!!!!!
c'est-à-dire en réalité 5 > 1>2 et encore à 2>3>4 (5 est plus grand que CINQ nombres et non 4 nombres!)
5<6<7<8<9 (5 est bien plus petit que 4 nombres)
Alors voilà, la médiane de 5 nombres en-dessous et de 4 nombres au-dessus..... mazette c'est pas logique!
La solution:
pour établir une médiane, il te faut que le total des nombres à comparer soit IMPAIR.
si tu tiens absolument à établir une médiane à partir d'un nombre total qui serait PAIR..... tu ne peux pas définir la médiane, mais tu définis ce que l'on appelle UN INTERVALLE MEDIAN: ce sont les deux nombres situés au-milieu de ta suite dans ton exemple c'est une valeur qui sera entre les nombres 4 et 5
car ta suite est (une fois remise dans l'ordre) 1 , 2 , 2 , 3 , 4 , 5 , 6, 7 ,8 , 9
La médiane des nombres est notamment utilisée en statistique, comme l'explique le document ci-dessous:
http://209.85.129.132/search?q=cache:9mJAsxaZCJ0J:epi.univ-paris1.fr/servlet/com.univ.collaboratif.utils.LectureFichiergw%3FID_FICHE%3D3687%26OBJET%3D0008%26ID_FICHIER%3D28180+mediane+de+nombres&hl=fr&ct=clnk&cd=10&gl=fr
Voilà et bon courage a+
Merci d'avoir mis ton source, c'est plus simple pour t'aider.
Mais.... il pourrait être utile que tu ajoutes un ou deux petits commentaires dans ton source, pour séparer les parties (//ici on entre les valeurs //début de l'algorithme de calcul ....)
D'autre part, essaie stp de mettre des noms évocateurs à tes variables : j ,a , b .... désolé mais ça demande un petit effort supplémentaire pour lire ton source et le comprendre.
Voilà, ceci étant dit, je crois qu'avant de commencer à programmer, il faut déjà bien définir sur papier ce qu'est la médiane de nombres...
Je suis donc allé voir sur plusieurs sites internet car j'avais un doute sur ta façon de concevoir la médiane de nombres.
Je pense que l'erreur vient de là au départ: la médiane de 10 nombres ce n'est pas possible...
En effet, si tu as un nombre qui est la médiane, il te reste 9 autres nombres. Soit 5 nombres au-dessus de la mediane et 4 nombres au-dessous de la mediane, soit l'inverse.
Dur,dur de trouver la médiane dans ce cas, entre 5 nombres d'un côté et 4 nombres de l'autre!
Tu expliques que:
" Or lorsque je rentre la suite de nombres suivante:
{2,2,4,3,1,6,7,5,9,8} je n'obtiens pas de mediane alors que celle ci vaut normalement 5.
Selon l'exercice la definition de la mediane est 5 puisque:
5>1>2>3>4 (5 est plus grand que 4 nombres)
5<6<7<8<9 (5 est plus petit que 4 nombres) "
Et bien en fait tu as deux fois le nombre 2 !!!!!!!
c'est-à-dire en réalité 5 > 1>2 et encore à 2>3>4 (5 est plus grand que CINQ nombres et non 4 nombres!)
5<6<7<8<9 (5 est bien plus petit que 4 nombres)
Alors voilà, la médiane de 5 nombres en-dessous et de 4 nombres au-dessus..... mazette c'est pas logique!
La solution:
pour établir une médiane, il te faut que le total des nombres à comparer soit IMPAIR.
si tu tiens absolument à établir une médiane à partir d'un nombre total qui serait PAIR..... tu ne peux pas définir la médiane, mais tu définis ce que l'on appelle UN INTERVALLE MEDIAN: ce sont les deux nombres situés au-milieu de ta suite dans ton exemple c'est une valeur qui sera entre les nombres 4 et 5
car ta suite est (une fois remise dans l'ordre) 1 , 2 , 2 , 3 , 4 , 5 , 6, 7 ,8 , 9
La médiane des nombres est notamment utilisée en statistique, comme l'explique le document ci-dessous:
http://209.85.129.132/search?q=cache:9mJAsxaZCJ0J:epi.univ-paris1.fr/servlet/com.univ.collaboratif.utils.LectureFichiergw%3FID_FICHE%3D3687%26OBJET%3D0008%26ID_FICHIER%3D28180+mediane+de+nombres&hl=fr&ct=clnk&cd=10&gl=fr
Voilà et bon courage a+
cs_stephane57
Messages postés
12
Date d'inscription
lundi 17 décembre 2007
Statut
Membre
Dernière intervention
6 janvier 2009
5 déc. 2008 à 15:29
5 déc. 2008 à 15:29
Suite à tes questions, j'ai codé un programme pour la médiane des nombres
Dans la constante TAILLE, tu mets combien de nombres doivent être entrés dans ta suite.
Tu saisis ensuite au clavier les différents nombres, qui sont mis à tour de rôle dans un tableau.
Les nombres contenus dans le tableau sont triés par odre croissant.
Enfin si TAILLE est impair, on affiche comme médiane des nombres celui qui est au milieu de la suite triée.
si TAILLE est pair, on affiche un intervalle médian constitué par les deux nombres au milieu de la suite triée.
Ci-dessous le source:
#include
using namespace std ; //permet d'éviter la lourdeur de std::cout et std::cin, remplacés par cout et cin
int main ()
{
const unsigned short int TAILLE=10; // vous pouvez mettre un nombre impair ou pair ici
unsigned short int Tableau[TAILLE];
// indiquer que la médiane sera calculée à partir de ... nombres à saisir au clavier
cout<<"Entrez " <<TAILLE <<" nombres" <<endl ;
// l'utilisateur entre successivement les dix nombres, qui sont mis à tour de rôle dans le tableau
for (int Iteration=0; Iteration<TAILLE ;Iteration++)
{
cin >> Tableau[Iteration];
}
// trier dans l'ordre croissant tous les éléments du tableau
unsigned short int Element_De_Reference=0 ;
unsigned short int Element_A_Comparer=1 ;
unsigned short int Stockage_Pour_Echange=0 ;
while(Element_De_Reference< TAILLE-1) // Prend pour référence le premier élément du tableau
{
while (Element_A_Comparer < (TAILLE)) // Compare le successivement avec tous les éléments suivants du tableau
{
if ( Tableau[Element_A_Comparer] < Tableau[Element_De_Reference] ) // Si un élément est plus petit que lui
{
//echange les deux valeurs
Stockage_Pour_Echange = Tableau[Element_De_Reference] ;
Tableau[Element_De_Reference] = Tableau [Element_A_Comparer];
Tableau[Element_A_Comparer] = Stockage_Pour_Echange ;
}
else
{
// sinon passe au test de l'élément suivant
Element_A_Comparer ++ ;
}
}
Element_De_Reference++ ; // Prend maitenant pour référence le deuxième... élément du tableau
Element_A_Comparer = Element_De_Reference + 1 ; // et compare le uniquement avec les éléments qui le suivent
}
// affiche le résultat du tri
cout << "voici la suite en ordre croissant: " ;
for (int Iteration=0; Iteration<TAILLE ;Iteration++)
{
cout << Tableau[Iteration] << " ";
}
cout << endl;
// affichage de la médiane
if (TAILLE%2 == 0) // si la taille de la suite est en nombre pair (car la division par 2 n'a pas de reste)
{
cout << "intervalle median de la suite est" ;
cout << " compris entre: "<< Tableau[(TAILLE/2)-1] <<" et " << Tableau[TAILLE/2] ;
}
else // sinon c'est que la suite est impaire
{
cout << "la mediane des nombres vaut: "<< Tableau[TAILLE/2] ;
}
cout << endl ;
return 0;
}
Dans la constante TAILLE, tu mets combien de nombres doivent être entrés dans ta suite.
Tu saisis ensuite au clavier les différents nombres, qui sont mis à tour de rôle dans un tableau.
Les nombres contenus dans le tableau sont triés par odre croissant.
Enfin si TAILLE est impair, on affiche comme médiane des nombres celui qui est au milieu de la suite triée.
si TAILLE est pair, on affiche un intervalle médian constitué par les deux nombres au milieu de la suite triée.
Ci-dessous le source:
#include
using namespace std ; //permet d'éviter la lourdeur de std::cout et std::cin, remplacés par cout et cin
int main ()
{
const unsigned short int TAILLE=10; // vous pouvez mettre un nombre impair ou pair ici
unsigned short int Tableau[TAILLE];
// indiquer que la médiane sera calculée à partir de ... nombres à saisir au clavier
cout<<"Entrez " <<TAILLE <<" nombres" <<endl ;
// l'utilisateur entre successivement les dix nombres, qui sont mis à tour de rôle dans le tableau
for (int Iteration=0; Iteration<TAILLE ;Iteration++)
{
cin >> Tableau[Iteration];
}
// trier dans l'ordre croissant tous les éléments du tableau
unsigned short int Element_De_Reference=0 ;
unsigned short int Element_A_Comparer=1 ;
unsigned short int Stockage_Pour_Echange=0 ;
while(Element_De_Reference< TAILLE-1) // Prend pour référence le premier élément du tableau
{
while (Element_A_Comparer < (TAILLE)) // Compare le successivement avec tous les éléments suivants du tableau
{
if ( Tableau[Element_A_Comparer] < Tableau[Element_De_Reference] ) // Si un élément est plus petit que lui
{
//echange les deux valeurs
Stockage_Pour_Echange = Tableau[Element_De_Reference] ;
Tableau[Element_De_Reference] = Tableau [Element_A_Comparer];
Tableau[Element_A_Comparer] = Stockage_Pour_Echange ;
}
else
{
// sinon passe au test de l'élément suivant
Element_A_Comparer ++ ;
}
}
Element_De_Reference++ ; // Prend maitenant pour référence le deuxième... élément du tableau
Element_A_Comparer = Element_De_Reference + 1 ; // et compare le uniquement avec les éléments qui le suivent
}
// affiche le résultat du tri
cout << "voici la suite en ordre croissant: " ;
for (int Iteration=0; Iteration<TAILLE ;Iteration++)
{
cout << Tableau[Iteration] << " ";
}
cout << endl;
// affichage de la médiane
if (TAILLE%2 == 0) // si la taille de la suite est en nombre pair (car la division par 2 n'a pas de reste)
{
cout << "intervalle median de la suite est" ;
cout << " compris entre: "<< Tableau[(TAILLE/2)-1] <<" et " << Tableau[TAILLE/2] ;
}
else // sinon c'est que la suite est impaire
{
cout << "la mediane des nombres vaut: "<< Tableau[TAILLE/2] ;
}
cout << endl ;
return 0;
}
alexey27
Messages postés
18
Date d'inscription
samedi 22 novembre 2008
Statut
Membre
Dernière intervention
11 janvier 2009
1
9 déc. 2008 à 13:04
9 déc. 2008 à 13:04
Merci beaucoup pour ton post. J'ai enfin reussi a faire mon exercice a partir de ton code source qui est tres bien ecrit!
