[Wordle] 로마(김범수) 미션 제출합니다.

README.md

@@ -10,6 +10,19 @@
 
 ## 🚀 기능 요구 사항
 
+- [x] 시작 문구를 띄워준다.
+- [x] 답안을 입력받는다.
+  - [x] 답안은 5글자여야 한다.
+  - 답안은 `words.txt` 안에 존재하는 단어여야 한다.
+- [x] 정답과 답안을 비교하여 결과를 타일로 표현한다.
+  - 맞는 글자는 초록색으로 표현한다.
+  - 위치가 틀리면 노란색으로 표현한다.
+  - 정답에 존재하지 않는 글자면 회색으로 표현한다.
+  - 두 개의 동일한 문자를 입력하고 그중 하나가 회색으로 표시되면 해당 문자 중 하나만 최종 단어에 나타난다.
+- [x] 정답은 매일 바뀐다.
+  - [x] `words.txt` 안의 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어이다.
+- [x] 정답을 맞췄을 경우 타일 표현 전에 몇 번째 만에 맞췄는지 출력한다.
+
 선풍적인 인기를 끌었던 영어 단어 맞추기 게임이다.
 
 - 6x5 격자를 통해서 5글자 단어를 6번 만에 추측한다.

src/main/kotlin/wordle/Application.kt

@@ -0,0 +1,32 @@
+package wordle
+
+import wordle.domain.Game
+import wordle.domain.Word
+import wordle.utils.WordsReader
+import wordle.view.InputView
+import wordle.view.OutputView
+
+fun main() {
+    val game = Game(WordsReader.getWords())
+    OutputView.printStartMessage(game)
+    doGame(game)
+}
+
+private fun doGame(game: Game) {
+    try {
+        submitAnswer(game)
+    } catch (exception: IllegalArgumentException) {
+        OutputView.printErrorMessage(exception)
+        doGame(game)
+    }
+}
+
+private fun submitAnswer(game: Game) {
+    var isOver = false
+    while (!isOver) {
+        val answer = Word(InputView.inputAnswer())
+        game.match(answer)
+        isOver = game.isGameOver(answer)
+        OutputView.printResults(game, isOver)
+    }
+}

src/main/kotlin/wordle/domain/Game.kt

@@ -0,0 +1,30 @@
+package wordle.domain
+
+private const val TOTAL_ROUNDS_NUM = 6
+
+class Game(
+    private val words: Words,
+    val totalCount: Int = TOTAL_ROUNDS_NUM
+) {
+
+    var count: Int = 0
+        private set
+
+    var results: MutableList<List<Tile>> = ArrayList()
+        private set
+
+    constructor(
+        words: List<Word>,
+        totalCount: Int = TOTAL_ROUNDS_NUM
+    ) : this(Words(words), totalCount)
+
+    fun isGameOver(answer: Word): Boolean {
+        return count >= totalCount || words.isCorrect(answer)
+    }
+
+    fun match(answer: Word) {
+        require(words.contains(answer)) { "등록된 단어가 아닙니다." }
+        results.add(words.check(answer))
+        count++
+    }
+}

src/main/kotlin/wordle/domain/Tile.kt

@@ -0,0 +1,6 @@
+package wordle.domain
+
+enum class Tile() {
+
+    YELLOW, GREEN, GRAY
+}

src/main/kotlin/wordle/domain/Word.kt

@@ -0,0 +1,41 @@
+package wordle.domain
+
+private const val WORD_SIZE = 5
+private val ALPHABET_REGEX = Regex("[a-zA-Z]*")
+
+class Word(_value: String) {
+
+    val value: String = _value.lowercase()
+
+    init {
+        require(value.isRightSize()) { "단어의 길이는 5글자여야 합니다." }
+        require(value.isAlphabet()) { "단어에 영어가 아닌 글자나 공백이 포함될 수 없습니다." }
+    }
+
+    fun isSameChar(other: Word, index: Int): Boolean {
+        return this.value[index] == other.value[index]
+    }
+
+    private fun String.isRightSize(): Boolean {
+        return this.length == WORD_SIZE
+    }
+
+    private fun String.isAlphabet(): Boolean {
+        return ALPHABET_REGEX.matches(this)
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as Word
+
+        if (value != other.value) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        return value.hashCode()
+    }
+}

src/main/kotlin/wordle/domain/Words.kt

@@ -0,0 +1,73 @@
+package wordle.domain
+
+import java.time.LocalDate
+
+class Words(private val values: List<Word>) {
+
+    private val answer: Word = findAnswer()
+    private var answerMap: MutableMap<Char, Int> = mutableMapOf()
+
+    private fun findAnswer(): Word {
+        val days = TODAY.compareTo(STANDARD_DATE)
+        return values[days % values.size]
+    }
+
+    fun contains(word: Word): Boolean {
+        return values.contains(word)
+    }
+
+    fun isCorrect(word: Word): Boolean {
+        return word == answer
+    }
+
+    fun check(word: Word): List<Tile> {
+        answerMap = initAnswerMap()
+        return DEFAULT_TILES.markGreen(word).markYellow(word)
+    }
+
+    private fun initAnswerMap(): MutableMap<Char, Int> {
+        return answer.value
+            .groupBy { it }
+            .mapValues { it.value.count() }
+            .toMutableMap()
+    }
+
+    private fun List<Tile>.markGreen(word: Word): List<Tile> {
+        return List(size) { index -> grayOrGreen(word, index) }
+    }
+
+    private fun grayOrGreen(word: Word, index: Int): Tile {
+        return if (answer.isSameChar(word, index)) {
+            calculateAnswerMap(word.value[index])
+            Tile.GREEN
+        } else {
+            Tile.GRAY
+        }
+    }
+
+    private fun List<Tile>.markYellow(word: Word): List<Tile> {
+        return mapIndexed { index, tile -> existOrYellow(tile, word, index) }
+    }
+
+    private fun existOrYellow(tile: Tile, word: Word, index: Int): Tile {
+        return if (tile != Tile.GREEN && answerMap.containsKey(word.value[index])) {
+            calculateAnswerMap(word.value[index])
+            Tile.YELLOW
+        } else {
+            tile
+        }
+    }
+
+    private fun calculateAnswerMap(key: Char) {
+        answerMap.computeIfPresent(key) { _, v -> v - 1 }
+        if (answerMap[key] == 0) {
+            answerMap.remove(key)
+        }
+    }
+
+    companion object {
+        private val TODAY = LocalDate.now()
+        private val STANDARD_DATE = LocalDate.of(2021, 6, 19)
+        private val DEFAULT_TILES = List(5) { Tile.GRAY }
+    }
+}

