[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,26 @@
+package wordle
+
+import wordle.domain.Game
+import wordle.domain.TOTAL_ROUNDS_NUM
+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(TOTAL_ROUNDS_NUM)
+    doGame(game)
+    OutputView.printCount(game.count)
+    OutputView.printResults(game.results)
+}
+
+private fun doGame(game: Game) {
+    val answer = Word(InputView.inputAnswer())
+    game.match(answer)
+    if (game.isGameOver(answer)) {
+        return
+    }
+    OutputView.printResults(game.results)
+    doGame(game)
+}

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

@@ -0,0 +1,24 @@
+package wordle.domain
+
+const val TOTAL_ROUNDS_NUM = 6
+
+class Game(private val words: Words) {
+
+    var count: Int = 0
+        private set
+
+    var results: MutableList<List<Tile>> = ArrayList()
+        private set
+
+    constructor(words: List<Word>) : this(Words(words))
+
+    fun isGameOver(answer: Word): Boolean {
+        return count >= TOTAL_ROUNDS_NUM || 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,8 @@
+package wordle.domain
+
+enum class Tile(val symbol: String) {
+
+    YELLOW("🟨"),
+    GREEN("🟩"),
+    GRAY("⬜")
+}

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

@@ -0,0 +1,32 @@
+package wordle.domain
+
+private const val WORD_SIZE = 5
+
+class Word(_value: String) {
+
+    val value: String = _value.lowercase()
+
+    init {
+        require(value.length == WORD_SIZE) { "단어의 길이는 5글자여야 합니다." }
+        require(Regex("[a-zA-Z]*").matches(value)) { "단어에 영어가 아닌 글자나 공백이 포함될 수 없습니다." }
+    }
+
+    fun isSameChar(other: Word, index: Int): Boolean {
+        return this.value[index] == other.value[index]
+    }
+
+    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
+import java.time.temporal.ChronoUnit
+
+class Words(private val values: List<Word>) {
+
+    private val answer: Word = findAnswer()
+    private var answerMap: MutableMap<Char, Int> = HashMap()
+
+    private fun findAnswer(): Word {
+        val nowDate: LocalDate = LocalDate.now()
+        val days: Int = ChronoUnit.DAYS.between(STANDARD_DATE, nowDate).toInt()
+        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()
+        val result: MutableList<Tile> = ArrayList()
+        repeat(5) { result.add(Tile.GRAY) }
+
+        repeat(5) { result[it] = findTileBySameCheck(word, it) }
+        repeat(5) { result[it] = findTileByContainCheck(result, word, it) }
+        return result
+    }
+
+    private fun initAnswerMap(): MutableMap<Char, Int> {
+        val answerMap: MutableMap<Char, Int> = HashMap()
+        answer.value.forEach {
+            answerMap.putIfAbsent(it, 0)
+            answerMap.computeIfPresent(it) { _, v -> v + 1 }
+        }
+        return answerMap
+    }
+
+    private fun findTileBySameCheck(word: Word, index: Int): Tile {
+        if (answer.isSameChar(word, index)) {
+            calculateAnswerMap(word.value[index])
+            return Tile.GREEN
+        }
+        return Tile.GRAY
+    }
+
+    private fun findTileByContainCheck(result: List<Tile>, word: Word, index: Int): Tile {
+        if (result[index] == Tile.GREEN) {
+            return Tile.GREEN
+        }
+        if (answerMap.keys.contains(word.value[index])) {
+            calculateAnswerMap(word.value[index])
+            return Tile.YELLOW
+        }
+        return Tile.GRAY
+    }
+
+    private fun calculateAnswerMap(key: Char) {
+        answerMap.computeIfPresent(key) { _, v -> v - 1 }
+        if (answerMap[key] == 0) {
+            answerMap.remove(key)
+        }
+    }
+
+    companion object {
+        private val STANDARD_DATE = LocalDate.of(2021, 6, 19)
+    }
+}

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,27 @@
+package wordle.view
+
+import wordle.domain.Tile
+
+object OutputView {
+
+    fun printStartMessage(round: Int) {
+        println("WORDLE을 {$round}번 만에 맞춰 보세요.")
+        println("시도의 결과는 타일의 색 변화로 나타납니다.")
+    }
+
+    fun printResults(results: List<List<Tile>>) {
+        println()
+        results.forEach { printResult(it) }
+        println()
+    }
+
+    private fun printResult(result: List<Tile>) {
+        result.forEach { print(it.symbol) }
+        println()
+    }
+
+    fun printCount(count: Int) {
+        println()
+        println("$count/6")
+    }
+}

src/test/kotlin/study/DslTest.kt

@@ -0,0 +1,109 @@
+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)
+
+
+

src/test/kotlin/wordle/domain/GameTest.kt

@@ -0,0 +1,25 @@
+package wordle.domain
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.throwable.shouldHaveMessage
+import org.junit.jupiter.api.Test
+
+class GameTest {
+
+    @Test
+    fun `등록된 단어가 아닌 경우 예외가 발생한다`() {
+        val game = Game(listOf(Word("apple"), Word("hello"), Word("spicy")))
+
+        shouldThrow<IllegalArgumentException> {
+            game.match(Word("spell"))
+        }.shouldHaveMessage("등록된 단어가 아닙니다.")
+    }
+
+    @Test
+    internal fun `게임 종료여부를 확인한다`() {
+        val game = Game(listOf(Word("apple"), Word("hello"), Word("spicy")))
+        repeat(6) { game.match(Word("apple")) }
+        game.isGameOver(Word("apple")) shouldBe true
+    }
+}