[hs] Mission2 - 좌표계산 선길이

README-HS.md

@@ -0,0 +1,50 @@
+## 기능 요구사항
+1. 좌표값 입력 : 에러 출력 후 다시 입력
+    - 괄호 분리 -> 괄호가 아닌 경우 에러
+    - 쉼표 분리 -> 쉼표가 아닌 경우 에러
+    - 구분자 '-' 분리 -> 구분자 아닌 경우 에러 
+    - 숫자 0~24 인지 검증 -> 아닌 경우 에러
+2. 거리 계산 출력
+
+## 프로그래밍 요구사항
+1. depth 1로 구현
+2. else 사용 금지
+3. 메서드 길이 10줄 넘어가지 않도록 구현
+4. 메소드 한가지 일만 하도록 구현
+5. 일급 컬렉션 사용
+
+
+## 실행 결과
+```
+좌표를 입력하세요.
+(10,10)-(14,15)
+
+24|
+  |
+22|
+  |
+20|
+  |
+18|
+  |
+16|
+  |
+14|
+  |                                       .
+12|
+  |
+10|                           .
+  |
+ 8|
+  |
+ 6|
+  |
+ 4|
+  |
+ 2|
+  |
+  +ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
+ 0    2     4     6     8     10    12    14    16    18    20    22    24
+두 점 사이 거리는 6.403124
+
+```

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/CoordinateMain.java

@@ -0,0 +1,17 @@
+import io.ResultView;
+import model.Calculator;
+import model.Points;
+import io.CoordinateScanner;
+
+public class CoordinateMain {
+    public static void main(String[] args) {
+        CoordinateScanner scanner = new CoordinateScanner();
+        Points points = scanner.input();
+
+        Calculator calculator = new Calculator(points);
+        double result = calculator.distance();
+
+        ResultView resultView = new ResultView(points, result);
+        resultView.print();
+    }
+}

src/main/java/io/CoordinateScanner.java

@@ -0,0 +1,71 @@
+package io;
+
+import messages.ErrorMessages;
+import model.Point;
+import model.Points;
+import util.StringUtil;
+
+import java.util.List;
+import java.util.Scanner;
+import java.util.regex.MatchResult;
+import java.util.regex.Pattern;
+
+public class CoordinateScanner {
+
+    private final Scanner scanner;
+
+    public CoordinateScanner(){
+        scanner = new Scanner(System.in);
+    }
+
+    public Points input(){
+        System.out.println("좌표를 입력하세요.");
+        String input = scanner.nextLine();
+
+        return validDots(input);
+
+    }
+
+    public Points validDots(String input){
+        Points points;
+
+        try{
+            checkMatchFormat(input);
+            points = parseNumber(input);
+        } catch (IllegalArgumentException ex){
+            System.out.println(ex.getMessage());
+            return input();
+        }
+
+        return points;
+    }
+
+
+    public void checkMatchFormat(String input){
+        if(!isMatchFormat(input)){
+            throw new IllegalArgumentException(ErrorMessages.INVALID_FORMAT_INPUT);
+        }
+    }
+
+    public boolean isMatchFormat(String input){
+        return input.matches("\\([0-9]{1,2},[0-9]{1,2}\\)-\\([0-9]{1,2},[0-9]{1,2}\\)");
+    }
+
+    public Points parseNumber(String input){
+        List<Double> numbers = Pattern.compile("\\d+")
+                .matcher(input)
+                .results()
+                .map(MatchResult::group)
+                .map(StringUtil::parseDouble)
+                .toList();
+
+        Point point1 = Point.from(numbers.get(0), numbers.get(1));
+        Point point2 = Point.from(numbers.get(2), numbers.get(3));
+
+        return new Points(point1, point2);
+    }
+
+
+
+
+}

src/main/java/io/ResultView.java

@@ -0,0 +1,69 @@
+package io;
+
+import model.Points;
+
+public class ResultView {
+    private static final int MAX_X = 24;
+    private static final int MAX_Y = 24;
+    private static final int MAX_X_LINE = 48;
+
+    private Points points;
+    private double result;
+
+    private StringBuilder sb;
+
+    public ResultView(Points points, double result){
+        this.points = points;
+        this.result = result;
+        this.sb = new StringBuilder();
+    }
+
+    public void print(){
+        System.out.println(drawGraph());
+        System.out.println("두 점 사이 거리는 " + result);
+    }
+
+    public String drawGraph(){
+        drawY();
+        drawX();
+
+        return sb.toString();
+    }
+
+    public void drawY(){
+        for(int i=MAX_Y; i>0; i--){
+            drawYLine(i);
+            points.drawPoints(i, sb);
+            sb.append("\n");
+        }
+    }
+
+    public void drawYLine(int i){
+        String str = "  |";
+
+        if (i % 2 == 0){
+            str = String.format("%2d|", i);
+        }
+
+        sb.append(str);
+    }
+
+
+    public void drawX(){
+        drawXLine();
+
+        sb.append("   ");
+
+        for(int i=0; i<=MAX_X; i+=2){
+            sb.append(String.format("%-6d", i));
+        }
+    }
+
+    public void drawXLine(){
+        sb.append("  +")
+            .append("―".repeat(MAX_X_LINE))
+            .append("\n");
+    }
+
+
+}

