Discussion :

[domxaline]

Bonsoir,
Cette fois, la même programme d'une autre façon écrire, je l'ai trouve dans l'internet,
j'ai un doute dans cette programme.

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
import java.util.Scanner;
public class Test4 
{
	 public static void main(String[] args) 
	 {   
		     boolean flag;
		     Scanner sc=new Scanner(System.in);
		     System.out.print("Entrez le nombre de valeur<10 = ");
		     int nb=sc.nextInt();
		     int tab[]=new int[nb];
		     for( int i=0; i<nb; i++ )
		     {
		       System.out.print("Entrez les nombres :"+(i+1)+" = ");		
		       tab[i] = sc.nextInt();
		     }
		     flag = true;
		     int i=1;
		     while ( tab[i] != tab[i-1] + 1 && i < nb-1 )
		     {
		        i = i+1;
		     }
		     if( tab[i] == tab[i-1] + 1 )
		     {
		        System.out.println("Les nombres sont consécutifs");
		     }
		     else  
		     {
		        System.out.println("Les nombres ne sont pas consécutifs");
		     }
		   }
		 }

output
Entrez le nombre de valeur<10 = 3
Entrez les nombres :1 = 4
Entrez les nombres :2 = 2
Entrez les nombres :3 = 7
Les nombres ne sont pas consécutifs

dans la ligne suivante:
int i=1;
while ( tab[i] != tab[i-1] + 1 && i < nb-1 )
// ici tab[1] != tab[1-1]+1
// tab[1] != tab[0]+1
dans la position 0 valeur est 4 et 4+1=5
while( 2!= 5)

mais je ne comprend pas i < nb-1 )
ice i<nb -1
4<3-1 est ce que c'est ça?
pouvez vous m'expliquez svp

[joel.drigo]

Le programme se veut reposer sur une sorte d'astuce :

1. on fait une boucle et on fait ensuite un dernier test
2. ce dernier test sert à déterminer si l'élément courant après la boucle qui incrémente i (tab[i]) dans le tableau est consécutif à son précédent (tab[i-1]).
3. comme tab[i] ne fonctionne que si i < nb, on incrémente i tant que i<nb-1, pour que lorsqu'on fait le dernier incrément, i soit encore < nb,
4. on incrémente également tant que les éléments consécutifs ne sont pas des entiers consécutifs : dès qu'on a plus tab[i]!=tab[i-1]+1, alors on sort de la boucle et on ne fait donc pas l'incrément, donc le test qu'on va faire après la boucle va tester les mêmes éléments (puisque i reste le même).
   On fait donc la boucle tant que i<nb-1 et tab[i] != tab[i-1] + 1, c'est-à-dire qu'on sort donc de la boucle si
   
   • si i>=nb-1
   • ou si tab[i] == tab[i-1] + 1
   
   
   1. Si i>=nb-1 est vrai quand on sort, on reteste donc tab[i] == tab[i-1] + 1, qui pouvait être vrai comme faux.
      
      1. On a parcourur tous les tab[i] tels que chacun soit non consécutif (!)
      2. On a également i=nb-1, donc on compare le dernier élément du tableau et son précédent.
      3. Si le dernier est consécutif à l'avant dernier, on considère que tous les nombres sont consécutifs : faux ! On sait déjà que les précédents ne l'étaient pas ! Première preuve que le programme ne fonctionne pas ! Essaye avec ce tableau : {1,32,42,43} où les nombres ne sont manifestement pas consécutifs, alors que le programme dit qu'ils le sont.
   2. Si i<nb-1 quand on sort, alors c'est que tab[i] != tab[i-1] + 1 est faux, donc que c'est que tab[i] == tab[i-1] + 1 est vrai (algèbre de Boole : !vrai==faux, ou !faux==vrai),
      Donc le test tab[i] == tab[i-1] + 1 qu'on fait après la boucle est forcément vrai (c'est la même condition sur la même valeuir de i), et donc on considère que les nombres sont consécutifs. Ce qui est abérant vu qu'on n'a pas parcouru l'ensemble des nombres déjà.
      Essaye le tableau suivant : {1,2,42,4}, et tu verras que ça dit que les nombres sont consécutifs, alors que c'est manifestement faux.
      
      Donc tu as bien raison d'avoir un doute sur ce programme qui est erroné. Avec while (tab[i] == tab[i - 1] + 1 && i < nb - 1) { (ou mieux, while ( i < nb - 1 && tab[i] == tab[i - 1] + 1 )), ça fonctionnerait (en gros on parcourt tous les nombres tant qu'ils sont consécutifs, ou qu'on a pas atteint l'avant dernier). Simplement on fait éventuellement un même test 2 fois. Personnellement, je ne suis pas pour ce genre d'astuce, car ça les rend moins évident à comprendre, et car une micro modification peut les rendre complètement dysfonctionnels, et que c'est pas facile à voir. Lorsqu'il y a un réel gain de performances ou d'économie mémoire, ça peut se discuter, mais là, je ne vois pas trop l'intérêt, par rapport à un for, à part le gain d'une variable au scope un peu large peut-être.
      
      
   
   

