[자동차 경주 게임] 효오 미션 제출합니다.

README.md

@@ -1,3 +1,23 @@
+# 1번째 미션 - 문자열 계산기
+## 기능 구현 목록
+1. [입력] 유저에게 인풋을 받는다.
+2. [처리] 유저의 인풋을 숫자와 기호로 나눈다.
+    * [예외처리] 유저의 인풋이 숫자가 아닌 경우를 확인한다.
+    * [예외처리] 유저의 인풋이 기호가 아닌 경우를 확인한다.
+    * [예외처리] 유저의 인풋이 Zero-Division인지 확인한다.
+3. [결과] 해당식의 결과를 출력한다.
+
+#2번째 미션 - java-racingcar
+## 기능 구현 목록
+1. [입력] 유저에게 자동차의 이름을 입력받는다.
+    * [예외처리] 이름의 공백이 경우를 확인한다.
+    * [예외처리] 중복된 이름이 있는 경우
+    * [예외처리] 이름이의 길이가 다섯자 이하인지 확인한다.
+2. [입력] 유저에게 시도학 횟수를 입력받는다.
+    * [예외처리] 0이하의 숫자인지 확인한다.
+3. [계산/출력] 자동차가 간 거리를 계산한다.
+4. [결과출력] 우승자를 출력한다.
+
 # java-racingcar
 자동차 경주 게임 미션 저장소
 

src/main/java/Calculator.java

@@ -0,0 +1,8 @@
+public class Calculator {
+    int addition(int i, int j) {
+        return i+j;
+    }
+    int subtraction(int i, int j) {
+        return i-j;
+    }
+}

src/main/java/calculator/Calculate.java

@@ -0,0 +1,15 @@
+package calculator;
+
+import exceptionsCalculator.CalculatorException;
+
+enum Calculate {
+    RESULT();
+
+    public int getCalculateResult(int firstNumber, int secondNumber, String symbol) {
+        if (symbol.equals("+")) return firstNumber + secondNumber;
+        if (symbol.equals("-")) return firstNumber - secondNumber;
+        if (symbol.equals("*")) return firstNumber * secondNumber;
+        if (symbol.equals("/")) return CalculatorException.divisionException(firstNumber, secondNumber);
+        return CalculatorException.applyCalculationException();
+    }
+}

src/main/java/calculator/Calculator.java

@@ -0,0 +1,47 @@
+package calculator;
+
+import exceptionsCalculator.CalculatorException;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Calculator {
+
+    public static void main(String[] args) {
+        doCalculate();
+    }
+
+    public static void doCalculate() {
+        String userInput = CalculatorException.readAndReceiveInput();
+        List<String> numbers = new ArrayList<>(Arrays.asList(userInput.split(" ")));
+        List<Integer> numberList = extractNumbers(numbers);
+        List<String> symbolList = extractSymbols(numbers);
+        System.out.println(calculate(numberList, symbolList));
+    }
+
+    public static List<Integer> extractNumbers(List<String> numbers) {
+        List<Integer> listOfNumbers = new ArrayList<>();
+        for (int i = 0; i < numbers.size(); i += 2) {
+            int number = CalculatorException.extractNumbersException(numbers.get(i));
+            listOfNumbers.add(number);
+        }
+        return listOfNumbers;
+    }
+
+    public static List<String> extractSymbols(List<String> symbols) {
+        List<String> listOfSymbols = new ArrayList<>();
+        for (int i = 1; i < symbols.size(); i += 2) {
+            listOfSymbols.add(symbols.get(i));
+        }
+        return listOfSymbols;
+    }
+
+    public static int calculate(List<Integer> listOfNumbers, List<String> listOfSymbols) {
+        int result = listOfNumbers.get(0);
+        for (int i = 0; i < listOfSymbols.size(); i++) {
+            result = Calculate.RESULT.getCalculateResult(result, listOfNumbers.get(i + 1), listOfSymbols.get(i));
+        }
+        return result;
+    }
+}

src/main/java/exceptionsCalculator/CalculatorException.java

@@ -0,0 +1,39 @@
+package exceptionsCalculator;
+
+import calculator.Calculator;
+
+import java.util.Scanner;
+
+public class CalculatorException {
+
+    public static String readAndReceiveInput() {
+        System.out.println("숫자를 입력해 주세요!");
+        Scanner reader = new Scanner(System.in);
+        return reader.nextLine();
+    }
+
+    public static int divisionException(int result, int number){
+        if (number == 0) {
+            System.out.println("0이 분모에 있습니다.");
+            Calculator.doCalculate();
+        }
+        return result / number;
+    }
+
+    public static int extractNumbersException(String stringNumber) {
+        try{
+            return Integer.parseInt(stringNumber);
+        }catch (Exception e){
+            System.out.println("잘못된 입력값입니다! 숫자가 아닙니다!");
+            Calculator.doCalculate();
+        }
+        return -1;
+    }
+
+    public static int applyCalculationException(){
+        System.out.println("잘못된 입력값입니다. 기호가 아닙니다!");
+        Calculator.doCalculate();
+        return -1;
+    }
+
+}

src/main/java/racingcar/Car.java

