[로또] 김시영 미션 제출합니다.

src/main/java/Application.java

@@ -0,0 +1,16 @@
+import controller.LottoController;
+import domain.generator.NumberGenerator;
+import domain.generator.RandomNumberGenerator;
+import view.InputView;
+import view.ResultView;
+
+public class Application {
+    public static void main(String[] args) {
+        InputView inputView = new InputView();
+        ResultView resultView = new ResultView();
+        NumberGenerator numberGenerator = new RandomNumberGenerator();
+
+        LottoController controller = new LottoController(inputView, resultView, numberGenerator);
+        controller.run();
+    }
+}

src/main/java/controller/LottoController.java

@@ -0,0 +1,55 @@
+package controller;
+
+import static domain.constant.LottoConstants.LOTTO_PRICE;
+
+import domain.LottoResult;
+import domain.Lottos;
+import domain.WinningLotto;
+import domain.generator.NumberGenerator;
+import java.util.List;
+import view.InputView;
+import view.ResultView;
+
+public class LottoController {
+    private static final String ERROR_INSUFFICIENT_AMOUNT = "금액이 부족합니다.";
+    private final InputView inputView;
+    private final ResultView resultView;
+    private final NumberGenerator numberGenerator;
+
+    public LottoController(InputView inputView, ResultView resultView, NumberGenerator numberGenerator) {
+        this.inputView = inputView;
+        this.resultView = resultView;
+        this.numberGenerator = numberGenerator;
+    }
+
+    public void run() {
+        Lottos lottos = setUpLottos();
+        WinningLotto winningLotto = setUpWinningLotto();
+        LottoResult lottoResult = new LottoResult(lottos, winningLotto);
+        resultView.printResult(lottoResult);
+    }
+
+    private Lottos setUpLottos() {
+        int amount = inputView.readAmount();
+        int count = amount / LOTTO_PRICE;
+        int manualCount = inputView.readManualLottoCount();
+        if (manualCount > count) {
+            throw new IllegalArgumentException(ERROR_INSUFFICIENT_AMOUNT);
+        }
+        int autoCount = count - manualCount;
+
+        List<List<Integer>> manualNumbers = inputView.readManualNumbers(manualCount);
+        Lottos lottos = Lottos.create(manualNumbers, autoCount, numberGenerator);
+
+        resultView.printLottoCount(manualCount, autoCount);
+        resultView.printLottos(lottos);
+        return lottos;
+    }
+
+    private WinningLotto setUpWinningLotto() {
+        return WinningLotto.create(
+                inputView.readWinningNumbers(),
+                inputView.readBonusNumber()
+        );
+    }
+}

src/main/java/domain/Lotto.java

@@ -0,0 +1,55 @@
+package domain;
+
+import static domain.constant.LottoConstants.LOTTO_NUMBER_COUNT;
+
+import domain.generator.NumberGenerator;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Lotto {
+    public static final String ERROR_INVALID_SIZE = "로또 번호는 " + LOTTO_NUMBER_COUNT + "개여야 합니다.";
+    public static final String ERROR_DUPLICATION = "로또 번호는 중복될 수 없습니다.";
+    private final List<LottoNumber> numbers;
+
+    public Lotto(NumberGenerator generator) {
+        this(generator.generate());
+    }
+
+    public Lotto(List<LottoNumber> numbers) {
+        validate(numbers);
+        this.numbers = new ArrayList<>(numbers);
+    }
+
+    private void validate(List<LottoNumber> numbers) {
+        validateSize(numbers);
+        validateDuplication(numbers);
+    }
+
+    private void validateSize(List<LottoNumber> numbers) {
+        if (numbers.size() != LOTTO_NUMBER_COUNT) {
+            throw new IllegalArgumentException(ERROR_INVALID_SIZE);
+        }
+    }
+
+    private void validateDuplication(List<LottoNumber> numbers) {
+        if (numbers.stream()
+                .distinct()
+                .count() != LOTTO_NUMBER_COUNT) {
+            throw new IllegalArgumentException(ERROR_DUPLICATION);
+        }
+    }
+
+    public boolean contains(LottoNumber number) {
+        return numbers.contains(number);
+    }
+
+    public int countMatch(Lotto other) {
+        return (int) numbers.stream()
+                .filter(other::contains)
+                .count();
+    }
+
+    public List<LottoNumber> getNumbers() {
+        return numbers;
+    }
+}

