在Java中匹配两个坐标

时间:2013-02-15 02:27:11

标签: java while-loop compare java.util.scanner

我有这个程序,我正在读取一行x和y坐标,并且必须找到最长的共线点。我正在读取它们并将所有xCoordinates存储在ArrayList中,并将所有yCoordinates存储在另一个列表中。我需要比较斜率并打印出最长的线。我计算了斜率,但无法弄清楚如何将它们相互比较。这就是我到目前为止所拥有的:

import java.util.ArrayList;
import java.util.Scanner;


public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        ArrayList<Double> list = new ArrayList<Double>();
        ArrayList<Double> xCoord = new ArrayList<Double>();
        ArrayList<Double> yCoord = new ArrayList<Double>();
        //      double xCoord[] = null;
        //      double yCoord[] = null;
        int i = 0;
        int count = 0; 
        double slope = 0;
        double slope2 = 0;


        while(scanner.hasNext()) {
            //grabs x and y coordinate
            xCoord.add(scanner.nextDouble());
            yCoord.add(scanner.nextDouble());

            //formatting
            if(i == 0) {
                System.out.println(" X  Y");
                System.out.println(" -  -");
            }
            System.out.print(xCoord.get(i) + " ");
            System.out.print(yCoord.get(i));
            System.out.print("\n");


            //ending case
            if((i > 0) && (xCoord.get(i).equals(xCoord.get(i-1)) && yCoord.get(i).equals(yCoord.get(i-1)))) {
                System.out.println("Hey, they matched");
                break;
            }


            if(i > 0) {
                slope = (xCoord.get(i-1) - xCoord.get(i))/(yCoord.get(i-1) - yCoord.get(i));
                System.out.println("Slope: " + slope);
            }


            i+=1;
        }




    }

}

当你得到两个相同的x,y坐标(我有那个工作)时,程序就会终止。

2 个答案:

答案 0 :(得分:0)

这是你的代码,我做了一些小的(?)修改,还添加了一些新的代码来获得最长的点

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class CollinearPoints {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        List<Coordinate> coordinates = new ArrayList<Coordinate>();
        List<Slope> slopes = new ArrayList<Slope>();
        int i = 0;
        while (scanner.hasNext()) {
            // grabs x and y coordinate
            Coordinate coordinate = new Coordinate(scanner.nextDouble(), scanner.nextDouble());

            // formatting
            if (i == 0) {
                System.out.println(" X  Y");
                System.out.println(" -  -");
            }
            System.out.print(coordinate.getX() + " ");
            System.out.print(coordinate.getY());
            System.out.print("\n");

            // ending case
            if ((i > 0)
                    && (coordinate.getX() == coordinates.get(i-1).getX() && 
                            coordinate.getY() == coordinates.get(i-1).getY())) {
                System.out.println("Hey, they matched");
                break;
            }
            coordinates.add(coordinate);
            i += 1;
        }
        /* Calculate slopes between all the points */
        for(i =0; i < coordinates.size(); i++){
            for(int j = i+1; j < coordinates.size(); j++){
                Coordinate coordinate1 = coordinates.get(i);
                Coordinate coordinate2 = coordinates.get(j);
                double slope = getSlope(coordinate1, coordinate2);
                slopes.add(new Slope(coordinate1, coordinate2, slope));
            }
        }
        /* Calculate slope counts (to know which one occurs max times) */
        Map<String, Double> slopeCountsMap = new HashMap<String, Double>();
        for(Slope slope : slopes){
            slopeCountsMap.put(String.valueOf(slope.getSlope()), Double.valueOf(String.valueOf(getMatchingSlopeCount(slope.getSlope(), slopes))));
        }
        /* Sort the slope :: slope-count map */
        ValueComparator bvc =  new ValueComparator(slopeCountsMap);
        TreeMap<String,Double> sorted_map = new TreeMap<String,Double>(bvc);
        sorted_map.putAll(slopeCountsMap);

        /* get the maximum occurring slope */
        double maxSlope = Double.parseDouble(sorted_map.firstKey());

        /* Collect the list of co-ordinates having the max occurring slope and which are collinear */
        List<Coordinate> colinearPoints = new ArrayList<Coordinate>();
        for(Slope slope : slopes){
            if(maxSlope == slope.getSlope()){
                if(colinearPoints.size() < 2){
                    if(!colinearPoints.contains(slope.getCoordinate1())){
                        colinearPoints.add(slope.getCoordinate1());
                    }
                    if(!colinearPoints.contains(slope.getCoordinate2())){
                        colinearPoints.add(slope.getCoordinate2());
                    }
                } else {
                    if(colinearPoints.contains(slope.getCoordinate1()) &&
                            !colinearPoints.contains(slope.getCoordinate2())){
                        colinearPoints.add(slope.getCoordinate2());
                    } else if(colinearPoints.contains(slope.getCoordinate2()) &&
                            !colinearPoints.contains(slope.getCoordinate1())){
                        colinearPoints.add(slope.getCoordinate1());
                    }
                }
            }
        }
        System.out.println("Colinear points: ");
        System.out.println(colinearPoints);
    }

    private static int getMatchingSlopeCount(double slope, List<Slope> slopes){
        int count = 0;
        for(Slope slope2 : slopes){
            if(slope == slope2.getSlope()){
                count ++;
            }
        }
        return count;
    }
    /* Calculate slope between two points */
    private static double getSlope(Coordinate coordinate1, Coordinate coordinate2){
        return ((coordinate2.getY() - coordinate1.getY()) / (coordinate2.getX() - coordinate1.getX()));
    }
}
/* Class to hold co-ordinates */
class Coordinate {
    private double x;
    private double y;

