4단계 - 로또(수동)

README.md

@@ -37,3 +37,4 @@
 * 구매한 n장의 로또에 대해 당첨 통계를 관리할 수 있다.
 * 보너스 볼을 입력을 수 있다.
 * 보너스 볼을 포함하여 당첨 통계를 낼 수 있다.
+* 수동으로 로또 번호를 입력받을 수 있다.

src/main/kotlin/lotto/LottoApplication.kt

@@ -1,18 +1,21 @@
 package lotto
 
+import lotto.domain.LottoMachine
 import lotto.domain.LottoTicketBundle
 import lotto.domain.StatisticalResultExtractor
-import lotto.domain.WinningNumbers
+import lotto.domain.strategy.LottoAutoGenerateStrategy
+import lotto.domain.strategy.LottoManualGenerateStrategy
 import lotto.view.InputView
 import lotto.view.OutputView
 
 fun main() {
     val ticketAmount = InputView.getPurchaseAmount()
-    val lottoTicketBundle = LottoTicketBundle(ticketAmount).lottoTickets
-    InputView.getNumberOfPurchases(lottoTicketBundle.size)
-    val winningNumber = InputView.getWinningNumber()
-    val lottoWinning = WinningNumberExtractor.process(
-        lottoTicketBundle, WinningNumbers(winningNumber.first, winningNumber.second)
-    )
-    OutputView.printOutput(StatisticalResultExtractor(lottoWinning), lottoTicketBundle.size)
+    val manualTicketCount = InputView.getManualTicketCount()
+    val ticketCount = LottoMachine.calculateTicketCount(ticketAmount, manualTicketCount)
+    InputView.printManualTicketNumber(ticketCount.manualTicketCount)
+    val lottoTicketBundle = LottoTicketBundle(ticketCount, listOf(LottoAutoGenerateStrategy(), LottoManualGenerateStrategy()))
+    InputView.printNumberOfPurchases(ticketCount)
+    val winningBallResult = InputView.getWinningBalls()
+    val lottoWinningResult = LottoMachine.process(lottoTicketBundle, winningBallResult)
+    OutputView.printOutput(StatisticalResultExtractor(lottoWinningResult), lottoTicketBundle.lottoTickets.size)
 }

src/main/kotlin/lotto/domain/LottoMachine.kt

@@ -0,0 +1,26 @@
+package lotto.domain
+
+import lotto.common.LottoTicketPolicy
+
+object LottoMachine {
+    fun calculateTicketCount(amount: Int, manualTicketCount: Int): LottoTicketCount {
+        val autoTicketCount = (amount / LottoTicketPolicy.PRICE) - manualTicketCount
+
+        return LottoTicketCount(autoTicketCount, manualTicketCount)
+    }
+
+    fun process(lottoTicketBundle: LottoTicketBundle, winningBallResult: WinningBallResult): LottoWinningResult {
+        val resultMap = mutableMapOf<LottoTicketResult, Int>()
+        lottoTicketBundle.lottoTickets.groupingBy { ticket ->
+            val intersectNumbers = ticket.intersect(winningBallResult.winningBalls)
+            val isBonusBallMatched = winningBallResult.bonusBall in ticket
+            LottoTicketResult(intersectNumbers.size, isBonusBallMatched)
+        }.eachCountTo(resultMap)
+
+        return LottoWinningResult(resultMap.toSortedMap(getTicketResultComparator()))
+    }
+
+    private fun getTicketResultComparator(): Comparator<LottoTicketResult> =
+        Comparator.comparing(LottoTicketResult::matchCount)
+            .thenComparing(LottoTicketResult::isBonusBallMatched)
+}

src/main/kotlin/lotto/domain/LottoNumber.kt

@@ -0,0 +1,13 @@
+package lotto.domain
+
+import lotto.common.LottoTicketPolicy.END_NUMBER
+import lotto.common.LottoTicketPolicy.START_NUMBER
+
+@JvmInline
+value class LottoNumber(
+    private val number: Int,
+) {
+    init {
+        require(number in START_NUMBER..END_NUMBER) { "로또 번호는 1~45 사이의 숫자만 가능합니다." }
+    }
+}

src/main/kotlin/lotto/LottoNumberSelector.kt → src/main/kotlin/lotto/domain/LottoNumberSelector.kt

