피드백 후 다시 구현

README.md

@@ -24,3 +24,68 @@ git checkout main // 기본 브랜치가 main인 경우
 git checkout -b 브랜치이름
 ex) git checkout -b apply-feedback
 ```
+---
+숫자야구 To Do List
+* 숫자를 입력받는다
+  1. 3자리 수인지 확인
+  2. 1~9사이의 수인지 확인
+  3. 중복된 값이 있는지 확인
+* 컴퓨터의 랜덤 숫자를 만든다
+  1. 3자리 수인지 확인
+  2. 1~9사이의 수인지 확인
+  3. 중복된 값이 있는지 확인
+* 입력한 수가 스트라이크가 몇개인지 확인
+* 입련한 수가 볼이 몇개인지 확인
+
+---
+수정내용
+* 숫자를 입력받는다
+  3자리 수인지 확인 -> 3자리 확인 + 숫자인지 확인 두가지 책임이 같이있으므로 분리
+  1~9사이의 수인지 확인 -> 앞에서 이미 체크한 내용이므로 제거
+
+수정 후 
+* 숫자를 입력받는다
+  1. 3자리 확인
+  2. 숫자인지 확인
+  3. 중복된 값이 있는지 확인
+
+---
+수정내용
+* 컴퓨터의 랜덤 3자리 숫자를 만든다
+  3자리 수인지 확인 -> 입력받아서 처리하는게 아니기 때문에 필요없음
+  1~9사이의 수인지 확인 -> 입력받아서 처리하는게 아니기 때문에 필요없음
+
+수정 후
+* 컴퓨터의 랜덤 3자리 숫자를 만든다
+  1. 중복된 값이 있는지 확인
+---
+
+수정내용
+* 입력한 수가 스트라이크가 몇개인지 확인
+* 입련한 수가 볼이 몇개인지 확인
+  몇개인지 확인하는건 여러기능을 복합적으로 확인해야함.
+
+수정 후
+* 입력한 수가 스트라이크인지, 볼인지 낫띵인지 확인
+  1. 위치와 숫자가 동일하면 스트라이크
+  2. 숫자만 존재한다면 볼
+  3. 숫자가 존재하지 않다면 낫띵
+ex)
+computer / user
+위치, 숫자 / 위치, 숫자
+1, 1     /  1, 1     스트라이크
+1, 1     /  2, 1     볼
+1, 1     /  2, 4     낫띵
+
+---
+(1,1), (2,5), (3,2) / (1,7), (2,6), (3,5) -> 1볼
+(1,1), (2,5), (3,2) / (1,1), (2,6), (3,5) -> 1볼 1스트라이크
+(1,1), (2,5), (3,2) / (1,1), (2,5), (3,2) -> 3스트라이크
+
+---
+* 숫자를 입력받는다
+  1. 3자리 확인
+  2. 1~9 인지 확인
+  3. 중복된 값이 있는지 확인
+* 컴퓨터의 랜덤 3자리 숫자를 만든다
+  1. 중복된 값이 있는지 확인

src/main/java/Main.java

@@ -0,0 +1,6 @@
+public class Main {
+    public static void main(String[] args) {
+
+
+    }
+}

src/main/java/baseball/Ball.java

@@ -0,0 +1,44 @@
+package baseball;
+
+import java.util.*;
+
+public class Ball {
+
+    private final int position;
+    private final int number;
+
+    public Ball(int position, int number) {
+        this.position = position;
+        this.number = number;
+    }
+
+    public BallStatus play(Ball ball) {
+        if(this.equals(ball)){
+            return BallStatus.STRIKE;
+        }
+
+        if(this.matchBallNumber(ball.number)){
+            return BallStatus.BALL;
+        }
+
+        return BallStatus.NOTHING;
+    }
+
+    public boolean matchBallNumber(int number){
+        return this.number == number;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Ball ball = (Ball) o;
+        return position == ball.position && number == ball.number;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(position, number);
+    }
+
+}

src/main/java/baseball/BallStatus.java

@@ -0,0 +1,13 @@
+package baseball;
+
+public enum BallStatus {
+    BALL, NOTHING, STRIKE;
+
+    public boolean isStrike() {
+        return this == STRIKE;
+    }
+
+    public boolean isBall() {
+        return this == BALL;
+    }
+}

src/main/java/baseball/Balls.java

@@ -0,0 +1,46 @@
+package baseball;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Balls {
+
+    private final List<Ball> results;
+    private final int MAX_SIZE = 3;
+    public Balls(List<Integer> numbers) {
+        checkSize(numbers);
+        this.results = mapBall(numbers);
+    }
+
+    private void checkSize(List<Integer> numbers){
+        if(numbers.size() > MAX_SIZE){
+            throw new IllegalArgumentException("볼 사이즈가 올바르지 않습니다");
+        }
+    }
+
+    private List<Ball> mapBall(List<Integer> numbers){
+        List<Ball> balls = new ArrayList<>();
+        for (int i = 0; i < MAX_SIZE; i++) {
+            Ball ball = new Ball(i+1, numbers.get(i));
+            balls.add(ball);
+        }
+        return balls;
+    }
+
+    public BallStatus compare(Ball ball) {
+        return results.stream()
+                .map(result -> result.play(ball))
+                .filter(status -> status != BallStatus.NOTHING)
+                .findFirst()
+                .orElse(BallStatus.NOTHING);
+    }
+
+    public BaseBallResult play(Balls userBalls) {
+        BaseBallResult result = new BaseBallResult();
+        for (int i = 0; i < MAX_SIZE; i++) {
+            BallStatus status = userBalls.compare(this.results.get(i));
+            result.add(status);
+        }
+        return result;
+    }
+}

src/main/java/baseball/BaseBallResult.java

@@ -0,0 +1,33 @@
+package baseball;
+
+public class BaseBallResult {
+    private int strikeCount = 0;
+    private int ballCount = 0;
+
+    public boolean isNotThing() {
+        return strikeCount == 0 && ballCount == 0;
+    }
+
+    public void add(BallStatus status) {
+        if( status.isStrike() ){
+            strikeCount++;
+            return;
+        }
+        if( status.isBall() ){
+            ballCount++;
+        }
+
+    }
+
+    public int getStrikeCount() {
+        return strikeCount;
+    }
+
+    public int getBallCount() {
+        return ballCount;
+    }
+
+    public boolean isGameOver() {
+        return strikeCount == 3;
+    }
+}

src/main/java/baseball/util/ValidationUtils.java

@@ -0,0 +1,24 @@
+package baseball.util;
+
+import java.util.List;
+import java.util.regex.Pattern;
+
+public class ValidationUtils {
+
+    private static final String NUMBER_REGEX = "^[0-9]*$";
+
+    public static boolean isNumber(String text) {
+        return Pattern.matches(NUMBER_REGEX, text);
+    }
+
+    public static boolean macthLength(String text, int length) {
+        return text.length() == length;
+    }
+
+    public static boolean isDuplicationNumber(List<Integer> numberList) {
+        long distinctCount = numberList.stream()
+                .distinct()
+                .count();
+        return numberList.size() == distinctCount;
+    }
+}

src/test/java/study/BallTest.java

@@ -0,0 +1,36 @@
+package study;
+
+import baseball.Ball;
+import baseball.BallStatus;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+public class BallTest {
+
+    private Ball computerBall;
+
+    @BeforeEach
+    void setUp(){
+        computerBall = new Ball(1,1);
+    }
+
+    @Test
+    void strike(){
+        Ball userBall = new Ball(1,1);
+        assertThat(computerBall.play(userBall)).isEqualTo(BallStatus.STRIKE);
+    }
+
+    @Test
+    void ball(){
+        Ball userBall = new Ball(2,1);
+        assertThat(computerBall.play(userBall)).isEqualTo(BallStatus.BALL);
+    }
+
+    @Test
+    void nothing(){
+        Ball userBall = new Ball(3,3);
+        assertThat(computerBall.play(userBall)).isEqualTo(BallStatus.NOTHING);
+    }
+}

src/test/java/study/BallsTest.java

@@ -0,0 +1,65 @@
+package study;
+
+import baseball.Ball;
+import baseball.BallStatus;
+import baseball.Balls;
+import baseball.BaseBallResult;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+public class BallsTest {
+
+    @Test
+    void play_gameOver(){
+        Balls computerBalls = new Balls(Arrays.asList(1,2,3));
+        Balls userBalls = new Balls(Arrays.asList(1,2,3));
+        BaseBallResult result = computerBalls.play(userBalls);
+        assertThat(result.isGameOver()).isTrue();
+    }
+    @Test
+    void play_nothing(){
+        Balls computerBalls = new Balls(Arrays.asList(1,2,3));
+        Balls userBalls = new Balls(Arrays.asList(4,5,6));
+        BaseBallResult result = computerBalls.play(userBalls);
+        assertThat(result.isNotThing()).isTrue();
+    }
+    @Test
+    void play_one_strike_one_ball(){
+        Balls computerBalls = new Balls(Arrays.asList(1,2,3));
+        Balls userBalls = new Balls(Arrays.asList(1,3,6));
+        BaseBallResult result = computerBalls.play(userBalls);
+        assertThat(result.getStrikeCount()).isEqualTo(1);
+        assertThat(result.getBallCount()).isEqualTo(1);
+    }
+    @Test
+    void play_one_strike(){
+        Balls computerBalls = new Balls(Arrays.asList(1,2,3));
+        Balls userBalls = new Balls(Arrays.asList(1,5,6));
+        BaseBallResult result = computerBalls.play(userBalls);
+        assertThat(result.getStrikeCount()).isEqualTo(1);
+    }
+
+    @Test
+    void nothing(){
+        Balls balls = new Balls(Arrays.asList(1,2,3));
+        BallStatus status = balls.compare(new Ball(1,4));
+        assertThat(status).isEqualTo(BallStatus.NOTHING);
+    }
+
+    @Test
+    void ball(){
+        Balls balls = new Balls(Arrays.asList(1,2,3));
+        BallStatus status = balls.compare(new Ball(1,3));
+        assertThat(status).isEqualTo(BallStatus.BALL);
+    }
+
+    @Test
+    void strike(){
+        Balls balls = new Balls(Arrays.asList(1,2,3));
+        BallStatus status = balls.compare(new Ball(1,1));
+        assertThat(status).isEqualTo(BallStatus.STRIKE);
+    }
+}

src/test/java/study/ValidationUtilsTest.java

@@ -0,0 +1,40 @@
+package study;
+
+import baseball.util.ValidationUtils;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+public class ValidationUtilsTest {
+
+    @Test
+    void checkNumber(){
+        assertThat(ValidationUtils.isNumber("2")).isTrue();
+        assertThat(ValidationUtils.isNumber("s")).isFalse();
+        assertThat(ValidationUtils.isNumber("223424")).isTrue();
+        assertThat(ValidationUtils.isNumber("1w2")).isFalse();
+        assertThat(ValidationUtils.isNumber("s1s")).isFalse();
+    }
+
+    @Test
+    void checkDigits(){
+        assertThat(ValidationUtils.macthLength("123",3)).isTrue();
+        assertThat(ValidationUtils.macthLength("123s",3)).isFalse();
+        assertThat(ValidationUtils.macthLength("1",0)).isFalse();
+    }
+
+    @Test
+    void distinctNumber(){
+
+        assertThat(ValidationUtils.isDuplicationNumber(Arrays.asList(1, 1, 1))).isFalse();
+        assertThat(ValidationUtils.isDuplicationNumber(Arrays.asList(1, 2, 3))).isTrue();
+        assertThat(ValidationUtils.isDuplicationNumber(Arrays.asList(1, 3))).isTrue();
+        assertThat(ValidationUtils.isDuplicationNumber(Arrays.asList(1, 1))).isFalse();
+        assertThat(ValidationUtils.isDuplicationNumber(Arrays.asList(1))).isTrue();
+        assertThat(ValidationUtils.isDuplicationNumber(Arrays.asList())).isTrue();
+    }
+
+
+}