[완두콩] 이지인 로또 미션 제출합니다.

src/main/java/Application.java

@@ -0,0 +1,37 @@
+import domain.*;
+import view.InputView;
+import view.ResultView;
+
+import java.util.List;
+
+
+public class Application {
+    public static void main(String[] args) {
+        LottoGenerator lottoGenerator = new LottoGenerator();
+        LottoResult lottoResult = new LottoResult();
+        WinningRate winningRate = new WinningRate();
+
+        int purchasePrice = InputView.inputPrice();
+        PurchaseAmount purchaseAmount = PurchaseAmount.from(purchasePrice);
+
+        int lottoCount = purchaseAmount.calculateCount();
+        int passiveCount = InputView.inputPassiveCount();
+        int autoCount = lottoCount - passiveCount;
+
+        List<List<LottoNumber>> passiveLotto = InputView.inputPassiveLotto(passiveCount);
+        List<List<LottoNumber>> autoLotto = lottoGenerator.lottoLists(autoCount);
+
+        passiveLotto.addAll(autoLotto);
+        ResultView.printPurchase(passiveLotto, passiveCount, autoCount);
+
+        List<Integer> wins = InputView.inputWinning();
+        int bonusBall = InputView.inputBonusBall();
+        List<Integer> counts = lottoResult.calculateCounts(passiveLotto, wins, bonusBall);
+
+        int winPrice = winningRate.calculateWinPrice(counts);
+        double rate = winningRate.calculateRate(winPrice, purchasePrice);
+
+        ResultView.printResult(counts, rate);
+    }
+}
+

src/main/java/domain/Lotto.java

