Step2 auto

README.md

@@ -18,4 +18,26 @@
 
 
 ## Step 1 힌트
-- [] 테스트할 수 있는 단위로 나누어 구현 목록을 만든다.
+- [X] 테스트할 수 있는 단위로 나누어 구현 목록을 만든다.
+
+
+## Step 2 기능 요구사항
+- [X] 사용자는 구입 금액을 입력할 수 있다.
+- [X] 구입 금액에 따라 해당 개수의 로또를 자동 발급해야 한다.
+- [X] 로또 1장의 가격은 1000원이다.
+- [X] 발급된 각 로또는 서로 다른 6개의 숫자(1~45 사이)로 구성되어야 한다.
+- [X] 발급된 로또 목록을 출력한다.
+- [X] 사용자로부터 지난 주 당첨 번호 6개를 입력받는다. 중복 없이 6개의 숫자를 입력해야 하며, 숫자는 1~45 사이여야 한다.
+- [X] 발급된 로또들에 대해 당첨 번호와의 일치 개수를 계산한다.
+- [X] 아래와 같은 기준으로 일치하는 로또 개수 통계를 출력한다:  
+  - 3개	5,000원  
+  - 4개	50,000원  
+  - 5개	1,500,000원  
+  - 6개	2,000,000,000원  
+- [X] 수익률을 계산해 출력한다. 수익률은 (당첨금-구입금액)/구입금액 으로 계산한다.
+- [X] 수익률 결과에 대해 기준이 1이라는 안내 메시지를 출력한다.
+
+## Step 2 힌트
+- [X] 로또 자동 생성은 Collections.shuffle() 메소드 활용한다.
+- [X] Collections.sort() 메소드를 활용해 정렬 가능하다.
+- [X] ArrayList의 contains() 메소드를 활용하면 어떤 값이 존재하는지 유무를 판단할 수 있다.

src/main/java/step1/calc/calculator/Calculator.java

@@ -3,15 +3,16 @@
 
 import java.util.List;
 import step1.calc.operand.Operand;
