Step3 - 로또(2등) (#959)

* refactor: 로또 자료구조 변경, domain패키치 추가, 테스트 코드 표현 변경(오류 -> 예외)

* Refactor: 로또 번호 랜덤 로직 추상화

* Refactor: 당첨 도메인 추가

* Docs: 보너스 볼 추가로 인한 기능목록 수정(README.md)

* Refactor: Lotto클래스로 로또 번호 중복 로직 역할 이동, 랜덤 로직 리팩토링, 로또 번호 반환 자료구조 변경

* Feat: 보너스 번호가 포함된 당첨 로또 데이터 추가.

* Refactor: 당첨 여부 검증, 당첨 통계 기능 리펙터링(with 보너스 번호)

* Feat: 보너스 볼 입력 로직 구현
Refactor: 당첨 통계 output로직 수정, 당첨 로또 생성 로직 수정

* Refactor: 랜덤 번호 생성 자료구조 변경(정렬 기능 추가)

Author: oyj7677

README.md

@@ -39,22 +39,20 @@
 - [O] 로또 번호의 조합을 가지고 있는다.
 
 로또 머신 (object)
-
 - [O] 입력받은 번호로 구성된 로또로 생성한다.
+- [O] 당첨 번호 생성(with 보너스 번호)
 - [O] 당첨 여부 검증
 - [O] 수익률 반환
 
-
 로또 게임 (class)
 - [O] 입력받은 금액의 최대 수량만큼 로또를 구해한다.
 - [O] 당첨 통계를 낸다.
 
-
 inputView (object)
 
 - [O] 입력된 금액 포맷 검증
     - [O] 숫자 포맷 검증
     - [O] 금액 범위는 1,000원 이상 100,000원 이하의 정수
-- [O] 지난 당첨 번호 포맷 검증
+- [] 지난 당첨 번호 포맷 검증
     - [O] 콤마(,)를 기준으로 나눈다
     - [O] 숫자 포맷 검증

src/main/kotlin/lotto/LottoGame.kt

@@ -1,21 +1,25 @@
 package lotto
 
+import lotto.data.LottoNumber
+import lotto.domain.LottoMachine
+import lotto.domain.RandomLogic
+import lotto.service.LottoGame
 import lotto.view.InputView
 import lotto.view.OutputView
 
 fun main() {
 
     val cash = InputView.inputCash()
-    val lottoGame = LottoGame()
-
+    val lottoGame = LottoGame(RandomLogic())
     val purchaseLottoList = lottoGame.buyLotto(cash.toInt())
 
     OutputView.showLottoList(purchaseLottoList)
 
     val winningNumberList = InputView.inputWinningNumber()
+    val bonusNumber = InputView.inputBonusNumber()
 
-    val winningStatus = lottoGame.getWinningStats(winningNumberList, purchaseLottoList)
-
+    val winningLotto = LottoMachine.createWinningLotto(winningNumberList, bonusNumber)
+    val winningStatus = lottoGame.getWinningStats(winningLotto, purchaseLottoList)
     val winningRate = LottoMachine.createWinningRate(cash.toInt(), winningStatus)
 
     OutputView.showWinningStatus(winningStatus, winningRate)

src/main/kotlin/lotto/LottoMachine.kt

@@ -1,5 +1,16 @@
 package lotto.data
 
-import java.util.TreeSet
+data class Lotto(val selectNumbers: Set<LottoNumber>) {
+    init {
+        validateDuplication(selectNumbers)
+    }
 
-data class Lotto(val selectNumbers: TreeSet<LottoNumber>)
+    private fun validateDuplication(lottoNumbers: Set<LottoNumber>) {
+        require(lottoNumbers.size == LOTTO_NUMBER_LENGTH) { ERR_MSG_OUT_OF_LOTTO_LENGTH }
+    }
+
+    companion object {
+        private const val LOTTO_NUMBER_LENGTH = 6
+        private const val ERR_MSG_OUT_OF_LOTTO_LENGTH = "번호는 6개로 구성되어야 합니다."
+    }
+}

src/main/kotlin/lotto/LottoMain.kt

@@ -1,47 +1,34 @@
 package lotto.data
 
-import java.util.TreeSet
+import lotto.domain.RandomLogicInterface
 
 class LottoNumber private constructor(private val number: Int) : Comparable<LottoNumber> {
 
+    override fun compareTo(other: LottoNumber): Int {
+        return this.number.compareTo(other.number)
+    }
+
+    override fun toString(): String {
+        return number.toString()
+    }
+
     companion object {
         private const val MIN_NUMBER = 1
         private const val MAX_NUMBER = 45
-        private const val SUB_LIST_START_POSITION = 0
-        private const val LOTTO_NUMBER_LENGTH = 6
         private const val ERR_MSG_OUT_OF_LOTTO_RANGE = "로또의 범위를 넘어서는 번호입니다."
-        private const val ERR_MSG_OUT_OF_LOTTO_LENGTH = "번호는 6개로 구성되어야 합니다."
 
         private val NUMBERS: Map<Int, LottoNumber> = (MIN_NUMBER..MAX_NUMBER).associateWith(::LottoNumber)
 
-        fun createLottoNumbers(numbers: List<Int>): TreeSet<LottoNumber> {
-            val lottoNumbers = TreeSet(numbers.map(::from))
-            validateDuplication(lottoNumbers)
-
-            return lottoNumbers
-        }
-
-        fun createRandomLotto(): TreeSet<LottoNumber> {
-            val randomNumberList = (MIN_NUMBER..MAX_NUMBER).shuffled()
-                .subList(SUB_LIST_START_POSITION, SUB_LIST_START_POSITION + LOTTO_NUMBER_LENGTH)
-
-            return TreeSet(randomNumberList.map(::from))
+        fun createLottoNumbers(numbers: List<Int>): Set<LottoNumber> {
+            return LinkedHashSet(numbers.map(::from))
         }
 
-        private fun validateDuplication(lottoNumbers: TreeSet<LottoNumber>) {
-            require(lottoNumbers.size == LOTTO_NUMBER_LENGTH) { ERR_MSG_OUT_OF_LOTTO_LENGTH }
+        fun createRandomLottoNumber(lottoCreation: RandomLogicInterface): Set<LottoNumber> {
+            return lottoCreation.createAutoLotto(NUMBERS)
         }
 
-        private fun from(value: Int): LottoNumber {
+        fun from(value: Int): LottoNumber {
             return NUMBERS[value] ?: throw IllegalArgumentException(ERR_MSG_OUT_OF_LOTTO_RANGE)
         }
     }
-
-    override fun compareTo(other: LottoNumber): Int {
-        return this.number.compareTo(other.number)
-    }
-
-    override fun toString(): String {
-        return number.toString()
-    }
 }

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

@@ -1,22 +1,27 @@
 package lotto.data
 
 enum class LottoRanking(val matchingNumberCnt: Int, val price: Int) : Prize {
-    FirstPlace(6, 2000000000) {
+    FirstPlace(6, 2_000_000_000) {
         override fun findPrize(winningStatus: Pair<LottoRanking, Int>): Int {
             return winningStatus.first.price * winningStatus.second
         }
     },
-    SecondPlace(5, 1500000) {
+    SecondPlace(5, 30_000_000) {
         override fun findPrize(winningStatus: Pair<LottoRanking, Int>): Int {
             return winningStatus.first.price * winningStatus.second
         }
     },
-    ThirdPlace(4, 50000) {
+    ThirdPlace(5, 1_500_000) {
         override fun findPrize(winningStatus: Pair<LottoRanking, Int>): Int {
             return winningStatus.first.price * winningStatus.second
         }
     },
-    FourthPlace(3, 5000) {
+    FourthPlace(4, 50_000) {
+        override fun findPrize(winningStatus: Pair<LottoRanking, Int>): Int {
+            return winningStatus.first.price * winningStatus.second
+        }
+    },
+    FifthPlace(3, 5_000) {
         override fun findPrize(winningStatus: Pair<LottoRanking, Int>): Int {
             return winningStatus.first.price * winningStatus.second
         }
@@ -28,6 +33,6 @@ enum class LottoRanking(val matchingNumberCnt: Int, val price: Int) : Prize {
     };
 }
 
-interface Prize {
+fun interface Prize {
     fun findPrize(winningStatus: Pair<LottoRanking, Int>): Int
 }

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

@@ -0,0 +1,3 @@
+package lotto.data
+
+data class WinningLotto(val lotto: Lotto, val bonusNumber: LottoNumber)

src/main/kotlin/lotto/data/LottoRanking.kt

@@ -0,0 +1,57 @@
+package lotto.domain
+
+import lotto.data.Lotto
+import lotto.data.LottoNumber
+import lotto.data.LottoRanking
+import lotto.data.LottoRanking.FifthPlace
+import lotto.data.LottoRanking.FirstPlace
+import lotto.data.LottoRanking.FourthPlace
+import lotto.data.LottoRanking.None
+import lotto.data.LottoRanking.SecondPlace
+import lotto.data.LottoRanking.ThirdPlace
+import lotto.data.WinningLotto
+
+object LottoMachine {
+
+    fun createSelectLotto(lottoNumbers: Set<LottoNumber>): Lotto {
+        return Lotto(lottoNumbers)
+    }
+
+    fun createWinningLotto(winningNumbers: List<Int>, bonusNumber: Int): WinningLotto {
+        val winningLotto = LottoNumber.createLottoNumbers(winningNumbers)
+        val bonusLottoNumber = LottoNumber.from(bonusNumber)
+        return WinningLotto(Lotto(winningLotto), bonusLottoNumber)
+    }
+
+    fun checkLotto(purchaseLotto: Lotto, winningLotto: WinningLotto): LottoRanking {
+        val intersectNumber = winningLotto.lotto.selectNumbers.intersect(purchaseLotto.selectNumbers)
+
+        return when (intersectNumber.size) {
+            FirstPlace.matchingNumberCnt -> FirstPlace
+            SecondPlace.matchingNumberCnt, ThirdPlace.matchingNumberCnt -> {
+                checkSecondPlace(purchaseLotto, winningLotto.bonusNumber)
+            }
+            FourthPlace.matchingNumberCnt -> FourthPlace
+            FifthPlace.matchingNumberCnt -> FifthPlace
+            else -> None
+        }
+    }
+
+    fun createWinningRate(cash: Int, winningStatus: Map<LottoRanking, Int>): Float {
+        val totalPrice = createTotalWinningPrice(winningStatus)
+
+        return totalPrice / cash.toFloat()
+    }
+
+    private fun checkSecondPlace(purchaseLotto: Lotto, bonusLottoNumber: LottoNumber): LottoRanking {
+        return if (purchaseLotto.selectNumbers.contains(bonusLottoNumber)) {
+            SecondPlace
+        } else {
+            ThirdPlace
+        }
+    }
+
+    private fun createTotalWinningPrice(winningStatus: Map<LottoRanking, Int>): Int {
+        return winningStatus.toList().sumOf { it.first.findPrize(it) }
+    }
+}

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

@@ -0,0 +1,17 @@
+package lotto.domain
+
+import lotto.data.LottoNumber
+import java.util.TreeSet
+
+class RandomLogic : RandomLogicInterface {
+
+    override fun createAutoLotto(numbers: Map<Int, LottoNumber>): Set<LottoNumber> {
+
+        return TreeSet(numbers.values.shuffled().subList(SUB_LIST_START_POSITION, LOTTO_NUMBER_LENGTH))
+    }
+
+    companion object {
+        private const val SUB_LIST_START_POSITION = 0
+        private const val LOTTO_NUMBER_LENGTH = 6
+    }
+}