[부나] 코틀린 자동차 경주 제출합니다.

.editorconfig

@@ -0,0 +1,16 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+trim_trailing_whitespace = true
+insert_final_newline = false
+max_line_length = 120
+tab_width = 4
+
+[*.{kt,kts}]
+disabled_rules=import-ordering
+# java.* 패키지를 의존하는 경우  IntelliJ의 Orgarnize Import 기능으로는 알파벳 순서대로 import 구문을 정렬할 수 없다.
+# 이는 ktlint의 import-ordering 규칙과 맞지 않는다.

build.gradle.kts

@@ -14,6 +14,8 @@ dependencies {
     testImplementation("org.junit.jupiter", "junit-jupiter", "5.8.2")
     testImplementation("org.assertj", "assertj-core", "3.22.0")
     testImplementation("io.kotest", "kotest-runner-junit5", "5.2.3")
+
+    testImplementation(kotlin("test"))
 }
 
 tasks {
@@ -29,4 +31,4 @@ tasks {
     ktlint {
         verbose.set(true)
     }
-}
+}

docs/README.md

@@ -0,0 +1,36 @@
+### 기능 목록
+- 
+- 입력
+  - 자동차 이름들 입력
+    - [x] 입력받은 문자열을 콤마를 기준으로 split
+    - [x] 앞뒤 공백 제거
+    - [X] 각각 0 이하 6자 이상 시 예외 발생 후 재입력
+    - [x] 중복이 있을 시 예외 발생 후 재입력
+  - 시도 횟수 입력
+    - [x] 숫자 형태 확인
+    - [x] 0 이하, int 범위 초과 시 예외 발생 후 재입력
+
+- 기능
+  - 전진 여부 발행
+    - [x] 0 ~ 9 무작위 발행
+    - [x] 4 이상일 경우 전진
+  - [x] 최종 우승자 산출 
+  - [x] 구현한 기능 통합   
+
+- 출력
+  - [x] 라운드 결과 출력
+  - [x] 우승자 출력
+
+경주할 자동차 이름을 입력하세요(이름은 쉼표(,)를 기준으로 구분).      
+pobi,woni,jun   
+시도할 횟수는 몇 회인가요?   
+5
+
+실행 결과   
+pobi : -   
+woni :   
+jun : -   
+
+pobi : --   
+woni : -   
+jun : --   

settings.gradle.kts

@@ -1 +1 @@
-rootProject.name = "kotlin-racingcar"
+rootProject.name = "kotlin-racingcar"

src/main/kotlin/racingcar/Application.kt

@@ -0,0 +1,8 @@
+package racingcar
+
+import racingcar.controller.RacingController
+
+fun main() {
+    val racingController = RacingController()
+    racingController.runRacing()
+}

src/main/kotlin/racingcar/controller/RacingController.kt

@@ -0,0 +1,67 @@
+package racingcar.controller
+
+import racingcar.model.Car
+import racingcar.service.RacingService
+import racingcar.utils.CAR_NAMES_REQUEST_MESSAGE
+import racingcar.utils.ROUNDS_RESULT_NOTIFICATION_MESSAGE
+import racingcar.utils.ROUND_COUNT_REQUEST_MESSAGE
+import racingcar.utils.Validator
+import racingcar.view.InputView
+import racingcar.view.OutputView
+
+class RacingController(
+    private val inputView: InputView = InputView(Validator()),
+    private val outputView: OutputView = OutputView(),
+    private val racingService: RacingService = RacingService(),
+) {
+    fun runRacing() {
+        val cars = createCars(readCarNames())
+        val roundCount = readRoundCount()
+
+        runRounds(roundCount, cars)
+
+        val winners = getWinners(cars)
+        printWinners(winners)
+    }
+
+    private fun readCarNames(): List<String> {
+        outputView.printMessage(CAR_NAMES_REQUEST_MESSAGE)
+        return inputView.readCarNames()
+    }
+
+    private fun readRoundCount(): Int {
+        outputView.printMessage(ROUND_COUNT_REQUEST_MESSAGE)
+        return inputView.readRoundCount()
+    }
+
+    private fun printRoundCountRequestMessage() = outputView.printMessage(ROUNDS_RESULT_NOTIFICATION_MESSAGE)
+
+    private fun printRoundResult(cars: List<Car>) = outputView.printRoundResult(cars)
+
+    private fun printWinners(winners: List<Car>) = outputView.printWinners(winners)
+
+    private fun runRounds(roundCount: Int, cars: List<Car>) {
+        printRoundCountRequestMessage()
+        repeat(roundCount) {
+            runRound(cars)
+        }
+    }
+
+    private fun runRound(cars: List<Car>) {
+        moveCarsRandomly(cars)
+        printRoundResult(cars)
+    }
+
+    private fun moveCarsRandomly(cars: List<Car>) {
+        cars.forEach { car ->
+            racingService.moveRandomly(car)
+        }
+    }
+
+    private fun createCars(carNames: List<String>) =
+        carNames.map { carName ->
+            racingService.createCar(carName)
+        }
+
+    private fun getWinners(cars: List<Car>): List<Car> = racingService.getWinners(cars)
+}

