FindsmallInterval(numbers) et calcultotalprice()

Version imprimable

07/10/2020, 10h58
master MI

FindsmallInterval(numbers) et calcultotalprice()

Bonjour,
j'ai 2 fonctions ou méthodes à implémenter en java ,j'ai cherché pendant longtemps
les solutions mais je n'ai pas pu trouver encore,quelqu'un peut-il m'aider svp?ou
m'apporter des indications.
07/10/2020, 11h56
gervais.b

Bonjour,

Est-ce que vous pourriez prendre la peine de re-copier les instructions dans votre question au lieu de nous rediriger vers un document Word.. ?
:roll:
07/10/2020, 12h28
master MI

Re
D'accord
je dois implémenter la méthode findSmallestInterval(numbers)
qui retourne le plus petit intervalle positif entre 2 éléments du
tableau numbers(numbers est en fait un array de type int)
Par exemple: si je considère le tableau [1 6 4 8 2],le plus petit
intervalle est 1(différence entre 2 et 1).

Les contraintes que j'ai sont:
numbers contient au moins 2 éléments et
au maximum 100000 éléments.
La solution qui privilégie la vitesse d'execution pour les tableaux
de grande taille aura obtiendra le plus de points
La différence entre 2 éléments ne dépassera jamais la capacité
d'un entier pour votre langage

La méthode est la suivante:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class Solution{ public static int findSmallestInterval(int[] numbers){ //on écrit le code ici } return 0; }
Quelqu'un a t'il une solution svp?
07/10/2020, 12h38
gervais.b

C'est le genre d'exercice qu'il est plus intéressant de solutionner seul. Mais parfois on à besoin d'un petit peu d'aide pour démarrer notre réflexion.

1. Comment faites-vous pour connaitre l'intervale entre deux nombres ?
2. Comment '' '' '' '' '' '' deux elements de votre tableau ?

Quand vous avez ces réponses commencez par chercher le plus petite intervalle entre numbers[0] et numbers[n].

3. Comment calculer l'intervale entre tous les éléments du tableau ?
4. Comment trouver la plus petite ?

Lorsque vous avez une solution, vous pouvez commencer à vous poser les questions d'optimisations qui passerons peut-être par un tri.

5. Qu'est ce qui défini la plus petite intervalle; quels sont les caractéristiques de nombres qui ont servis à l'obtenir ?
07/10/2020, 13h00
master MI

Re

1) pour connaitre l'intervalle entre 2 nombres, on calcul la différence
2)pour connaitre l'intervalle entre 2 éléments du tableau,on cherche le nombre de combinaison de 2
éléments,et pour chaque combinaison trouvée on calcule la différence.
3)pour trouver le plus petit intervalle(la plus petite différence),on prend le minimum des différences trouvées

J'ai toutes ces réponses,maintenant comment je dois les traduire en code java?

J'ai donc fait le code suivant:

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
import java.util.Arrays;
 
public class FindSmallestInterval {
 
	public static void main(String[] args) {
 
		int[] numbers= {1, 6 ,4 ,8 ,2};
		System.out.println(findSmallestInterval(numbers));
 
 
	}
 
	 public static int findSmallestInterval (int [] numbers) {
	        // we write the code here
 
		 Arrays.sort(numbers);//i sorted it
		 int diff = numbers[1] - numbers[0];
		 int diffNeu = 0;
 
		 for(int i = 1; i < numbers.length-1; i++)
		 {
		     diffNeu = numbers[i + 1] - numbers[i];
		     if(diffNeu < diff)
		     {
		         diff = diffNeu;
		     }
		 }
	        ;
			return diffNeu;
	    }
 
}

Mais la solution qu'il me retourne est 2 quand je le compile alors qu'il doit me donner 1 comme solution
puisque le plus petit intervalle dans l'array numbers suivant {1 ,6, 4, 8, 2} est 1(différence entre 2 et 1).
Pourquoi mon code me donne t il 2?alors qu'il doit me donner 1.

07/10/2020, 14h40
gervais.b
Peut-etre que votre boucle est en cause.

