2nd / 3rd 과제 PR _ 문자열 사칙 연산 계산기 구현 / 초간단 자동차 경주 게임

build.gradle

@@ -1,3 +1,5 @@
+
+
 plugins {
     id 'java'
 }

gradle.properties

@@ -1,2 +1,2 @@
 org.gradle.jvmargs=-Dfile.encoding=UTF-8
-org.gradle.console=plain
+org.gradle.console=plain

gradle/wrapper/gradle-wrapper.properties

@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
+zipStorePath=wrapper/dists

gradlew

@@ -72,7 +72,7 @@ case "`uname`" in
   Darwin* )
     darwin=true
     ;;
-  MINGW* )
+  MSYS* | MINGW* )
     msys=true
     ;;
   NONSTOP* )

gradlew.bat

@@ -86,4 +86,4 @@ exit /b 1
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal
 
-:omega
+:omega

src/main/java/Calculator/CalculatorUserInput.java

@@ -0,0 +1,21 @@
+package Calculator;
+
+public class CalculatorUserInput {
+        public int calculateUser(String input) {
+            String[] expression = separate(input);
+
+            int result = getInt(expression[0]);
+            for(int i=0; i<expression.length-2; i+=2){
+                result = Operator.calculate(result, getInt(expression[i+2]), expression[i+1]);
+            }
+            return result;
+        }
+
+        private int getInt(String str){
+            return Integer.parseInt(str);
+        }
+
+        public String[] separate(String str){
+            return str.split(" ");
+        }
+}

src/main/java/Calculator/Operator.java

@@ -0,0 +1,31 @@
+package Calculator;
+
+import java.util.function.BiFunction;
+
+public enum Operator{
+    ADD("+", (operand1, operand2) -> operand1+operand2),
+    SUB("-", (operand1, operand2) -> operand1-operand2),
+    MUL("*", (operand1, operand2) -> operand1*operand2),
+    DIV("/", (operand1, operand2) -> operand1/operand2);
+
+    private String symbol;
+    private BiFunction<Integer, Integer, Integer> expression;
+
+    Operator(String symbol, BiFunction<Integer, Integer, Integer> expression){
+        this.symbol = symbol;
+        this.expression = expression;
+    }
+
+    public static int calculate(int operand1, int operand2, String inputSymbol){
+        for(Operator operator : Operator.values()) {
+            if(operator.match(inputSymbol)){
+                return operator.expression.apply(operand1, operand2);
+            }
+        }
+        throw new IllegalArgumentException();
+    }
+
+    private boolean match(String inputSymbol) {
+        return this.symbol.equals(inputSymbol);
+    }
+}

src/main/java/Car.java