@@ -1,19 +1,19 @@
-package lotto
+package lotto.domain
 
 import lotto.common.LottoTicketPolicy.END_NUMBER
 import lotto.common.LottoTicketPolicy.MAX_LOTTO_NUMBER_SIZE
 import lotto.common.LottoTicketPolicy.START_NUMBER
 import lotto.utils.RandomNumberGenerator
 
 object LottoNumberSelector {
-    fun select(): Set<Int> {
-        val lottoNumbers = mutableSetOf<Int>()
+    fun select(): Set<LottoNumber> {
+        val lottoNumbers = mutableSetOf<LottoNumber>()
         while (lottoNumbers.size < MAX_LOTTO_NUMBER_SIZE) {
-            lottoNumbers.add(generateRandomNumber())
+            lottoNumbers.add(generateLottoNumber())
         }
 
         return lottoNumbers
     }
 
-    private fun generateRandomNumber() = RandomNumberGenerator.generate(START_NUMBER..END_NUMBER)
+    private fun generateLottoNumber() = LottoNumber(RandomNumberGenerator.generate(START_NUMBER..END_NUMBER))
 }

src/main/kotlin/lotto/domain/LottoTicket.kt

@@ -1,7 +1,5 @@
 package lotto.domain
 
-import lotto.LottoNumberSelector
-
 data class LottoTicket(
-    val numbers: Set<Int> = LottoNumberSelector.select(),
-) : Set<Int> by numbers
+    val numbers: Set<LottoNumber>,
+) : Set<LottoNumber> by numbers

src/main/kotlin/lotto/domain/LottoTicketBundle.kt

@@ -1,10 +1,19 @@
 package lotto.domain
 
-import lotto.common.LottoTicketPolicy
+import lotto.domain.strategy.LottoGenerateStrategy
+import lotto.domain.strategy.TicketGenerateType
 
