Discussion :

[MattCand]

Bonjour^^
Je cherche à comparer les valeurs et les clés d'une Hashtable, elle-même contenue dans une Hashtable en tant que valeur (Hashtable<String, Hashtable>), avec d'autres Hashtables; Je ne sais pas du tout comment m'y prendre >< Need help =)

[tchize_]

tu pourrais préciser quels sont tes critères de comparaison et pourquoi la méthode equals ne te convient pas?

[MattCand]

En gros, je dois créer une méthode makeable (Hashtable ingrédients, Hashtable recette) qui doit retourner la liste des recettes possibles avec les ingrédients disponibles.

On a ingrédients<nom, quantité> et recette<nom, <ingédients qu'il faut> > mais je ne sais pas comment manipuler tout ça...

[tchize_]

Le mieux serait ceci comme structure

List<Ingredient> (listes des ingrédients)

et Map<Recette,List<Ingredient>> (liste des recetes avec pour chaque une liste d'ingrédients)

ensuite tu parcoure tes recettes:

Code :

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

1
2
3
4
5
6
7
8
9
 
List<Recette> makeable(Map<Recette,List<Ingredient>>  recettes,  List<Ingredient> disponibles){
  List<Recette> result = new ArrayList<Recette>();
  for (Map.Entry<Recette,List<Ingredient>> element : recettes.entrySet()){
    if (disponible.containsAll(element.getValue())
        result.add(element.getKey());
  }
  return result;
}

autre option

Code :

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

1
2
3
4
5
6
7
8
9
 
List<Recette> makeable(List<Recette> recettes,  List<Ingredient> disponibles){
  List<Recette> result = new ArrayList<Recette>();
  for (Recette recette: recettes){
    if (disponible.containsAll(recette.getIngredients())
        result.add(recette);
  }
  return result;
}

[MattCand]

Merci pour ta réponse, mais je ne vois pas comment une liste pourrait stocker l'ingrédient PLUS la quantité disponible...
Ma Hashtable inventaire est comme ceci :
sucre 5
sel 2
oeufs 3

et et recette comme ça :
gateau : sucre 2 oeuf 1
omelette : sel 1 oeufs 2

[tchize_]

dans ce cas, tu fais deux boucles imbriquée et tu fais tout à la main.

[bhamp0]

Tu fais un objet "Nourriture", qui a 2 attributs :
* 1 String : l'ingrédient lui-même
* 1 Integer : la quantité

Après, tu fais un objet "Inventaire", qui a 2 attributs :
* 1 String : le nom du proprio du frigo [on ne fait jamais un programme que pour soi-même, il faut prévoir l'évolution]
* 1 List<Nourriture>

Et tu fais un objet "Recette", qui a 2 attributs :
* 1 String : le nom de la recette
* 1 List<Nourriture> : l'ensemble des ingrédients de la recette


Par contre, ce que je constate, c'est qu'il faudrait voir pour définir correctement ta comparaison, car faire un equals est légèrement bête : si on imagine que tu as 3 oeufs dans ton frigo, et que ta recette en demande 2, je pense qu'il faudrait répondre OK sur le fait qu'on peut faire la recette. Je verrais plutôt un "contains" plutôt qu'un "equals".

[MattCand]

Merci mais le problème est que je dois scrupuleusement respecter les entreées et la sortie de la méthode makeable, qui prend en paramètres deux Hashtables et qui renvoie une Arraylist.

Je suis désolé mais je ne comprends pas l'histoire de la double boucle imbriquée =S Pourrais-tu être plus concret?

[tchize_]

ben tu parcoure ta liste de recette (1ère boucle) et pour chaque recette tu parcoure la liste des ingrédients nécessaires (deuxième boucle), et pour chacun tu regarde si il y en a assez de dispo. Si pas tu passe à la recette suivante.

[MattCand]

J'ai essayé mais il me renvoie pleins d'erreurs de compilation...

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
 
 
Enumeration e = ingredients.elements();
Enumeration k = ingredients.keys();
Enumeration e1 = recettes.elements();
Enumeration k1 = recettes.keys();
 
 
 
 
 
while(e1.hasMoreElements()) {
			 Enumeration z = ((Hashtable) e1.nextElement()).keys();
			 Enumeration z1 = ((Hashtable) e1.nextElement()).elements();
			 while(z.hasMoreElements()) {
				 while(k.hasMoreElements()) {
 
					 if (z.nextElement().equals(k.nextElement())) {
						 if (Integer.parseInt(e1.nextElement().toString()) >= Integer.parseInt( z1.nextElement().toString())) {
							 System.out.println(e1.nextElement().toString());
 
						 }
					 }
 
				 }
 
 
 
				 //System.out.println(z.nextElement().toString());
			 } 
 
		}

[Fifan31]

Si la signature de makable ne t'est pas imposéé, tu peux utiliser cette implémentation

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public List<Recette> makable(Map<String, Integer> ingrediantsDisponibles,
			List<Recette> recettes) {
		List<Recette> recettesRealisables = new LinkedList<Recette>();
 
		for (Recette recette : recettes) {
			if (recette.canBeDoneWith(ingrediantsDisponibles)) {
				recettesRealisables.add(recette);
			}
		}
 
		return recettesRealisables;
	}

Avec la classe recette:

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
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
 
public class Recette {
	private String nom;
	private Map<String, Integer> ingrediants = new HashMap<String, Integer>();
 
	public Recette(String nom, Map<String, Integer> ingrediants) {
		super();
		this.nom = nom;
		this.ingrediants = ingrediants;
	}
 
	public void addIngrediant(String ingrediant, int quantite) {
		ingrediants.put(ingrediant, quantite);
	}
 
	/**
         * @return the nom
         */
	public String getNom() {
		return nom;
	}
 
	/**
         * @param nom
         *            the nom to set
         */
	public void setNom(String nom) {
		this.nom = nom;
	}
 
	/**
         * @return the ingrediants
         */
	public Map<String, Integer> getIngrediants() {
		return ingrediants;
	}
 
	/**
         * @param ingrediants
         *            the ingrediants to set
         */
	public void setIngrediants(Map<String, Integer> ingrediants) {
		this.ingrediants = ingrediants;
	}
 
	public boolean canBeDoneWith(Map<String, Integer> ingrediantsDisponibles) {
		boolean canBeDone = true;
		Iterator<Entry<String, Integer>> iterator = ingrediants.entrySet()
				.iterator();
// Tant que la recette reste realisable
// On itère sur les ingrediants necessaires
		while (iterator.hasNext() && canBeDone) {
			Entry<String, Integer> ingrediantNecessaire = iterator.next();
 
// La recette est realisable si ...
			canBeDone = 
// ... on dispose des ingrediants necessaires
ingrediantsDisponibles.containsKey(ingrediantNecessaire.getKey()) &&
// ... en quantité suffisante
ingrediantsDisponibles.get(ingrediantNecessaire.getKey())>=ingrediantNecessaire.getValue(); 
		}
 
		return canBeDone;
	}
 
}

Le tout avec un semblant de test rapide

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
/**
         * @param args
         */
	public static void main(String[] args) {
		Map<String, Integer> ingrediantsDansLeFrigo = new HashMap<String, Integer>() {
			{
				put("Persil", 4); 
				put("Oeuf", 5);
				put("Farine", 200); // 200g
				put("Lait", 400); // 4 briques de 1L
//				put("Beurre", 500);
			}
		};
 
		Recette crepes = new Recette("Crepes", new HashMap<String, Integer>() {
			{
				put("Oeuf", 2);
				put("Farine", 200);
				put("Lait", 100);
			}
		});
		Recette bechamel = new Recette("Sauce béchamel",
				new HashMap<String, Integer>() {
					{
						put("Beurre", 100);
						put("Farine", 100);
						put("Lait", 100);
					}
				});
 
		List<Recette> recettes = new ArrayList<Recette>(2);
		recettes.add(crepes);
		recettes.add(bechamel);
 
		List<Recette> makable = makable(ingrediantsDansLeFrigo,
				recettes);
		for (Recette recette : makable) {
			System.out.println(recette.getNom());
		}
 
	}