[hs] Mission3 - 좌표 계산기 사각형 면적

README-HS.md

@@ -0,0 +1,72 @@
+## 요구사항
+1. 좌표값을 두 개 입력한 경우 두 점을 잇는 직선으로 가정
+2. 좌표와 좌표값 사이 '-' 문자로 구분
+3. 좌표값을 네 개 입력한 경우 네 점을 연결하는 사각형으로 가정
+    - 네 점이 뒤틀어진 사다리꼴이나 마름모는 제외하고 직사각형만 허용하도록 검사
+    - 사각형인 경우 사각형 넓이를 계산해서 출력
+
+
+## 프로그래밍 요구사항
+1. depth 2를 넘지 않도록 구현 (1까지만 허용)
+2. 3항 연산자 금지
+3. else 예약어 금지
+4. switch/case 금지
+5. 메소드 10줄 넘어가지 않도록 구현
+6. 일급 컬렉션
+
+
+## 실행 결과
+```
+좌표를 입력하세요.
+(10,10)-(22,10)-(22,18)-(10,18)
+
+
+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
+
+사각형의 넓이는 96
+```
+
+## 힌트
+1. 사각형 면적은 width * height 방식으로 계산할 수 있다.
+2. Point 라는 객체를 추가해 x, y 좌표를 관리하도록 한다.
+
+- 직사각형 좌표
+(2,3)-(2,10)-(7,3)-(7,10)
+(4,6)-(4,15)-(12,6)-(12,15)
+
+- 직사각형이 아닌 좌표
+(3,5)-(7,14)-(15,18)-(21,3)
+(2,8)-(9,17)-(18,6)-(23,11)
+
+- 마름모
+(12,6)-(18,18)-(6,18)-(0,6)
+(6,12)-(12,18)-(18,12)-(12,6)
+
+- 선 
+(10,10)-(14,15)
+두 점 사이 거리는 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,20 @@
+import io.InputScanner;
+import io.ResultView;
+import model.Calculator;
+import model.Points;
+
+public class CoordinateMain {
+    public static void main(String[] args) {
+        InputScanner scanner = new InputScanner();
+        Points points = scanner.input();
+
+        Calculator calculator = new Calculator(points);
+        double result = calculator.calculate();
+
+        ResultView resultView = new ResultView(points, result);
+        resultView.print();
+
+    }
+
+
+}

src/main/java/io/InputScanner.java

@@ -0,0 +1,59 @@
+package io;
+
+import messages.ErrorMessages;
+import model.Points;
+import model.Rectangle;
+
+import java.util.Scanner;
+
+public class InputScanner {
+    private final Scanner scanner;
+
+    public InputScanner(){
+        scanner = new Scanner(System.in);
+    }
+
+    public Points input(){
+        System.out.println("좌표를 입력하세요.");
+        return validateInput(scanner.nextLine());
+    }
+
+    public Points validateInput(String input){
+        Points points;
+
+        try{
+            checkMatchPattern(input);
+            points = Points.fromString(input);
+            checkRectangleShapes(points);
+
+        } catch(IllegalArgumentException ex){
+            System.out.println(ex.getMessage());
+            return input();
+        }
+
+        return points;
+    }
+
+    public void checkMatchPattern(String input){
+        if(!isMatchTwoPoints(input) && !isMatchFourPoints(input)){
+            throw new IllegalArgumentException(ErrorMessages.INVALID_PATTERN);
+        }
+    }
+
+    public boolean isMatchTwoPoints(String input) {
+        return input.matches("\\([0-9]{1,2},[0-9]{1,2}\\)-\\([0-9]{1,2},[0-9]{1,2}\\)");
+    }
+
+
+    public boolean isMatchFourPoints(String input) {
+        return input.matches("\\([0-9]{1,2},[0-9]{1,2}\\)-\\([0-9]{1,2},[0-9]{1,2}\\)-\\([0-9]{1,2},[0-9]{1,2}\\)-\\([0-9]{1,2},[0-9]{1,2}\\)");
+    }
+
+    public void checkRectangleShapes(Points points){
+        if (points.isFourPoints()){
+            Rectangle rectangle = new Rectangle(points);
+            rectangle.validateRectangle();
+        }
+    }
+
+}

src/main/java/io/ResultView.java

@@ -0,0 +1,32 @@
+package io;
+
+import model.Graph;
+import model.Points;
+
+public class ResultView {
+
+    private Points points;
+    private Graph graph;
+    private double result;
+
+    public ResultView(Points points, double result){
+        this.points = points;
+        this.graph = Graph.from(points);
+        this.result = result;
+    }
+
+    public void print(){
+        StringBuilder[] graphDrawing  = graph.draw();
+
+        for (StringBuilder drawing : graphDrawing){
+            System.out.println(drawing.toString());
+        }
+
+        if (points.isTwoPoints()){
+            System.out.println("두 점 사이 거리는 " + result);
+        }
+
+        System.out.println("사각형의 넓이는 " + result);
+    }
+
+}

src/main/java/messages/ErrorMessages.java