src/main/java/messages/ErrorMessages.java

@@ -0,0 +1,8 @@
+package messages;
+
+public class ErrorMessages {
+    public static final String INVALID_FORMAT_INPUT = "잘못된 입력 포맷입니다. 다시 입력해주세요.";
+    public static final String INVALID_NUMBER_INPUT = "좌표는 숫자만 입력 가능합니다. 다시 입력해주세요.";
+    public static final String INVALID_RANGE_INPUT = "좌표의 0부터 24까지 입력 가능합니다. 다시 입력해주세요.";
+
+}

src/main/java/model/Calculator.java

@@ -0,0 +1,30 @@
+package model;
+
+public class Calculator {
+    public static final int SQUARE_EXPONENT = 2;
+
+    private final Points points;
+
+    public Calculator(Points points){
+        this.points = points;
+    }
+
+    public double distance(){
+        // 제곱근((A.x - B.x)^제곱 + (A.y - B.y)^제곱)
+        double xDistance = powOfTwo(points.minusX());
+        double yDistance = powOfTwo(points.minusY());
+
+        return plusAndSquareRoot(xDistance, yDistance);
+    }
+
+    public double powOfTwo(double minusCoordinate){
+        return Math.pow(minusCoordinate, SQUARE_EXPONENT);
+    }
+
+    public double plusAndSquareRoot(double xDistance, double yDistance){
+        return Math.sqrt(xDistance + yDistance);
+    }
+
+
+
+}

src/main/java/model/Coordinate.java

@@ -0,0 +1,52 @@
+package model;
+
+
+import java.util.Objects;
+
+public class Coordinate {
+    private static final double MAX_COORDINATION = 24.0;
+    private static final double MIN_COORDINATION = 0.0;
+    private static final int GRAPH_SPACE = 3;
+
+    private final double coordination;
+
+    public Coordinate(double coordination){
+        this.coordination = coordination;
+    }
+
+    public boolean isCorrectRange() {
+        return coordination <= MAX_COORDINATION && coordination >= MIN_COORDINATION;
+    }
+
+    public boolean equals(double e){
+        return coordination == e;
+    }
+
+    public int getGraphPosition(){
+        return (int) (coordination * GRAPH_SPACE);
+    }
+
+    public int getGraphPositionDifference(Coordinate other){
+        return (int) minus(other) * GRAPH_SPACE;
+    }
+
+    public double minus(Coordinate other) {
+        return this.coordination - other.coordination;
+    }
+
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Coordinate that = (Coordinate) o;
+        return Double.compare(coordination, that.coordination) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(coordination);
+    }
+
+}
+

src/main/java/model/Point.java

@@ -0,0 +1,75 @@
+package model;
+
+import messages.ErrorMessages;
+
+import java.util.Objects;
+
+public class Point {
+    private Coordinate x;
+    private Coordinate y;
+
+    public Point(Coordinate x, Coordinate y){
+        this.x = x;
+        this.y = y;
+        validateRange();
+    }
+
+    public static Point from(double x, double y) {
+        return new Point(
+                new Coordinate(x),
+                new Coordinate(y)
+        );
+    }
+
+    public double minusX(Point other) {
+        return this.x.minus(other.x);
+    }
+
+    public double minusY(Point other){
+        return this.y.minus(other.y);
+    }
+
+    public void validateRange(){
+        if(!x.isCorrectRange() || !y.isCorrectRange()){
+            throw new IllegalArgumentException(ErrorMessages.INVALID_RANGE_INPUT);
+        }
+    }
+
+    public void drawPointIfMatchY(int yValue, StringBuilder sb){
+        if (isEqualY(yValue)){
+            sb.append(" ".repeat(x.getGraphPosition()))
+            .append("ㆍ");
+        }
+    }
+
+    public void drawPointIfMatchY(int yValue, StringBuilder sb, Point other){
+        if (isEqualY(yValue)){
+            sb.append(" ".repeat(x.getGraphPositionDifference(other.x)))
+            .append("ㆍ");
+        }
+    }
+
+    public boolean isEqualY(int yValue){
+        return y.equals(yValue);
+    }
+
+    public boolean isEqualY(Point other){
+        return y.equals(other.y);
+    }
+
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Point point = (Point) o;
+        return Objects.equals(x, point.x) && Objects.equals(y, point.y);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(x, y);
+    }
+
+}
+