[완두콩] 박주희 로또 미션 제출합니다 (1단계-4단계)

README.md

@@ -0,0 +1,51 @@
+# 로또 (Lotto) 미션
+
+## 프로젝트 소개
+
+이 프로그램은 주어진 기능 및 프로그래밍 요구사항을 만족하는 콘솔 기반의 로또 게임을 구현하는 것을 목표로 합니다. 
+사용자는 로또를 수동 또는 자동으로 구매하고, 당첨 번호와 비교하여 당첨금 관련 결과를 확인할 수 있습니다. 
+
+---
+
+## 기능 요구사항
+
+- 로또 구입 금액을 입력하면 구입 금액에 해당하는 로또 티켓을 발급합니다.
+- 사용자가 수동으로 로또 번호를 입력할 수 있어야 합니다.
+  - 수동으로 구매할 로또 수를 입력받고, 그 수만큼 로또 번호를 입력받습니다.
+  - 수동 구매 후 남은 금액만큼 자동으로 로또를 발급합니다.
+- 지난 주 당첨 번호 6개와 보너스 볼 1개를 입력받습니다.
+- 로또 번호와 당첨 번호를 비교하여 당첨 결과를 결정합니다.
+- 최종적으로 당첨 통계와 수익률을 계산하여 출력합니다.
+  - 수익률이 1 미만일 경우 손해임을 명시합니다.
+  - 수익률이 1 이상일 경우 이득임을 명시합니다. (임의 설정)
+
+---
+
+## 비즈니스 규칙
+
+- **로또 구매 규칙**
+    - 로또 1장의 가격은 1,000원입니다.
+    - 구매 금액은 1,000원 단위로 입력해야 합니다.
+- **로또 번호 규칙**
+    - 로또 번호는 1부터 45 사이의 숫자입니다.
+    - 로또 한 장은 중복되지 않는 6개의 숫자로 구성됩니다.
+    - 수동으로 로또를 구매할 때 6개의 번호를 입력하지 않으면 오류가 발생합니다.
+- **당첨 조건 및 상금**
+    - 1등: 6개 번호 일치 (2,000,000,000원)
+    - 2등: 5개 번호 일치 + 보너스 볼 일치 (30,000,000원)
+    - 3등: 5개 번호 일치 (1,500,000원)
+    - 4등: 4개 번호 일치 (50,000원)
+    - 5등: 3개 번호 일치 (5,000원)
+
+---
+
+## 프로그래밍 요구사항
+
+- **코드 컨벤션**: 자바 코드 컨벤션을 지키면서 프로그래밍합니다.
+- **들여쓰기**: `indent`(인덴트, 들여쓰기) depth를 1까지만 허용합니다. (메서드 분리로 해결)
+- **`else` 사용 금지**: `else` 예약어, `switch/case`, 3항 연산자를 사용하지 않습니다. (if문에서 값 반환으로 해결)
+- **메서드 분리**:
+  - 함수(또는 메서드)의 길이는 10라인을 넘어가지 않도록 구현합니다.
+  - 함수(또는 메서드)가 한 가지 일만 하도록 최대한 작게 만듭니다.
+- **자료구조**: 배열이 아닌 컬렉션을 사용합니다.
+- **축약 금지**: 변수명, 클래스명, 메서드명 등에 축약을 사용하지 않습니다.

src/main/java/Application.java

