Problème sur un algorithme

Version imprimable

20/01/2014, 17h17
tamerla

Problème sur un algorithme

Salut,
J'ai un petit problème sur un algorithme, avec des tableaux d'entiers, que je n'arrive pas a résoudre. Voici l'énoncé : "Un livre décrit les achats et ventes successives de 10 produits numérotés de 1 à 10. Au depart, Le stock de chacun des produits est de 0.
Chaque ligne du livre décrit l'achat ou la vente d'une certaine quantité de l'un des produits.
Votre objectif est de déterminer pour chaque produit, la quantité restant dans le stock à l'issue de l'ensemble de ces achats et ventes."

On doit entrer au clavier un ingrédient et faire une opération pour celui-ci. Au départ, j'ai donc pensé à créer un tableau de taille 10 où chaque indice correspondrait au numéro de l'ingrédient. Le problème est que je ne sais pas comment remplir le tableau, vu que c'est l'utilisateur qui choisit l'ingrédient (l'indice). Ça parait surement bête, mais je n'ai jamais été confronté à ce genre de problème. Merci de votre aide:mrgreen:
21/01/2014, 00h51
joel.drigo

Salut,

Gérer le stock par un tableau est une bonne idée pour commencer ; ça le mérite d'être simple et adapté au fait que les produits sont identifiés par des numéros. Chaque valeur correspondant au stock de chaque produit, initialisé à 0, d'après l'énoncé.
Chaque opération saisie correspond à un numéro de produit, à une quantité, et à un type d'opération (mettons Vendre ou Acheter). Utilises par exemple la classe Scanner pour lire donc 2 nombres (numéro de produit et quantité) et 1 mot, par exemple, pour l'opération (Vendre ou Acheter).
Le numéro de produit est donc tout simplement l'indice dans le tableau (éventuellement décalé de -1, si tes numéros de produit vont de 1 à n, alors que les indices de tableaux vont de 0 à 9).
Dans le cas de Acheter, et que le stock disponible est suffisant (afficher un refus dans le cas contraire), la valeur du stock sera diminuée de la quantité achetée, et dans le cas de Vendre, la quantité sera augmentée de la quantité vendue.
A la fin, les valeurs de stock contenues dans le tableau sont l'état du stock, pour chaque produit.

Bonjour,

En effet, cet exercice est relativement simple. Je te propose deux solutions imparfait pour ce problème. Cependant, tu devrais tenter de réaliser ta solution avant même de les regarder. Sinon tu peux les améliorés en pensant au cas limites. (stock insuffisant / produit inexistant etc...) Changer la structure pour avoir aussi l'historique des entrées/sorties ?

Cordialement,
Patrick Kolodziejczyk.

Code:

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
package org.k.developpez.forum;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
 
public class SellRegistry {
	public static Map<String, Integer> stockLine = new HashMap<>();
 
	public static void main(String[] args) throws IOException {
		initStock();
		do {
			displayStock();
		} while (doEntry());
	}
 
	private static void initStock() {
		for (int i = 0; i < 10; i++) {
			stockLine.put(String.valueOf(i+1), new Integer(0));
		}
	}
 
	private static void displayStock() {
		System.out.println("Les quantité actuelles sont :");
		for (String productName : stockLine.keySet()) {
			System.out.println(productName+" : "+stockLine.get(productName));
		}
	}
 
	private static boolean doEntry() throws IOException {
		/** Convertion du flux en BufferedReader */
		BufferedReader entree = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Entrez l'identifiant du produit ('x pour sortir')");
		String productName = entree.readLine();
		// Gestion rapide de la fin du programme
		if ("x".equals(productName)) {
			return false;
		}
		System.out.println("Entrez la quantité entré en stock (- si sortie)");
		String quantityAsString = entree.readLine();
		Integer quantity = new Integer(quantityAsString);
		if (stockLine.containsKey(productName)) {
			Integer oldQuantity = stockLine.get(productName);
			Integer newQuantity = new Integer(oldQuantity + quantity);
			stockLine.put(productName, newQuantity);
		} else {
			// Cas d'un nouveau produit
			stockLine.put(productName, quantity);
		}
		return true;
	}
}

Code:

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
package org.k.developpez.forum;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class SellRegistry {
	public static int[] stockLine = new int[10];
 
	public static void main(String[] args) throws IOException {
		do {
			displayStock();
		} while (doEntry());
	}
 
	private static void displayStock() {
		System.out.println("Les quantité actuelles sont :");
		for (int i = 0; i < stockLine.length; i++) {
			System.out.println(i+" : "+stockLine[i]);
		}
	}
 
	private static boolean doEntry() throws IOException {
		/** Convertion du flux en BufferedReader */
		BufferedReader entree = new BufferedReader(new InputStreamReader(System.in));
		System.out.println("Entrez l'identifiant du produit ('x pour sortir')");
		String productName = entree.readLine();
		int productId = Integer.parseInt(productName);
		// Gestion rapide de la fin du programme
		if ("x".equals(productName)) {
			return false;
		}
		System.out.println("Entrez la quantité entré en stock (- si sortie)");
		String quantityAsString = entree.readLine();
		Integer quantity = new Integer(quantityAsString);
		if (productId>-1 && productId< stockLine.length) {
			Integer oldQuantity = stockLine[productId];
			int newQuantity = oldQuantity + quantity;
			stockLine[productId] = newQuantity;
		}
		return true;
	}
}

