[kakao] frank 사전 과제 제출합니다.

README.md

@@ -1 +1,69 @@
-# java-baseball-precourse
+~~# java-baseball-precourse
+
+## ⚾ 숫자 야구 게임 구현 기능 목록
+
+### 1. 게임 실행
+- 프로그램 시작 시 숫자 야구 게임을 실행한다.
+- 사용자에게 게임 시작 안내 문구를 출력한다.
+
+---
+
+### 2. 숫자 야구 게임 정답 생성
+- 컴퓨터는 1~9 사이의 서로 다른 숫자 3개를 랜덤으로 생성한다.
+- 생성된 숫자는 게임이 끝날 때까지 정답으로 유지한다.
+
+---
+
+### 3. 사용자 입력 처리
+- 사용자가 3자리 숫자를 입력한다.
+- 입력은 한 번에 문자열 형태로 받는다.
+
+---
+
+### 4. 입력 검증
+사용자의 입력이 올바른 형식인지 검증한다.
+
+#### 4-2. 입력 길이가 3인지 확인
+- 입력값이 정확히 3자리인지 검사한다.
+
+#### 4-2. 숫자만 입력되었는지 확인
+- 입력값이 1-9 사이의 숫자로만 구성되어 있는지 검사한다.
+
+#### 4-3. 중복 숫가 존재하는 지 확인
+- 입력값이 1-9 사이의 숫자로만 구성되어 있는지 검사한다.
+
+#### 4-4. 예외 발생 시 출력
+- 잘못된 입력이 들어오면 [ERROR]로 시작하는 메시지를 출력한다.
+
+---
+
+### 5. 판정 로직
+입력값과 정답을 비교하여 결과를 판정한다.
+
+#### 5-1. Strike 판정
+- 숫자와 위치가 모두 일치하면 `strike`로 판단한다.
+
+#### 5-2. Ball 판정
+- 숫자는 포함되지만 위치가 다르면 `ball`로 판단한다.
+
+#### 5-3. Nothing 판정
+- 일치하는 숫자가 하나도 없다면 `낫싱`을 출력한다.
+
+---
+
+### 6. 결과 출력
+- 판정 결과에 따라 `볼`, `스트라이크`, `낫싱`을 출력한다.
+- 3 strike가 되면 게임 종료 문구를 출력한다.
+
+---
+
+### 7. 재시작 및 종료
+게임이 종료된 후 사용자의 선택을 입력받는다.
+
+#### 7-1. 게임 재시작
+- 사용자가 `1`을 입력하면 새로운 게임을 시작한다.
+
+#### 7-2. 게임 종료
+- 사용자가 `2`를 입력하면 프로그램을 종료한다.~~
+
+

build.gradle

@@ -1,5 +1,6 @@
 plugins {
     id 'java'
+    id 'application'
 }
 
 group = 'camp.nextstep.edu'
@@ -23,3 +24,7 @@ dependencies {
 test {
     useJUnitPlatform()
 }
+
+application {
+    mainClass = 'Application'
+}

src/main/java/Application.java

@@ -0,0 +1,17 @@
+import controller.GameController;
+import service.GameService;
+import view.InputView;
+import view.OutputView;
+import service.RandomNumberGenerator;
+
+public class Application {
+    public static void main(String[] args) {
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+        GameService gameService = new GameService(
+                new RandomNumberGenerator()
+        );
+
+        new GameController(inputView, outputView, gameService).run();
+    }
+}

src/main/java/controller/GameController.java

@@ -0,0 +1,57 @@
+package controller;
+
+import domain.JudgeCount;
+import service.GameService;
+import util.Validator;
+import view.InputView;
+import view.OutputView;
+
+public class GameController {
+    private final InputView inputView;
+    private final OutputView outputView;
+    private final GameService gameService;
+
+    public GameController(InputView inputView, OutputView outputView, GameService gameService) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+        this.gameService = gameService;
+    }
+
+    public void run() {
+        outputView.printStartMessage();
+        while (true) {
+            playGame();
+            if (shouldStop()) {
+                return;
+            }
+        }
+    }
+
+    private void playGame() {
+        gameService.startNewGame();
+        playUntilWin();
+    }
+
+    private void playUntilWin() {
+        while (!gameService.isGameOver()) {
+            try {
+                JudgeCount count = gameService.play(inputView.readGuess());
+                outputView.printResult(count);
+            } catch (IllegalArgumentException exception) {
+                outputView.printError(exception.getMessage());
+            }
+        }
+        outputView.printGameEndMessage();
+    }
+
+    private boolean shouldStop() {
+        while (true) {
+            String input = inputView.readRestartCommand();
+            String error = Validator.restartError(input);
+            if (error == null) {
+                return "2".equals(input);
+            }
+            outputView.printError(error);
+        }
+    }
+}

src/main/java/domain/Game.java

@@ -0,0 +1,20 @@
+package domain;
+
+public class Game {
+    private final Numbers answer;
+    private JudgeCount lastCount;
+
+    public Game(Numbers answer) {
+        this.answer = answer;
+    }
+
+    public JudgeCount play(String guessInput) {
+        JudgeCount count = answer.judge(Numbers.from(guessInput));
+        lastCount = count;
+        return count;
+    }
+
+    public boolean isOver() {
+        return lastCount != null && lastCount.isThreeStrikes();
+    }
+}

src/main/java/domain/JudgeCount.java

@@ -0,0 +1,8 @@
+package domain;
+
+public record JudgeCount(int ball, int strike) {
+
+    public boolean isThreeStrikes() {
+        return strike == 3;
+    }
+}