src/main/kotlin/racingcar/model/Car.kt

@@ -0,0 +1,36 @@
+package racingcar.model
+
+import racingcar.utils.Validator
+
+class Car(
+    private val name: String,
+    private var position: Int = 0
+) : Comparable<Car> {
+
+    init {
+        val validator = Validator()
+        validator.checkCarNameLength(name)
+    }
+
+    fun move() = ++position
+
+    override fun compareTo(other: Car) = this.position - other.position
+
+    override fun equals(other: Any?): Boolean {
+        if (other is Car) {
+            return this.position == other.position
+        }
+
+        return false
+    }
+
+    override fun toString() = name
+
+    override fun hashCode(): Int {
+        var result = name.hashCode()
+        result = 31 * result + position
+        return result
+    }
+
+    fun getPositionAsDash() = "-".repeat(position)
+}

src/main/kotlin/racingcar/service/RacingService.kt

@@ -0,0 +1,31 @@
+package racingcar.service
+
+import racingcar.model.Car
+import racingcar.utils.END_RANDOM_MOVEMENT_PROBABILITY
+import racingcar.utils.MOVEMENT_PROBABILITY
+import racingcar.utils.Random
+import racingcar.utils.START_RANDOM_MOVEMENT_PROBABILITY
+
+class RacingService {
+
+    fun createCar(carName: String) = Car(carName)
+
+    fun moveRandomly(car: Car) {
+        if (isMove()) {
+            car.move()
+        }
+    }
+
+    private fun isMove(): Boolean {
+        val random = Random.pickInRange(START_RANDOM_MOVEMENT_PROBABILITY, END_RANDOM_MOVEMENT_PROBABILITY)
+        if (random < MOVEMENT_PROBABILITY) {
+            return false
+        }
+        return true
+    }
+
+    fun getWinners(cars: List<Car>): List<Car> {
+        val winnerStandard = cars.max()
+        return cars.filter { it == winnerStandard }
+    }
+}

src/main/kotlin/racingcar/utils/BlankRemover.kt

@@ -0,0 +1,11 @@
+package racingcar.utils
+
+object BlankRemover {
+    fun removeBlank(texts: MutableList<String>) {
+        for (i in texts.indices) {
+            texts[i] = removeBlank(texts[i])
+        }
+    }
+
+    private fun removeBlank(text: String): String = text.trim()
+}

src/main/kotlin/racingcar/utils/Dimens.kt

@@ -0,0 +1,13 @@
+package racingcar.utils
+
+const val MIN_CAR_NAME_LENGTH = 1
+const val MAX_CAR_NAME_LENGTH = 5
+
+const val MIN_ROUND_COUNT = 1
+const val MAX_ROUND_COUNT = Int.MAX_VALUE
+
+const val RANDOM_SEED = 10
+
+const val START_RANDOM_MOVEMENT_PROBABILITY = 1
+const val END_RANDOM_MOVEMENT_PROBABILITY = 10
+const val MOVEMENT_PROBABILITY = 4

src/main/kotlin/racingcar/utils/Random.kt

