[Step2] 로또 제출합니다.

src/main/kotlin/lotto/Main.kt

@@ -0,0 +1,28 @@
+package lotto
+
+import lotto.domain.Lotto
+import lotto.domain.Lotto.Companion.LOTTO_PRICE
+import lotto.domain.LottoBunch
+import lotto.domain.LottoNumber
+import lotto.domain.RandomGenerator
+import lotto.view.InputView
+import lotto.view.ResultView
+
+fun main() {
+    val inputView = InputView()
+    val resultView = ResultView()
+
+    val purchaseAmount = inputView.getPurchaseAmount() ?: return
+    val purchaseCount = purchaseAmount / LOTTO_PRICE
+
+    resultView.showPurchaseCount(purchaseCount)
+    val lottoBunch = LottoBunch(List(purchaseCount) { Lotto(RandomGenerator) })
+    resultView.showPurchaseLotto(lottoBunch)
+
+    val winningNumbers = inputView.getWinningNumbers() ?: return
+    val winningLottoNumbers = winningNumbers.map { LottoNumber.get(it) }
+
+    resultView.showResultInterface()
+    resultView.showMatchLottoResult(lottoBunch.getMatchLottoResult(winningLottoNumbers))
+    resultView.showYield(lottoBunch.getYield(winningLottoNumbers, purchaseAmount))
+}

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

@@ -0,0 +1,41 @@
+package lotto.domain
+
+class Lotto(private val lottoNumberGenerator: LottoNumberGenerator? = null, vararg lottoNumber: Int) {
+    init {
+        require(!(lottoNumberGenerator == null && lottoNumber.isEmpty())) { LOTTO_PARAMETERS_ERROR_MESSAGE }
+    }
+
+    val lottoNumbers: Set<LottoNumber> =
+        if (lottoNumber.isNotEmpty()) {
+            getByManual(lottoNumber)
+        } else {
+            getByAuto()
+        }
+
+    private fun getByAuto(): MutableSet<LottoNumber> {
+        lottoNumberGenerator ?: return mutableSetOf()
+        val lotto: MutableSet<LottoNumber> = mutableSetOf()
+        while (lotto.size < LOTTO_NUMBER_COUNT) {
+            lotto.add(LottoNumber.get(lottoNumberGenerator.generateLottoNumber()))
+        }
+        return lotto
+    }
+
+    private fun getByManual(lottoNumber: IntArray): Set<LottoNumber> {
+        require(lottoNumber.size == LOTTO_NUMBER_COUNT) { LOTTO_NUMBER_COUNT_EXCEPTION_MESSAGE }
+        require(lottoNumber.distinct().size == LOTTO_NUMBER_COUNT) { LOTTO_NUMBER_DISTINCT_MESSAGE }
+        return lottoNumber.map { LottoNumber.get(it) }.toSet()
+    }
+
+    fun match(winningNumber: List<LottoNumber>): MatchingResult? =
+        MatchingResult.fromMatchNumber(lottoNumbers.intersect(winningNumber).size)
+
+    companion object {
+        private const val LOTTO_NUMBER_COUNT = 6
+        private const val LOTTO_NUMBER_COUNT_EXCEPTION_MESSAGE = "로또 초기화시 입력된 로또 번호가 6개가 아닙니다."
+        private const val LOTTO_NUMBER_DISTINCT_MESSAGE = "로또 초기화시 입력된 로또 번호에 중복이 있습니다."
+        private const val LOTTO_PARAMETERS_ERROR_MESSAGE = "로또 생성시 필요한 매개변수를 잘못입력하셨습니다."
+
+        const val LOTTO_PRICE = 1000
+    }
+}

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

@@ -0,0 +1,24 @@
+package lotto.domain
+
+class LottoBunch(val value: List<Lotto>) {
+    fun getMatchLottoResult(winningNumbers: List<LottoNumber>): Map<MatchingResult, Int> {
+        val result: MutableMap<MatchingResult, Int> = MatchingResult.entries.associateWith { 0 }.toMutableMap()
+        value.forEach {
+            val stepResult = it.match(winningNumbers) ?: return@forEach
+            result[stepResult] = result.getOrDefault(stepResult, 0) + 1
+        }
+        return result
+    }
+
+    fun getYield(
+        winningNumbers: List<LottoNumber>,
+        purchaseAmount: Int,
+    ): Double {
+        val matchResults: Map<MatchingResult, Int> = getMatchLottoResult(winningNumbers)
+        var totalPrize = 0
+        matchResults.forEach { (matchingResult, winCount) ->
+            totalPrize += (matchingResult.prizeAmount * winCount)
+        }
+        return totalPrize.toDouble() / purchaseAmount
+    }
+}

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