src/main/java/domain/Number.java

@@ -0,0 +1,25 @@
+package domain;
+
+import util.Validator;
+
+public class Number {
+    private final int value;
+
+    private Number(int value) {
+        this.value = value;
+    }
+
+    public static Number fromChar(char digitChar) {
+        String error = Validator.numberError(digitChar);
+        if (error != null) throw new IllegalArgumentException(error);
+        return new Number(digitChar - '0');
+    }
+
+    public int value() {
+        return value;
+    }
+
+    public boolean same(int other) {
+        return value == other;
+    }
+}

src/main/java/domain/Numbers.java

@@ -0,0 +1,64 @@
+package domain;
+
+import util.Validator;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Numbers {
+    private static final int LENGTH = 3;
+    private final List<Number> numbers;
+
+    private Numbers(List<Number> numbers) {
+        this.numbers = numbers;
+    }
+
+    public static Numbers from(String input) {
+        String error = Validator.guessError(input);
+        if (error != null) {
+            throw new IllegalArgumentException(error);
+        }
+        return new Numbers(parse(input));
+    }
+
+    private static List<Number> parse(String input) {
+        List<Number> parsedNumbers = new ArrayList<>(LENGTH);
+        for (char digitChar : input.toCharArray()) {
+            parsedNumbers.add(Number.fromChar(digitChar));
+        }
+        return parsedNumbers;
+    }
+
+    public int get(int index) {
+        return numbers.get(index).value();
+    }
+
+    public boolean contains(int number) {
+        for (Number numberItem : numbers) {
+            if (numberItem.same(number)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public int size() {
+        return numbers.size();
+    }
+
+    public JudgeCount judge(Numbers guess) {
+        int ball = 0;
+        int strike = 0;
+        for (int index = 0; index < size(); index++) {
+            int guessDigit = guess.get(index);
+            if (guessDigit == get(index)) {
+                strike++;
+                continue;
+            }
+            if (contains(guessDigit)) {
+                ball++;
+            }
+        }
+        return new JudgeCount(ball, strike);
+    }
+}

src/main/java/service/GameService.java

@@ -0,0 +1,27 @@
+package service;
+
+import domain.Game;
+import domain.JudgeCount;
+import domain.Numbers;
+
+public class GameService {
+    private final RandomNumberGenerator randomNumberGenerator;
+    private Game currentGame;
+
+    public GameService(RandomNumberGenerator randomNumberGenerator) {
+        this.randomNumberGenerator = randomNumberGenerator;
+    }
+
+    public void startNewGame() {
+        Numbers answer = randomNumberGenerator.numberGenerate();
+        currentGame = new Game(answer);
+    }
+
+    public JudgeCount play(String guessInput) {
+        return currentGame.play(guessInput);
+    }
+
+    public boolean isGameOver() {
+        return currentGame.isOver();
+    }
+}

src/main/java/service/RandomNumberGenerator.java

@@ -0,0 +1,26 @@
+package service;
+
+import domain.Numbers;
+
+import java.util.concurrent.ThreadLocalRandom;
+
+public class RandomNumberGenerator {
+    public Numbers numberGenerate() {
+        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        shuffle(numbers);
+        return Numbers.from("" + numbers[0] + numbers[1] + numbers[2]);
+    }
+
+    private void shuffle(int[] numbers) {
+        for (int currentIndex = numbers.length - 1; currentIndex > 0; currentIndex--) {
+            int swapIndex = ThreadLocalRandom.current().nextInt(currentIndex + 1);
+            swap(numbers, currentIndex, swapIndex);
+        }
+    }
+
+    private void swap(int[] numbers, int firstIndex, int secondIndex) {
+        int temp = numbers[firstIndex];
+        numbers[firstIndex] = numbers[secondIndex];
+        numbers[secondIndex] = temp;
+    }
+}

src/main/java/util/Validator.java

@@ -0,0 +1,54 @@
+package util;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Validator {
+    private static final String ERROR_PREFIX = "[ERROR] ";
+    private static final int INPUT_LENGTH = 3;
+    private static final String RESTART_CODE = "1";
+    private static final String EXIT_CODE = "2";
+
+    public static String guessError(String input) {
+        if (input.length() != INPUT_LENGTH) {
+            return errorMessage(INPUT_LENGTH + "자여야 합니다.");
+        }
+        return validateCharacters(input);
+    }
+
+    private static String validateCharacters(String input) {
+        Set<Character> uniqueChars = new HashSet<>();
+
+        for (char digitChar : input.toCharArray()) {
+            String error = numberError(digitChar);
+            if (error != null) {
+                return error;
+            }
+            if (!uniqueChars.add(digitChar)) {
+                return errorMessage("중복된 숫자는 사용할 수 없습니다.");
+            }
+        }
+        return null;
+    }
+
+    public static String numberError(char digitChar) {
+        if (!Character.isDigit(digitChar)) {
+            return errorMessage("숫자만 입력해야 합니다.");
+        }
+        if (digitChar == '0') {
+            return errorMessage("0은 사용할 수 없습니다.");
+        }
+        return null;
+    }
+
+    public static String restartError(String input) {
+        if (RESTART_CODE.equals(input) || EXIT_CODE.equals(input)) {
+            return null;
+        }
+        return errorMessage(String.format("%s(재시작), %s(종료)만 입력 가능합니다.", RESTART_CODE, EXIT_CODE));
+    }
+
+    private static String errorMessage(String message) {
+        return ERROR_PREFIX + message;
+    }
+}