src/main/java/domain/LottoNumber.java

@@ -0,0 +1,37 @@
+package domain;
+
+import static domain.constant.LottoConstants.*;
+
+public class LottoNumber {
+    public static final String ERROR_OUT_OF_RANGE =
+            "로또 번호는 " + LOTTO_MIN_NUMBER + "부터 " + LOTTO_MAX_NUMBER + " 사이여야 합니다.";
+    private final int number;
+
+    public LottoNumber(int number) {
+        validateRange(number);
+        this.number = number;
+    }
+
+    private void validateRange(int number) {
+        if (number < LOTTO_MIN_NUMBER || number > LOTTO_MAX_NUMBER) {
+            throw new IllegalArgumentException(ERROR_OUT_OF_RANGE);
+        }
+    }
+
+    public int getNumber() {
+        return number;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        LottoNumber number1 = (LottoNumber) o;
+        return number == number1.number;
+    }
+
+    @Override
+    public int hashCode() {
+        return Integer.hashCode(number);
+    }
+}

src/main/java/domain/LottoRank.java

@@ -0,0 +1,38 @@
+package domain;
+
+import java.util.Arrays;
+import java.util.function.BiPredicate;
+
+public enum LottoRank {
+    FIRST((matchCount, bonusMatch) -> matchCount == 6, 6, 2000000000),
+    SECOND((matchCount, bonusMatch) -> matchCount == 5 && bonusMatch, 5, 30000000),
+    THIRD((matchCount, bonusMatch) -> matchCount == 5 && !bonusMatch, 5, 1500000),
+    FOURTH((matchCount, bonusMatch) -> matchCount == 4, 4, 50000),
+    FIFTH((matchCount, bonusMatch) -> matchCount == 3, 3, 5000),
+    MISS((matchCount, bonusMatch) -> matchCount < 3, 0, 0);
+
+    private final BiPredicate<Integer, Boolean> condition;
+    private final int matchCount;
+    private final int prize;
+
+    LottoRank(BiPredicate<Integer, Boolean> condition, int matchCount, int prize) {
+        this.condition = condition;
+        this.matchCount = matchCount;
+        this.prize = prize;
+    }
+
+    public static LottoRank findRank(int matchCount, boolean bonusMatch) {
+        return Arrays.stream(values())
+                .filter(rank -> rank.condition.test(matchCount, bonusMatch))
+                .findFirst()
+                .orElse(MISS);
+    }
+
+    public int getMatchCount() {
+        return matchCount;
+    }
+
+    public int getPrize() {
+        return prize;
+    }
+}

src/main/java/domain/LottoResult.java

@@ -0,0 +1,44 @@
+package domain;
+
+import static domain.constant.LottoConstants.LOTTO_PRICE;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class LottoResult {
+    private final Map<LottoRank, Integer> result = new HashMap<>();
+    private final int totalCost;
+    private final int totalPrize;
+
+    public LottoResult(Lottos lottos, WinningLotto winningLotto) {
+        for (Lotto lotto : lottos.getLottos()) {
+            int matchCount = winningLotto.countMatch(lotto);
+            boolean bonusMatch = winningLotto.matchBonus(lotto);
+            LottoRank rank = LottoRank.findRank(matchCount, bonusMatch);
+            result.merge(rank, 1, Integer::sum);
+        }
+        totalCost = lottos.getLottos().size() * LOTTO_PRICE;
+        totalPrize = calculateTotalPrize();
+    }
+
+    private int calculateTotalPrize() {
+        return result.entrySet().stream()
+                .mapToInt(entry -> entry.getKey().getPrize() * entry.getValue())
+                .sum();
+    }
+
+    public double calculateProfitRate() {
+        if (totalCost == 0) {
+            return 0;
+        }
+        return (double) totalPrize / totalCost;
+    }
+
+    public int getMatchCountByRank(LottoRank rank) {
+        return result.getOrDefault(rank, 0);
+    }
+
+    public Map<LottoRank, Integer> getResult() {
+        return new HashMap<>(result);
+    }
+}