@@ -0,0 +1,51 @@
+import static view.InputView.lottoScanner;
+
+import domain.LottoChecker;
+import domain.LottoResult;
+import domain.LottoStatistics;
+import domain.LottoTicketCount;
+import domain.LottoTickets;
+import domain.LottoWinningType;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import view.InputView;
+import view.OutputView;
+
+public class Application {
+
+    public static void main(String[] args) {
+        LottoTicketCount lottoTicketCount = new LottoTicketCount();
+        int totalCount = lottoTicketCount.convertLottoPriceToTicketCount(InputView.inputLottoTotalPrice());
+
+        int manualCount = InputView.inputUserSelectedLottoCount();
+        List<String> userSelectedNumbersInput = InputView.inputUserSelectedLottoNumbers(manualCount);
+
+        int autoCount = totalCount - manualCount;
+
+        OutputView.printLottoCount(manualCount, autoCount);
+
+        LottoTickets lottoTickets = new LottoTickets();
+        lottoTickets.addUserSelectedLottos(userSelectedNumbersInput);
+        lottoTickets.addAutoLottos(autoCount);
+
+        OutputView.printLottoNumbers(lottoTickets);
+
+        String[] winningNumbers = InputView.inputWinningLottoNumbers().split(",\\s*");
+        String bonusNumber = InputView.inputBonusBallNumber();
+
+        LottoChecker lottoChecker = new LottoChecker(winningNumbers, lottoTickets, bonusNumber);
+        ArrayList<LottoWinningType> checkedTickets = lottoChecker.checkAllTickets();
+
+        LottoStatistics lottoStatistics = new LottoStatistics();
+        Map<LottoWinningType, Integer> countedMatches = lottoStatistics.countMatches(checkedTickets);
+
+        OutputView.printMatchCount(countedMatches);
+
+        LottoResult lottoResult = new LottoResult(lottoStatistics, (totalCount * LottoTicketCount.PRICE_PER_ONE_LOTTO_TICKET));
+        OutputView.printRateOfReturn(lottoResult.calculateProfitRate());
+
+        InputView.closeScanner(lottoScanner);
+    }
+}

src/main/java/domain/Lotto.java

@@ -0,0 +1,40 @@
+package domain;
+
+import java.util.List;
+import java.util.Random;
+import java.util.TreeSet;
+
+public class Lotto {
+    public static final int LOTTO_NUMBER_LOWER_BOUND = 1;
+    public static final int LOTTO_NUMBER_BOUND = 45;
+    public static final int LOTTO_NUMBER_COUNT = 6;
+
+    TreeSet<Integer> randomNumberSet = new TreeSet<>();
+    Random random = new Random();
+
+    public Lotto() {
+        setLottoNumber();
+    }
+
+    public Lotto(List<Integer> userSelectedNumbers) {
+        if (userSelectedNumbers.size() != LOTTO_NUMBER_COUNT) {
+            throw new IllegalArgumentException("로또 번호는" + LOTTO_NUMBER_COUNT + "개여야 합니다.");
+        }
+        this.randomNumberSet.addAll(userSelectedNumbers);
+        if (this.randomNumberSet.size() != LOTTO_NUMBER_COUNT) {
+            throw new IllegalArgumentException("로또 번호는 중복될 수 없습니다.");
+        }
+    }
+
+    public TreeSet<Integer> getRandomNumberSet() {
+        return this.randomNumberSet;
+    }
+
+    private void setLottoNumber(){
+        while (randomNumberSet.size() < LOTTO_NUMBER_COUNT) {
+            randomNumberSet.add(random.nextInt(LOTTO_NUMBER_LOWER_BOUND, LOTTO_NUMBER_BOUND + 1));
+        }
+
+    }
+
+}

src/main/java/domain/LottoChecker.java

