[그리디] 이고은 로또 미션 3, 4, 5단계 제출합니다.

README.md

@@ -0,0 +1,32 @@
+## 로또 미션 1-5단계
+
+### 기능 요구사항
+
+#### 1단계
+- 사용자는 로또 구매 금액을 입력할 수 있다.
+- 로또 가격은 1,000원이다.
+- 사용자는 구매 금액에 해당하는 로또를 자동으로 발급받는다.
+  - 1~45 사이의 숫자 중 6개를 랜덤으로 선택한다.
+  - 겹치는 숫자는 있으면 안 된다.
+  - 로또 번호는 크기 순서대로 정렬되어야 한다.
+
+#### 2단계
+- 사용자는 당첨 번호를 입력할 수 있다.
+- 일치한 번호 수에 따른 당첨 금액을 알려준다.
+  - 3개 일치: 5000원
+  - 4개 일치: 50000원
+  - 5개 일치: 1500000원
+  - 5개 일치: 30000000원
+  - 6개 일치: 2000000000원
+- 총 수익률을 알려준다.
+  - 수익률 = (총 당첨 금액) / (총 구매 금액)
+  - 소수점 둘째 자리까지 표시한다.
+  - 1미만시 손해이고 1이상이면 이득이다.
+
+#### 3단계
+- 보너스볼이 들어온다
+- 5개 일치 + 보너스볼 일치: 30000000원 
+- 5개 일치 + 보너스볼 일치하지 않음 : 1500000원
+
+#### 4단계
+- 사용자는 수동으로 구매할 로또 수를 입력할 수 있다.

build.gradle

@@ -1,5 +1,10 @@
 plugins {
     id 'java'
+    id 'application'
+}
+
+application {
+    mainClass = 'Main'
 }
 
 group = 'cholog'

src/main/java/Main.java

@@ -0,0 +1,9 @@
+import controller.LottoController;
+
+public class Main {
+    public static void main(String[] args) {
+
+        LottoController lottoController = new LottoController();
+        lottoController.run();
+    }
+}

src/main/java/controller/LottoController.java

@@ -0,0 +1,85 @@
+package controller;
+
+import domain.Lotto;
+import domain.LottoNumber;
+import domain.LottoService;
+import domain.LottoTicketCount;
+import domain.LottoTickets;
+import domain.LottoTotalPrice;
+import domain.Money;
+import domain.MatchCount;
+import domain.ProfitRate;
+import view.InputView;
+import view.OutputView;
+import view.ResultView;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class LottoController {
+    OutputView outputView = new OutputView();
+    InputView inputView = new InputView();
+    ResultView resultView = new ResultView();
+
+    public void run() {
+        outputView.printWonMessage();
+        Money money = new Money(inputView.inputMoney());
+
+        LottoTickets lottoTickets = buyLotto(money);
+        checkLotto(lottoTickets, money);
+    }
+
+
+    public LottoTickets buyLotto(Money money) {
+        LottoTicketCount ticketNumber = Money.getTicketCount(money);
+        resultView.printTicketNumbers(ticketNumber.getCount());
+
+        outputView.printManualCount();
+        int manualCount = inputView.inputManualCount();
+
+        List<Lotto> manualLottos = new ArrayList<>();
+        outputView.printManualNumbers();
+
+        LottoService lottoService = new LottoService();
+        for (int i = 0; i < manualCount; i++) {
+            String manualNumbers = inputView.inputManualNumbers();
+            manualLottos.add(lottoService.parseLottoAnswer(manualNumbers));
+
+        }
+
+        int autoCount = ticketNumber.getCount() - manualCount;
+
+        resultView.printManualAuto(manualCount, autoCount);
+        outputView.lottoResult();
+        LottoTickets lottoTickets = LottoTickets.createMixedTickets(manualLottos, autoCount);
+
+        for (Lotto lotto : lottoTickets.getTickets()) {
+            System.out.println(lotto);
+        }
+
+        return lottoTickets;
+    }
+
+
+    public void checkLotto(LottoTickets tickektAutoCount, Money money) {
+        outputView.printLottoAnswer();
+
+        LottoService lottoService = new LottoService();
+        String lottoAnswer = inputView.inputLottoAnswer();
+        outputView.printBonusMessage();
+        int bonusBallNumber = inputView.inputBonusNumber();
+        LottoNumber bonuseBall = new LottoNumber(bonusBallNumber);
+
+        Lotto lottoAnswerObj = lottoService.parseLottoAnswer(lottoAnswer);
+        lottoService.validateBonusBall(lottoAnswerObj, bonuseBall);
+
+        MatchCount matchCount = lottoService.calculateMatchCount(tickektAutoCount.getTickets(), lottoAnswerObj, bonuseBall);
+
+        ProfitRate profitRate = new ProfitRate(money, new LottoTotalPrice(matchCount));
+
+        outputView.lottoResult();
+        resultView.printLottoMatch(matchCount);
+        resultView.printLottoProfit(profitRate.getProfitRate());
+    }
+}

src/main/java/domain/Lotto.java