@@ -0,0 +1,17 @@
+package lotto.domain
+
+@JvmInline
+value class LottoNumber private constructor(val value: Int) {
+    init {
+        require(value in 1..45)
+    }
+
+    companion object {
+        private val lottoNumbers: MutableMap<Int, LottoNumber> = mutableMapOf()
+
+        fun get(lottoNumber: Int): LottoNumber =
+            lottoNumbers[lottoNumber] ?: LottoNumber(lottoNumber).apply {
+                lottoNumbers[lottoNumber] = this
+            }
+    }
+}

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

@@ -0,0 +1,5 @@
+package lotto.domain
+
+interface LottoNumberGenerator {
+    fun generateLottoNumber(): Int
+}

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

@@ -0,0 +1,15 @@
+package lotto.domain
+
+enum class MatchingResult(val prizeAmount: Int, val matchNumber: Int) {
+    MATCHED_THREE(5_000, 3),
+    MATCHED_FOUR(50_000, 4),
+    MATCHED_FIVE(1_500_000, 5),
+    MATCHED_SIX(2_000_000_000, 6), ;
+
+    companion object {
+        private const val MATCH_NUMBER_TRANSFER_ERROR_MESSAGE = "로또 결과 이넘값 변환 오류가 발생하였습니다."
+        private val matchNumberToMatchResultMap = entries.associateBy { it.matchNumber }
+
+        fun fromMatchNumber(matchNumber: Int): MatchingResult? = matchNumberToMatchResultMap[matchNumber]
+    }
+}

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

@@ -0,0 +1,5 @@
+package lotto.domain
+
+object RandomGenerator : LottoNumberGenerator {
+    override fun generateLottoNumber(): Int = (1..45).random()
+}

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

@@ -0,0 +1,34 @@
+package lotto.view
+
+class InputView {
+    fun getPurchaseAmount(): Int? {
+        println("구입금액을 입력해 주세요.")
+        val input = readlnOrNull()
+        if (input.isNullOrEmpty()) {
+            println("아무값도 입력되지 않았습니다.")
+            return null
+        }
+        if (input.toIntOrNull() == null) {
+            println("숫자만 입력 가능합니다.")
+            return null
+        }
+        return input.toInt()
+    }
+
+    fun getWinningNumbers(): List<Int>? {
+        println("지난 주 당첨 번호를 입력해 주세요.")
+        val input = readlnOrNull()
+        if (input.isNullOrEmpty()) {
+            println("아무값도 입력되지 않았습니다.")
+            return null
+        }
+        val slicedInput = input.split(",")
+        slicedInput.forEach {
+            if (it.toIntOrNull() == null) {
+                println("숫자만 입력 가능합니다.")
+                return null
+            }
+        }
+        return slicedInput.map { it.toInt() }
+    }
+}

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

@@ -0,0 +1,31 @@
+package lotto.view
+
+import lotto.domain.LottoBunch
+import lotto.domain.MatchingResult
+
+class ResultView {
+    fun showPurchaseCount(purchaseCount: Int) {
+        println("${purchaseCount}개를 구매했습니다.")
+    }
+
+    fun showPurchaseLotto(lottoBunch: LottoBunch) {
+        lottoBunch.value.forEach {
+            println(it.lottoNumbers.map { it.value }.toString())
+        }
+    }
+
+    fun showResultInterface() {
+        println("당첨 통계")
+        println("----------")
+    }
+
+    fun showMatchLottoResult(result: Map<MatchingResult, Int>) {
+        result.forEach { key, value ->
+            println("${key.matchNumber}개 일치 (${key.prizeAmount}원)- ${value}개")
+        }
+    }
+
+    fun showYield(yield: Double) {
+        println("총 수익률은 ${String.format("%.2f", yield)}입니다.")
+    }
+}

src/main/kotlin/lotto/기능목록.md

@@ -0,0 +1,20 @@
+# 로또
+로또를 만드는게 아니라 로또 당첨됐으면 좋겠다.
+
+## 도메인
+- [x] 로또를 생성한다.
+  - [x] 로또 번호를 랜덤하게 생성한다.
+  - [x] 로또 번호는 중복될 수 없다.
+- [x] 당첨 로또 수를 계산한다.
+  - [x] 몇등 당첨인지 확인한다.
+- [x] 수익률을 계산한다.
+- [x] 로또 번호는 1~45사이로 한정한다.
+
+
+## 뷰
+### 입력
+- [ ] 구입금액을 입력받는다.
+- [ ] 로또 당첨 번호를 입력받는다.
+### 출력
+- [ ] 구매 내역을 출력해준다.(구매 갯수,로또 내역)
+- [ ] 결과를 출력해준다.

src/test/kotlin/lotto/domain/LottoBunchTest.kt

