probleme compilation et affichage

Version imprimable

Bonjour, il faudrait que le programme m'affiche les deux meilleures cote sur 5 cotes, voici mon programme :
p

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
ublic class DeuxMeilleuresCotes{
 
   public static java.util.Scanner scanner = new java.util.Scanner(System.in);
   public static void main(String[] args){
 
      double cote = scanner.nextDouble();
      double cote1 = scanner.nextDouble();
      double cote2 = scanner.nextDouble();
      double cote3 = scanner.nextDouble();
      double cote4 = scanner.nextDouble();
      double cote5 = scanner.nextDouble();
 
      if(cote1>cote2){
         System.out.print("Meilleure cote : " +cote);
 
      }
      else{ 
         System.out.print("Meilleure cote : " +cote);
 
         for(i=1; i<=5; i++){
            System.out.print("Entrez la cote obtenue : ");
 
 
         }
      }
   }
}

Quelles sont mes erreurs ? Merci

29/09/2019, 17h08
joel.drigo
Citation:

Envoyé par imnamn

Bonjour, il faudrait que le programme m'affiche les deux meilleures cote sur 5 cotesi

Dans ce cas, d'abord il faudrait saisir 5 cotes, pas 6.
Ensuite, si tu fais la saisie dans 5 variables, il va falloir faire de très nombreux tests, imbriqués, pour obtenir le résultat escompté, c'est à dire les 2 cotes les plus élevées. Ce qui est très fastidieux et le risque d'erreurs est accru.

Le plus simple est de stocker les saisies dans un tableau.

Ensuite, il y a deux façons de traiter le problème :
1. la manière intuitive est de chercher la plus grande des cotes. On parcourt le tableau et on compare chaque cote à une variable qu'on initialise à la plus petite cote possible. A chaque comparaison, si la cote courante est plus grande, elle la remplace. A la fin on a la plus grande cote possible.
  Code:
  
  1 2 3 4 5 6 7 double maxcote=-1; for(int i=0; i<cotes.length, i++) { if ( cotes[i]>maxcote ) { maxcote=cotes[i]; } } // ici maxcote contient la plus grande cote possible dans le tableau cotes
  Pour la deuxième cote la plus grande, il suffit de faire la même chose en ignorant la cote déjà trouvée dans le premier parcours. Pour faire ça, on peut stocker sa position dans une variable maxcoteindex par exemple, lors du premier parcours, qui servira à connaître la position dans le tableau à ignorer lors du second parcours
2. La solution optimisée consiste à trier le tableau et à prendre les valeurs des deux dernières positions, ou deux premières, selon qu'on tri par ordre croissant ou décroissant. Mais si c'est un exercice d'école et que tu n'as ni étudier les algorithmes de tris, ni le droit d'utiliser les fonctions de tris de l'api Java, la première solution est celle que tu dois utiliser à priori.
29/09/2019, 19h01
imnamn

Quelle est cette notion de tableau en fait ?

Citation:

Envoyé par imnamn

Quelle est cette notion de tableau en fait ?

Si tu poses la question c'est qu'à priori tu n'as pas encore vu cette notion et donc tu ne devrais pas l'utiliser. Dans ce cas, tu vas être obligé d'écrire toutes les combinaisons de tests qui vont te permettre de déterminer les deux valeurs les plus grandes, du genre de :
Code:

1 2 3 4 5 6 7 8 9 10 11 if ( cote1>=cote2 && cote1>=cote3 && cote1>=cote4 && cote1>=cote5 ) { // on compare une variable à chacune des 4 autres // alors cote1 est la plus grande // c'est la variable qui contient la valeur qui est plus grande que les quatre autres qui est la plus grande if ( cote2>=cote3 && cote2>=cote4 && cote2>=cote5 ) { // on refait le test pour la deuxième plus grande en ne comparant qu'une variable autre que celle qui est sélectionné par le premier test qu'on compare aux trois autres, le résultat (les déductions) étant similaire au premier test // alors cote2 est la plus seconde plus grande } else if ( cote3>=cote2 && cote3>=cote4 && cote3>=cote5 ) { // on recommence avec une autre variable, et ainsi de suite jusqu'à avoir fait les comparaisons des 4 variables // alors cote3 est la plus seconde plus grande } else ... } else ... // on recommence avec une autre variable, et ainsi de suite jusqu'à avoir fait les comparaisons des 5 variables et dans le bloc on répète le processus pour les cas de tests qui n'ont pas encore été traités (il y a des tests qu'on peut éliminer parce qu'on les a déjà fait)
Sinon les tableaux sont des structures de données permettant de stocker un nombre fini et déterminé de valeurs de même type. On déclare un tableau en ajoutant [] au type :

Code:

int[] tab; // tab est un tableau de int

On initialise un tableau en déclarant en même temps sa taille (le nombre de valeurs qu'il va contenir. On parle de cellule également, pour parler des cases du tableau qui contiennent les valeurs) :

int[] tab = new int[5]; // on initialise le tableau en déclarant que sa taille est 5 cellules de type int, qui valent 0
int[] tab = {1,2,3,4}; // on initialise le tableau en déclarant que sa taille est 4 cellules de type int, qui contiennent respectivement les valeurs 1, 2, 3 et 4.
il y a d'autres façons d'initialiser un tableau...

Les index de cellules commencent à zéro.

On lit la valeur d'une cellule de tableau en indiquant l'index de cellule entre crochets :

Code:

int valeur = tab[1]; // on lit la cellule d'index 1 (la deuxième donc) du tableau tab

On écrit la valeur avec la même notation :

Code:

tab[2]=42; // on met la valeur 42 dans la cellule d'index 2 (la troisième donc)

Les tableaux permettent en outre de parcourir plusieurs valeurs, en faisant varier l'index entre 0 inclus et la taille du tableau obtenue par l'attribut length, exclue :
Code:

1 2 3 4 5 for(int i=0; i<tab.length; i++) { int val = tab[i]; // val va contenir la valeur à l'index i if ( val>42 ) { // cette condition va être appliquée à chaque valeur du tableau } }
Si le tableau est de taille 5, et qu'il faut faire le même traitement avec 5 variables, il faut écrire chaque test if (val>42) cinq fois, un par variable. S'il est conditions sont appliquées à des séries, ça devient encore plus compliqué. Par exemple, s'il faut sortir de la boucle lorsque val<0, alors les tests de chaque condition deviennent plus complexe à écrire avec 5 variables... et n'en parlons pas s'il y en a 60, ou 5000...