Mais, si vous triez le tableau, il va les trier du plus petit au plus grand. Et la plus petite intervalle est celle entre les deux plus petits nombres. Donc, vous pouvez faire la différence entre les deux plus petits éléments du tableau pour obtenir la plus petite intervalle.
Code:

1 2 3 Arrays.sort(numbers); int smallestInterval = numbers[1] - numbers[0]
07/10/2020, 14h52
master MI

Re

Merci pour la piste,je dois donc chercher les 2 plus petits éléments de mon tableau
ensuite faire leur différence.
Je peux donc faire :
int min1=Arrays.stream(numbers).reduce(Integer::min).getAsInt();
il me donne directement le minimum de l'array en utilisant stream
int min2=??? //comment trouver le deuxième minimum de l'array?

ensuite je ferai la différence :int smallinterval=(min2-min1);
Mais comment trouver le deuxième minimum d'un array?
07/10/2020, 14h59
master MI

Re

Ah oui je viens de comprendre je n'ai pas besoin de faire une boucle for puisqu'il trie du plus petit
au plus grand je fais juste la différence entre numbers[1] et numbers[0],puis qu'il les a déjà
rangé du plus petit au plus grand.

Merci je n'avais pas compris et je viens de comprendre.
07/10/2020, 15h21
gervais.b
Avec plaisir.

Si vous voulez tenter la version avec un Stream je dirais qu'il faut le trier puis le limiter et ensuite le réduire.
Code:

1 2 3 4 5 Arrays.stream(numbers) .sorted() .limit(2) .reduce((small, big) -> big-small)
07/10/2020, 15h39
master MI

Re

Ouahou vous vous êtes un petit génie!!!,merci pour la proposition avec le Stream c'est plus moderne.
Je le teste tout de suite.
07/10/2020, 15h42
gervais.b

Je crains que non.

Notez que, d'après votre énoncé, les solutions les plus efficaces seront les mieux notées. Stream est sympa mais parfois moins performant.
07/10/2020, 15h58
master MI

Re
Je l'ai fait avec Stream et j'obtient le code suivant:
Code:

1 2 3 4 5 public static int findSmallestInterval1 (int [] numbers) { return Arrays.stream(numbers).sorted().limit(2).reduce((small, big)->(big-small)).getAsInt(); }
il fallait que j'ajoute un getAsInt() à la fin sinon il marchait pas.
Par contre , je ne comprends pas l'écriture ou la notation :(big,small)->(big-small),je sais que c'est une expression lambda
mais dans ce cas précis ça remplace quel code svp?
07/10/2020, 16h11
gervais.b
En effet, il faut un getAsInt car cette version du reduce renvoie un OptionalInt (si le stream est vide il n'y à rien à réduire et donc pas de valeur à retourner)

(small, big) -> big - small est en effet une expression lambda, c'est un raccourci pour
Code:

1 2 3 4 5 new BiFunction<Integer, Integer, Integer>{ public Integer apply(Integer small, Integer big) { return big - small; } }
07/10/2020, 16h42
master MI

Re
J'ai un autre exercice que j'ai cherché et j'ai pas encore trouvé:

Je voudrais implémenter une méthode calculateTotalPrice(),qui se trouve dans l'énoncé suivant:
"Vous travaillez pour un magasin qui souhaite offrir une réduction de "discount%" sur le produit le plus cher acheté par un client donné pendant la période des soldes.
Le responsable du magasin vous demande de développer la méthode calculateTotalPrice().
Cette méthode:
prend en paramètres la liste de prix des produits achetés par le client et le pourcentage de réduction" discount".
retourne le prix de vente total (arrondi à l'entier inférieur si le total ne tombe pas rond).
Contraintes:
0=<"discount"<=100
0=<prix d'un produit <100000
0<nombre de produits<100

Je dois donc implémenter calculateTotalPrice(),le code est le suivant:
Code:

1 2 3 4 5 6 7 8 9 10 public class CalculateTotalPrice { public static int calculateTotalPrice(int[] prices,int discount) { //write your code here return 0; } }
Comment puis je l'implémenter svp?
07/10/2020, 16h44
gervais.b

Le mieux serait de créer une nouvelle question.
07/10/2020, 17h37
thelvin

... Je suis à peu près sûr que trier le tableau ne garantit pas que le plus petit écart soit au début :

[1, 1000, 1010, 1012, 1013]
07/10/2020, 17h37
master MI

Re

D'accord je vais le créer à l'instant même

Salut , j'un petit soucis avec les 2 méthodes pour trouver le plus petit intervalle,
dans l'énoncé on me dit de choisir la méthode qui privilégie la vitesse d'exécution
pour les tableaux de grande taille(en effet le tableau peut contenir jusqu'à 100000 éléments).
Laquelle de ces 2 solutions est la plus rapide(privilégie la vitesse d'exécution) avec un tableau
de 100000 éléments?
Méthode 1:
Code:

1 2 3 4 5 6 7 8 9 public static int findSmallestInterval (int [] numbers) { // we write the code here Arrays.sort(numbers);//i sorted it int smallestInterval = numbers[1] - numbers[0]; return smallestInterval; }
Méthode2:
Code:

1 2 3 4 5 public static int findSmallestInterval1 (int [] numbers) { return Arrays.stream(numbers).sorted().limit(2).reduce((small, big)->(big-small)).getAsInt(); }
Je sais que la méthode 1 est O(nlog(n)) mais la méthode 2 je ne sais pas, je ne connais pas sa rapidité.

08/10/2020, 13h57
thelvin

Même chose. Note qu'elles sont toutes les deux incorrectes (puisqu'elles font la même chose écrite de deux manières différentes)
08/10/2020, 14h12
master MI

Re

Ah oui je viens de me rendre compte que trier le tableau ne garantit pas le plus petit
écart, vous avez raison oui,donc ces 2 méthodes sont incorrectes pour trouver le plus petit
écart,que dois je faire alors pour garantir le plus petit écart?

[1, 1000, 1010, 1012, 1013], en prenant votre exemple on voit que le plus petit écart
ne se situe pas au niveau des 2 plus petits éléments du tableau trié.
08/10/2020, 14h15
thelvin

Vérifier tous les écarts.

Mais sur un tableau trié, ça signifie simplement tester l'écart de chaque élément avec le suivant, puisque chaque élément se retrouve entouré de ceux qui sont le plus proches de lui.
08/10/2020, 14h19
master MI

Re

D'accord et j'implémente comment alors ma méthode ?

J'utilise donc la première solution que j'avais proposée c'est à dire:

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
import java.util.Arrays;
 
public class FindSmallestInterval {
 
	public static void main(String[] args) {
 
		int[] numbers= {1, 6 ,4 ,8 ,2};
		System.out.println(findSmallestInterval(numbers));
 
 
	}
 
	 public static int findSmallestInterval (int [] numbers) {
	        // we write the code here
 
		 Arrays.sort(numbers);//i sorted it
		 int diff = numbers[1] - numbers[0];
		 int diffNeu = 0;
 
		 for(int i = 1; i < numbers.length-1; i++)
		 {
		     diffNeu = numbers[i + 1] - numbers[i];
		     if(diffNeu < diff)
		     {
		         diff = diffNeu;
		     }
		 }
	        ;
			return diffNeu;
	    }
 
}

Je dois donc la corriger et l'améliorer

08/10/2020, 16h15
thelvin

Le problème, c'est juste que tu retournes diffNeu.
08/10/2020, 16h19
master MI

Re

Je dois donc retourner diff à la place de diffNeu,c'est ça que vous voulez dire?
08/10/2020, 16h27
thelvin

Il faudrait que tu essaies de travailler un peu tout seul. On est là pour aider, pas pour te dispenser d'apprendre. D'ailleurs, si tu ne veux pas apprendre, alors arrête juste ces exercices, quel intérêt de continuer ?

Des erreurs d'inattention qu'on n'arrive pas à trouver, ça nous est tous arrivé, c'est normal, on comprend. Mais une fois qu'on te la pointe du doigt, ça devrait être évident.
D'autant plus que tu aurais dû essayer de débugger ton code, et même si tu n'y arrivais pas sans aide, la réponse à ta dernière question est évidente quand on essaie de trouver le problème.
08/10/2020, 16h39
master MI

RE

D'accord je vais debugger et je suis sur la bonne piste

Fuseau horaire GMT +2. Il est actuellement 15h27.