Discussion :

[master MI]

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.

[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.. ?

[master MI]

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 :

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

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?

[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 ?

[master MI]

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?

[master MI]

J'ai donc fait le code suivant:

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
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.

[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 :

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

1
2
3
 
Arrays.sort(numbers);
int smallestInterval = numbers[1] - numbers[0]

[master MI]

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?

[master MI]

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.

[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 :

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

1
2
3
4
5
 
Arrays.stream(numbers)
    .sorted()
    .limit(2)
    .reduce((small, big) -> big-small)

[master MI]

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.

[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.

[master MI]

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

Code :

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

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?

[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 :

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

1
2
3
4
5
new BiFunction<Integer, Integer, Integer>{
  public Integer apply(Integer small, Integer big) {
    return big - small;
  }
}

[master MI]

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 :

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

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?

[gervais.b]

Le mieux serait de créer une nouvelle question.

[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]

[master MI]

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

[master MI]

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 :

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

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 :

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

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é.

[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)