[그리디] 김민욱 로또 미션 3,4,5 단계 제출합니다.

README.md

@@ -0,0 +1,15 @@
+* **[1] 구입 금액 입력 및 시도 횟수 계산**
+  * 숫자 형식, 1,000원 단위, 0 이하 값 입력 시 `IllegalArgumentException` 발생 및 재시도.
+* **[2] 수동 로또 개수 입력 및 번호 생성**
+  * 총 발행 횟수 초과 및 음수 입력 검증.
+  * 1~45 범위의 중복되지 않는 6개 숫자 입력 검증.
+* **[3] 자동 로또 번호 생성**
+  * 총 횟수에서 수동 횟수를 제외한 만큼 `RandomLottoNumberGenerator`를 통해 번호 자동 생성 및 오름차순 정렬.
+* **[4] 로또 발급 내역 출력**
+  * 수동 및 자동 발급 수량과 전체 로또 번호 리스트 출력.
+* **[5] 당첨 번호 및 보너스 번호 입력**
+  * 우승 로또 번호 입력 검증.
+  * 보너스 번호의 범위(1~45) 및 당첨 번호와의 중복 여부 검증.
+* **[6] 당첨 결과 계산 및 통계 출력**
+  * `LottoResult`와 `Rank` Enum을 활용하여 일치 개수 및 상금 계산.
+  * 당첨 내역 출력 및 수익률(소수점 셋째 자리 내림 처리) 계산 후 출력.

src/main/java/Application.java

@@ -0,0 +1,8 @@
+import controller.Controller;
+
+public class Application {
+    public static void main(String[] args) {
+        Controller controller = new Controller();
+        controller.run();
+    }
+}

src/main/java/controller/Controller.java

@@ -0,0 +1,100 @@
+package controller;
+
+import domain.Lotto;
+import domain.LottoMachine;
+import domain.LottoTickets;
+import domain.TrialNumber;
+import domain.LottoResult;
+import domain.RandomLottoNumberGenerator;
+import domain.validator.BonusNumberValidator;
+import domain.validator.ManualCountValidator;
+
+import view.InputView;
+import view.OutputView;
+
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Controller {
+
+    public void run() {
+        TrialNumber trialNumber = getTrialNumber();
+        int manualTrialCount = getManualTrialCount(trialNumber.getTrialCount());
+        LottoTickets manualTickets = getManualLottoTickets(manualTrialCount);
+        int autoTrialCount = trialNumber.getTrialCount() - manualTrialCount;
+        LottoTickets autoTickets = issueLottoTickets(autoTrialCount, manualTrialCount);
+        Lotto winningLotto = getWinningLotto();
+        int bonusNumber = getBonusNumber(winningLotto);
+        LottoResult statisticsResult = calculateAndPrintResults(autoTickets, winningLotto, bonusNumber, manualTickets);
+        OutputView.printWinningStatistics(statisticsResult, trialNumber.getPurchaseAmount());
+    }
+
+    private TrialNumber getTrialNumber() {
+        return retry(() -> {
+            OutputView.printInputPurchaseAmount();
+            return new TrialNumber(InputView.inputPurchaseMoney());
+        });
+    }
+
+    private int getManualTrialCount(int totalTrialCount) {
+        return retry(() -> {
+            OutputView.printManualTrialCount();
+            int manualCount = InputView.inputManualLottoNumberTrialCount();
+            ManualCountValidator.validate(totalTrialCount, manualCount);
+            return manualCount;
+        });
+    }
+
+    private LottoTickets getManualLottoTickets(int trialCount) {
+        if (trialCount == 0) {
+            return new LottoTickets(List.of());
+        }
+        return retry(() -> {
+            OutputView.printManualLottoTickets();
+            List<Lotto> manualLottos = IntStream.range(0, trialCount)
+                    .mapToObj(i -> new Lotto(InputView.inputManualLottoNumber()))
+                    .collect(Collectors.toList());
+            return new LottoTickets(manualLottos);
+        });
+    }
+
+    private LottoTickets issueLottoTickets(int trialCount, int manualCount) {
+        LottoMachine lottoMachine = new LottoMachine(new RandomLottoNumberGenerator());
+        List<Lotto> generatedLottos = lottoMachine.issue(trialCount);
+        LottoTickets lottoTickets = new LottoTickets(generatedLottos);
+
+        OutputView.printLottoNumber(lottoTickets, trialCount, manualCount);
+        return lottoTickets;
+    }
+
+    private Lotto getWinningLotto() {
+        return retry(() -> {
+            OutputView.printInputWinningNumber();
+            return new Lotto(InputView.inputWinningNumber());
+        });
+    }
+
+    private int getBonusNumber(Lotto winningLotto) {
+        return retry(() -> {
+            OutputView.printBonusNumber();
+            int bonusNumber = InputView.inputBonusNumber();
+            BonusNumberValidator.validate(winningLotto, bonusNumber);
+            return bonusNumber;
+        });
+    }
+
+    private LottoResult calculateAndPrintResults(LottoTickets autoTickets, Lotto winningLotto, int bonusNumber, LottoTickets manualTickets) {
+        return new LottoResult(autoTickets, winningLotto, bonusNumber, manualTickets);
+    }
+
+    private <T> T retry(Supplier<T> supplier) {
+        try {
+            return supplier.get();
+        } catch (IllegalArgumentException e) {
+            OutputView.printErrorMessage(e.getMessage());
+            return retry(supplier);
+        }
+    }
+}

