Algorithme un peu bizarre a mon avis.

**free_01_binairy** · 08/06/2016, 00h23

Je suis débutant en programmation java
j'ai fait ce petit programme qui vient après pour m’exercer histoire d'avoir la main (je pars du principe qu'aucune fonction n'intervient dans le main[ ]: parce que non connue)
le menu du programme donne les directives pour les unités de distance.
Mais j'ai l'impression que les traitements (l'algorithme) sont redondants:
Il n'y aurait-il pas un autre algorithme qui serait plus simple que ça.
Si vous découvrez aussi des bugs dans celui-ci dites le moi avant de me proposer le changement 'algorithme.
CODE SOURCE:

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
 
package test;
 
import java.util.Scanner;
 
/**
 *
 * @author free_01_binairy
 * C'est un programme qui convertit des distances en une autre (km,m,cm)
 * juste ces trois unites de distance.
 */
public class Test {
 
 
    public static void main(String[] args) {
        // TODO code application logic here
      System.out.println("CE PROGRAMME CONVERTIT DES DISTANCES");
 
      System.out.println( "\n");
      System.out.println("* *************************************************************** *");
      System.out.println("* *************************************************************** *");
      System.out.println("* *                                                                            * *");
      System.out.println("* *                 VOICI LE MENU                                  * *"); 
      System.out.println("* *                    1:km                                                * *");
      System.out.println("* *                    2:m                                                  * *");
      System.out.println("* *                    3:cm                                                * *");
      System.out.println("* *************************************************************** *");
      System.out.println("* **************************************************************  *");
 
       /*
      1m = 100cm // 1cm= 0.01;
      1km = 1000m //1m= 0.001m
      1km = 100000cm //1cm= 0.00001km
      */
 
     Scanner sc= new Scanner(System.in) ;
 
     System.out.println("Saisissez le nombre a convertir:");
     float num = sc.nextFloat(); 
     while(num!=0){ //Une facon d'echaper aux chaines de caracteres ou aux caracteres.
      sc.nextLine();
 
     System.out.println("Donnez son unite correspondant:");
     int from = sc.nextInt();
     sc.nextLine();
 
      System.out.println("Convertir en:");
     int to = sc.nextInt();
        switch (from) {
             case 1:
                 switch(to){
                     case 1:
                     System.out.println(num+ " km") ;
                         break;
                     case 2:
                         System.out.println(num*1000+" m");
                         break;
                     case 3:
                         System.out.println(num*100000+" cm");
                         break;
                     default:
                         System.out.println("Unite non prise en charge");
                    return ;     
 
                 }
             break;
             case 2:
                  switch(to){
                     case 1:
                     System.out.println(num*0.001+" km") ;
                         break;
                     case 2:
                         System.out.println(num+" m");
                         break;
                     case 3:
                         System.out.println(num*100+" cm");
                         break;
                     default:
                         System.out.println("Unite non prise en charge");
                      return;   
                  }
              break;
             case 3:
                  switch(to){
                     case 1:
                     System.out.println(num*0.00001+" km") ;
                         break;
                     case 2:
                         System.out.println(num*0.01+" m");
                         break;
                     case 3:
                         System.out.println(num+" cm");
                         break;
                     default:
                         System.out.println("Unite non prise en charge");
                     return;    
                  }
             default:
                 System.out.println("Unite non prise en charge");
 
        }
        return;  
       }
    }               
}

Merci de contribution.

**dinobogan** · 08/06/2016, 10h34

Ton problème, c'est l'interfaçage. C'est un soucis courant en programmation. Il faut s'approprier les données d'entrées en contrôlant leur format. Il faut considérer que tout ce qui vient de l'extérieur peut être faux et modifier les données selon notre propre convenance, sans que cela ne soit dictée de l'extérieur.
Voici une possibilité de code modifié, un peu plus court que le tient et surtout sans redondance :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import java.util.Scanner;
 
/**
 *
 * @author free_01_binairy C'est un programme qui convertit des distances en une
 *         autre (km,m,cm) juste ces trois unites de distance.
 */
public class Convertir
{
	public static void main( String[] args )
	{
		// TODO code application logic here
		System.out.println( "CE PROGRAMME CONVERTIT DES DISTANCES" );
 
		System.out.println( "\n" );
		System.out.println( "* *************************************************************** *" );
		System.out.println( "* *************************************************************** *" );
		System.out.println( "* *                                                                            * *" );
		System.out.println( "* *                 VOICI LE MENU                                  * *" );
		System.out.println( "* *                    1:km                                                * *" );
		System.out.println( "* *                    2:m                                                  * *" );
		System.out.println( "* *                    3:cm                                                * *" );
		System.out.println( "* *************************************************************** *" );
		System.out.println( "* **************************************************************  *" );
 
		/*
		 * 1m = 100cm // 1cm= 0.01; 1km = 1000m //1m= 0.001m 1km = 100000cm
		 * //1cm= 0.00001km
		 */
 
		Scanner sc = new Scanner( System.in );
 
		System.out.println( "Saisissez le nombre a convertir:" );
		float num = sc.nextFloat();
		while( num != 0 )
		{ // Une facon d'echaper aux chaines de caracteres ou aux caracteres.
			sc.nextLine();
 
			System.out.println( "Donnez son unite correspondant:" );
			int from = sc.nextInt();
			sc.nextLine();
 
			switch( from )
			{
				case 1: num *= 1000; break;
				case 2: break;
				case 3: num /= 100; break;
				default:
					System.out.println("Unite non prise en charge");
					return;
			}
 
			System.out.println( "Convertir en:" );
			int to = sc.nextInt();
			switch( to )
			{
				case 1: System.out.println( num / 1000 + " km" ); break;
				case 2: System.out.println( num + " m" ); break;
				case 3: System.out.println( num * 100 + " cm" ); break;
				default:
					System.out.println( "Unite non prise en charge" );
					return;
			}
		}
	}
}

Le principe : la valeur entrée est convertie depuis son unité vers le mètre. Cette unité est arbitraire, n'importe quelle autre unité est possible.
Ensuite, selon le choix de l'utilisateur, cette valeur en mètre est convertie dans l'unité d'arrivée.

Pour l'interfaçage, il n'y a pas de règle universelle. Par exemple, dans ma façon de faire, il y a deux calculs : conversion en mètre puis conversion dans le format d'arrivé. Alors que ton programme ne faisait qu'un seul calcul. Par contre mon code est beaucoup plus court et il est facile d'ajouter une autre unité de conversion : il faudra en gros ajouter deux lignes : la première pour la conversion de X vers mètre et la seconde pour la conversion de mètre vers X. Par contre, dans ton code, ajouter une nouvelle unité c'est doubler la taille du code car tu effectues toutes les combinaisons !

**free_01_binairy** · 08/06/2016, 12h20

Ton algorithme est plus clair surtout plus court ce qui permet de comprendre facilement,
et aussi de pouvoir l’étendre a d'autres unités sans beaucoup d’écriture de code.

Merci énormément ...

Algorithme un peu bizarre a mon avis.

avec Java

Discussions similaires

Partager

Partager