@@ -0,0 +1,36 @@
+package domain;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class Lotto {
+    private final List<LottoNumber> numbers;
+
+    private Lotto(List<LottoNumber> numbers) {
+        this.numbers = numbers;
+    }
+
+    public static Lotto from(List<LottoNumber> numbers) {
+        validateCount(numbers);
+        validateDuplicate(numbers);
+        return new Lotto(numbers);
+    }
+
+    private static void validateCount(List<LottoNumber> numbers) {
+        if(numbers.size() != 6) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    private static void validateDuplicate(List<LottoNumber> numbers) {
+        Set<LottoNumber> set = new HashSet<>(numbers);
+        if (set.size() != numbers.size()) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+
+
+
+}

src/main/java/domain/LottoGenerator.java

@@ -0,0 +1,53 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class LottoGenerator {
+    private static List<Integer> lottoList() {
+        List<Integer> lotto = new ArrayList<>();
+
+        for (int i = 0; i < 45; i++) {
+            lotto.add(i+1);
+        }
+        return lotto;
+    }
+
+    private void lottoShuffle(List<Integer> lotto) {
+        Collections.shuffle(lotto);
+    }
+
+    private List<LottoNumber> lottoPick(List<Integer> lotto) {
+        List<LottoNumber> lottoSix = new ArrayList<>();
+        for (int i = 0; i < 6; i++) {
+            lottoSix.add(LottoNumber.from(lotto.get(i)));
+        }
+
+        return lottoSix;
+    }
+
+    private void lottoSort(List<LottoNumber> lotto) {
+        Collections.sort(lotto);
+    }
+
+    public List<LottoNumber> run() {
+        List<Integer> lottoList = lottoList();
+
+        lottoShuffle(lottoList);
+        List<LottoNumber> lotto = lottoPick(lottoList);
+        lottoSort(lotto);
+
+        return lotto;
+    }
+
+    public List<List<LottoNumber>> lottoLists(int count) {
+        List<List<LottoNumber>> lottos = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            lottos.add(run());
+        }
+        return lottos;
+    }
+
+
+}

src/main/java/domain/LottoNumber.java

@@ -0,0 +1,52 @@
+package domain;
+
+import java.util.Objects;
+
+public class LottoNumber implements Comparable<LottoNumber>{
+    private final int number;
+
+    private LottoNumber(int number) {
+        this.number = number;
+    }
+
+    public int getNumber() {
+        return number;
+    }
+
+    public static LottoNumber from(int number) {
+        validate(number);
+        return new LottoNumber(number);
+    }
+
+    private static final int MIN = 1;
+    private static final int MAX = 45;
+
+    private static void validate(int number) {
+        if (number < MIN || number > MAX)  {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    @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 Objects.hashCode(number);
+    }
+
+    @Override
+    public int compareTo(LottoNumber o) {
+        return Integer.compare(number, o.number);
+    }
+
+    @Override
+    public String toString() {
+        return String.valueOf(number);
+    }
+}

src/main/java/domain/LottoResult.java

@@ -0,0 +1,37 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LottoResult {
+
+    private boolean containsWinningNumber(List<LottoNumber> lottoList, int win) {
+        return lottoList.contains(LottoNumber.from(win));
+    }
+
+    private int resultCounting(List<LottoNumber> lottoList, int win, int count) {
+        if (containsWinningNumber(lottoList, win)) {
+            count++;
+        }
+        return count;
+    }
+
+    private int checkingWinningNumbers(List<LottoNumber> lottoList, List<Integer> wins, int bonusBall) {
+        int count = 0;
+        for (int win : wins) {
+            count = resultCounting(lottoList, win, count);
+        }
+
+        if (count == 5 && containsWinningNumber(lottoList, bonusBall)) return 7;
+        return count;
+    }
+
+    public List<Integer> calculateCounts(List<List<LottoNumber>> lottos, List<Integer> wins, int bonusBall) {
+        List<Integer> counts = new ArrayList<>();
+
+        for (List<LottoNumber> lotto : lottos) {
+            counts.add(checkingWinningNumbers(lotto, wins, bonusBall));
+        }
+        return counts;
+    }
+}

src/main/java/domain/PurchaseAmount.java

@@ -0,0 +1,31 @@
+package domain;
+
+public class PurchaseAmount {
+    private final int amount;
+
+    private PurchaseAmount(int amount) {
+        validate(amount);
+        this.amount = amount;
+    }
+
+    public static PurchaseAmount from(int amount) {
+        return new PurchaseAmount(amount);
+    }
+
+    private static void validate(int amount) {
+        if (amount < 1000) {
+            throw new IllegalArgumentException();
+        }
+        if (amount % 1000 != 0) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public int getAmount() {
+        return amount;
+    }
+
+    public int calculateCount() {
+        return amount / 1000;
+    }
+}

src/main/java/domain/WinningPrize.java

@@ -0,0 +1,25 @@
+package domain;
+
+public enum WinningPrize {
+    THREE(3, 5000),
+    FOUR(4, 50000),
+    FIVE(5, 1500000),
+    BONUS(7, 30000000),
+    SIX(6, 2000000000);
+
+    private final int goal;
+    private final int prize;
+
+    WinningPrize(int goal, int prize) {
+        this.goal = goal;
+        this.prize = prize;
+    }
+
+    public int getGoal() {
+        return goal;
+    }
+
+    public int getPrize() {
+        return prize;
+    }
+}

src/main/java/domain/WinningRate.java

@@ -0,0 +1,47 @@
+package domain;
+
+import java.util.List;
+
+public class WinningRate {
+
+    public int calculateWinPrice(List<Integer> counts) {
+        return threeWin(counts) + fourWin(counts) + fiveWin(counts) + secondWin(counts) + sixWin(counts);
+    }
+
+    private int threeWin(List<Integer> counts) {
+        return countGoal(counts, WinningPrize.THREE.getGoal()) * WinningPrize.THREE.getPrize();
+    }
+
+    private int fourWin(List<Integer> counts) {
+        return countGoal(counts, WinningPrize.FOUR.getGoal())
+                * WinningPrize.FOUR.getPrize();
+    }
+
+    private int fiveWin(List<Integer> counts) {
+        return countGoal(counts, WinningPrize.FIVE.getGoal())
+                * WinningPrize.FIVE.getPrize();
+    }
+
+    private int secondWin(List<Integer> counts) {
+        return countGoal(counts, WinningPrize.BONUS.getGoal())
+                * WinningPrize.BONUS.getPrize();
+    }
+
+    private int sixWin(List<Integer> counts) {
+        return countGoal(counts, WinningPrize.SIX.getGoal())
+                * WinningPrize.SIX.getPrize();
+    }
+
+    private int countGoal(List<Integer> counts, int goal) {
+        int count = 0;
+
+        for (int i = 0; i < counts.size(); i++) {
+            if (goal == counts.get(i)) count++;
+        }
+        return count;
+    }
+
+    public double calculateRate(int winPrice, int purchasePrice) {
+        return (double) winPrice / purchasePrice;
+    }
+}

src/main/java/view/InputView.java

@@ -0,0 +1,69 @@
+package view;
+
+import domain.LottoNumber;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class InputView {
+
+    private static Scanner scanner = new Scanner(System.in);
+
+    public static int inputPrice() {
+
+        System.out.println("구입금액을 입력해 주세요.");
+        int price = scanner.nextInt();
+
+        return price;
+    }
+
+    public static List<Integer> inputWinning() {
+        System.out.println("\n지난 주 당첨 번호를 입력해 주세요.");
+        String win = scanner.nextLine();
+
+        String[] wins = win.split(",");
+        List<Integer> nums = new ArrayList<>();
+
+        for (int i = 0; i < wins.length; i++) {
+            nums.add(Integer.parseInt(wins[i]));
+        } return nums;
+    }
+    public static int inputBonusBall() {
+        System.out.println("\n보너스 볼을 입력해 주세요.");
+        int bonusBall = scanner.nextInt();
+
+        return bonusBall;
+    }
+
+    public static int inputPassiveCount() {
+        System.out.println("\n수동으로 구매할 로또 수를 입력해 주세요.");
+        int count = scanner.nextInt();
+        return count;
+    }
+
+    public static List<List<LottoNumber>> inputPassiveLotto(int manualCount) {
+        scanner.nextLine();
+
+        System.out.println("\n수동으로 구매할 번호를 입력해 주세요.");
+        List<List<LottoNumber>> passiveLottos = new ArrayList<>();
+
+        for (int i = 0; i < manualCount; i++) {
+            passiveLottos.add(inputManualLotto());
+        }
+        return passiveLottos;
+    }
+
+    private static List<LottoNumber> inputManualLotto() {
+        String input = scanner.nextLine();
+        String[] numbers = input.split(",");
+
+        List<LottoNumber> lotto = new ArrayList<>();
+
+        for (String number : numbers) {
+            lotto.add(LottoNumber.from(Integer.parseInt(number.trim())));
+        }
+
+        return lotto;
+    }
+}