src/main/java/domain/Lotto.java

@@ -0,0 +1,36 @@
+package domain;
+
+import domain.validator.LottoNumberValidator;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+
+public class Lotto {
+    private static final int LOTTO_SIZE = 6;
+
+    private final List<Integer> lottoNumber;
+
+    public Lotto(List<Integer> lottoNumber) {
+        validate(lottoNumber);
+        validateRange(lottoNumber);
+        this.lottoNumber = lottoNumber;
+    }
+
+    private void validate(List<Integer> lottoNumber) {
+        if (lottoNumber.size() != LOTTO_SIZE) {
+            throw new IllegalArgumentException("[ERROR] 로또 번호는 6개여야 합니다.");
+        }
+        if (new HashSet<>(lottoNumber).size() != LOTTO_SIZE) {
+            throw new IllegalArgumentException("[ERROR] 로또 번호에 중복된 숫자가 있습니다.");
+        }
+    }
+
+    private void validateRange(List<Integer> lottoNumber) {
+        lottoNumber.forEach(LottoNumberValidator::validateRange);
+    }
+
+    public List<Integer> getNumbers() {
+        return Collections.unmodifiableList(lottoNumber);
+    }
+}

src/main/java/domain/LottoMachine.java

@@ -0,0 +1,19 @@
+package domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class LottoMachine {
+    private final LottoNumberGenerator generator;
+
+    public LottoMachine(LottoNumberGenerator generator) {
+        this.generator = generator;
+    }
+
+    public List<Lotto> issue(int trialCount) {
+        return IntStream.range(0, trialCount)
+                .mapToObj(i -> new Lotto(generator.generate()))
+                .collect(Collectors.toList());
+    }
+}

src/main/java/domain/LottoNumberGenerator.java

@@ -0,0 +1,7 @@
+package domain;
+
+import java.util.List;
+
+public interface LottoNumberGenerator {
+    List<Integer> generate();
+}

src/main/java/domain/LottoResult.java

@@ -0,0 +1,55 @@
+package domain;
+
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+
+public class LottoResult {
+    private final Map<Rank, Integer> matchResults;
+    private final int bonusNumber;
+    private static final int INITIAL_COUNT = 0;
+    private static final int INCREMENT_COUNT = 1;
+
+    public LottoResult(LottoTickets lottoTickets, Lotto winningLotto, int bonusNumber, LottoTickets manualLottoTickets) {
+        this.matchResults = new EnumMap<>(Rank.class);
+        this.bonusNumber = bonusNumber;
+        initResults();
+        calculate(lottoTickets.getLottoNumber(), winningLotto.getNumbers(), this.bonusNumber, manualLottoTickets.getLottoNumber());
+    }
+
+    private void initResults() {
+        for (Rank rank : Rank.values()) {
+            matchResults.put(rank, INITIAL_COUNT);
+        }
+    }
+
+    private void calculate(List<Lotto> lottoNumber, List<Integer> winningNumbers, int bonusNumber, List<Lotto> manullottoNumber) {
+        lottoNumber.forEach(lotto -> updateMatchResult(lotto, winningNumbers, bonusNumber));
+        manullottoNumber.forEach(lotto -> updateMatchResult(lotto, winningNumbers, bonusNumber));
+    }
+
+    private void updateMatchResult(Lotto lotto, List<Integer> winningNumbers, int bonusNumber) {
+        int matchCount = countMatch(lotto.getNumbers(), winningNumbers);
+        boolean matchBonus = lotto.getNumbers().contains(bonusNumber);
+        Rank rank = Rank.valueOfRank(matchCount, matchBonus);
+        matchResults.put(rank, matchResults.get(rank) + INCREMENT_COUNT);
+    }
+
+    private int countMatch(List<Integer> lottoNumber, List<Integer> winningNumbers) {
+        return (int) lottoNumber.stream()
+                .filter(winningNumbers::contains)
+                .count();
+    }
+
+    public double calculateProfitRate(int purchaseAmount) {
+        long totalPrize = 0L;
+        for (Map.Entry<Rank, Integer> entry : matchResults.entrySet()) {
+            totalPrize += (long) entry.getKey().getPrizeMoney() * entry.getValue();
+        }
+        return (double) totalPrize / purchaseAmount;
+    }
+
+    public int getRankCount(Rank rank) {
+        return matchResults.get(rank);
+    }
+}