src/main/kotlin/wordle/utils/WordsReader.kt

@@ -0,0 +1,14 @@
+package wordle.utils
+
+import wordle.domain.Word
+import java.io.FileReader
+
+private const val WORDS_PATH = "src/main/resources/words.txt"
+
+object WordsReader {
+
+    fun getWords(): List<Word> {
+        val reader = FileReader(WORDS_PATH)
+        return reader.readLines().map { Word(it) }
+    }
+}

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

@@ -0,0 +1,9 @@
+package wordle.view
+
+object InputView {
+
+    fun inputAnswer(): String {
+        println("정답을 입력해 주세요.")
+        return readln()
+    }
+}

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

@@ -0,0 +1,47 @@
+package wordle.view
+
+import wordle.domain.Game
+import wordle.domain.Tile
+
+object OutputView {
+
+    fun printStartMessage(game: Game) = println(
+        """
+            |WORDLE을 ${game.totalCount}번 만에 맞춰 보세요.
+            |시도의 결과는 타일의 색 변화로 나타납니다.
+        """.trimMargin()
+    )
+
+    fun printResults(game: Game, isGameOver: Boolean) {
+        if (isGameOver) {
+            printCount(game.count, game.totalCount)
+        }
+        println()
+        game.results.forEach { printResult(it) }
+        println()
+    }
+
+    private fun printResult(result: List<Tile>) {
+        result.forEach { printTile(it) }
+        println()
+    }
+
+    private fun printCount(count: Int, totalRound: Int) = println(
+        """
+            |
+            |$count/$totalRound
+        """.trimMargin()
+    )
+
+    fun printErrorMessage(exception: RuntimeException) {
+        println(exception.message)
+    }
+
+    private fun printTile(tile: Tile) {
+        when (tile) {
+            Tile.GREEN -> print("🟩")
+            Tile.YELLOW -> print("🟨")
+            Tile.GRAY -> print("⬜")
+        }
+    }
+}

src/test/kotlin/study/DslTest.kt

@@ -0,0 +1,106 @@
+package study
+
+import io.kotest.assertions.assertSoftly
+import io.kotest.matchers.collections.shouldContainExactly
+import io.kotest.matchers.collections.shouldHaveSize
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+/*
+introduce {
+  name("박재성")
+  company("우아한형제들")
+  skills {
+    soft ("A passion for problem solving")
+    soft ("Good communication skills")
+    hard ("Kotlin")
+  }
+  languages {
+    "Korean" level 5
+    "English" level 3
+  }
+}
+ */
+class DslTest {
+
+    @Test
+    fun `자기소개 함수 버전`() {
+        val person = introduce {
+            name("김범수")
+            company("우아한형제들")
+            skills {
+                soft("코틀린")
+                soft("자바")
+                hard("운동")
+            }
+            languages {
+                "Korean" level 100
+                "English" level 10
+                "Japanese" level 0
+            }
+        }
+
+        assertSoftly(person) {
+            it.name shouldBe "김범수"
+            it.company shouldBe "우아한형제들"
+            it.skills.soft shouldHaveSize 2
+            it.skills.hard shouldHaveSize 1
+            it.languages.values shouldHaveSize 3
+            it.languages.values shouldContainExactly listOf(
+                Language("Korean", 100),
+                Language("English", 10),
+                Language("Japanese", 0)
+            )
+        }
+    }
+}
+
+fun introduce(builder: PersonBuilder.() -> Unit): Person {
+    return PersonBuilder().apply(builder).build()
+}
+
+class PersonBuilder {
+    lateinit var name: String
+    lateinit var company: String
+    lateinit var skills: Skills
+    lateinit var languages: Languages
+
+    fun name(value: String) {
+        name = value
+    }
+
+    fun company(value: String) {
+        company = value
+    }
+
+    fun skills(builder: Skills.() -> Unit) {
+        skills = Skills(mutableListOf(), mutableListOf()).apply(builder)
+    }
+
+    fun languages(builder: Languages.() -> Unit) {
+        languages = Languages(mutableListOf()).apply(builder)
+    }
+
+    fun build(): Person = Person(name, company, skills, languages)
+}
+
+data class Person(val name: String, val company: String, val skills: Skills, val languages: Languages)
+
+class Skills(val soft: MutableList<String>, val hard: MutableList<String>) {
+    fun soft(value: String) {
+        soft.add(value)
+    }
+
+    fun hard(value: String) {
+        hard.add(value)
+    }
+}
+
+class Languages(val values: MutableList<Language>) {
+
+    infix fun String.level(level: Int) {
+        values.add(Language(this, level))
+    }
+}
+
+data class Language(val value: String, val level: Int)