    @Override
    public String toString() {
        return "(" + x + "," + y + ")";
    }
    public double getX() {
        return x;
    }
    public void setX(double x) {
        this.x = x;
    }
    public double getY() {
        return y;
    }
    public void setY(double y) {
        this.y = y;
    }
    public Coordinate() {
    }
    public Coordinate(double x, double y) {
        super();
        this.x = x;
        this.y = y;
    }
    @Override
    public boolean equals(Object o) {
        return (((Coordinate)o).getX() == this.getX() && ((Coordinate)o).getY() == this.getY());
    }
}
/* Class to hold slope between two points */
class Slope {
    private Coordinate coordinate1;
    private Coordinate coordinate2;
    private double slope;
    @Override
    public String toString() {
        return "(" + coordinate1.getX() + "," + coordinate1.getY() + ")(" + coordinate2.getX() + "," + coordinate2.getY() + ")";
    }
    public double getSlope() {
        return slope;
    }
    public void setSlope(double slope) {
        this.slope = slope;
    }
    public Coordinate getCoordinate1() {
        return coordinate1;
    }
    public void setCoordinate1(Coordinate coordinate1) {
        this.coordinate1 = coordinate1;
    }
    public Coordinate getCoordinate2() {
        return coordinate2;
    }
    public void setCoordinate2(Coordinate coordinate2) {
        this.coordinate2 = coordinate2;
    }
    public Slope() {
    }
    public Slope(Coordinate coordinate1, Coordinate coordinate2, double slope) {
        super();
        this.coordinate1 = coordinate1;
        this.coordinate2 = coordinate2;
        this.slope = slope;
    }
}
/* Comparator to sort the map */
class ValueComparator implements Comparator<String> {
    Map<String, Double> base;
    public ValueComparator(Map<String, Double> base) {
        this.base = base;
    }
    // Note: this comparator imposes orderings that are inconsistent with equals.    
    public int compare(String a, String b) {
        if (base.get(a) >= base.get(b)) {
            return -1;
        } else {
            return 1;
        } // returning 0 would merge keys
    }
}

答案 1 :(得分:-1)

首先声明一个变量来保存到目前为止找到的最长行。说longestSoFar。将其设置为较小的数字,例如0,因为您不会得到任何短于0的行。在循环中,当您找到行的长度时,只需将其与longestSoFar进行比较。

  if(lengthOfCurrentLine > longestSoFar){
         longestSoFar = lengthOfCurrentLine;
  }

当然,到目前为止,你将保留给出最长线的点数。

在循环结束时,存储在该变量中的是你的答案。