[엘리] 자동차 경주 미션 제출합니다.

README.md

@@ -1,5 +1,44 @@
-# java-racingcar
-자동차 경주 게임 미션 저장소
+# 문자열 덧셈 계산기
+## 요구사항
+- [x] 쉼표(,) 또는 콜론(:)을 구분자로 가지는 문자열을 전달하는 경우 구분자를 기준으로 분리한 각 숫자의 합을 반환
+- [x] 앞의 기본 구분자(쉼표, 콜론)외에 커스텀 구분자를 지정할 수 있다. 커스텀 구분자는 문자열 앞부분의 “//”와 “\n” 사이에 위치하는 문자를 커스텀 구분자로 사용한다.
+- [x] 문자열 계산기에 숫자 이외의 값 또는 음수를 전달하는 경우 RuntimeException 예외를 throw한다.
 
-## 우아한테크코스 코드리뷰
-* [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+## 프로그래밍 요구사항
+- indent(들여쓰기) depth를 2단계에서 1단계로 줄여라.
+    - depth의 경우 if문을 사용하는 경우 1단계의 depth가 증가한다. if문 안에 while문을 사용한다면 depth가 2단계가 된다.
+- 메소드의 크기가 최대 10라인을 넘지 않도록 구현한다.
+    - method가 한 가지 일만 하도록 최대한 작게 만들어라.
+- else를 사용하지 마라.
+
+
+# 자동차 경주 게임 미션 저장소
+## 요구사항
+- [x] 자동차 이름 입력 받기
+    - [x] 쉼표 기준으로 구분
+    - 예외처리
+        - [x] 공백이 입력되었을 경우
+        - [x] 이름이 6자 이상 입력되었을 경우
+- [x] 시도할 횟수 입력 받기
+    - 예외처리
+        - [x] 숫자가 아닌 경우
+        - [x] 양수가 아닌 경우
+- [x] 경주할 자동차 생성
+    - [x] 자동차에 이름, 포지션 부여
+    - [x] 랜덤 값이 4 이상이면 전진, 3 이하이면 멈춘다
+- [x] 위치값 생성(0~9의 랜덤값)
+    - [x] 자동차에게 랜덤값 전달
+- [x] 실행 결과 출력
+    - [x] 전진 횟수를 "-"로 출력
+    - [x] 자동차 개수만큼 출력
+    - [x] 시도 횟수만큼 출력
+- [x] 최종 우승자 출력
+
+## 프로그래밍 요구사항
+- 모든 로직에 단위 테스트를 구현한다. 단, UI(System.out, System.in) 로직은 제외
+- 자바 코드 컨벤션을 지키면서 프로그래밍한다.
+- indent(인덴트, 들여쓰기) depth를 3을 넘지 않도록 구현한다. 2까지만 허용한다.
+- else 예약어를 쓰지 않는다.
+- 함수(또는 메소드)의 길이가 15라인을 넘어가지 않도록 구현한다.
+- 함수(또는 메소드)가 한 가지 일만 잘 하도록 구현한다.

src/main/java/calculator/StringCalculator.java

@@ -0,0 +1,36 @@
+package calculator;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class StringCalculator {
+    public static int calculate(String text) {
+        if (text == null || text.isEmpty()) {
+            return 0;
+        }
+        if (text.contains("-")) {
+            throw new RuntimeException("message");
+        }
+        return splitAndSum(text);
+    }
+
+    private static int splitAndSum(String text) {
+
+        Matcher m = Pattern.compile("//(.)\n(.*)").matcher(text);
+        if (m.find()) {
+            String customDelimiter = m.group(1);
+            String[] tokens = m.group(2).split(customDelimiter);
+            return sum(tokens);
+        }
+        String[] numbers = text.split(",|:");
+        return sum(numbers);
+    }
+
+    private static int sum(String[] numbers) {
+        int result = 0;
+        for (String number : numbers) {
+            result += Integer.parseInt(number);
+        }
+        return result;
+    }
+}

src/main/java/racingcar/Application.java

@@ -0,0 +1,10 @@
+package racingcar;
+
+import racingcar.domain.Game;
+
+public class Application {
+    public static void main(String[] args) {
+        Game game = new Game();
+        game.run();
+    }
+}

src/main/java/racingcar/domain/Car.java

@@ -0,0 +1,44 @@
+package racingcar.domain;
+
+public class Car implements Comparable<Car> {
+    public static final String POSITION_MARK = "-";
+
+    private Name name;
+    private int position;
+
+    public Car(Name name) {
+        this.name = name;
+        this.position = 0;
+    }
+
+    public int movePosition(int moveValue) {
+        if (moveValue >= 4) {
+            position++;
+        }
+        return position;
+    }
+
+    public String getCurrentPosition() {
+        StringBuilder currentPosition = new StringBuilder(name.getName());
+        currentPosition.append(" : ");
+
+        for (int i = 0; i < position; i++) {
+            currentPosition.append(POSITION_MARK);
+        }
+        return currentPosition.toString();
+    }
+
+    public boolean isMaxPosition(Car maxPositionCar) {
+        return this.position >= maxPositionCar.position;
+    }
+
+    @Override
+    public String toString() {
+        return name.getName();
+    }
+
+    @Override
+    public int compareTo(Car car) {
+        return this.position - car.position;
+    }
+}

src/main/java/racingcar/domain/Cars.java

@@ -0,0 +1,40 @@
+package racingcar.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Cars {
+    public static final int RANDOM_VALUE_LIMIT = 10;
+
+    private List<Car> cars;
+
+    public Cars(Names names) {
+        this.cars = names.getNames()
+                .stream()
+                .map(Car::new)
+                .collect(Collectors.toList());
+    }
+
+    public int createRandomValue() {
+        return (int) (Math.random() * RANDOM_VALUE_LIMIT);
+    }
+
+    public void moveCars() {
+        for (Car car : cars) {
+            car.movePosition(createRandomValue());
+        }
+    }
+
+    public String getCurrentResult() {
+        StringBuilder currentResult = new StringBuilder();
+        for (Car car : cars) {
+            currentResult.append(car.getCurrentPosition());
+            currentResult.append("\n");
+        }
+        return currentResult.toString();
+    }
+
+    public List<Car> getCars() {
+        return cars;
+    }
+}

src/main/java/racingcar/domain/Game.java

@@ -0,0 +1,21 @@
+package racingcar.domain;
+
+import racingcar.view.InputView;
+import racingcar.view.OutputView;
+
+public class Game {
+    public void run() {
+        Names names = InputView.getNames();
+        Trial trial = InputView.getTrial();
+
+        Cars cars = new Cars(names);
+
+        OutputView.printCurrentResultTitle();
+        for (int i = 0; i < trial.getTrial(); i++) {
+            cars.moveCars();
+            OutputView.printCurrentResult(cars.getCurrentResult());
+        }
+        Winners.selectWinners(cars.getCars());
+        OutputView.printWinnerResult();
+    }
+}

src/main/java/racingcar/domain/Name.java

@@ -0,0 +1,33 @@
+package racingcar.domain;
+
+public class Name {
+    public static final int NAME_LENGTH_LIMIT = 5;
+
+    private String name;
+
+    public Name(String name) throws IllegalArgumentException {
+        this.name = name;
+        isCorrectName();
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void isCorrectName() throws IllegalArgumentException {
+        isBlankValidation();
+        isOverSixLetters();
+    }
+
+    private void isBlankValidation() {
+        if (name.replace(" ", "").isEmpty()) {
+            throw new IllegalArgumentException("공백이 입력되었습니다.");
+        }
+    }
+
+    private void isOverSixLetters() {
+        if (name.length() > NAME_LENGTH_LIMIT) {
+            throw new IllegalArgumentException("이름은 5자 이내로 작성해주세요.");
+        }
+    }
+}

src/main/java/racingcar/domain/Names.java

@@ -0,0 +1,29 @@
+package racingcar.domain;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Names {
+    public static final String COMMA = ",";
+
+    private final List<Name> names;
+
+    public Names(String carNames) throws IllegalArgumentException {
+        this.names = Arrays.stream(nameSplitValidation(carNames))
+                .map(Name::new)
+                .collect(Collectors.toList());
+    }
+
+    private String[] nameSplitValidation(String carNames) {
+        String[] splittedNames = carNames.split(COMMA);
+        if (splittedNames.length == 0 || carNames.contains(",,")) {
+            throw new IllegalArgumentException("이름을 입력해주세요.");
+        }
+        return splittedNames;
+    }
+
+    public List<Name> getNames() {
+        return names;
+    }
+}

src/main/java/racingcar/domain/Trial.java

@@ -0,0 +1,29 @@
+package racingcar.domain;
+
+public class Trial {
+    private static final int GAME_COUNT_MINIMUM = 1;
+    private int trial;
+
+    public int getTrial() {
+        return trial;
+    }
+
+    public Trial(String trial) throws Exception {
+        this.trial = isNotNumber(trial);
+        isNotPositiveNumber();
+    }
+
+    private int isNotNumber(String trial) {
+        try {
+            return Integer.parseInt(trial);
+        } catch (NumberFormatException e) {
+            throw new NumberFormatException("시도 횟수는 숫자를 입력해주세요.");
+        }
+    }
+
+    private void isNotPositiveNumber() {
+        if (this.trial < GAME_COUNT_MINIMUM) {
+            throw new IllegalArgumentException("시도 횟수는 양수만 입력해주세요.");
+        }
+    }
+}

src/main/java/racingcar/domain/Winners.java

@@ -0,0 +1,28 @@
+package racingcar.domain;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Winners {
+    private static List<Car> winners = new ArrayList<>();
+
+    public static void selectWinners(List<Car> cars) {
+        Car maxDistanceCar = cars.stream()
+                .max(Car::compareTo)
+                .get();
+        for (Car car : cars) {
+            if (car.isMaxPosition(maxDistanceCar)) {
+                winners.add(car);
+            }
+        }
+    }
+
+    public static String getWinners() {
+        return winners.stream()
+                .map(Car::toString)
+                .collect(Collectors
+                        .joining(","));
+    }
+}

src/main/java/racingcar/view/InputView.java

@@ -0,0 +1,32 @@
+package racingcar.view;
+
+import racingcar.domain.Names;
+import racingcar.domain.Trial;
+
+import java.util.Scanner;
+
+public class InputView {
+    private static final Scanner scanner = new Scanner(System.in);
+
+    public static Names getNames() {
+        try {
+            OutputView.askCarNames();
+            String carNames = scanner.nextLine();
+            return new Names(carNames);
+        } catch (IllegalArgumentException e) {
+            OutputView.printErrorMessage(e.getMessage());
+            return getNames();
+        }
+    }
+
+    public static Trial getTrial() {
+        try {
+            OutputView.askTrial();
+            String trial = scanner.nextLine();
+            return new Trial(trial);
+        } catch (Exception e) {
+            OutputView.printErrorMessage(e.getMessage());
+            return getTrial();
+        }
+    }
+}