src/main/java/domain/LottoTickets.java

@@ -0,0 +1,16 @@
+package domain;
+
+import java.util.Collections;
+import java.util.List;
+
+public class LottoTickets {
+    private final List<Lotto> lottoTickets;
+
+    public LottoTickets(List<Lotto> lottoTickets) {
+        this.lottoTickets = lottoTickets;
+    }
+
+    public List<Lotto> getLottoNumber() {
+        return Collections.unmodifiableList(lottoTickets);
+    }
+}

src/main/java/domain/RandomLottoNumberGenerator.java

@@ -0,0 +1,30 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class RandomLottoNumberGenerator implements LottoNumberGenerator {
+
+
+    private static final int MIN_LOTTO_NUMBER = 1;
+    private static final int MAX_LOTTO_NUMBER = 45;
+    private static final int LOTTO_NUMBER_COUNT = 6;
+
+    private final List<Integer> lottoPool;
+
+    public RandomLottoNumberGenerator() {
+        this.lottoPool = new ArrayList<>();
+        for (int i = MIN_LOTTO_NUMBER; i <= MAX_LOTTO_NUMBER; i++) {
+            lottoPool.add(i);
+        }
+    }
+
+    @Override
+    public List<Integer> generate() {
+        Collections.shuffle(lottoPool);
+        List<Integer> selectedNumbers = new ArrayList<>(lottoPool.subList(0, LOTTO_NUMBER_COUNT));
+        Collections.sort(selectedNumbers);
+        return selectedNumbers;
+    }
+}

src/main/java/domain/Rank.java

@@ -0,0 +1,55 @@
+package domain;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public enum Rank {
+    NONE(0, false, 0),
+    THREE(3, false, 5000),
+    FOUR(4, false, 50000),
+    FIVE(5, false, 1500000),
+    FIVE_BONUS(5, true, 30000000),
+    SIX(6, false, 2000000000);
+
+    private final int matchCount;
+    private final boolean matchBonus;
+    private final int prizeMoney;
+
+    Rank(int matchCount, boolean matchBonus, int prizeMoney) {
+        this.matchCount = matchCount;
+        this.matchBonus = matchBonus;
+        this.prizeMoney = prizeMoney;
+    }
+
+    public static Rank valueOfRank(int matchCount, boolean matchBonus) {
+        return Arrays.stream(values())
+                .filter(rank -> rank.isMatch(matchCount, matchBonus))
+                .findFirst()
+                .orElse(NONE);
+    }
+
+    private boolean isMatch(int matchCount, boolean matchBonus) {
+        if (this.matchCount != matchCount) {
+            return false;
+        }
+        if (this == FIVE_BONUS || this == FIVE) {
+            return this.matchBonus == matchBonus;
+        }
+        return true;
+    }
+
+    public static List<Rank> getWinningRanks() {
+        return Arrays.stream(values())
+                .filter(rank -> rank != NONE)
+                .collect(Collectors.toList());
+    }
+
+    public int getPrizeMoney() {
+        return prizeMoney;
+    }
+
+    public int getMatchCount() {
+        return matchCount;
+    }
+}

src/main/java/domain/TrialNumber.java

@@ -0,0 +1,31 @@
+package domain;
+
+public class TrialNumber {
+    private static final int LOTTO_PRICE = 1000;
+    private static final int ZERO = 0;
+    private final int trialCount;
+    private final int purchaseAmount;
+
+    public TrialNumber(int purchaseAmount) {
+        validateAmount(purchaseAmount);
+        this.purchaseAmount = purchaseAmount;
+        this.trialCount = purchaseAmount / LOTTO_PRICE;
+    }
+
+    private void validateAmount(int amount) {
+        if (amount <= ZERO) {
+            throw new IllegalArgumentException("[ERROR] 구입 금액은 0보다 커야 합니다.");
+        }
+        if (amount % LOTTO_PRICE != ZERO) {
+            throw new IllegalArgumentException("[ERROR] 구입 금액은 1000원 단위여야 합니다.");
+        }
+    }
+
+    public int getTrialCount() {
+        return trialCount;
+    }
+
+    public int getPurchaseAmount() {
+        return purchaseAmount;
+    }
+}

src/main/java/domain/validator/BonusNumberValidator.java

@@ -0,0 +1,13 @@
+package domain.validator;
+
+import domain.Lotto;
+
+public class BonusNumberValidator {
+
+    public static void validate(Lotto winningLotto, int bonusNumber) {
+        LottoNumberValidator.validateRange(bonusNumber);
+        if (winningLotto.getNumbers().contains(bonusNumber)) {
+            throw new IllegalArgumentException("[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다.");
+        }
+    }
+}