@@ -0,0 +1,70 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+public class LottoChecker {
+
+    private final ArrayList<Integer> winningLottoNumbers;
+    private final LottoTickets lottoTickets;
+
+    private final int bonusNumber;
+
+    public LottoChecker(String[] lastWeekWinnerLottoNumbers, LottoTickets lottoTickets, String bonusNumber) {
+        this.winningLottoNumbers = wrappingToIntegerLottoNumbers(lastWeekWinnerLottoNumbers);
+        this.lottoTickets = lottoTickets;
+        validateBonusNumber(bonusNumber);
+        this.bonusNumber = Integer.parseInt(bonusNumber);
+    }
+
+    public ArrayList<LottoWinningType> checkAllTickets() {
+        ArrayList<LottoWinningType> winningTypes = new ArrayList<>();
+
+        for (int i = 0; i < lottoTickets.getSize(); i++) {
+            int matchCount = calculateMatchCountForTicket(i);
+            boolean matchBonus = hasBonusNumber(i);
+
+            winningTypes.add(LottoWinningType.valueOf(matchCount, matchBonus));
+        }
+        return winningTypes;
+    }
+
+    public boolean hasBonusNumber(int lottoTicketIndex) {
+        return lottoTickets.getLottoTreeSet(lottoTicketIndex).contains(this.bonusNumber);
+    }
+
+    private ArrayList<Integer> wrappingToIntegerLottoNumbers(String[] stringWinnerNumbers) {
+        return (ArrayList<Integer>) Arrays.stream(stringWinnerNumbers)
+                .map(Integer::parseInt)
+                .collect(Collectors.toList());
+    }
+
+    private void validateBonusNumber(String bonusNumber) {
+        try {
+            int number = Integer.parseInt(bonusNumber);
+            if (number < Lotto.LOTTO_NUMBER_LOWER_BOUND || number > Lotto.LOTTO_NUMBER_BOUND) {
+                throw new IllegalArgumentException(
+                        "보너스 볼은" + Lotto.LOTTO_NUMBER_LOWER_BOUND + "과" + Lotto.LOTTO_NUMBER_BOUND + "사이의 숫자여야 합니다.");
+            }
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("보너스 볼은 숫자여야 합니다.");
+        }
+    }
+
+    private int calculateMatchCountForTicket(int lottoTicketIndex) {
+        int matchCount = 0;
+        for (int winningNumber : winningLottoNumbers) {
+            matchCount += getMatchScore(lottoTicketIndex, winningNumber);
+        }
+        return matchCount;
+    }
+
+    private int getMatchScore(int lottoTicketIndex, int winningNumber) {
+        if (lottoTickets.getLottoTreeSet(lottoTicketIndex).contains(winningNumber)) {
+            return 1;
+        }
+        return 0;
+    }
+
+}

src/main/java/domain/LottoResult.java

@@ -0,0 +1,35 @@
+package domain;
+
+import java.util.Map;
+
+public class LottoResult {
+
+    private final LottoStatistics lottoStatistics;
+    private final int purchaseAmount;
+
+    public LottoResult(LottoStatistics lottoStatistics, int purchaseAmount) {
+        this.lottoStatistics = lottoStatistics;
+        this.purchaseAmount = purchaseAmount;
+    }
+
+    public double calculateProfitRate() {
+        long totalWinningPrize = calculateTotalPrize();
+        if (totalWinningPrize == 0) {
+            return 0.0;
+        }
+        return (double) totalWinningPrize / purchaseAmount;
+    }
+
+    private long calculateTotalPrize() {
+        long totalPrize = 0;
+        Map<LottoWinningType, Integer> stats = lottoStatistics.getMatchStatistics();
+
+        for (Map.Entry<LottoWinningType, Integer> entry : stats.entrySet()) {
+            LottoWinningType type = entry.getKey();
+            int count = entry.getValue();
+            totalPrize += (long) type.prizeExpression(count);
+        }
+        return totalPrize;
+    }
+
+}

src/main/java/domain/LottoStatistics.java

@@ -0,0 +1,26 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+public class LottoStatistics {
+    private Map<LottoWinningType, Integer> matchStatistics = new HashMap<>();
+
+    public LottoStatistics() {
+        for (LottoWinningType type : LottoWinningType.values()) {
+            matchStatistics.put(type, 0);
+        }
+    }
+
+    public Map<LottoWinningType, Integer> countMatches(ArrayList<LottoWinningType> winningTypes) {
+        for (LottoWinningType type : winningTypes) {
+            matchStatistics.put(type, matchStatistics.get(type) + 1);
+        }
+        return matchStatistics;
+    }
+
+    public Map<LottoWinningType, Integer> getMatchStatistics() {
+        return matchStatistics;
+    }
+}

src/main/java/domain/LottoTicketCount.java

