Discussion :

[LauraRL]

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
 
public class JavaApp {
	public static Boolean canBalance(int [] table)
	{
		if (table.length<1)
		{
			return false;
		}
		int leftSum = 0;
		int rightSum = 0;
		for (int i = 0; i<table.length; i++)
		{
			leftSum = leftSum + table[i];
			rightSum = 0;
			for (int j = i+1; j<table.length; j++)
			{
				rightSum = rightSum + table[j];
			}
		}
		if (leftSum == rightSum)
			return true;
		return false;
	}
 
	public static void main (String[] args)
	{
		int table[]={1,1,1,2,1};
		Boolean result = canBalance(table);
		System.out.println(result);
	}
}

Dans ce programme doit parcourir le tableau et voir si on peut séparer le tableau en deux de tel sorte que la somme des nombres se trouvant de le tableau de droite soit égale à celle de gauche. Sauf que ici j'ai false qui s'affiche alors que je dois avoir true... Est ce que quelqu'un peut m'indiquer d'où vient l'erreur?

[joel.drigo]

Salut,

Ton programme ne fait pas du tout ce qu'il est censé faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
for (int i = 0; i<table.length; i++) {
			leftSum = leftSum + table[i];
}

donc leftSum est la somme de tous les éléments.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
rightSum = 0;
for (int j = i+1; j<table.length; j++) {
   rightSum = rightSum + table[j];
}

Pour chaque i, on calcule la somme des suivants. Donc lorsque i vaut table.length-1 (la dernière itération), j vaut, au départ, table.length, donc n'est pas inférieur à table.length. On n'entre donc pas dans la boucle : rightSum reste à 0.
A moins que le tableau ne contienne que des 0, la somme de tous ses éléments n'est jamais égale à 0 !


Pour calculer la somme des éléments à gauche, il suffit de boucler de 0 à table.length/2. Et pour celle des éléments de droite, de boucle à partir de table.length/2 jusqu'à la fin. Attention toutefois aux tableaux qui ont un nombre impair d'éléments : ne doivent-ils pas ne pas être traités ? Si oui, il faudra s'arranger pour la valeur du milieu soit neutre : soit elle n'est intégrée dans aucune des 2 sommes, soit elle doit l'être dans les deux.

Si le traitement doit être effectué en une seule boucle, il suffit d'avoir un booléen qui soit faux avant table.length/2 puis vrai ensuite (donc passe de faux à vrai à la moitié du tableau) ,ou simplement comparer i à table.length/2 :

Code pseudocode(si table.length%2==0) :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
leftSum=rightSum=0
pour tous les i tels que 0 <= i < table.length
   si  i < table.length/2 alors 
      leftSum <- leftSum + table[i]
   sinon
      rightSum <- rightSum + table[i]
   fin si
fin pour

On pourrait aussi utiliser l'astuce de n'utiliser qu'une seule variable somme, et d'ajouter tant que moitie est faux, puis de retirer quand moitie est vrai : si la somme est égale à 0 à la fin, alors la somme de droite et de gauche sont égales. Mais cette astuce n'apporte pas grand chose (ni plus optimisé ni moins, ni plus complexe ni moins, juste une variable en moins) si ce n'est rendre un peu plus obscur ce que fait le programme à la lecture.

[EDIT]Par ailleurs, je n'avais pas remarqué :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public static Boolean canBalance(int [] table)

boolean pas Boolean. C'est toujours mieux d'utiliser le type primitif lorsque c'est possible.

[LauraRL]

D'accord merci beaucoup =)