@@ -0,0 +1,10 @@
+package racingcar.utils
+
+import kotlin.random.Random
+
+object Random {
+
+    private val random = Random(RANDOM_SEED)
+
+    fun pickInRange(start: Int, end: Int) = random.nextInt(start, end + 1)
+}

src/main/kotlin/racingcar/utils/Strings.kt

@@ -0,0 +1,17 @@
+package racingcar.utils
+
+// Delimiter
+const val CAR_NAME_DELIMITER = ","
+
+// Error
+const val CAR_NAME_BOUNDARY_ERROR_MESSAGE = "자동차 이름의 길이는 $MIN_CAR_NAME_LENGTH 이상 $MAX_CAR_NAME_LENGTH 이하로 부탁이요~"
+const val DUPLICATED_CAR_NAME_ERROR_MESSAGE = "자동차 이름 중복 빼주세요~"
+
+const val NOT_INTEGER_TYPE_ERROR_MESSAGE = "숫자 형태로 부탁이요~"
+const val ROUND_COUNT_BOUNDARY_ERROR_MESSAGE = "라운드 횟수는 $MIN_ROUND_COUNT 이상 $MAX_ROUND_COUNT 이하로 부탁이요~"
+
+// Request Message
+const val CAR_NAMES_REQUEST_MESSAGE = "경주할 자동차 이름을 입력하세요(이름은 쉼표(,)를 기준으로 구분)."
+const val ROUND_COUNT_REQUEST_MESSAGE = "시도할 횟수는 몇 회인가요?"
+const val ROUNDS_RESULT_NOTIFICATION_MESSAGE = "\n실행 결과"
+const val WINNER_NOTIFICATION_MESSAGE = "최종 우승자"

src/main/kotlin/racingcar/utils/Validator.kt

@@ -0,0 +1,32 @@
+package racingcar.utils
+
+class Validator {
+    fun checkCarNames(names: List<String>): List<String> {
+        checkDuplicatedCarNames(names)
+        return names
+    }
+
+    private fun checkDuplicatedCarNames(names: List<String>) {
+        if (names.toSet().size != names.size) {
+            throw IllegalArgumentException(DUPLICATED_CAR_NAME_ERROR_MESSAGE)
+        }
+    }
+
+    fun checkRoundCount(input: String): Int {
+        val roundCount = input.toIntOrNull()
+
+        requireNotNull(roundCount) { NOT_INTEGER_TYPE_ERROR_MESSAGE }
+
+        if (roundCount !in MIN_ROUND_COUNT..MAX_ROUND_COUNT) {
+            throw IllegalArgumentException(ROUND_COUNT_BOUNDARY_ERROR_MESSAGE)
+        }
+
+        return roundCount
+    }
+
+    fun checkCarNameLength(name: String) {
+        if (name.length !in MIN_CAR_NAME_LENGTH..MAX_CAR_NAME_LENGTH) {
+            throw IllegalArgumentException(CAR_NAME_BOUNDARY_ERROR_MESSAGE)
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+package racingcar.view
+
+import racingcar.utils.BlankRemover
+import racingcar.utils.CAR_NAME_DELIMITER
+import racingcar.utils.Validator
+
+class InputView(private val validator: Validator) {
+
+    fun readCarNames(): List<String> {
+        val names = readln().split(CAR_NAME_DELIMITER).toMutableList()
+        BlankRemover.removeBlank(names)
+
+        return validator.checkCarNames(names)
+    }
+
+    fun readRoundCount() = validator.checkRoundCount(readln())
+}

src/main/kotlin/racingcar/view/OutputView.kt

@@ -0,0 +1,19 @@
+package racingcar.view
+
+import racingcar.model.Car
+import racingcar.utils.WINNER_NOTIFICATION_MESSAGE
+
+class OutputView {
+    fun printMessage(message: String) = println(message)
+
+    fun printRoundResult(cars: List<Car>) {
+        cars.forEach { car ->
+            println("$car : ${car.getPositionAsDash()}")
+        }
+        println()
+    }
+
+    fun printWinners(winners: List<Car>) {
+        println("$WINNER_NOTIFICATION_MESSAGE: ${winners.joinToString(", ")}")
+    }
+}