src/main/java/domain/Lottos.java

@@ -0,0 +1,30 @@
+package domain;
+
+import domain.generator.NumberGenerator;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Lottos {
+    private final List<Lotto> lottos;
+
+    public Lottos(List<Lotto> lottos) {
+        this.lottos = lottos;
+    }
+
+    public static Lottos create(List<List<Integer>> manualNumbers, int autoCount, NumberGenerator generator) {
+        List<Lotto> totalLottos = new ArrayList<>();
+        for (List<Integer> numbers : manualNumbers) {
+            totalLottos.add(new Lotto(() -> numbers.stream().map(LottoNumber::new).toList()));
+        }
+        for (int i = 0; i < autoCount; i++) {
+            totalLottos.add(new Lotto(generator));
+        }
+
+        return new Lottos(totalLottos);
+    }
+
+
+    public List<Lotto> getLottos() {
+        return new ArrayList<>(lottos);
+    }
+}

src/main/java/domain/WinningLotto.java

@@ -0,0 +1,37 @@
+package domain;
+
+import java.util.List;
+
+public class WinningLotto {
+    public static final String ERROR_DUPLICATE_BONUS = "보너스 번호는 당첨 번호와 중복될 수 없습니다.";
+    private final Lotto winningLotto;
+    private final LottoNumber bonusNumber;
+
+    public WinningLotto(Lotto winningLotto, LottoNumber bonusNumber) {
+        validateBonusNumber(winningLotto, bonusNumber);
+        this.winningLotto = winningLotto;
+        this.bonusNumber = bonusNumber;
+    }
+
+    public static WinningLotto create(List<Integer> winningNumbers, int bonusNumber) {
+        List<LottoNumber> numbers = winningNumbers.stream()
+                .map(LottoNumber::new)
+                .toList();
+        Lotto lotto = new Lotto(numbers);
+        return new WinningLotto(lotto, new LottoNumber(bonusNumber));
+    }
+
+    private void validateBonusNumber(Lotto winningLotto, LottoNumber bonusNumber) {
+        if (winningLotto.contains(bonusNumber)) {
+            throw new IllegalArgumentException(ERROR_DUPLICATE_BONUS);
+        }
+    }
+
+    public int countMatch(Lotto other) {
+        return winningLotto.countMatch(other);
+    }
+
+    public boolean matchBonus(Lotto other) {
+        return other.contains(bonusNumber);
+    }
+}

src/main/java/domain/constant/LottoConstants.java

@@ -0,0 +1,8 @@
+package domain.constant;
+
+public class LottoConstants {
+    public static final int LOTTO_MIN_NUMBER = 1;
+    public static final int LOTTO_MAX_NUMBER = 45;
+    public static final int LOTTO_NUMBER_COUNT = 6;
+    public static final int LOTTO_PRICE = 1000;
+}

src/main/java/domain/generator/NumberGenerator.java

@@ -0,0 +1,8 @@
+package domain.generator;
+
+import domain.LottoNumber;
+import java.util.List;
+
+public interface NumberGenerator {
+    List<LottoNumber> generate();
+}

src/main/java/domain/generator/RandomNumberGenerator.java

@@ -0,0 +1,27 @@
+package domain.generator;
+
+import static domain.constant.LottoConstants.LOTTO_MAX_NUMBER;
+import static domain.constant.LottoConstants.LOTTO_MIN_NUMBER;
+import static domain.constant.LottoConstants.LOTTO_NUMBER_COUNT;
+
+import domain.LottoNumber;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class RandomNumberGenerator implements NumberGenerator {
+
+    @Override
+    public List<LottoNumber> generate() {
+        List<Integer> candidates = new ArrayList<>();
+        for (int i = LOTTO_MIN_NUMBER; i <= LOTTO_MAX_NUMBER; i++) {
+            candidates.add(i);
+        }
+        Collections.shuffle(candidates);
+
+        return candidates.stream()
+                .limit(LOTTO_NUMBER_COUNT)
+                .map(LottoNumber::new)
+                .toList();
+    }
+}