@@ -0,0 +1,83 @@
+package racingcar;
+
+import java.util.*;
+
+public class Car {
+    private static final int MAX_NAME_SIZE = 5;
+    private static final int POSSIBLE_MOVE_CAR = 4;
+    private static final int MAX_RANDOM_NUMBER = 10;
+    private static final int MIN_RANDOM_NUMBER = 0;
+
+    private final String name;
+    private int position = 0;
+
+    Car(String name) {
+        if (isWhiteSpaceOnly(name)) {
+            throw new IllegalArgumentException();
+        }
+        if (isOverLimit(name)) {
+            throw new IllegalArgumentException();
+        }
+        this.name = name;
+    }
+
+    Car(String name, int position) {
+        this.name = name;
+        this.position = position;
+    }
+
+    public static boolean isWhiteSpaceOnly(String name) {
+        return name.isEmpty();
+    }
+
+    public static boolean isOverLimit(String name) {
+        return name.length() > MAX_NAME_SIZE;
+    }
+
+    public Car moveCar(int randomNumber) {
+        if (randomNumber >= POSSIBLE_MOVE_CAR) {
+            position++;
+        }
+        return this;
+    }
+
+    public static int randomNumberGenerator() {
+        return (int) (Math.random() * MAX_RANDOM_NUMBER) + MIN_RANDOM_NUMBER;
+    }
+
+    public int findMax(int max) {
+        if (position > max) {
+            max = position;
+        }
+        return max;
+    }
+
+    public String sameMaxPositionCarName(int maxPosition) {
+        if (this.position == maxPosition) {
+            return this.name;
+        }
+        return null;
+    }
+
+    public String getCarState() {
+        String carState = this.name + " : ";
+        for (int i = 0; i < this.position; i++) {
+            carState += "-";
+        }
+        return carState;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Car car = (Car) o;
+        return position == car.position &&
+                Objects.equals(name, car.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, position);
+    }
+}

src/main/java/racingcar/CarGameLauncher.java

@@ -0,0 +1,20 @@
+package racingcar;
+
+import racingcar.view.InputView;
+import racingcar.view.InputViewException;
+import racingcar.view.OutputView;
+
+public class CarGameLauncher {
+    public static void main(String[] args) {
+        doCarGame();
+    }
+
+    public static void doCarGame() {
+        Cars cars = new Cars(InputView.askAndReceiveCarNames());
+        int totalTurns = InputViewException.askAndReceiveTotalTurns();
+        Play.printCarState(cars, totalTurns);
+        Winners winners = new Winners(cars);
+        OutputView.printWinners(winners);
+        System.exit(0);
+    }
+}

src/main/java/racingcar/Cars.java

@@ -0,0 +1,69 @@
+package racingcar;
+
+import java.util.*;
+
+public class Cars {
+    private List<Car> cars = new ArrayList<>();
+
+    Cars(String names) {
+        names = names.replaceAll("\\s+", "");
+        List<String> carNames = new ArrayList<>(Arrays.asList(names.split(",")));
+        instantiateCar(carNames);
+    }
+
+    Cars(ArrayList<Car> cars) {
+        this.cars = cars;
+    }
+
+    public int getSize() {
+        return cars.size();
+    }
+
+    public String getCarState(int index) {
+        return cars.get(index).getCarState();
+    }
+
+    public void updateCarMovement(int index) {
+        cars.get(index).moveCar(Car.randomNumberGenerator());
+    }
+
+    public List<Car> getCars() {
+        return cars;
+    }
+
+    public void instantiateCar(List<String> carNames) {
+        try {
+            isDuplicate(carNames);
+            addCarToCars(carNames);
+        } catch (Exception e) {
+            CarGameLauncher.doCarGame();
+        }
+    }
+
+    public void addCarToCars(List<String> carNames) {
+        for (String name : carNames) {
+            cars.add(new Car(name));
+        }
+    }
+
+    public static void isDuplicate(List<String> names) {
+        Set<String> nameSet = new HashSet<>(names);
+        if (names.size() != nameSet.size()) {
+            System.out.println("이름에 중복이 있습니다!");
+            throw new IllegalArgumentException();
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Cars cars1 = (Cars) o;
+        return Objects.equals(cars, cars1.cars);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(cars);
+    }
+}

src/main/java/racingcar/Play.java

@@ -0,0 +1,31 @@
+package racingcar;
+
+import racingcar.view.OutputView;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Play {
+
+    public static void printCarState(Cars cars, int turn) {
+        OutputView.printResult();
+        for (int i = 0; i < turn; i++) {
+            moveCar(cars);
+            OutputView.printState(getCarStates(cars));
+        }
+    }
+
+    public static List<String> getCarStates(Cars cars) {
+        List<String> carStates = new ArrayList<>();
+        for (int i = 0, n = cars.getSize(); i < n; i++) {
+            carStates.add(cars.getCarState(i));
+        }
+        return carStates;
+    }
+
+    public static void moveCar(Cars cars) {
+        for (int i = 0, n = cars.getSize(); i < n; i++) {
+            cars.updateCarMovement(i);
+        }
+    }
+}

src/main/java/racingcar/Winners.java

@@ -0,0 +1,39 @@
+package racingcar;
+
+import java.util.*;
+
+public class Winners {
+    private List<String> listOfWinners = new ArrayList<>();
+
+    Winners(Cars cars) {
+        List<Car> carsState = cars.getCars();
+        int maxPosition = decideMaxPosition(carsState);
+        decideWinners(carsState, maxPosition);
+    }
+
+    public int decideMaxPosition(List<Car> cars) {
+        int max = 0;
+        for (Car car : cars) {
+            max = car.findMax(max);
+        }
+        return max;
+    }
+
+    public void decideWinners(List<Car> cars, int maxPosition) {
+        for (Car car : cars) {
+            addWinners(car, maxPosition);
+        }
+    }
+
+    public void addWinners(Car car, int maxPosition) {
+        String winnerName = car.sameMaxPositionCarName(maxPosition);
+        if (winnerName != null) {
+            listOfWinners.add(winnerName);
+        }
+    }
+
+    public String getWinners() {
+        return String.join(", ", listOfWinners);
+    }
+
+}