@@ -0,0 +1,54 @@
+package lotto.domain
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class LottoBunchTest : StringSpec({
+    "당첨 로또수를 계산한다." {
+        val classUnderTest: LottoBunch =
+            getLottoBunch(
+                listOf(
+                    listOf(1, 2, 3, 4, 5, 6),
+                    listOf(1, 2, 3, 4, 5, 6),
+                    listOf(1, 2, 3, 4, 5, 6),
+                    listOf(1, 2, 3, 4, 5, 6),
+                    listOf(1, 2, 3, 4, 5, 45),
+                    listOf(1, 2, 3, 4, 5, 45),
+                    listOf(1, 2, 3, 4, 5, 45),
+                    listOf(1, 2, 3, 4, 44, 45),
+                    listOf(1, 2, 3, 4, 44, 45),
+                    listOf(1, 2, 3, 43, 44, 45),
+                ),
+            )
+        val winningNumbers = listOf(1, 2, 3, 4, 5, 6).map { LottoNumber.get(it) }
+        val expected =
+            mapOf(
+                MatchingResult.MATCHED_THREE to 1,
+                MatchingResult.MATCHED_FOUR to 2,
+                MatchingResult.MATCHED_FIVE to 3,
+                MatchingResult.MATCHED_SIX to 4,
+            )
+        classUnderTest.getMatchLottoResult(winningNumbers) shouldBe expected
+    }
+
+    "수익률을 계산한다." {
+        val classUnderTest: LottoBunch =
+            getLottoBunch(
+                listOf(
+                    listOf(1, 2, 3, 4, 5, 6),
+                    listOf(1, 2, 3, 4, 5, 45),
+                    listOf(1, 2, 3, 4, 44, 45),
+                    listOf(1, 2, 3, 43, 44, 45),
+                ),
+            )
+        val winningNumbers = listOf(1, 2, 3, 4, 5, 6).map { LottoNumber.get(it) }
+        val purchaseAmount = 10000
+        val totalPrize = MatchingResult.entries.map { it.prizeAmount }.sum()
+
+        classUnderTest.getYield(winningNumbers, purchaseAmount) shouldBe totalPrize.toDouble() / purchaseAmount
+    }
+}) {
+    private companion object {
+        fun getLottoBunch(numbers: List<List<Int>>): LottoBunch = LottoBunch(numbers.map { Lotto(null, *it.toIntArray()) })
+    }
+}

src/test/kotlin/lotto/domain/LottoNumberTest.kt

@@ -0,0 +1,23 @@
+package lotto.domain
+
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.assertions.throwables.shouldThrowAny
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.inspectors.forAll
+
+class LottoNumberTest : StringSpec({
+    "로또 번호는 1~45 사이 값이여야 한다." {
+        (1..45).toList().forAll { lottoNumber ->
+            shouldNotThrowAny { LottoNumber.get(lottoNumber) }
+        }
+    }
+
+    "1~45이 아닌 값으로 로또 번호를 생성할시 에러가 발생한다." {
+        (-45..0).toList().forAll { lottoNumber ->
+            shouldThrowAny { LottoNumber.get(lottoNumber) }
+        }
+        (46..100).toList().forAll { lottoNumber ->
+            shouldThrowAny { LottoNumber.get(lottoNumber) }
+        }
+    }
+})

src/test/kotlin/lotto/domain/LottoTest.kt

@@ -0,0 +1,41 @@
+package lotto.domain
+
+import io.kotest.assertions.throwables.shouldNotThrowAny
+import io.kotest.assertions.throwables.shouldThrowAny
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.inspectors.forAll
+import io.kotest.matchers.shouldBe
+
+class LottoTest : StringSpec({
+    "로또를 발급한다." {
+        shouldNotThrowAny {
+            Lotto(RandomGenerator)
+        }
+    }
+
+    "로또를 직접 초기화할때 중복되지 않은 6개의 숫자를 입력해야한다." {
+        listOf(listOf(1, 2, 3, 4), listOf(1, 1, 2, 3, 4, 5)).forAll { numberList ->
+            shouldThrowAny {
+                Lotto(null, *numberList.toIntArray())
+            }
+        }
+    }
+
+    "발급된 로또의 로또번호 갯수는 6개이다." {
+        Lotto(RandomGenerator).lottoNumbers.size shouldBe 6
+    }
+
+    "각 로또의 번호를 매칭하여 결과를 도출한다." {
+        listOf(
+            Pair(listOf(45, 44, 43, 42, 41, 40), null),
+            Pair(listOf(1, 45, 44, 43, 42, 41), null),
+            Pair(listOf(1, 2, 45, 44, 43, 42), null),
+            Pair(listOf(1, 2, 3, 45, 44, 43), MatchingResult.MATCHED_THREE),
+            Pair(listOf(1, 2, 3, 4, 45, 44), MatchingResult.MATCHED_FOUR),
+            Pair(listOf(1, 2, 3, 4, 5, 45), MatchingResult.MATCHED_FIVE),
+            Pair(listOf(1, 2, 3, 4, 5, 6), MatchingResult.MATCHED_SIX),
+        ).forAll { (winningNumbers, matchingResult) ->
+            Lotto(null, 1, 2, 3, 4, 5, 6).match(winningNumbers.map { LottoNumber.get(it) }) shouldBe matchingResult
+        }
+    }
+})