ok merci pour vos réponses.
Kolodz sympa pour les codes mais j'en suis pas a la niveau programmation, on est encore a la "base" pour l'instant , donc je comprends presque rien mais merci quand meme :mrgreen: .

Voila ce que jai fait :
Code:

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 import java.util.Scanner; class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int nbOperations = sc.nextInt(); int ingredient = 10; int somme = 0; int[] t = new int[ingredient]; for(int i = 0; i < nbOperations; i++) { int j = sc.nextInt(); t[j] = sc.nextInt(); somme = somme + t[j]; t[j] = somme; somme = 0; } System.out.println(); for(int i = 0; i < t.length; i++) { System.out.println(t[i]); } } }
Donc il est pas tout a fait bon car a la fin, je veuix qui'il m'affiche le stock restant pour chaque produit or si je choisis par exemple une premiere fois l'ingrédient 1 et que j'attribue une valeur a la case, il va oublier la valeur que j'ai deja mise et ne va pas l'additionner avec la nouvelle, comment je peux r égler le probleme? Et comment je peux faire pour que l'ingrédient 1 corresponde a la case d'indice 0?

Bon jen demande peut etre un peu trop mais ce me bloque :aie:

21/01/2014, 17h21
joel.drigo
Salut,

Dans le code qui suit (extrait du tiens), on lit un int sur l'entrée standard et on le met dans la case du tableau censé stocker le stock pour le produit d'indice j : donc on écrase la valeur de stock.

Code:

t[j] = sc.nextInt();

Ensuite, ici :
Code:

1 2 3 somme = somme + t[j]; t[j] = somme; somme = 0;
On ajoute à une variable qui vaut 0, la valeur qui est dans le tableau, donc celle qu'on vient de lire. Puis on la stocke dans le tableau, à la bonne place. Puis on remet somme à zéro, qui sera bien toujours à zéro lorsqu'on y ajoute t[j].
Donc en gros ce code fait :
Code:

1 2 somme = 0 + t[j] donc somme = t[j] t[j] = somme donc, vu la ligne dessus, t[j] = t[j].
En résumé, ton code ne fait que stocker la valeur lue au clavier dans t[j].

Utilises plutôt une variable locale, pour stocker la valeur lue au clavier :
Code:

1 2 3 int quantite = sc.nextInt(); somme = t[j] + quantite; // on incrémente le stocke qui se trouve dans t[j] t[j] = somme; // on stocke le résultat dans t[j], pour mémoriser le nouveau stocke
La, tu vois qu'on peut même se passer de somme, en écrivant :
Code:

1 2 int quantite = sc.nextInt(); t[j] = t[j] + quantite; // on incrémente le stock qui se trouve dans t[j]
21/01/2014, 18h03
tamerla

ok j'ai fini l'exercice, merci de tes explications
21/01/2014, 18h39
joel.drigo

Citation:

Envoyé par tamerla

ok j'ai fini l'exercice, merci de tes explications

Mouais, je suis pas aussi sûr que toi : dans ton code, il n'y a pas la vente (tu augments le stock, mais tu ne le diminue jamais). Mais, bon, c'est toi qui voit.

sisi je t'assure le site m'a validé mon code, je te le copie ici :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.Scanner;
 
class Main {
 
    public static void main(String[] args) {
   Scanner sc = new Scanner(System.in);
 
   int nbOperations = sc.nextInt();
   int ingredient = 10; 
   int[] t = new int[ingredient];
 
   for(int i = 0; i < nbOperations; i++) {
       int j = sc.nextInt();
       int quantite = sc.nextInt();
       t[j-1] = t[j-1] + quantite;
   }
 
   System.out.println();
   for(int i = 0; i < t.length; i++) {
       System.out.println(t[i]);
   }
    }
}

vu que c'est l'(utilisateur qui entre les quantités je peux tres bien decider de rentrer aussi bien une vente qu'un achat donc ca fonctionne (une vente correspondant a une valeur negative)

21/01/2014, 19h53
joel.drigo

Si ce code est validé, c'est bien pour rendre l'exercice. On peut effectivement gérer une vente par une quantité négative, mais c'est vraiment parce que c'est un exercice de base. Mais, sans parler de gestion d'erreur minimum (on en est loin), tolérer les stocks négatifs me semblait juste étonnant.
21/01/2014, 23h52
kolodz

Il est très bien son code ! Simple et explicite. Bravo !
Bonne continuation pour la suite.

Cordialement,
Patrick Kolodziejczyk.