Calcul de distances

Version imprimable

Calcul de distances

Bonjour,

Je bloque sur ce problème , je ne sais pas quoi faire ?

besoin d'une aide pour un début de code svp

Citation:

/*Calcul des distances
Dans le fichier fourni, définissez un méthode :
double calculerDistance(int x1, int y1, int x2, int y2)
qui calcule et retourne la distance entre les deux points (x1,y1) et (x2, y2)
passés en arguments.
Pour calculer la distance entre deux points (x1, y1) et (x2, y2), vous utiliserez
la formule suivante :
p = (x1 - x2)2 + (y1 - y2)2
Indication : Pour représenter la distance la plus importante possible entre le point
choisi pour la décharge et un habitation, vous pourrez utiliser la constante Java
Integer.MAX_VALUE*/

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
55
56
57
58
59
60
61
62
63
64
65
66
67
 
 
import java.util.Scanner;
import java.util.Arrays;
import java.text.DecimalFormat;
 
public class Decharge {
	private static DecimalFormat df = new DecimalFormat("#.000");
 
       /*******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
 
 
        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/
 
	public static void afficheTroisPlusProches(int x, int y, int[] coordonneesHabitations) {
		int[] tpp = troisPlusProches(x, y, coordonneesHabitations);
 
		System.out.println("(" + x + "," + y + ") est a :");
		for (int i = 0 ; i < 3 ; i++) {
			System.out.println("    " + df.format(calculerDistance(x, y, tpp[2*i], tpp[2*i+1])) + " de (" + tpp[2*i] + "," + tpp[2*i+1] + ")"); 
		}
	}
 
 
 
	//PROGRAMME PRINCIPAL
	public static void main(String args[]) {
 
		int[] coordonneesHabitations = {
				9, 30, 18, 8, 3, 18, 25, 36
		};
 
		// Lecture des donnees
		Scanner clavier = new Scanner(System.in);
		System.out.print("Entrez la coordonnee x de la decharge: ");
		int x = clavier.nextInt();
		System.out.print("Entrez le coordonnee y de la decharge: ");
		int y = clavier.nextInt();
 
		// trouve les coordonnees de l'habitation la plus proche
		// (identifiees par l'indice correspondant dans le tableau
		// de coordonnees)
		int plusProche = plusProche(x, y, coordonneesHabitations);
		System.out.println("--- Question 1 ---");
		System.out.println("Coordonnees de l'habitation la plus proche de la decharge :");
		System.out.println("(" + coordonneesHabitations[plusProche * 2] + "," + coordonneesHabitations[plusProche * 2 + 1] + ") ; distance = " +
						   df.format(calculerDistance(x, y, coordonneesHabitations[plusProche * 2], coordonneesHabitations[plusProche * 2 + 1]))  + " metres");	
 
		// trouve les coordonnees des 3 habitations les plus proches et affiche les coordonnees
 
		System.out.println("--- Question 2 ---");
		System.out.println("Coordonnees des 3 habitations les plus proches de la decharge :");
		afficheTroisPlusProches(x, y, coordonneesHabitations);
 
		// affiche le centre de gravite des 3 plus proches (la meilleure place)
		int[] grav = meilleurePlace(x, y, coordonneesHabitations);
		System.out.println("--- Question 3 ---");
		System.out.println("Coordonnees de la meilleure place pour la decharge :");
		System.out.println("(" + grav[0] + "," + grav[1] + ")");
		clavier.close();
	}
 
}

25/10/2014, 14h04
joel.drigo

Salut,

On te demande juste de créer une méthode appelée calculerDistance (à l'endroit signalé dans le code fourni) avec 4 paramètres (les coordonnées de 2 points), et d'appliquer la formule qu'on te donne (qui est incomplète d'ailleurs, mais c'est peut-être un problème de copier-coller : la bonne formule est dist(A,B) = racine carrée de ( (xA-xB) au carré + (yA-yB) au carré)) avec A=(xA,yA) et B=(xB,yB).

Quel problème as-tu pour faire ça (si c'est la méthode java pour calculer la racine carrée, c'est Math.sqrt()) ? Quel code as-tu déjà écrit ?
25/10/2014, 14h20
moras13

Bonjour Joel,
merci de me répondre
je dois créer une méthode en fin de programme pour une réutilisation pour mes conditions
j'ai pas mis de code pour l'instant ,c'est pour avoir un avis
merci
exemple de déroulement du programme :

int[] coordonneesHabitations = {
9, 30, 18, 8, 3, 18, 25, 36
};
Entrez la coordonnee x de la decharge: 10
Entrez le coordonnee y de la decharge: 15
--- Question 1 ---
Coordonnees de l’habitation la plus proche de la decharge :
(3,18) ; distance = 7.616 metres
--- Question 2 ---
Coordonnees des 3 habitations les plus proches de la decharge :
(10,15) est a :
7.616 de (3,18)
10.630 de (18,8)
15.033 de (9,30)
--- Question 3 ---
Coordonnees de la meilleure place pour la decharge :
(10,18)
25/10/2014, 14h28
joel.drigo

Bah, il suffit d'écrire la méthode et d'y appliquer la formule.

J'ai juste des doutes sur le sens de

Citation:

Indication : Pour représenter la distance la plus importante possible entre le point
choisi pour la décharge et un habitation, vous pourrez utiliser la constante Java
Integer.MAX_VALUE

Qu'est-ce que ça peut bien cacher comme idée ? Traiter l'overflow sur le calcul de la distance ? Je ne sais pas. Surtout que la distance résultat est à priori typée en double (vu qu'on l'affiche avec un DecimalFormat) : il y a une logique qui m'échappe dans cette indication.
25/10/2014, 14h44
moras13

Citation:

Envoyé par joel.drigo

Bah, il suffit d'écrire la méthode et d'y appliquer la formule.

J'ai juste des doutes sur le sens de

Qu'est-ce que ça peut bien cacher comme idée ? Traiter l'overflow sur le calcul de la distance ? Je ne sais pas. Surtout que la distance résultat est à priori typée en double (vu qu'on l'affiche avec un DecimalFormat) : il y a une logique qui m'échappe dans cette indication.

Citation:

exercice complet avec les contraintes du code initial
1 Exercice 1
1.1 Introduction
Votre commune cherche le meilleur endroit pour installer sa décharge publique.
Elle souhaite que sa décharge soit la plus éloignée possible des habitations. Les
habitations sont repérées par leur coordonnées x et y sur un plan à deux dimensions.
Comme la commune a déjà une idée de l’endroit où elle aimerait placer
la décharge, elle souhaite vérifier que la distance entre la position souhaitée et la
plus proche des habitations soit raisonnable et la placer de façon optimale près de
l’endroit envisagé.
Voici un exemple de configuration des données (les cercles désignent les habitations
et le carré, la position souhaitée pour la décharge) :
x
y
1
Télécharger le programme fourni sur le site du cours 1 et le compléter.
ATTENTION : vous ne devez modifier ni le début ni la fin du programme, juste
ajouter vos propres lignes à l’endroit indiqué. Il est donc primordial de respecter
la procédure suivante (les points 1 et 3 concernent spécifiquement les utilisateurs
d’Eclipse) :
1. désactiver le formatage automatique dans Eclipse :
Window > Preferences > Java > Editor > Save Actions
(et décocher l’option de reformatage si elle est cochée)
2. sauvegarder le fichier téléchargé sous le nom Decharge.java (avec
une majuscule, notamment). Si vous travaillez avec Eclipse vous ferez
cette sauvegarde à l’emplacement [dossierDuProjetPourCetExercice]/src/ ;
3. rafraîchir le projet Eclipse où est stocké le fichier (clic droit sur le projet >
refresh) pour qu’il le prenne en compte ;
4. écrire le code à fournir entre ces deux commentaires :
/*******************************************
* Completez le programme a partir d’ici.
*******************************************/
/*******************************************
* Ne rien modifier apres cette ligne.
*******************************************/
5. sauvegarder et tester son programme pour être sûr(e) qu’il fonctionne correctement,
par exemple avec les valeurs données plus bas ;
6. rendre le fichier modifié dans « OUTPUT
submission » (et non pas dans « Additional ! »).
Il s’agit donc ici de vous faire compléter le programme fourni pour trouver l’habitation
la plus proche de l’endroit souhaité pour la décharge, puis trouver une
position idéale.
La portion de code mise ainsi à disposition définit un tableau coordonneesHabitations
stockant les cordonnées des habitations de la commune.
Il y a toujours un nombre pair d’entrées dans ce tableau. La convention adoptée
est que pour tout i pair correspondant à un indice valide du tableau : tab[i] est
la coordonnée x d’une habitation et tab[i+1] en est la coordonnée y.
Toutes les méthodes que vous définirez dans votre programme devront être
public et static

2
1.2 Calcul des distances
Dans le fichier fourni, définissez un méthode :
double calculerDistance(int x1, int y1, int x2, int y2)
qui calcule et retourne la distance entre les deux points (x1,y1) et (x2, y2)
passés en arguments.
Pour calculer la distance entre deux points (x1, y1) et (x2, y2), vous utiliserez
la formule suivante :
p
(x1 �� x2)2 + (y1 �� y2)2
Indication : Pour représenter la distance la plus importante possible entre le point
choisi pour la décharge et un habitation, vous pourrez utiliser la constante Java
Integer.MAX_VALUE.
Voir l’exemple de déroulement plus bas pour des valeurs de test.
1.3 Habitation la plus proche
Complétez votre programme en définissant la méthode :
int plusProche(int x, int y, int[] coordonneesHabitations)
où coordonneesHabitations est un tableau de coordonnées pour les habitations
de la commune, tel que décrit plus haut. La méthode plusProche doit
retourner la position (dans le tableau coordonnesHabitations) de la paire
(xp; yp) de l’habitation la plus proche de point (x, y). Par exemple, si c’est la
deuxième habitation (12, 55) du tableau (33, 12, 12, 55, 12, 12),
la méthode doit retourner 1 (la numérotation commence à 0). Dans le cas où plusieurs
habitations seraient candidates, seule la première dans le tableau sera retenue.
Voir l’exemple de déroulement plus bas pour des valeurs de test.
1.4 Trois habitations les plus proches
Complétez votre programme en définissant une méthode supplémentaire :
int[] troisPlusProches(int x, int y, int[] coordonneesHabitations)
3
qui retourne dans un tableau d’entiers les coordonnées des trois habitations les
plus proches du point de (x,y) donné en argument parmi toutes les habitations
de la commune (passée en argument). La tableau sera ordonné selon les mêmes
conventions que pour la tableau de coordonnées des habitations (cooordonnée en
x puis en y).
Il sera aussi ordonné de la coordonnée la plus proche à la plus distante.
Indication : Pour atteindre ce résultat, vous pouvez copier la tableau des coordonnées
dans un tableau temporaire tmp au moyen de l’instruction
System.arraycopy(coordonneesHabitations, 0, tmp, 0,
coordonneesHabitations.length);
puis chercher trois fois le point le plus proche dans tmp. A chaque fois qu’un
point le plus proche aura été déterminé il faudra le remplacer par une point trop
éloigné pour être à nouveau candidat. Vous prendrez la valeur 1000000 pour
chacune de ces coordonnées (nous supposerons qu’à cette distance on sort de la
commune).
Voir l’exemple de déroulement plus bas pour des valeurs de test.
1.5 Place optimale
Terminez enfin votre programme en définissant la fonction
int[] meilleurePlace(int x, int y, int[] coordonneesHabitations)
qui donne le centre de gravité du triangle définit par les trois habitations les plus
proches du point de (x,y).
Le tableau retourné sera donc un tableau à deux entrées dont la première sera la
coordonnée en x et la seconde la coordonnées en y du centre de gravité.
Ce « centre de gravité » représente le meilleur compromis pour les trois habitations
les plus proches. Si (x1,y1), (x2,y2) et (x3,y3) sont les points les plus
proches du point (x,y), les coordonnées (cx,cy) du centre de gravité seront :
cx = (x1 + x2 + x3) / 3
cy = (y1 + y2 + y3) / 3
4
Exemple de déroulement Cet exemple s’applique au tableau de coordonnées
d’habitations fourni, à savoir :
int[] coordonneesHabitations = {
9, 30, 18, 8, 3, 18, 25, 36
};
Entrez la coordonnee x de la decharge: 10
Entrez le coordonnee y de la decharge: 15
--- Question 1 ---
Coordonnees de l’habitation la plus proche de la decharge :
(3,18) ; distance = 7.616 metres
--- Question 2 ---
Coordonnees des 3 habitations les plus proches de la decharge :
(10,15) est a :
7.616 de (3,18)
10.630 de (18,8)
15.033 de (9,30)
--- Question 3 ---
Coordonnees de la meilleure place pour la decharge :
(10,18)

voilà

alors pour un débutant c'est plus raide
25/10/2014, 15h03
joel.drigo

Procède par étape et reste concentré sur la première question : écrire la méthode pour calculer la distance. A la limite, l'indication sur Integer.MAX_VALUE peut être ignorée et tu reviendras dessus à la fin. Peut-être pourras demander des précisions au prof...
25/10/2014, 15h20
moras13

Citation:

Envoyé par joel.drigo

Procède par étape et reste concentré sur la première question : écrire la méthode pour calculer la distance. A la limite, l'indication sur Integer.MAX_VALUE peut être ignorée et tu reviendras dessus à la fin. Peut-être pourras demander des précisions au prof...

Merci Joel

bien une méthode et non fonction et j'ignore la fonction integer max_value