@@ -0,0 +1,30 @@
+public class Car {
+    private final String name;
+    private int position;
+
+    public Car(String name) {
+        validNameCheck(name);
+        this.name = name;
+    }
+
+    private void validNameCheck(String name) {
+        if(name.length() > Constant.CAR_NAME_LIMIT) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getPosition() {
+        return position;
+    }
+
+    public int move(boolean isSuccess) {
+        if(isSuccess){
+            position++;
+        }
+        return position;
+    }
+}

src/main/java/Constant.java

@@ -0,0 +1,8 @@
+public class Constant {
+    // numberConstant
+    public static final int FORWARD_MIN = 4;
+    public static final int FORWARD_MAX = 10;
+    public static final int CAR_NAME_LIMIT = 5;
+
+    public static final char POSITION_MARK = '-';
+}

src/main/java/Control.java

@@ -0,0 +1,16 @@
+public class Control {
+    public static void main(String[] args) {
+
+        InputView inputView = new InputView();
+        inputView.setUpRacingGame();
+
+        ResultView resultView = new ResultView();
+
+        RacingGame racingGame = new RacingGame(inputView.getNames());
+        racingGame.startGame(inputView.getTryCount());
+        racingGame.endGame();
+        resultView.showRacingResult(inputView.getTryCount());
+        resultView.showWinner();
+
+    }
+}

src/main/java/InputView.java

@@ -0,0 +1,22 @@
+import java.util.Scanner;
+
+public class InputView {
+    private String inputNames;
+    private int tryCount;
+
+    public void setUpRacingGame(){
+        Scanner s = new Scanner(System.in);
+        System.out.println("경주할 자동차 이름을 입력하세요(이름은 쉼표(,)를 기준으로 구분).");
+        inputNames = s.nextLine();
+        System.out.println("시도할 회수는 몇 회 인가요?");
+        tryCount = s.nextInt();
+    }
+
+    public String getNames() {
+        return inputNames;
+    }
+
+    public int getTryCount(){
+        return tryCount;
+    }
+}

src/main/java/MoveStrategy.java

@@ -0,0 +1,3 @@
+public interface MoveStrategy {
+    public boolean isMoveAble();
+}

src/main/java/RacingCars.java

@@ -0,0 +1,32 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class RacingCars {
+
+    private final Map<Car, List<Integer>> positionInfo = new HashMap<>();
+
+    public RacingCars(String inputNames){
+        readyGame(splitNames(inputNames));
+    }
+
+    private String[] splitNames(String names) {
+        return names.split(",");
+    }
+
+    private void readyGame(String[] cars) {
+        for(String name : cars) {
+            positionInfo.put(new Car(name), new ArrayList<>());
+        }
+    }
+
+    public void moveCars() {
+       positionInfo.forEach((k, v) -> v.add(k.move(new RandomMoveStrategy().isMoveAble())));
+    }
+
+    public Map<Car, List<Integer>> getPositionInfo() {
+        return positionInfo;
+    }
+
+}

src/main/java/RacingGame.java

@@ -0,0 +1,20 @@
+public class RacingGame {
+
+    private final RacingCars cars;
+
+    public RacingGame(String inputNames) {
+        this.cars = new RacingCars(inputNames);
+    }
+
+    public void startGame(int tryCount){
+        for(int i=0; i<tryCount; i++){
+            cars.moveCars();
+        }
+    }
+
+    public void endGame(){
+        Winner winner = new Winner(cars.getPositionInfo());
+        winner.findWinner();
+    }
+
+}

src/main/java/RandomMoveStrategy.java

@@ -0,0 +1,15 @@
+import java.util.Random;
+
+public class RandomMoveStrategy implements MoveStrategy{
+
+    private final Random random = new Random();
+
+    @Override
+    public boolean isMoveAble() {
+        return getRandomNumber() >= Constant.FORWARD_MIN;
+    }
+
+    private int getRandomNumber() {
+        return random.nextInt(Constant.FORWARD_MAX);
+    }
+}

src/main/java/ResultView.java

@@ -0,0 +1,26 @@
+public class ResultView {
+    RacingCars cars;
+    private Winner winner;
+
+    public void showRacingResult(int tryCount) {
+        for(int i=0; i<tryCount; i++) {
+            final int index = i;
+            cars.getPositionInfo().forEach((k, v) -> showCarPosition(k, v.get(index)));
+        }
+    }
+
+    public void showWinner() {
+        String winnerName = String.join(",", winner.getWinnerNames());
+        System.out.println(winnerName + " 가 최종우승했습니다.");
+    }
+
+    private void showCarPosition(Car car, int position){
+
+        System.out.println(car.getName() + " : ");
+            for (int i=0; i<position; i++) {
+                System.out.print(Constant.POSITION_MARK);
+            }
+            System.out.println();
+        };
+    }
+

src/main/java/Winner.java

@@ -0,0 +1,40 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class Winner {
+    private final Map<Car, List<Integer>> infoCar;
+    private final List<String> winnerNames = new ArrayList<>();
+    private int max=0;
+
+    public Winner(Map<Car, List<Integer>> infoCar) {
+        this.infoCar = infoCar;
+    }
+
+    public List<String> getWinnerNames() {
+        return winnerNames;
+    }
+
+    public Map<Car, List<Integer>> getInfoCar() {
+        return infoCar;
+    }
+
+    public void findWinner() {
+        findMaxPosition();
+        addWinner();
+    }
+
+    private void addWinner() {
+        for(Car car : infoCar.keySet()){
+            if(max == car.getPosition()){
+                winnerNames.add(car.getName());
+            }
+        }
+    }
+
+    private void findMaxPosition() {
+        for(Car car : infoCar.keySet()){
+            max = Math.max(max, car.getPosition());
+        }
+    }
+}

src/test/java/CalculatorTest/CalculatorTest.java

@@ -0,0 +1,49 @@
+package CalculatorTest;
+
+import Calculator.CalculatorUserInput;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class CalculatorTest {
+    CalculatorUserInput calculator = new CalculatorUserInput();
+
+    @Test
+    @DisplayName("더하기 테스트")
+    void addtest(){
+        assertThat(5).isEqualTo(calculator.calculateUser("3 + 2"));
+    }
+
+    @Test
+    @DisplayName("빼기 테스트")
+    void substracttest(){
+        assertThat(5).isEqualTo(calculator.calculateUser("12 - 7"));
+    }
+
+    @Test
+    @DisplayName("곱하기 테스트")
+    void multiplytest(){
+        assertThat(5).isEqualTo(calculator.calculateUser("5 * 1"));
+    }
+
+    @Test
+    @DisplayName("나누기 테스트")
+    void dividetest(){
+        assertThat(5).isEqualTo(calculator.calculateUser("25 / 5"));
+    }
+
+    @Test
+    @DisplayName("문자열 나누기 테스트")
+    void seperatetest(){
+        String str = "3 + 2";
+        String[] result = {"3", "+", "2"};
+        assertThat(result).isEqualTo(calculator.separate(str));
+    }
+
+    @Test
+    @DisplayName("사칙 연산 모두 포함하는 테스트")
+    void allarithmetictest(){
+        assertThat(5).isEqualTo(calculator.calculateUser("3 + 12 - 5 * 4 / 8"));
+    }
+}

src/test/java/CalculatorTest/ExceptionCalculatorTest.java

@@ -0,0 +1,29 @@
+package CalculatorTest;
+
+import Calculator.CalculatorUserInput;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class ExceptionCalculatorTest{
+    CalculatorUserInput calculator = new CalculatorUserInput();
+
+    @Test
+    @DisplayName("입력 값이 null 또는 빈 공백 문자인지 테스트")
+    void inputformExceptiontest(){
+        String str = "";
+        assertThatThrownBy(()->{
+            calculator.calculateUser(str);
+        }).isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    @DisplayName("사칙연산 기호 테스트")
+    void operatorExceptiontest(){
+        String str = "2 $ 3";
+        assertThatThrownBy(()->{
+            calculator.calculateUser(str);
+        }).isInstanceOf(IllegalArgumentException.class);
+    }
+}