-class LottoTicketBundle(amount: Int) {
-    private val count = amount / LottoTicketPolicy.PRICE
-    val lottoTickets: List<LottoTicket> = List(count) {
-        LottoTicket()
+class LottoTicketBundle(
+    lottoTicketCount: LottoTicketCount,
+    lottoGenerateStrategies: List<LottoGenerateStrategy>,
+) {
+    private val lottoGenerateStrategyMap = lottoGenerateStrategies.associateBy { it.ticketGenerateType }
+
+    val lottoTickets: List<LottoTicket> = List(lottoTicketCount.autoTicketCount) {
+        val autoGenerateStrategy = lottoGenerateStrategyMap.getValue(TicketGenerateType.AUTO)
+        autoGenerateStrategy.generate()
+    } + List(lottoTicketCount.manualTicketCount) {
+        val manualGenerateStrategy = lottoGenerateStrategyMap.getValue(TicketGenerateType.MANUAL)
+        manualGenerateStrategy.generate()
     }
 }

src/main/kotlin/lotto/domain/LottoTicketCount.kt

@@ -0,0 +1,6 @@
+package lotto.domain
+
+data class LottoTicketCount(
+    val autoTicketCount: Int,
+    val manualTicketCount: Int,
+)

src/main/kotlin/lotto/domain/LottoTicketResult.kt

@@ -0,0 +1,6 @@
+package lotto.domain
+
+data class LottoTicketResult(
+    val matchCount: Int,
+    val isBonusBallMatched: Boolean,
+)

src/main/kotlin/lotto/domain/LottoWinningResult.kt

@@ -0,0 +1,11 @@
+package lotto.domain
+
+data class LottoWinningResult(
+    val result: Map<LottoTicketResult, Int>,
+) {
+    fun totalAmount(): Long {
+        return result.entries.sumOf {
+            WinningAmount.from(it.key.matchCount, it.key.isBonusBallMatched).amount * it.value
+        }
+    }
+}

src/main/kotlin/lotto/domain/StatisticalResultExtractor.kt

@@ -1,18 +1,17 @@
 package lotto.domain
 
-import lotto.TicketResult
 import lotto.common.LottoTicketPolicy
 
 class StatisticalResultExtractor(
-    private val lottoWinning: LottoWinning,
+    private val lottoWinningResult: LottoWinningResult,
 ) {
     fun getMatchCount(winningAmount: WinningAmount): Int {
-        val ticketResult = TicketResult(winningAmount.count, winningAmount.isBonusBallMatched)
-        return lottoWinning.result[ticketResult] ?: ZERO_COUNT
+        val lottoTicketResult = LottoTicketResult(winningAmount.count, winningAmount.isBonusBallMatched)
+        return lottoWinningResult.result[lottoTicketResult] ?: ZERO_COUNT
     }
 
     fun getTotalRateOfReturn(ticketCount: Int): Double {
-        return lottoWinning.totalAmount() / (ticketCount * LottoTicketPolicy.PRICE).toDouble()
+        return lottoWinningResult.totalAmount() / (ticketCount * LottoTicketPolicy.PRICE).toDouble()
     }
 
     companion object {

src/main/kotlin/lotto/domain/WinningBallResult.kt

@@ -0,0 +1,10 @@
+package lotto.domain
+
+data class WinningBallResult(
+    val winningBalls: WinningBalls,
+    val bonusBall: LottoNumber,
+) {
+    init {
+        require(!winningBalls.contains(bonusBall)) { "보너스 볼은 당첨 번호와 중복될 수 없습니다." }
+    }
+}

src/main/kotlin/lotto/domain/WinningBalls.kt

@@ -0,0 +1,9 @@
+package lotto.domain
+
+data class WinningBalls(
+    val balls: Set<LottoNumber>,
+) : Set<LottoNumber> by balls {
+    init {
+        require(balls.size == 6) { "당첨 번호는 중복이 없어야 합니다." }
+    }
+}

src/main/kotlin/lotto/domain/strategy/LottoGenerateStrategy.kt

@@ -0,0 +1,27 @@
+package lotto.domain.strategy
+
+import lotto.domain.LottoNumber
+import lotto.domain.LottoNumberSelector
+import lotto.domain.LottoTicket
+
+interface LottoGenerateStrategy {
+    val ticketGenerateType: TicketGenerateType
+    fun generate(): LottoTicket
+}
+
+class LottoAutoGenerateStrategy : LottoGenerateStrategy {
+    override val ticketGenerateType = TicketGenerateType.AUTO
+    override fun generate(): LottoTicket {
+        return LottoTicket(LottoNumberSelector.select())
+    }
+}
+
+class LottoManualGenerateStrategy : LottoGenerateStrategy {
+    override val ticketGenerateType = TicketGenerateType.MANUAL
+    override fun generate(): LottoTicket {
+        val manualLottoNumberStr = readln()
+        val manualLottoNumber = manualLottoNumberStr.split(", ").map { LottoNumber(it.toInt()) }.toSet()
+
+        return LottoTicket(manualLottoNumber)
+    }
+}

src/main/kotlin/lotto/domain/strategy/TicketGenerateType.kt

@@ -0,0 +1,6 @@
+package lotto.domain.strategy
+
+enum class TicketGenerateType {
+    AUTO,
+    MANUAL,
+}

src/main/kotlin/lotto/view/InputView.kt

@@ -1,5 +1,10 @@
 package lotto.view
 
+import lotto.domain.LottoNumber
+import lotto.domain.LottoTicketCount
+import lotto.domain.WinningBallResult
+import lotto.domain.WinningBalls
+
 object InputView {
     fun getPurchaseAmount(): Int {
         println("구매금액을 입력해 주세요.")
@@ -9,22 +14,32 @@ object InputView {
         return amount.toInt()
     }
 
-    fun getNumberOfPurchases(count: Int) {
-        println("$count 개를 구매했습니다.")
+    fun getManualTicketCount(): Int {
+        println("수동으로 구매할 로또 수를 입력해 주세요.")
+        val manualTicketCount = readln()
+
+        return manualTicketCount.toInt()
+    }
+
+    fun printManualTicketNumber(manualTicketCount: Int) {
+        when (manualTicketCount) {
+            0 -> return
+            else -> println("수동으로 구매할 번호를 입력해 주세요.")
+        }
     }
 
-    fun getWinningNumber(): Pair<Set<Int>, Int> {
+    fun printNumberOfPurchases(lottoTicketCount: LottoTicketCount) {
+        println("수동으로 ${lottoTicketCount.manualTicketCount}장, 자동으로 ${lottoTicketCount.autoTicketCount}개를 구매했습니다.")
+    }
+
+    fun getWinningBalls(): WinningBallResult {
         println("지난 주 당첨 번호를 입력해 주세요.")
         val winningNumber = readln()
         require(winningNumber.isNotEmpty()) { "당첨 번호를 입력해주세요." }
-
-        val numbers = winningNumber.split(", ").map { it.toInt() }.toSet()
-        require(numbers.size == 6) { " 중복없는 6개의 숫자를 입력해주세요." }
-
+        val winningBalls = WinningBalls(winningNumber.split(", ").map { LottoNumber(it.toInt()) }.toSet())
         println("보너스 볼을 입력해 주세요.")
-        val bonusBall = readln().toInt()
-        require(!numbers.contains(bonusBall)) { "보너스 볼은 당첨 번호와 중복될 수 없습니다." }
+        val bonusBall = LottoNumber(readln().toInt())
 
-        return numbers to bonusBall
+        return WinningBallResult(winningBalls, bonusBall)
     }
 }