[domxaline]

vous avez bien expliqué, merci d'avance.
mais,vous m'avez pas expliqué ceci:

mais je ne comprend pas i < nb-1 )
ice i<nb -1
4<3-1 est ce que c'est ça?
pouvez vous m'expliquez svp

est ce que mon raisonnement est bon?
ou 0<3-1
sinon pouvez vous m'expliquez svp

[joel.drigo]

vous avez bien expliqué, merci d'avance.
mais,vous m'avez pas expliqué ceci:

mais je ne comprend pas i < nb-1 )
ice i<nb -1
4<3-1 est ce que c'est ça?

Si j'ai expliqué pourquoi i < nb - 1 :

comme tab[i] ne fonctionne que si i < nb, on incrémente i tant que i<nb-1, pour que lorsqu'on fait le dernier incrément, i soit encore < nb,

est ce que mon raisonnement est bon?
sinon pouvez vous m'expliquez svp

Non, le raisonnement n'est pas bon : tu confonds les indices des cases du tableau avec les valeurs qui sont dans les cases.
4 c'est la valeur qui dans la case d'indice 0 (la première case), or i c'est l'indice (qu'on incrémente dans la boucle pour pouvoir parcourir toutes les cases du tableau). C'est i qui vaut 0 qu'on compare à nb-1, pas tab[i], soit tab[0] qui contient 4. Autrement dit : tab[i] ce n'est pas i.
Pour analogie, prends 3 personnes, Tom, Pat et Bob : Tom a un chapeau rouge, Pat a un chapeau vert et Bob, un chapeau bleu. Bob n'est pas bleu, Bob c'est Bob. Et bleue est la couleur de son chapeau. Bob c'est la valeur de l'indice de la case, et bleu c'est la valeur dans la case.

[domxaline]

alors,
i<nb-1 veut dire
0<3-1
est ce que c'est ça?

[joel.drigo]

alors,
i<nb-1 veut dire
0<4-1
est ce que c'est ça?

Bah quand i vaut 0 et nb vaut 4 oui. Mais dans ton déroulement de programme tu as "Entrez le nombre de valeur<10 = 3", donc nb vaut 3 ici.
Ensuite, à chaque itération, i est incrémenté. Au début i vaut 1 (i=1 !), donc le premier test i<nb-1 qu'on fait c'est 1<3-1 !
Ajoute des traces à ton programme pour afficher chaque variable si tu ne sais pas le faire en mode debug :

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
import java.util.Scanner;
public class Test4 
{
	 public static void main(String[] args) 
	 {   
		     boolean flag;
		     Scanner sc=new Scanner(System.in);
		     System.out.print("Entrez le nombre de valeur<10 = ");
		     int nb=sc.nextInt();
		     System.out.println("Saisie du nombre de valeurs : nb vaut " + nb); // TRACE
		     int tab[]=new int[nb];
		     for( int i=0; i<nb; i++ )
		     {
		       System.out.print("Entrez les nombres :"+(i+1)+" = ");		
		       tab[i] = sc.nextInt();
			   System.out.println("Saisie de tab[i] = tab["+i+"] = "+tab[i]); // TRACE
		     }
		     flag = true;
		     int i=1;
			 System.out.println("Tant que tab[i] != tab[i-1] + 1 && i < nb-1 avec i = "+i+ " correspond à tab["+i+"] != tab["+(i-1)+"] && " + i + " < nb - 1, soit " + tab[i] + " != " + tab[i-1] + " && " + i + " < " + (nb-1) + " qui est " + (tab[i] != tab[i-1] + 1 && i < nb-1)); // TRACE
		     while ( tab[i] != tab[i-1] + 1 && i < nb-1 )
		     {
				 System.out.print("on incrémente i qui vaut "+ i); // TRACE
		        i = i+1;
				 System.out.println(" et qui vaut après incrémentation " + i); // TRACE
				 System.out.println("Tant que tab[i] != tab[i-1] + 1 && i < nb-1 avec i = "+i+ " correspond à tab["+i+"] != tab["+(i-1)+"] && " + i + " < nb - 1, soit " + tab[i] + " != " + tab[i-1] + " && " + i + " < " + (nb-1) + " qui est " + (tab[i] != tab[i-1] + 1 && i < nb-1)); // TRACE
				 System.out.println();
		     }
			 System.out.println("on teste si tab[i] == tab[i-1] + 1 avec i = "+i+ " soit tab["+i+"] == tab["+(i-1)+"] qui est " + (tab[i] == tab[i-1] + 1)); // TRACE
		     if( tab[i] == tab[i-1] + 1 )
		     {
		        System.out.println("Les nombres sont consécutifs");
		     }
		     else  
		     {
		        System.out.println("Les nombres ne sont pas consécutifs");
		     }
		   }
		 }

[domxaline]

merci beaucoup, j'ai compris