Mon programme n'analyse pas les bonnes valeurs à droite

Question

---

import java.util.ArrayList; 
import java.util.Arrays; 

public class Cloud { 
    private ArrayList<Point> points; 
    private double left; 
    private double right; 
    private double top; 
    private double bottom; 

    private final double epsilon = 10e-6; 
    /** 
    * 
    * @param p a Point 
    * @return whether p in the cloud 
    */ 
    public boolean hasPoint(Point p) { 
     return points.contains(p); 
    } 

    /** 
    * Constructor 
    * @param maxSize: points array size 
    */ 
    public Cloud(){ 
     points = new ArrayList<Point>(); 
     this.left = 0.0; 
     this.right = 0.0; 
     this.top = 0.0; 
     this.bottom = 0.0; 
    } 

    /** 
    * 
    * @param p 
    * if (size < maxSize) add p to points, increment size 
    * @return the boolean value returned by the ArrayList add method 
    *   
    */ 
    public boolean addPoint(Point p){ 
     extremes(); 
     return points.add(p); 
    } 

    /** 
    * Use the method toString of ArrayList 
    */ 
    public String toString(){ 
     return points.toString(); 
     } 

    /* 
    * return an array of the double extremes instance variables: 
    *  left, right, top, bottom 
    */ 
    public double[] getExtremes(){ 
     double[] ext = new double[4]; 
     ext[0] = left; 
     ext[1] = right; 
     ext[2] = top; 
     ext[3] = bottom; 

     return ext; 
    } 


    /** 
    * Compute four double values: 
    * left: the x coordinate of a left-most Point 
    * right: the x coordinate of a right-most Point 
    * top: the y coordinate of a highest Point 
    * bottom: the y coordinate of a lowest Point 
    * 
    * and put them in the appropriate instance variables 
    */ 
    private void extremes(){ 
     for (int i=0; i<points.size(); i++){ 
      Point p = points.get(i); 
      if(p.getX() < left){ 
       left = p.getX(); 
      } 
      if(p.getX() > right){ 
       right = p.getX(); 
      } 
      if(p.getY() < bottom){ 
       bottom = p.getY(); 
      } 
      if(p.getY() > top){ 
       top = p.getY(); 
      } 
     } 
    } 

    /** 
    * 
    * @param p1 
    * @param p2 
    * 
    * all Points outside the rectangle, line or point spanned 
    * by p1 and p2 are removed 
    * 
    * After removal, the extreme values left, right, top and bottom 
    * are updated using the extremes method; then using an assert the 
    * extremes of the Cloud are checked using the extremes of the two 
    * Points p1, and p2 
    * 
    */ 
    public void crop(Point p1, Point p2){ 
     if(p1 == p2){ 
      Point temp = p1; 
      points.clear(); 
      points.add(temp); 
     } 
     if(p1.getX() == p2.getX()){ 
      double temp = p1.getX(); 
      for(int i=0; i<points.size(); i++){ 
       if(points.get(i).getX() != temp){ 
        points.remove(i); 
       } 
      } 
     } 
     if(p1.getY() == p2.getY()){ 
      double temp = p1.getY(); 
      for(int i=0; i<points.size(); i++){ 
       if(points.get(i).getY() != temp){ 
        points.remove(i); 
       } 
      } 
     } 
     else{ 
      double tempLeft = p1.getX(); 
      double tempRight = p1.getX(); 
      double tempTop = p1.getY(); 
      double tempBottom = p1.getY(); 
      if(p2.getX() < tempLeft){ 
       tempLeft = p2.getX(); 
      } 
      if(p2.getX() > tempRight){ 
       tempRight = p2.getX(); 
      } 
      if(p2.getY() > tempTop){ 
       tempTop = p2.getY(); 
      } 
      if(p2.getY() < tempBottom){ 
       tempBottom = p2.getY(); 
      } 
      for(int i=0; i<points.size(); i++){ 
       if(points.get(i).getX() < tempLeft){ 
        points.remove(i); 
       } 
       if(points.get(i).getX() > tempRight){ 
        points.remove(i); 
       } 
       if(points.get(i).getY() < tempBottom){ 
        points.remove(i); 
       } 
       if(points.get(i).getY() > tempTop){ 
        points.remove(i); 
       } 
      } 
      } 
    } 
    /* 
    * equality check for doubles 
    */ 
    private boolean dblEq(double a, double b){ 
     return Math.abs(a-b) < epsilon; 
    } 


    /** 
    * @param args: not used 
    */ 
    public static void main(String[] args) { 
     // TODO test all cloud methods 
     Cloud set = new Cloud(); 
     System.out.println("initial set: " + set); 
     for(int i=0; i<5; i++) 
      for (int j=0; j<i; j++){ 
       set.addPoint(new Point(i-j*0.5,j)); 
      } 
     System.out.println("set after addPoints: " + set);   
     double[] ext = set.getExtremes(); 
     if(ext != null) { 
     System.out.println("extremes: " + Arrays.toString(ext)); 
     System.out.println("left of set: " + ext[0]); 
     System.out.println("right of set: " + ext[1]); 
     System.out.println("top of set: " + ext[2]); 
     System.out.println("bottom of set: " + ext[3]); 

     set.crop(new Point(3,0), new Point(2,2)); 
     System.out.println("set after crop 1: " + set); 
     assert set.dblEq(set.left,2.0) && set.dblEq(set.right,3.0) && 
       set.dblEq(set.bottom,0.0) && set.dblEq(set.top,2.0); 

     set.crop(new Point(3,2),new Point(2,2)); 
     System.out.println("set after crop 2: " + set); 
     assert set.dblEq(set.left,2.0) && set.dblEq(set.right,3.0) && 
       set.dblEq(set.bottom,2.0) && set.dblEq(set.top,2.0); 
     } 
    } 

} 

---

êtes ici est la sortie:

---

initial set: [] 

set after addPoints: [(1.0,0.0), (2.0,0.0), (1.5,1.0), (3.0,0.0), (2.5,1.0), (2.0,2.0), (4.0,0.0), (3.5,1.0), (3.0,2.0), (2.5,3.0)] 

extremes: [0.0, 4.0, 2.0, 0.0] 

left of set: 0.0 

right of set: 4.0 

top of set: 2.0 

bottom of set: 0.0 

set after crop 1: [(2.0,0.0), (3.0,0.0), (2.5,1.0), (2.0,2.0), (3.5,1.0), (3.0,2.0)] 

set after crop 2: [(3.0,0.0), (2.0,2.0), (3.0,2.0)] 

---

Comme vous pouvez le voir les extrêmes ne sont pas correctes (le haut de l'ensemble devrait être 3.0), et il ne recadre pas les valeurs correctes. Qu'ai-je fait de mal? D'accord, mon programme est censé ajouter des "points" (deux valeurs doubles) à un "nuage" et définir les extrêmes (le plus éloigné et le moins éloigné du haut de mon nuage, comme si c'était un graphique) et ensuite passer et recadrer (mettre deux points et se débarrasser de tous les points pas dans le carré qui est dessiné par les deux points donnés). J'espère que ça aide.

Answer 1

Dans votre point de départ, vous devez d'abord calculer l'extrême, puis ajouter le point, afin que votre dernier point ne soit pas inclus dans cet extrême.

public addPoint booléen (Point p) { extremes(); points de retour.add (p); Pourquoi vous ne vérifiez pas l'extrême sur le point ajouté au lieu de l'exécuter sur l'ensemble complet. Le seul changement peut être causé par le dernier point ajouté. vous construisez le nuage en O (n^2) au lieu de O (n)

Roni