Mediane d'une suite de nombres [Résolu]

alexey27 18 Messages postés samedi 22 novembre 2008Date d'inscription 11 janvier 2009 Dernière intervention - 1 déc. 2008 à 23:59 - Dernière réponse : alexey27 18 Messages postés samedi 22 novembre 2008Date d'inscription 11 janvier 2009 Dernière intervention
- 9 déc. 2008 à 13:04
Bonsoir je dois creer un programme qui affiche la mediane d'une suite de 10 nombres. Voici ce que j'ai fait :


#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;  
}
  


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)
Afficher la suite 

Votre réponse

9 réponses

Meilleure réponse
cs_stephane57 12 Messages postés lundi 17 décembre 2007Date d'inscription 6 janvier 2009 Dernière intervention - 9 déc. 2008 à 09:14
3
Merci
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;  
}

Merci cs_stephane57 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 123 internautes ce mois-ci

Commenter la réponse de cs_stephane57
coucou747 12336 Messages postés mardi 10 février 2004Date d'inscription 30 juillet 2012 Dernière intervention - 2 déc. 2008 à 01:04
0
Merci
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;  
}
Commenter la réponse de coucou747
coucou747 12336 Messages postés mardi 10 février 2004Date d'inscription 30 juillet 2012 Dernière intervention - 2 déc. 2008 à 01:12
0
Merci
hum... j'oubliais un detail : si t'as a = b-1, ou b = a-1 alors c'est aussi une mediane.
Commenter la réponse de coucou747
alexey27 18 Messages postés samedi 22 novembre 2008Date d'inscription 11 janvier 2009 Dernière intervention - 2 déc. 2008 à 13:32
0
Merci
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....
Commenter la réponse de alexey27
coucou747 12336 Messages postés mardi 10 février 2004Date d'inscription 30 juillet 2012 Dernière intervention - 2 déc. 2008 à 17:06
0
Merci
t'ajoutes un break apres l'affichage.
Commenter la réponse de coucou747
cs_stephane57 12 Messages postés lundi 17 décembre 2007Date d'inscription 6 janvier 2009 Dernière intervention - 4 déc. 2008 à 15:57
0
Merci
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+
Commenter la réponse de cs_stephane57
cs_stephane57 12 Messages postés lundi 17 décembre 2007Date d'inscription 6 janvier 2009 Dernière intervention - 5 déc. 2008 à 15:29
0
Merci
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;  
}
Commenter la réponse de cs_stephane57
alexey27 18 Messages postés samedi 22 novembre 2008Date d'inscription 11 janvier 2009 Dernière intervention - 6 déc. 2008 à 17:19
0
Merci
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)
Commenter la réponse de alexey27
alexey27 18 Messages postés samedi 22 novembre 2008Date d'inscription 11 janvier 2009 Dernière intervention - 9 déc. 2008 à 13:04
0
Merci
Merci beaucoup pour ton post. J'ai enfin reussi a faire mon exercice a partir de ton code source qui est tres bien ecrit!
Commenter la réponse de alexey27

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.