@@ -0,0 +1,30 @@
+package domain;
+
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+public class Lotto {
+    private final SortedSet<LottoNumber> numbers;
+
+    public Lotto(SortedSet<LottoNumber> numbers) {
+        if (numbers.size() != createList.LOTTO_NUMBER_COUNT) {
+            throw new IllegalArgumentException("로또 숫자는 6개여야 하며, 중복될 수 없습니다.");
+        }
+        this.numbers = new TreeSet<>(numbers);
+    }
+
+    public int contains(LottoNumber number) {
+        if (numbers.contains(number)) return 1;
+        return 0;
+    }
+
+    public SortedSet<LottoNumber> getNumbers() {
+        return new TreeSet<>(numbers);
+    }
+
+    @Override
+    public String toString() {
+        return numbers.toString();
+    }
+
+}

src/main/java/domain/LottoNumber.java

@@ -0,0 +1,38 @@
+package domain;
+
+public class LottoNumber implements Comparable<LottoNumber> {
+    private final int number;
+
+    public LottoNumber(int number) {
+        if (number < createList.LOTTO_MIN_NUMBER || number > createList.LOTTO_MAX_NUMBER) {
+            throw new IllegalArgumentException("로또 번호는 1부터 45 사이의 숫자여야 합니다.");
+        }
+        this.number = number;
+    }
+
+    public int getNumber() {
+        return number;
+    }
+
+    @Override
+    public int compareTo(LottoNumber o) {
+        return Integer.compare(this.number, o.number);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        LottoNumber that = (LottoNumber) o;
+        return number == that.number;
+    }
+
+    @Override
+    public int hashCode() {
+        return number;
+    }
+
+    public String toString() {
+        return String.valueOf(number);
+    }
+}

src/main/java/domain/LottoPrice.java

@@ -0,0 +1,19 @@
+package domain;
+
+public enum LottoPrice {
+    MATCH_3(5000),
+    MATCH_4(50000),
+    MATCH_5(1500000),
+    MATCH_5_BONUS(30000000),
+    MATCH_6(2000000000);
+
+    private final int price;
+
+    LottoPrice(int price) {
+        this.price = price;
+    }
+
+    public int getPrice() {
+        return price;
+    }
+}

src/main/java/domain/LottoService.java

@@ -0,0 +1,26 @@
+package domain;
+
+import java.util.List;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+public class LottoService {
+    public Lotto parseLottoAnswer(String lottoAnswer) {
+        SortedSet<LottoNumber> numbers = new TreeSet<>();
+        for (String num : lottoAnswer.split(",")) {
+            numbers.add(new LottoNumber(Integer.parseInt(num.trim())));
+        }
+        return new Lotto(numbers);
+    }
+
+    public void validateBonusBall(Lotto answer, LottoNumber bonusBall) {
+        if (answer.getNumbers().contains(bonusBall)) {
+            throw new IllegalArgumentException("보너스 볼은 당첨 번호와 중복될 수 없습니다.");
+        }
+    }
+
+    public MatchCount calculateMatchCount(List<Lotto> tickets, Lotto answer, LottoNumber bonusBall) {
+        return MatchCount.calculateStatistics(tickets, answer, bonusBall);
+    }
+}
+

src/main/java/domain/LottoTicketCount.java

@@ -0,0 +1,13 @@
+package domain;
+
+public class LottoTicketCount {
+    private final int count;
+
+    public LottoTicketCount(int count) {
+        this.count = count;
+    }
+
+    public int getCount() {
+        return count;
+    }
+}

src/main/java/domain/LottoTickets.java

@@ -0,0 +1,37 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+public class LottoTickets {
+    private List<Lotto> tickets;
+
+    public LottoTickets() {
+        this.tickets = new ArrayList<>();
+    }
+
+    public static LottoTickets createMixedTickets(List<Lotto> manualLottos, int autoCount) {
+        LottoTickets lottoTickets = new LottoTickets();
+
+        lottoTickets.tickets.addAll(manualLottos);
+
+        for (int i = 0; i < autoCount; i++) {
+            Set<Integer> generatedNumbers = createList.generateLottoNumbers();
+            if (generatedNumbers.size() != 6) {
+                throw new IllegalArgumentException("로또 번호에 중복된 숫자가 있습니다.");
+            }
+            SortedSet<LottoNumber> lottoNumbers = generatedNumbers.stream().map(LottoNumber::new).collect(Collectors.toCollection(TreeSet::new));
+            lottoTickets.tickets.add(new Lotto(lottoNumbers));
+        }
+
+        return lottoTickets;
+    }
+
+    public List<Lotto> getTickets() {
+        return tickets;
+    }
+}

src/main/java/domain/LottoTotalPrice.java

@@ -0,0 +1,19 @@
+package domain;
+
+import java.util.Arrays;
+
+public class LottoTotalPrice {
+    private final long totalSum;
+
+    public LottoTotalPrice(MatchCount matchCount) {
+        this.totalSum = calculateTotalSum(matchCount);
+    }
+
+    private long calculateTotalSum(MatchCount matchCount) {
+        return Arrays.stream(LottoPrice.values()).mapToLong(price -> (long) matchCount.getCount(price) * price.getPrice()).sum();
+    }
+
+    public long getTotalSum() {
+        return totalSum;
+    }
+}

src/main/java/domain/Match.java

@@ -0,0 +1,15 @@
+package domain;
+
+public class Match {
+
+    public static int getMatchCount(Lotto lotto, Lotto lottoAnswer) {
+        int matchCount = 0;
+
+        for (LottoNumber number : lotto.getNumbers()) {
+            if (lottoAnswer.getNumbers().contains(number)) {
+                matchCount++;
+            }
+        }
+        return matchCount;
+    }
+}