Step3 로또(2등)

README.md

@@ -71,4 +71,29 @@
 - [x] Numbers::validate 시 find api 사용
 - [x] Parser::덧셈수 변수명 고려
 - [x] StringAddCalculatorTest::커스텀 구분자 테스트 케이스 추가
-- [x] Parser::parser 테스트 추가
+- [x] Parser::parser 테스트 추가
+
+# Step3 로또(2등)
+## 기능 요구사항
+- 2등을 위해 추가 번호를 하나 더 추첨한다.
+- 당첨 통계에 2등도 추가해야 한다.
+
+### Step2 - 리뷰 반영사항
+- [x] LotteryNumbers::intersect infix 함수 문법 적용
+- [x] TicketMachineTest::테스트 케이스 추가
+- [x] LotteryApplication::스태틱임포트 원복
+- [x] LotteryTest::로또번호 일치 수 반환 테스트 케이스 추가
+- [x] WinningLottery::lotto 가 아닌 lotteryNumbers 를 갖도록 수정
+- [x] Ticket::object 로 수정
+- [x] Money::value class 로 수정
+- [x] Money::divideBy operator fun 으로 수정
+- [x] DrawResult::getTotalReward 로직 내 타입 명시
+
+## 기능 구현 목록
+- [x] 로또 영문명을 Lotto 로 변경
+- [x] 로또 번호를 값 객체로 래핑한다.
+- [x] 일급컬렉션으로 로또 번호 리스트를 래핑한다.
+- [x] 보너스볼은 로또번호와 중복되지 않는다.
+- [x] 5개 일치와 보너스볼 일치는 2등이다.
+- [x] 5개 일치는 3등이다.
+- [x] 보너스 볼 일치를 출력한다.

src/main/kotlin/lotto/controller/LotteryApplication.kt

@@ -0,0 +1,26 @@
+package lotto.controller
+
+import lotto.domain.DrawResult
+import lotto.domain.LottoMachine
+import lotto.domain.Money
+import lotto.domain.TicketMachine
+import lotto.domain.WinningLotto
+import lotto.view.InputView
+import lotto.view.ResultView
+
+fun main() {
+    val purchaseAmount = Money(InputView.inputPurchaseAmount())
+    val tickets = TicketMachine.exchange(purchaseAmount)
+    ResultView.printTicketCount(tickets)
+
+    val purchaseLotteries = LottoMachine.purchase(tickets)
+    ResultView.printLotteries(purchaseLotteries)
+
+    val winningLotto =
+        WinningLotto.create(
+            InputView.inputWinningLottoNumbers(),
+            InputView.inputWinningBonusNumber(),
+        )
+    val drawResult = DrawResult.from(winningLotto, purchaseLotteries)
+    ResultView.printStatistic(purchaseAmount, drawResult)
+}

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

@@ -0,0 +1,37 @@
+package lotto.domain
+
+data class DrawResult(private val rankRewardLottoCountMap: Map<RankReward, LottoCount>) {
+    fun getProfitRate(purchaseAmount: Money): Double {
+        return getTotalReward() / purchaseAmount
+    }
+
+    fun getLottoCount(rankReward: RankReward): LottoCount {
+        return rankRewardLottoCountMap[rankReward] ?: LottoCount(0)
+    }
+
+    private fun getTotalReward(): Money {
+        return rankRewardLottoCountMap.entries.fold(Money.ZERO) { total: Money, (rankReward: RankReward, lottoCount: LottoCount) ->
+            val totalRewardPerRank: Money = rankReward.money * lottoCount.count
+            total + totalRewardPerRank
+        }
+    }
+
+    companion object {
+        fun from(
+            winningLotto: WinningLotto,
+            purchaseLotteries: List<Lotto>,
+        ): DrawResult {
+            val rankRewardLottoCountMap =
+                purchaseLotteries
+                    .map { lotto ->
+                        val matchedCount = winningLotto.countMatchedNumber(lotto)
+                        val matchBonus = winningLotto.matchBonus(lotto)
+                        RankReward.valueOf(matchedCount, matchBonus)
+                    }
+                    .groupingBy { it }
+                    .eachCount()
+                    .mapValues { LottoCount(it.value) }
+            return DrawResult(rankRewardLottoCountMap)
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+package lotto.domain
+
+data class Lotto(val lottoNumbers: LottoNumbers) {
+    override fun toString(): String {
+        return "$lottoNumbers"
+    }
+
+    companion object {
+        fun create(): Lotto {
+            return Lotto(LottoNumbers.create())
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+package lotto.domain
+
+@JvmInline
+value class LottoCount(val count: Int) {
+    override fun toString(): String {
+        return "$count"
+    }
+}

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

@@ -0,0 +1,7 @@
+package lotto.domain
+
+object LottoMachine {
+    fun purchase(tickets: List<Ticket>): List<Lotto> {
+        return List(tickets.size) { Lotto.create() }
+    }
+}

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

@@ -0,0 +1,24 @@
+package lotto.domain
+
+@JvmInline
+value class LottoNumber(val number: Int) {
+    init {
+        require(number in LOTTO_NUMBER_RANGE) { "로또 번호는 $LOTTO_MIN_NUMBER 부터 $LOTTO_MAX_NUMBER 사이어야 합니다" }
+    }
+
+    override fun toString(): String {
+        return "$number"
+    }
+
+    companion object {
+        private const val LOTTO_MIN_NUMBER = 1
+        private const val LOTTO_MAX_NUMBER = 45
+        private val LOTTO_NUMBER_RANGE = LOTTO_MIN_NUMBER..LOTTO_MAX_NUMBER
+
+        val ALL = LOTTO_NUMBER_RANGE.map { LottoNumber(it) }
+
+        fun create(): LottoNumber {
+            return LottoNumber(LOTTO_NUMBER_RANGE.random())
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+package lotto.domain
+
+class LottoNumbers(numbers: Set<LottoNumber>) {
+    val numbers: Set<LottoNumber>
+
+    init {
+        require(numbers.size == LOTTO_NUMBER_COUNT) { "로또 번호는 $LOTTO_NUMBER_COUNT 개이어야 합니다" }
+        this.numbers = numbers.sortedBy { it.number }.toSet()
+    }
+
+    fun countMatchedNumber(other: LottoNumbers): Int {
+        return (numbers intersect other.numbers).size
+    }
+
+    fun containsNumber(other: LottoNumber): Boolean {
+        return numbers.contains(other)
+    }
+
+    override fun toString(): String {
+        return "$numbers"
+    }
+
+    companion object {
+        private const val LOTTO_NUMBER_COUNT = 6
+
+        fun create(): LottoNumbers {
+            return LottoNumbers(LottoNumber.ALL.shuffled().take(LOTTO_NUMBER_COUNT).toSet())
+        }
+
+        fun from(numbers: Set<Int>): LottoNumbers {
+            return LottoNumbers(numbers.map { LottoNumber(it) }.toSet())
+        }
+    }
+}