@@ -0,0 +1,21 @@
+package domain;
+
+public class LottoTicketCount {
+    public static final int PRICE_PER_ONE_LOTTO_TICKET = 1000;
+    private int lottoTicketCount;
+
+    public int convertLottoPriceToTicketCount(int totalLottoPrice) {
+        validatePurchaseAmount(totalLottoPrice);
+        lottoTicketCount = totalLottoPrice / PRICE_PER_ONE_LOTTO_TICKET;
+        return lottoTicketCount;
+    }
+
+    private void validatePurchaseAmount(int price) {
+        if (price < PRICE_PER_ONE_LOTTO_TICKET) {
+            throw new IllegalArgumentException("구입 금액은 " + PRICE_PER_ONE_LOTTO_TICKET + "원 이상이어야 합니다.");
+        }
+        if (price % PRICE_PER_ONE_LOTTO_TICKET != 0) {
+            throw new IllegalArgumentException("구입 금액은 " + PRICE_PER_ONE_LOTTO_TICKET + "원 단위로 입력해야 합니다.");
+        }
+    }
+}

src/main/java/domain/LottoTickets.java

@@ -0,0 +1,34 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+public class LottoTickets {
+    ArrayList<Lotto> lottoArrayList = new ArrayList<>();
+
+    public void addUserSelectedLottos(List<String> userSelectedNumbersInput) {
+        for (String numbersString : userSelectedNumbersInput) {
+            List<Integer> numbers = Arrays.stream(numbersString.split(",\\s*"))
+                    .map(Integer::parseInt)
+                    .collect(Collectors.toList());
+            lottoArrayList.add(new Lotto(numbers));
+        }
+    }
+
+    public void addAutoLottos(int autoCount) {
+        for (int i = 0; i < autoCount; i++) {
+            lottoArrayList.add(new Lotto());
+        }
+    }
+
+    public TreeSet<Integer> getLottoTreeSet(int lottoTicketNumber){
+        return new TreeSet<>(lottoArrayList.get(lottoTicketNumber).getRandomNumberSet());
+    }
+
+    public int getSize() {
+        return lottoArrayList.size();
+    }
+}

src/main/java/domain/LottoWinningType.java

@@ -0,0 +1,48 @@
+package domain;
+
+import java.util.Arrays;
+import java.util.function.Function;
+
+public enum LottoWinningType {
+    FIRST_PLACE("6개 일치 (2000000000원)- ", tickets -> tickets * 2000000000),
+    SECOND_PLACE("5개 일치, 보너스 볼 일치(30000000원)- ", tickets -> tickets * 30000000),
+    THIRD_PLACE("5개 일치 (1500000원)- ", tickets -> tickets * 1500000),
+    FOURTH_PLACE("4개 일치 (50000원)- ", tickets -> tickets * 50000),
+    FIFTH_PLACE("3개 일치 (5000원)- ", tickets -> tickets * 5000),
+    NO_PRIZE("2개 이하 일치 (0원)- ", tickets -> 0d);
+
+    private String winningDescription;
+    private Function<Double, Double> prizeExpression;
+
+
+    LottoWinningType(String winningDescription, Function<Double, Double> prizeExpression) {
+        this.winningDescription = winningDescription;
+        this.prizeExpression = prizeExpression;
+
+    }
+
+    public double prizeExpression(double matchingTickets) {
+        return prizeExpression.apply(matchingTickets);
+    }
+
+    public String getWinningDescription() {
+        return winningDescription;
+    }
+
+    public static LottoWinningType valueOf(int matchCount, boolean matchBonus) {
+        if (matchCount == 6) return FIRST_PLACE;
+        if (matchCount == 5 && matchBonus) return SECOND_PLACE;
+        if (matchCount == 5) return THIRD_PLACE;
+        if (matchCount == 4) return FOURTH_PLACE;
+        if (matchCount == 3) return FIFTH_PLACE;
+        return NO_PRIZE;
+    }
+
+    public static LottoWinningType findLottoWinningType(String winningType){
+        return Arrays.stream(LottoWinningType.values())
+                .filter(lottoWinningTypePrize -> lottoWinningTypePrize.name().equals(winningType))
+                .findAny()
+                .orElse(NO_PRIZE);
+    }
+
+}