Step3 (#1115)

* test: cashier 역할 변경에 따른 테스트 코드 수정

* refactor: 기본 생성자를 LottoNumber 생성하도록 수정한다.

* refactor: 로또 관련 숫자를 한 클래스에서 관리하도록 변경한다.

* refactor: FakeLottoNumberGenerator를 하나의 파일에서 관리하도록 수정한다.

* refactor: 정적함수 클래스를 object 클래스에서 관리하도록 수정한다.

* refactor: 사용자의 로또와 당첨로또의 숫자를 비교를 Lotto 클래스에서 담당한다.

* fix: 로또 생성 시 LottoNumber size를 검증한다.

* refactor: 로또 관련 상수를 하나의 파일에서 관리하도록 수정한다.

* refactor: LottoNumberListGenerator 반환 타입을 `Set<LottoNumber>`로 수정한다.

* refactor: 숫자를 직접 넣어 로또를 생성할 수 있는 코드를 제공한다.

* refactor: 로또 생성 시 LottoNumber size를 검증한다.

* refactor: 로또 생성시 중복을 허용하지 않는다.

* docs: step3 요구사항 정리

* feat: 보너스볼 일치 여부로 2등을 계산한다.

* feat: 보너스볼 일치 여부를 판단한다.

* test: Lotto.getIntersectSize() 테스트 추가

* feat: 보너스볼을 입력받는다.

* refactor: 로또 등수 계산을 WinningLotto 클래스로 분리

* refactor: 로또 등수 계산을 WinningLotto 클래스로 분리

* refactor: 로또 등수 enum으로 변경

* refactor: 로또 등수 enum으로 변경

* feat: 당첨 로또와 수익률을 계산한다.

* feat: 로또 결과 출력

* fix: 로또 집계시 1 ~ 5등 출력되도록 수정

* refactor: 매직넘버 수정

Author: devtaebong

docs/step3.md

@@ -0,0 +1,10 @@
+# 🚀 3단계 - 로또(2등)
+
+## 기능 요구사항
+
+- 2등을 위해 추가 번호를 하나 더 추첨한다.
+- 당첨 통계에 2등도 추가해야 한다.
+
+- [ ] 보너스볼을 입력받는다. (`InputView.kt`)
+- [ ] 보너스볼과 당첨번호를 비교해서 로또 등수를 계산한다. (`Match.kt`)
+- [ ] 보너스볼 일치 여부(2등)을 통계에 추가한다. (`Statistics.kt`)

src/main/kotlin/lotto/LottoApplication.kt

@@ -2,7 +2,10 @@ package lotto
 
 import lotto.domain.Cashier
 import lotto.domain.Lotto
+import lotto.domain.LottoNumber
+import lotto.domain.LottoRank
 import lotto.domain.Statistics
+import lotto.domain.WinningLotto
 import lotto.stretagy.RandomLottoNumberListGenerator
 import lotto.view.InputView
 import lotto.view.OutputView
@@ -11,13 +14,19 @@ fun main() {
     val randomNumberListGenerator = RandomLottoNumberListGenerator()
     val amount = InputView.purchaseAmount()
 
-    val userLottos = Cashier.purchaseLotto(amount, randomNumberListGenerator)
-    OutputView.printPurchaseResult(userLottos)
+    val cashier = Cashier(amount, randomNumberListGenerator)
+    val lottos = cashier.purchaseLotto()
 
-    val winningNumbers = InputView.winningNumbers()
-    val winningLotto = Lotto.createLotto(winningNumbers)
+    OutputView.printPurchaseResult(lottos)
 
-    val statisticsList = Statistics.of(userLottos, winningLotto)
-    val earningRatio = Statistics.calculateEarningRatio(statisticsList, amount)
-    OutputView.printLottoStatistics(statisticsList, earningRatio)
+    val winningNumbers = InputView.winningNumbers().map(::LottoNumber).toSet()
+    val bonusBall = LottoNumber(InputView.bonusBall())
+    val winningLotto = WinningLotto(Lotto(winningNumbers), bonusBall)
+
+    val statistics = Statistics(winningLotto, lottos)
+    val lottoResult: Map<LottoRank, Int> = statistics.lottoResultGroupByRank()
+    val earningRatio = statistics.calculateEarningRatio(amount)
+    val earningResult = statistics.getProfitStatus(earningRatio)
+
+    OutputView.printLottoResult(lottoResult, earningRatio, earningResult)
 }

src/main/kotlin/lotto/constant/LottoRankConstant.kt

@@ -2,13 +2,4 @@ package lotto.constant
 
 const val MINIMUM_NUMBER = 1
 const val MAXIMUM_NUMBER = 45
-const val FIRST_RANK = 1
-const val SECOND_RANK = 2
-const val THIRD_RANK = 3
-const val FOURTH_RANK = 4
-const val FIFTH_RANK = 5
-const val NO_RANK = 0
-const val MATCH_COUNT_SIX = 6
-const val MATCH_COUNT_FIVE = 5
-const val MATCH_COUNT_FOUR = 4
-const val MATCH_COUNT_THREE = 3
+const val REQUIRED_LOTTO_SIZE = 6

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

@@ -2,19 +2,19 @@ package lotto.domain
 
 import lotto.stretagy.LottoNumberListGenerator
 
-class Cashier {
+class Cashier(
+    private val amount: Int,
+    private val lottoNumberListGenerator: LottoNumberListGenerator,
+) {
+    fun purchaseLotto(): List<Lotto> {
+        require(amount >= LOTTO_PRICE)
+        val numberOfLotto = calculateNumberOfLotto(amount)
+        return List(numberOfLotto) { Lotto(lottoNumberListGenerator.generate()) }
+    }
+
     companion object {
         private const val LOTTO_PRICE = 1000
 
-        fun purchaseLotto(
-            amount: Int,
-            lottoNumberListGenerator: LottoNumberListGenerator,
-        ): List<Lotto> {
-            require(amount >= LOTTO_PRICE)
-            val numberOfLotto = calculateNumberOfLotto(amount)
-            return List(numberOfLotto) { Lotto.createLotto(lottoNumberListGenerator.generate()) }
-        }
-
         private fun calculateNumberOfLotto(amount: Int): Int {
             return amount / LOTTO_PRICE
         }

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

@@ -1,11 +1,27 @@
 package lotto.domain
 
-class Lotto private constructor(val lottoNumbers: Set<LottoNumber>) {
-    companion object {
-        fun createLotto(numbers: List<Int>): Lotto {
-            val lottoNumbers = numbers.map { LottoNumber.from(it) }.toSet()
+import lotto.constant.REQUIRED_LOTTO_SIZE
+
+class Lotto(val lottoNumbers: Set<LottoNumber>) {
+    constructor(vararg numbers: Int) : this(numbers.map(::LottoNumber).toSet())
 
-            return Lotto(lottoNumbers)
+    init {
+        require(lottoNumbers.size == REQUIRED_LOTTO_SIZE) {
+            ERROR_WRONG_NUMBER_COUNT
         }
     }
+
+    fun getIntersectSize(winningLotto: Lotto): Int {
+        val lottoNumbers: Set<LottoNumber> = lottoNumbers
+        val winningLottoNumbers: Set<LottoNumber> = winningLotto.lottoNumbers
+        return lottoNumbers.intersect(winningLottoNumbers).size
+    }
+
+    fun isMatchedBonusBall(bonusBall: LottoNumber): Boolean {
+        return lottoNumbers.contains(bonusBall)
+    }
+
+    companion object {
+        private const val ERROR_WRONG_NUMBER_COUNT = "정확히 6개의 숫자를 입력해야 합니다."
+    }
 }

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

@@ -1,22 +1,17 @@
 package lotto.domain
 
+import lotto.constant.MAXIMUM_NUMBER
+import lotto.constant.MINIMUM_NUMBER
+
 @JvmInline
 value class LottoNumber(val number: Int) {
-    companion object {
-        private const val MINIMUM_NUMBER = 1
-        private const val MAXIMUM_NUMBER = 45
-        private const val CANNOT_CREATE_LOTTO_NUMBER_MESSAGE = "Lotto number must be between %s and %s."
-
-        private val NUMBERS: Map<Int, LottoNumber> = (MINIMUM_NUMBER..MAXIMUM_NUMBER).associateWith { LottoNumber(it) }
-
-        fun from(number: Int): LottoNumber {
-            return NUMBERS[number] ?: throw IllegalArgumentException(
-                CANNOT_CREATE_LOTTO_NUMBER_MESSAGE.format(MINIMUM_NUMBER, MAXIMUM_NUMBER),
-            )
+    init {
+        require(number in MINIMUM_NUMBER..MAXIMUM_NUMBER) {
+            CANNOT_CREATE_LOTTO_NUMBER_MESSAGE.format(MINIMUM_NUMBER, MAXIMUM_NUMBER)
         }
     }
 
-    override fun toString(): String {
-        return number.toString()
+    companion object {
+        private const val CANNOT_CREATE_LOTTO_NUMBER_MESSAGE = "Lotto number must be between %s and %s."
     }
 }

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

@@ -0,0 +1,13 @@
+package lotto.domain
+
+enum class LottoRank(val matchCount: Int, val prize: Long) {
+    FIRST(6, 2_000_000_000L),
+    SECOND(5, 30_000_000L),
+    THIRD(5, 1_500_000L),
+    FOURTH(4, 50_000L),
+    FIFTH(3, 5_000L),
+    NONE(0, 0L),
+    ;
+
+    fun calculatePrize(count: Int): Long = prize * count
+}

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

@@ -1,36 +1,22 @@
 package lotto.domain
 
-import lotto.constant.FIFTH_RANK
-import lotto.constant.FIRST_RANK
-import lotto.constant.FOURTH_RANK
-import lotto.constant.MATCH_COUNT_FIVE
-import lotto.constant.MATCH_COUNT_FOUR
-import lotto.constant.MATCH_COUNT_SIX
-import lotto.constant.MATCH_COUNT_THREE
-import lotto.constant.NO_RANK
-import lotto.constant.THIRD_RANK
-
-class Match {
-    companion object {
-        fun lottoNumber(
-            userLotto: Lotto,
-            winningLotto: Lotto,
-        ): Int {
-            val lottoNumbers: Set<LottoNumber> = userLotto.lottoNumbers
-            val winningLottoNumbers: Set<LottoNumber> = winningLotto.lottoNumbers
-
-            val matchCount = lottoNumbers.intersect(winningLottoNumbers).size
-            return rank(matchCount)
+class Match(private val matchCount: Int, private val isMatchedBonusBall: Boolean) {
+    fun rank(): LottoRank {
+        if (matchCount == 6) {
+            return LottoRank.FIRST
         }
-
-        private fun rank(matchCount: Int): Int {
-            return when (matchCount) {
-                MATCH_COUNT_SIX -> FIRST_RANK
-                MATCH_COUNT_FIVE -> THIRD_RANK
-                MATCH_COUNT_FOUR -> FOURTH_RANK
-                MATCH_COUNT_THREE -> FIFTH_RANK
-                else -> NO_RANK
-            }
+        if (matchCount == 5 && isMatchedBonusBall) {
+            return LottoRank.SECOND
+        }
+        if (matchCount == 5) {
+            return LottoRank.THIRD
+        }
+        if (matchCount == 4) {
+            return LottoRank.FOURTH
+        }
+        if (matchCount == 3) {
+            return LottoRank.FIFTH
         }
+        return LottoRank.NONE
     }
 }

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

@@ -1,56 +1,45 @@
 package lotto.domain
 
-import lotto.constant.FIFTH_RANK
-import lotto.constant.FIRST_RANK
-import lotto.constant.FOURTH_RANK
-import lotto.constant.SECOND_RANK
-import lotto.constant.THIRD_RANK
-
-data class Statistics(val rank: Int, val matchCount: Int) {
-    fun earnings(): Long {
-        return earningPriceByRanking() * matchCount
+import kotlin.math.floor
+
+data class Statistics(private val winningLotto: WinningLotto, private val lottos: List<Lotto>) {
+    fun lottoResultGroupByRank(): Map<LottoRank, Int> {
+        val initialRanks =
+            LottoRank.entries
+                .filter { it.matchCount in MINIMUM_MATCH_COUNT..MAXIMUM_MATCH_COUNT }
+                .associateWith { 0 }
+
+        val actualRanks =
+            lottos.map { winningLotto.getUserRank(it) }
+                .filter { it.matchCount in MINIMUM_MATCH_COUNT..MAXIMUM_MATCH_COUNT }
+                .groupingBy { it }
+                .eachCount()
+
+        return initialRanks + actualRanks
     }
 
-    private fun earningPriceByRanking(): Long =
-        when (rank) {
-            FIRST_RANK -> FIRST_RANK_EARNING
-            SECOND_RANK -> SECOND_RANK_EARNING
-            THIRD_RANK -> THIRD_RANK_EARNING
-            FOURTH_RANK -> FOURTH_RANK_EARNING
-            FIFTH_RANK -> FIFTH_RANK_EARNING
-            else -> NO_RANK_EARNING
-        }
+    fun calculateEarningRatio(price: Int): Double {
+        val ratio =
+            lottoResultGroupByRank()
+                .map { (rank, count) -> rank.calculatePrize(count) }
+                .sum().toDouble() / price
 
-    companion object {
-        private const val FIRST_RANK_EARNING = 2_000_000_000L
-        private const val SECOND_RANK_EARNING = 1_500_000L
-        private const val THIRD_RANK_EARNING = 50_000L
-        private const val FOURTH_RANK_EARNING = 5_000L
-        private const val FIFTH_RANK_EARNING = 0L
-        private const val NO_RANK_EARNING = 0L
-
-        fun of(
-            userLottos: List<Lotto>,
-            winningLotto: Lotto,
-        ): List<Statistics> {
-            val groupByRanking: Map<Int, List<Lotto>> =
-                (FIFTH_RANK downTo FIRST_RANK).associateWith { emptyList<Lotto>() } +
-                    userLottos.groupBy { Match.lottoNumber(it, winningLotto) }
-
-            val statistics: List<Statistics> =
-                groupByRanking.map { Statistics(it.key, it.value.size) }.sortedByDescending { it.rank }
-            return getRankedLottos(statistics)
-        }
+        return floor(ratio * 100) / 100
+    }
 
-        fun calculateEarningRatio(
-            statisticsList: List<Statistics>,
-            amount: Int,
-        ): Double {
-            return statisticsList.sumOf { it.earnings() }.toDouble() / amount
+    fun getProfitStatus(earningRatio: Double): String =
+        when {
+            earningRatio > EARNING_RATIO_THRESHOLD -> PROFIT_MESSAGE
+            earningRatio == EARNING_RATIO_THRESHOLD -> BREAK_EVEN_MESSAGE
+            else -> LOSS_MESSAGE
         }
 
-        private fun getRankedLottos(statisticsList: List<Statistics>): List<Statistics> {
-            return statisticsList.filter { it.rank in FIRST_RANK..FIFTH_RANK && it.rank != SECOND_RANK }
-        }
+    companion object {
+        private const val MINIMUM_MATCH_COUNT = 3
+        private const val MAXIMUM_MATCH_COUNT = 6
+        private const val EARNING_RATIO_THRESHOLD = 1.0
+        private const val PROFIT_MESSAGE = "이익"
+        private const val BREAK_EVEN_MESSAGE = "본전"
+        private const val LOSS_MESSAGE = "손해"
     }
 }

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

@@ -0,0 +1,9 @@
+package lotto.domain
+
+data class WinningLotto(private val winningLotto: Lotto, private val bonusBall: LottoNumber) {
+    fun getUserRank(userLotto: Lotto): LottoRank {
+        val matchCount = userLotto.getIntersectSize(this.winningLotto)
+        val isMatchedBonusBall = userLotto.isMatchedBonusBall(bonusBall)
+        return Match(matchCount, isMatchedBonusBall).rank()
+    }
+}

src/main/kotlin/lotto/stretagy/LottoNumberListGenerator.kt

@@ -1,5 +1,7 @@
 package lotto.stretagy
 
+import lotto.domain.LottoNumber
+
 interface LottoNumberListGenerator {
-    fun generate(): List<Int>
+    fun generate(): Set<LottoNumber>
 }

src/main/kotlin/lotto/stretagy/RandomLottoNumberListGenerator.kt

@@ -2,15 +2,15 @@ package lotto.stretagy
 
 import lotto.constant.MAXIMUM_NUMBER
 import lotto.constant.MINIMUM_NUMBER
+import lotto.constant.REQUIRED_LOTTO_SIZE
+import lotto.domain.LottoNumber
 
 class RandomLottoNumberListGenerator : LottoNumberListGenerator {
-    override fun generate(): List<Int> {
+    override fun generate(): Set<LottoNumber> {
         return (MINIMUM_NUMBER..MAXIMUM_NUMBER).shuffled()
-            .take(NUMBER_OF_SELECT)
+            .take(REQUIRED_LOTTO_SIZE)
             .sorted()
-    }
-
-    companion object {
-        private const val NUMBER_OF_SELECT = 6
+            .map(::LottoNumber)
+            .toSet()
     }
 }

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

@@ -7,6 +7,7 @@ class InputView {
         private const val REPLACEMENT_SOURCE = " "
         private const val REPLACEMENT_TARGET = ""
         private const val WINNING_NUMBER_INPUT_MESSAGE = "지난 주 당첨 번호를 입력해 주세요."
+        private const val BONUS_BALL_NUMBER_INPUT_MESSAGE = "보너스 볼을 입력해 주세요."
         private const val ERROR_INVALID_NUMBER = "유효한 숫자를 입력해주세요."
         private const val ERROR_WRONG_NUMBER_COUNT = "정확히 6개의 숫자를 입력해야 합니다."
 
@@ -16,12 +17,19 @@ class InputView {
                 ?: throw IllegalArgumentException(ERROR_INVALID_NUMBER)
         }
 
-        fun winningNumbers(): List<Int> {
+        fun winningNumbers(): Set<Int> {
             println(WINNING_NUMBER_INPUT_MESSAGE)
             return readln().replace(REPLACEMENT_SOURCE, REPLACEMENT_TARGET)
                 .split(WINNING_NUMBER_DELIMITERS)
                 .also { require(it.size == 6) { ERROR_WRONG_NUMBER_COUNT } }
                 .map { it.toIntOrNull() ?: throw IllegalArgumentException(ERROR_INVALID_NUMBER) }
+                .toSet()
+        }
+
+        fun bonusBall(): Int {
+            println(BONUS_BALL_NUMBER_INPUT_MESSAGE)
+            return readln().toIntOrNull()
+                ?: throw IllegalArgumentException(ERROR_INVALID_NUMBER)
         }
     }
 }