Discussion :

[Wise_Sherkaan]

Bonsoir,

Je suis NUL de chez NUL en algo....et je n'arrive pas à effectuer une simple sous-totalisation...

Mon but est d'écrire toute les lignes d'une liste, en insérant une ligne de sous-totalisation à rupture sur un attribut de type String.
Classe Java utilisée

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
import java.math.BigDecimal;
 
public class FondsMontant
{
 
	private BigDecimal montant;
 
	private String codeFonds;
 
	public FondsMontant(BigDecimal montant, String codeFonds)
	{
		super();
		this.montant = montant;
		this.codeFonds = codeFonds;
	}
 
	/**
         * @return the montant
         */
	public BigDecimal getMontant()
	{
		return montant;
	}
 
	/**
         * @param montant the montant to set
         */
	public void setMontant(BigDecimal montant)
	{
		this.montant = montant;
	}
 
	/**
         * @return the codeFonds
         */
	public String getCodeFonds()
	{
		return codeFonds;
	}
 
	/**
         * @param codeFonds the codeFonds to set
         */
	public void setCodeFonds(String codeFonds)
	{
		this.codeFonds = codeFonds;
	}
 
 
 
}

Début de codage de la sous-totalisation :

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
public class DateTest extends TestCase
 
{
 
	public void testerRupture()
	{
 
		BigDecimal sousTotal = BigDecimal.ZERO;
		String fondsPrecedent = "ceci nest pas un fonds";
 
		List<FondsMontant> liste = new ArrayList<FondsMontant>();
 
		FondsMontant fm1 = new FondsMontant(new BigDecimal("1.1"), "code1");
		FondsMontant fm2 = new FondsMontant(new BigDecimal("2.2"), "code1");
		FondsMontant fm3 = new FondsMontant(new BigDecimal("3.3"), "code1");
		FondsMontant fm4 = new FondsMontant(new BigDecimal("4.4"), "code2");
		FondsMontant fm5 = new FondsMontant(new BigDecimal("5.5"), "code2");
		FondsMontant fm6 = new FondsMontant(new BigDecimal("6.6"), "code2");
		liste.add(fm1);
		liste.add(fm2);
		liste.add(fm3);
		liste.add(fm4);
		liste.add(fm5);
		liste.add(fm6);
 
		for (FondsMontant fondsMontant : liste)
		{
 
 
			if (fondsPrecedent.compareTo(fondsMontant.getCodeFonds()) == 0)
			{
				sousTotal=sousTotal.add(fondsMontant.getMontant());
 
				System.out.println(fondsMontant.getCodeFonds() + " - "
						+ fondsMontant.getMontant());
				System.out.println(sousTotal);
			}
			else
			{
 
				fondsPrecedent = fondsMontant.getCodeFonds();
 
				sousTotal=BigDecimal.ZERO;
 
 
			}
			System.out.println(fondsMontant.getCodeFonds() + " - "
					+ fondsMontant.getMontant());
			System.out.println(sousTotal);
 
 
		}
 
	}
 
}

Si vous pouviez m'aider pour l'algo au moins.....j'ai honte!
Cordialement,
Sherkaan

[joel.drigo]

Salut,

Tu n'es pas si loin de la solution : comme tu l'indiques dans ton énoncé, il faut insérer une ligne lorsqu'il y a rupture, c'est-à-dire lorsque précédent!=courant, donc dans le else, il devrait y avoir l'affichage du sous-total du groupe précédent (donc avant de mettre à zéro le sosu-total).Il y a juste un cas particulier la rupture au tout début, qu'il faut exclure, par un moyen ou un autre (valeur particulière de l'attribut de rupture, index de ligne, boolean d'exclusion...). Et il y a le cas particulier de la rupture à la fin (en dehors de la boucle, après).
Le montant de chaque ligne devant être pris en compte, l'ajout du montant de la ligne courante devrait être en dehors du if comme du else (ou dans les 2, mais ce de la duplication de code inutile)
Les lignes doivent toujours être affichées, donc en dehors du if et du else, après le sous-total (puisqu'il concerne les lignes d'avant). Accessoirement, autant tester l'égalité par equals(), plutôt que de faire un compareTo()==0.

L'algorithme en résumé :

Code pseudocode :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
s'il existe des lignes 
    pour toutes les lignes
       si rupture 
          afficher sous-total
          remettre à zéro sous-total
       fin si
       cumuler sous-total
       afficher la ligne
   fin pour
   afficher sous-total
fin si

Soit

Code pseudocode :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
codefond = null
initialiser soustotal à 0
pour toutes les lignes
    si codefond est null // rupture particulière du début : on affiche pas de sous-total (le reste peut-être exactement pareil pour les deux
       codefond = ligne.codefond
    sinon si codefond différent de ligne.codefond (rupture)
       afficher sous-total
       remettre à zéro sous-total
       codefond = ligne.codefond
    fin si
    ajouter ligne.montant ) sous-total
    afficher la ligne