@@ -0,0 +1,8 @@
+package messages;
+
+public class ErrorMessages {
+    public static final String INVALID_PATTERN = "입력이 올바르지 않습니다. 다시 입력해주세요.";
+    public static final String INVALID_NUMBER = "숫자가 아닌 값은 입력할 수 없습니다. 다시 입력해주세요.";
+    public static final String INVALID_RECTANGLE = "직사각형이 아닌 좌표는 입력할 수 없습니다. 다시 입력해주세요.";
+    public static final String INVALID_RANGE = "좌표값은 0부터 24까지만 입력 가능합니다. 다시 입력해주세요.";
+}

src/main/java/model/Calculator.java

@@ -0,0 +1,23 @@
+package model;
+
+public class Calculator {
+
+    private Points points;
+
+    public Calculator(Points points){
+        this.points = points;
+    }
+
+    public double calculate(){
+        if (points.isTwoPoints()){
+            Line line = new Line(points);
+            return line.calculateLength();
+        }
+
+        Rectangle rectangle = new Rectangle(points);
+        return rectangle.calculateArea();
+    }
+
+
+
+}

src/main/java/model/Graph.java

@@ -0,0 +1,77 @@
+package model;
+
+public class Graph {
+    private final static int TOTAL_X_SIZE = 48;
+    private final static int TOTAL_Y_SIZE = 26;
+    private final static int X_LINE = 24;
+    private final static int X_NUMBER_LINE = 25;
+    private final static int MAX_NUMBER = 24;
+
+    private Points points;
+    private StringBuilder[] graph;
+
+    public Graph(Points points){
+        this.points = points;
+        initGraph();
+    }
+
+    public void initGraph(){
+        graph = new StringBuilder[TOTAL_Y_SIZE];
+
+        for (int i=0; i<=X_LINE; i++){
+            graph[i] = new StringBuilder("  ".repeat(TOTAL_X_SIZE));
+        }
+    }
+
+    public static Graph from(Points points){
+        return new Graph(points);
+    }
+
+    public StringBuilder[] draw(){
+        drawY();
+        drawX();
+        points.drawPoints(graph);
+
+        return graph;
+    }
+
+
+    public void drawY(){
+        int yNum = MAX_NUMBER;
+
+        for(int i=0; i<MAX_NUMBER; i++){
+            drawYLine(i, yNum);
+            yNum -= 1;
+        }
+    }
+
+    public void drawYLine(int i, int yNum){
+        String str = "  |";
+
+        if (i % 2 == 0){
+            str = String.format("%2d|", yNum);
+        }
+
+        graph[i].replace(0, 3, str);
+    }
+
+
+    public void drawX(){
+        drawXLine();
+        drawXNumber();
+    }
+
+    public void drawXLine(){
+        graph[X_LINE].replace(0, TOTAL_X_SIZE, "  +" + "―".repeat(TOTAL_X_SIZE));
+    }
+
+    public void drawXNumber(){
+        graph[X_NUMBER_LINE] = new StringBuilder();
+
+        for(int i=0; i<=MAX_NUMBER; i+=2){
+            graph[X_NUMBER_LINE].append(String.format("%-6d", i));
+        }
+    }
+
+
+}

src/main/java/model/Line.java

@@ -0,0 +1,34 @@
+package model;
+
+public class Line {
+    public static final int SQUARE_EXPONENT = 2;
+
+    private Points points;
+
+    public Line(Points points){
+        this.points = points;
+    }
+
+    public static Line of(Point point1, Point point2) {
+        return new Line(Points.from(point1, point2));
+    }
+
+    public double calculateLength(){
+        double xDistance = powOfTwo(minusX());
+        double yDistance = powOfTwo(minusY());
+
+        return Math.sqrt(xDistance + yDistance);
+    }
+
+    public double minusX(){
+        return points.getPoint(0).minusX(points.getPoint(1));
+    }
+    public double minusY(){
+        return points.getPoint(0).minusY(points.getPoint(1));
+    }
+
+    public double powOfTwo(double minusCoordinate){
+        return Math.pow(minusCoordinate, SQUARE_EXPONENT);
+    }
+
+}

src/main/java/model/Lines.java

@@ -0,0 +1,38 @@
+package model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Lines {
+    private final Points points;
+    private final List<Line> lines;
+
+    public Lines(Points points){
+        this.points = points;
+        this.lines = createAllLines();
+    }
+
+    public List<Line> createAllLines(){
+        List<Line> lineList = new ArrayList<>();
+
+        for (int i=0; i<points.size(); i++){
+            allLineForPoints(points, lineList, i);
+        }
+
+        return lineList;
+    }
+
+    public void allLineForPoints(Points points, List<Line> lineList, int i){
+        for (int j=i+1; j<points.size(); j++){
+            lineList.add(Line.of(points.getPoint(i), points.getPoint(j)));
+        }
+    }
+
+
+    public List<Double> allSortedLinesLength(){
+        return lines.stream()
+                .map(Line::calculateLength)
+                .sorted()
+                .toList();
+    }
+}