+import step1.calc.operation.Operation;
 import step1.calc.operator.Operator;
 
 public class Calculator {
 
     public Operand calculate(List<String> expressions) {
         Operand result = new Operand(expressions.get(0));
         for (int i = 1; i < expressions.size(); i += 2) {
-            Operator operator = new Operator(expressions.get(i));
-            result = operator.operate(result, new Operand(expressions.get(i + 1)));
+            Operation operation = Operator.getOperation(expressions.get(i));
+            result = operation.operate(result, new Operand(expressions.get(i + 1)));
         }
         return result;
     }

src/main/java/step1/calc/operator/Operator.java

@@ -17,17 +17,13 @@ public class Operator {
         "/", new Division()
     );
 
-    private final Operation operation;
-
-    public Operator(String symbol) {
-        this.operation = OPERATION_MAP.get(symbol);
-        if (this.operation == null) {
+    public static Operation getOperation(String symbol) {
+        Operation operation = OPERATION_MAP.get(symbol);
+        if (operation == null) {
             throw new IllegalArgumentException("지원하지 않는 연산자입니다: " + symbol);
         }
+        return operation;
     }
 
-    public Operand operate(Operand a, Operand b) {
-        return operation.operate(a, b);
-    }
 }
 

src/main/java/step2/lotto/Main.java

@@ -0,0 +1,25 @@
+package step2.lotto;
+
+import step2.lotto.domain.Lottos;
+import step2.lotto.domain.Statistic;
+import step2.lotto.game.Game;
+import step2.lotto.view.InputView;
+import step2.lotto.view.ResultView;
+
+public class Main {
+
+    public static void main(String[] args) {
+        int paidMoney = InputView.getPaidMoney();
+
+        Game game = new Game();
+        Lottos lottos = game.createLottos(paidMoney);
+        ResultView.showLottos(lottos);
+
+        String winningLotto = InputView.lastWeekLottoNumbers();
+        Statistic stat = game.play(winningLotto);
+
+        ResultView.showStatistics(stat, paidMoney);
+
+    }
+
+}

src/main/java/step2/lotto/domain/Lotto.java

@@ -0,0 +1,47 @@
+package step2.lotto.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class Lotto {
+
+    private final List<Integer> lottoNumbers;
+
+    public Lotto(List<Integer> lottoNumbers) {
+        lottoNumbers.forEach(this::validateNumber);
+        checkDuplicate(lottoNumbers);
+        checkSize(lottoNumbers);
+        this.lottoNumbers = lottoNumbers;
+    }
+
+    private void validateNumber(int lottoNumber) {
+        if (lottoNumber < 1 || lottoNumber > 45) {
+            throw new IllegalArgumentException("로또 번호는 1부터 45까지의 숫자만 가능합니다.");
+        }
+    }
+
+    private void checkSize(List<Integer> lottoNumbers) {
+        if (lottoNumbers.size() != 6) {
+            throw new IllegalArgumentException("로또 번호는 6개여야 합니다.");
+        }
+    }
+
+    private void checkDuplicate(List<Integer> lottoNumbers) {
+        if (lottoNumbers.stream().distinct().count() != lottoNumbers.size()) {
+            throw new IllegalArgumentException("로또 번호는 중복될 수 없습니다.");
+        }
+    }
+
+    public List<Integer> lottoNumbers() {
+        return lottoNumbers;
+    }
+
+    public int matchCount(Lotto lastWeekLotto) {
+        return (int) this.lottoNumbers().stream()
+            .filter(lastWeekLotto.lottoNumbers()::contains)
+            .count();
+    }
+
+
+}

src/main/java/step2/lotto/domain/LottoNumberGenerator.java

@@ -0,0 +1,24 @@
+package step2.lotto.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class LottoNumberGenerator {
+
+    private final List<Integer> numbers;
+
+    public LottoNumberGenerator() {
+        this.numbers = new ArrayList<>();
+        for (int i = 1; i <= 45; i++) {
+            numbers.add(i);
+        }
+    }
+
+    public List<Integer> generate() {
+        Collections.shuffle(numbers);
+        List<Integer> generatedNumbers = new ArrayList<>(numbers.subList(0, 6));
+        Collections.sort(generatedNumbers);
+        return generatedNumbers;
+    }
+}

src/main/java/step2/lotto/domain/Lottos.java

@@ -0,0 +1,21 @@
+package step2.lotto.domain;
+
+import java.util.List;
+
+public class Lottos {
+
+    private List<Lotto> lottos;
+
+    public Lottos(List<Lotto> lottos) {
+        this.lottos = lottos;
+    }
+
+    public int size() {
+        return lottos.size();
+    }
+
+    public List<Lotto> getLottos() {
+        return lottos;
+    }
+
+}

src/main/java/step2/lotto/domain/Statistic.java

@@ -0,0 +1,48 @@
+package step2.lotto.domain;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Statistic {
+
+    public static final Map<Integer, Integer> PRIZE_MAP = Map.of(
+        3, 5000,
+        4, 50000,
+        5, 1500000,
+        6, 2000000000
+    );
+    private final Map<Integer, Integer> matchCountMap = new HashMap<>();
+    private int totalPrize = 0;
+
+    public void calculate(Lottos lottos, Lotto lastWeekLotto) {
+        for (Lotto lotto : lottos.getLottos()) {
+            int match = lotto.matchCount(lastWeekLotto);
+            statistic(match);
+        }
+    }
+
+    public Map<Integer, Integer> getMatchCountMap() {
+        return matchCountMap;
+    }
+
+    public int getTotalPrize() {
+        return totalPrize;
+    }
+
+    private void statistic(int match) {
+        if (match >= 3) {
+            matchCountMap.put(match, matchCountMap.getOrDefault(match, 0) + 1);
+            totalPrize += PRIZE_MAP.get(match);
+        }
+    }
+
+    public double getProfitRate(int paidMoney) {
+        // lottoCount * 1000 = 총 투자금
+        int lottoCount = paidMoney / 1000;
+        if (lottoCount <= 0) {
+            return 0.0;
+        }
+        return (double) totalPrize / paidMoney;
+
+    }
+}

src/main/java/step2/lotto/game/Game.java

@@ -0,0 +1,55 @@
+package step2.lotto.game;
+
+import java.util.ArrayList;
+import java.util.List;
+import step2.lotto.domain.LottoNumberGenerator;
+import step2.lotto.domain.Lotto;
+import step2.lotto.domain.Lottos;
+import step2.lotto.domain.Statistic;
+
+public class Game {
+
+    private final int LOTTO_PRICE = 1000;
+    private int gameCount;
+    private final LottoNumberGenerator generator;
+    private Lottos lottos;
+
+    public Game() {
+        this.generator = new LottoNumberGenerator();
+    }
+
+    public Lottos createLottos(int paidMoney) {
+        calculateLottoCount(paidMoney);
+        rollingLotto();
+        return lottos;
+    }
+
+    public void calculateLottoCount(int paidMoney) {
+        gameCount = paidMoney / LOTTO_PRICE;
+    }
+
+    public void rollingLotto() {
+        List<Lotto> lotto = new ArrayList<>();
+        for (int i = 0; i < gameCount; i++) {
+            lotto.add(new Lotto(generator.generate()));
+        }
+        this.lottos = new Lottos(lotto);
+    }
+
+    public Statistic play(String winningLotto) {
+        Lotto lastWeekLotto = new Lotto(convertStringToList(winningLotto));
+        Statistic stat = new Statistic();
+        stat.calculate(lottos, lastWeekLotto);
+        return stat;
+    }
+
+    private List<Integer> convertStringToList(String lastWeekLottoResult) {
+        String[] split = lastWeekLottoResult.trim().split(",");
+        List<Integer> integerList = new ArrayList<>();
+        for (String s : split) {
+            integerList.add(Integer.parseInt(s.trim()));
+        }
+        return integerList;
+    }
+
+}

src/main/java/step2/lotto/view/InputView.java

@@ -0,0 +1,20 @@
+package step2.lotto.view;
+
+import java.util.Scanner;
+
+public class InputView {
+
+    private static final Scanner scanner = new Scanner(System.in);
+
+    public static int getPaidMoney() {
+        System.out.println("구입금액을 입력해 주세요.");
+        int money = scanner.nextInt();
+        scanner.nextLine();
+        return money;
+    }
+
+    public static String lastWeekLottoNumbers() {
+        System.out.println("지난 주 당첨 번호를 입력해 주세요.");
+        return scanner.nextLine();
+    }
+}

src/main/java/step2/lotto/view/ResultView.java

@@ -0,0 +1,29 @@
+package step2.lotto.view;
+
+import step2.lotto.domain.Lotto;
+import step2.lotto.domain.Lottos;
+import step2.lotto.domain.Statistic;
+
+public class ResultView {
+
+    public static void showLottos(Lottos lottos) {
+        System.out.println(lottos.size() + "개를 구매했습니다.");
+        for (Lotto lotto : lottos.getLottos()) {
+            System.out.println(lotto.lottoNumbers());
+        }
+    }
+
+    public static void showStatistics(Statistic stat, int paidMoney) {
+        System.out.println("\n당첨 통계\n---------");
+        for (int i = 3; i <= 6; i++) {
+            int count = stat.getMatchCountMap().getOrDefault(i, 0);
+            int prize = Statistic.PRIZE_MAP.get(i);
+            System.out.printf("%d개 일치 (%d원)- %d개\n", i, prize, count);
+        }
+
+        double rate = stat.getProfitRate(paidMoney);
+
+        System.out.printf("총 수익률은 %.2f입니다.(기준이 1이기 때문에 결과적으로 %s)\n",
+            rate, rate < 1 ? "손해라는 의미임" : "이득이라는 의미임");
+    }
+}

src/test/java/step1/calc/operator/OperatorTest.java

@@ -8,7 +8,7 @@ public class OperatorTest {
     @Test
     void 사칙연산_기호가_아닌경우(){
         assertThatIllegalArgumentException().isThrownBy(() -> {
-            new Operator("a");
+            Operator.getOperation("a");
         }).withMessage("지원하지 않는 연산자입니다: a");
 
     }

src/test/java/step2/domain/GameTest.java

@@ -0,0 +1,36 @@
+package step2.domain;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatCode;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
+
+import org.junit.jupiter.api.Test;
+import step2.lotto.game.Game;
+
+public class GameTest {
+
+    @Test
+    void 지난주_로또_번호는_쉼표를_구분지어_입력한다() {
+        assertThatThrownBy(() -> {
+            Game game = new Game();
+            game.play("1, 2, 3, 4, 5, 6, 10");
+        }).hasMessage("로또 번호는 6개여야 합니다.");
+
+        assertThatThrownBy(() -> {
+            Game game = new Game();
+            game.play("1. 2. 3. 4. 5");
+        }).hasMessage("For input string: \"1. 2. 3. 4. 5\"");
+
+        assertThatThrownBy(() -> {
+            Game game = new Game();
+            game.play("1, 2, 3, 4, 5, 46");
+        }).hasMessage("로또 번호는 1부터 45까지의 숫자만 가능합니다.");
+
+        assertThatCode(() -> {
+            Game game = new Game();
+            game.calculateLottoCount(1000);
+            game.rollingLotto();
+            game.play("1, 2, 3, 4, 5, 6");
+        }).doesNotThrowAnyException();
+    }
+
+}