fin pour
afficher sous-total

Accessoirement, en Java8, on peut le faire comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
liste.stream()
     .collect(Collectors.groupingBy(FondsMontant::getCodeFonds, LinkedHashMap::new, Collectors.toList()))
     .entrySet()
     .forEach(e-> {
                   System.out.println("Sous-total: " + e.getValue().stream()
                                                                   .peek(System.out::println)
                                                                   .map(FondsMontant::getMontant)
                                                                   .reduce(BigDecimal.ZERO, BigDecimal::add));
		  }
             );

[Wise_Sherkaan]

Bonjour, et merci d'avoir pris le temps.....je vais commencer par comprendre l'algo et le pseudo code

J'ai toujours été nul avec tout ça...pourtant, ce n'est que de la logique

Bonne journée!!!!

[joel.drigo]

Il est difficile de te donner une méthode genre recette de cuisine pour déterminer un algorithme (qui ne soit pas un algorithme standard qui existe déjà et qu'on peut trouver facilement tout fait sur le web).
Tout ce que je peux te conseiller, c'est d'essayer de faire sur papier ce que ton programme est censé faire, en décomposant chaque tâche, et en notant ce chacune de ces tâches élémentaires. Découper le problème en sous-problèmes, forcément plus simples, aide souvent. Dans ton cas, on peut déjà diviser le problème en 3 :

1. afficher les FondMontants (afficher une liste donc)
2. calculer les sous-totaux
3. afficher les sous-totaux

Pour afficher une liste, il faut l'avoir appris : en cours, dans un tutoriel, en ayant regarder le code d'autres personnes, etc...

En écrivant la liste sur papier, puis en insérant le sous-totaux aux bons endroits, on remarque qu'on doit les afficher lorsqu'il y a rupture (quand le code change entre 2 lignes), ce que tu as pu faire sans problème (donc tu n'es pas nul). Remarquer que la première ligne et la dernière ligne ont quelque chose de spécial demande de connaitre un minimum le langage (mais on peut aussi le remarquer après la première exécution aussi : c'est tout à fait le genre de chose qu'un débutant ne traitera pas de prime abord, mais remarquera comme bug à la premièr exécution, et c'est normal) : ici, le fait de devoir comparer 2 lignes successives est impossible entre la première ligne et celle qui se trouve avant (elle n'existe pas). Idem pour comparer la dernière et la suivante de la dernière, avec en plus le fait qu'on se trouve en dehors de la boucle, puisqu'on y traite forcément des lignes qui existent. On pourrait s'arranger pour que la boucle intègre ces lignes (avant la première et après la dernière) avec des tests, qui alourdirait le code.

Pour la calcul des sous-totaux, on peut voir simplement qu'on doit traiter toutes les lignes qui ont le même code : en déduire qu'on peut le faire au fur et à mesure du traitement dans la boucle n'est pas évident à déduire avec une méthode toute faite. Pour moi, c'est le genre de chose qu'on apprend et qu'on reproduit : seule l'expérience te permettra de le faire tout seul. En attendant, regarde et étudie ce que les autres font.

Autre conseil : ce n'est pas un problème d'écrire un code qui fait beaucoup trop de chose et de façon compliquée au début. Tant que ça résout le problème. Quand le programme fonctionne : tu peux plus facilement voir comment le modifier pour qu'il soit moins compliqué (supprimer les répétitions, les tests inutilement compliqués, limiter le nombre de variable (sans utiliser la même variable pour plusieurs choses différentes évidemment), etc...)

On aurait pu aborder ton problème en disant :

Code pseudocode :

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

1
2
3
4
5
6
 
pour chaque code 
    afficher toutes les lignes avec ce code
    calculer le total des lignes avec ce code
    afficher ce total
fin pour

Ce qui revient à peu de choses près au découpage dont j'ai parlé ci-avant, donc ce pseudo-code aurait pu en être déduit.

En le transformant en :

Code pseudocode :

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

1
2
3
4
5
6
7
8
9
10
11
 
pour chaque code 
    pour chaque ligne avec ce code
         affiche ligne
    fin pour
    total = 0
    pour chaque ligne avec ce code
         total = total + montant de la ligne
    fin pour
    afficher total
fin pour

On peut voir que :

1. qu'on boucle 2 fois sur les lignes de même code, donc on peut réfléchir à la façon de le faire avec une seule
2. on peut voir qu'on a besoin d'avoir séparément les lignes de même code, ce qui peut se faire par recherche( avoir une méthode List<FondMontant> getFondModants(String code), ou par tri : ce qui permet déjà de voir qu'il faut que notre liste soit triée par code, si on veut tout traiter en une seule boucle
3. ...