[Wordle] 조조그린(조한석) 미션 제출합니다.

README.md

@@ -1,5 +1,22 @@
 # 미션 - 워들
 
+## 📝 기능 목록
+
+### 코틀린 워들 기능목록 / 페퍼, 조조그린
+
+- [x] 시작메시지 출력하는 기능
+- [x] 답안을 입력받는 기능
+  - [x] 입력값은 5자리 문자열로 제한하는 기능
+  - [x] 입력값은 `words.txt` 에 존재하는 단어만 가능
+  - [x] 답안은 6번 만 입력 가능
+- [x] 오늘의 정답을 선택하는 기능
+    - [x] 정답은 `words.txt` 의 ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어
+- [x] 답안이 각 문자가 정답의 문자와 어떻게 매칭되는지 찾는 기능
+    - [x] 두 개의 동일한 문자를 입력하고 그중 하나가 회색으로 표시되면 해당 문자 중 하나만 최종 단어에 표시
+- [x] 확인된 정보에 맞게 출력하는 기능
+    - [x] 맞는 글자는 초록색, 위치가 틀리면 노란색, 없으면 회색으로 표시
+- [x] 게임 결과를 출력하는 기능
+
 ## 🔍 진행 방식
 
 - 미션은 **기능 요구 사항, 프로그래밍 요구 사항, 과제 진행 요구 사항** 세 가지로 구성되어 있다.

src/main/kotlin/Application.kt

@@ -0,0 +1,5 @@
+import wordle.controller.WordleController
+
+fun main() {
+    WordleController().run()
+}

src/main/kotlin/wordle/controller/WordleController.kt

@@ -0,0 +1,21 @@
+package wordle.controller
+
+import wordle.domain.Answer
+import wordle.domain.Game
+import wordle.domain.pickTodayWord
+import wordle.view.inputAnswer
+import wordle.view.printResults
+import wordle.view.printStartMessage
+import java.time.LocalDate
+
+class WordleController {
+
+    fun run() {
+        printStartMessage()
+        val game = Game(LocalDate.now().pickTodayWord())
+        while (game.isPlaying) {
+            game.playRound(Answer(inputAnswer()))
+            printResults(game)
+        }
+    }
+}

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

@@ -0,0 +1,60 @@
+package wordle.domain
+
+import wordle.domain.Mark.*
+
+class Answer(private val answer: String) {
+
+    init {
+        require(answer.length == WORD_SIZE) { "[ERROR] 부적절한 글자 길이입니다." }
+        require(answer.isInWords()) { "[ERROR] 목록에 존재하지 않는 단어입니다." }
+    }
+
+    fun compareToWord(word: String): List<Mark> {
+        val result = MutableList(WORD_SIZE) { NONE }
+        val wordTable = createWordTable(word)
+        matchExact(word, result, wordTable)
+        matchExist(result, wordTable)
+        return result
+    }
+
+    private fun createWordTable(word: String): HashMap<Char, Int> {
+        val wordTable = HashMap<Char, Int>()
+        for (char in word) {
+            wordTable[char] = wordTable.getOrDefault(char, 0) + 1
+        }
+        return wordTable
+    }
+
+    private fun matchExact(word: String, result: MutableList<Mark>, wordTable: HashMap<Char, Int>) {
+        for (i in 0 until WORD_SIZE) {
+            markExact(i, word, result, wordTable)
+        }
+    }
+
+    private fun markExact(i: Int, word: String, result: MutableList<Mark>, wordTable: HashMap<Char, Int>) {
+        if (word[i] == answer[i]) {
+            result[i] = EXACT
+            wordTable.computeIfPresent(word[i]) { _, v -> v - 1 }
+        }
+    }
+
+    private fun matchExist(result: MutableList<Mark>, wordTable: HashMap<Char, Int>) {
+        for (index in 0 until WORD_SIZE) {
+            markExist(index, result, wordTable)
+        }
+    }
+
+    private fun markExist(index: Int, result: MutableList<Mark>, wordTable: HashMap<Char, Int>) {
+        if (isExist(index, result, wordTable, answer[index])) {
+            result[index] = EXIST
+            wordTable.computeIfPresent(answer[index]) { _, v -> v - 1 }
+        }
+    }
+
+    private fun isExist(
+        index: Int,
+        result: MutableList<Mark>,
+        wordTable: HashMap<Char, Int>,
+        charOfAnswer: Char,
+    ) = result[index] == NONE && wordTable.containsKey(charOfAnswer) && wordTable[charOfAnswer] != 0
+}

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

@@ -0,0 +1,22 @@
+package wordle.domain
+
+class Game(private val word: String) {
+
+    val results: Results = Results()
+    var isPlaying: Boolean = true
+        private set
+
+    fun playRound(answer: Answer) {
+        val result = answer.compareToWord(word)
+        results.add(result)
+        if (isOver(result)) {
+            isPlaying = false
+        }
+    }
+
+    private fun isOver(result: List<Mark>) =
+        results.isLimit() || result.all { it == Mark.EXACT }
+
+    fun findTryCount() =
+        results.findTryCount()
+}

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

@@ -0,0 +1,8 @@
+package wordle.domain
+
+enum class Mark {
+
+    NONE,
+    EXIST,
+    EXACT
+}

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

@@ -0,0 +1,20 @@
+package wordle.domain
+
+private const val LIMIT_SIZE = 6
+
+class Results {
+
+    private val _results: MutableList<List<Mark>> = mutableListOf()
+    val results: List<List<Mark>>
+        get() = _results
+
+    fun add(result: List<Mark>) {
+        _results.add(result)
+    }
+
+    fun findTryCount() =
+        _results.size
+
+    fun isLimit() =
+        _results.size >= LIMIT_SIZE
+}

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

@@ -0,0 +1,16 @@
+package wordle.domain
+
+import java.io.FileReader
+import java.time.LocalDate
+import java.time.temporal.ChronoUnit
+
+const val WORD_SIZE = 5
+
+val BASIC_DATE = LocalDate.of(2021, 6, 19)!!
+val WORDS = FileReader("src/main/resources/words.txt").readLines()
+
+fun LocalDate.pickTodayWord() =
+    WORDS[(ChronoUnit.DAYS.between(BASIC_DATE, this) % WORDS.size).toInt()]
+
+fun String.isInWords() =
+    WORDS.contains(this)

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

@@ -0,0 +1,54 @@
+package wordle.view
+
+import wordle.domain.Mark.EXACT
+import wordle.domain.Mark.NONE
+import wordle.domain.Mark.EXIST
+import wordle.domain.Results
+import wordle.domain.Game
+import wordle.domain.Mark
+
+fun printStartMessage() {
+    println("WORDLE 을 6번 만에 맞춰 보세요.\n시도의 결과는 타일의 색 변화로 나타납니다.")
+}
+
+private fun printInputMessage() {
+    println("정답을 입력해 주세요.")
+}
+
+fun inputAnswer(): String {
+    printInputMessage()
+    return readln()
+}
+
+fun printResults(game: Game) {
+    if (!game.isPlaying) {
+        printTryCount(game.findTryCount())
+    }
+    printTiles(game.results)
+}
+
+fun printTryCount(tryCount: Int) {
+    println()
+    println("$tryCount/6")
+}
+
+fun printTiles(results: Results) {
+    println()
+    results.results.forEach {
+        printTile(it)
+    }
+    println()
+}
+
+private fun printTile(result: List<Mark>) {
+    StringBuilder().apply {
+        result.forEach {
+            when (it) {
+                NONE -> append("⬜")
+                EXIST -> append("\uD83D\uDFE8")
+                EXACT -> append("\uD83D\uDFE9")
+            }
+        }
+        println(toString())
+    }
+}

src/test/kotlin/study/DslTest.kt

@@ -0,0 +1,92 @@
+package study
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class DslTest {
+
+    @Test
+    fun introduce() {
+        val person = introduce {
+            name("조조그린")
+            company("우아한테크코스")
+            skills {
+                soft("A passion for problem solving")
+                soft("Good communication skills")
+                hard("Java")
+            }
+            languages {
+                "Korean" level 5
+                "English" level 3
+            }
+        }
+
+        assertThat(person.toString()).isEqualTo("Person(name=조조그린, company=우아한테크코스, skills=Skills(softSkills=[A passion for problem solving, Good communication skills], hardSkills=[Java]), languages=Languages(languages=[Korean level : 5, English level : 3]))")
+    }
+}
+
+fun introduce(builder: PersonBuilder.() -> Unit): Person {
+    return PersonBuilder().apply(builder).build()
+}
+
+class PersonBuilder {
+    private lateinit var name: String
+    private lateinit var company: String
+    private lateinit var skills: Skills
+    private lateinit var languages: Languages
+
+    fun name(input: String) {
+        name = input
+    }
+
+    fun company(input: String) {
+        company = input
+    }
+
+    fun skills(builder: SkillsBuilder.() -> Unit) {
+        skills = SkillsBuilder().apply(builder).build()
+    }
+
+    fun languages(builder: LanguagesBuilder.() -> Unit) {
+        languages = LanguagesBuilder().apply(builder).build()
+    }
+
+    fun build(): Person {
+        return Person(name, company, skills, languages)
+    }
+}
+
+class SkillsBuilder {
+    private val softSkills: MutableList<String> = mutableListOf()
+    private val hardSkills: MutableList<String> = mutableListOf()
+
+    fun soft(input: String) {
+        this.softSkills.add(input)
+    }
+
+    fun hard(input: String) {
+        this.hardSkills.add(input)
+    }
+
+    fun build(): Skills {
+        return Skills(softSkills, hardSkills)
+    }
+}
+
+class LanguagesBuilder {
+    private var languages: MutableList<String> = mutableListOf()
+
+    infix fun String.level(value: Int) {
+        languages.add(plus(" level : ") + value)
+    }
+
+    fun build(): Languages {
+        return Languages(languages)
+    }
+}
+
+data class Person(val name: String, val company: String, val skills: Skills, val languages: Languages)
+
+data class Skills(val softSkills: List<String>, val hardSkills: List<String>)
+
+data class Languages(val languages: List<String>)

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

@@ -0,0 +1,40 @@
+package wordle.domain
+
+import org.junit.jupiter.api.assertThrows
+import wordle.domain.Mark.EXACT
+import wordle.domain.Mark.NONE
+import wordle.domain.Mark.EXIST
+import io.kotest.matchers.throwable.shouldHaveMessage
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+internal class AnswerTest {
+
+    @Test
+    fun 글자길이가_5가_아닌_경우_예외발생() {
+        assertThrows<IllegalArgumentException> { Answer("abcdef") }
+            .shouldHaveMessage("[ERROR] 부적절한 글자 길이입니다.")
+    }
+
+    @Test
+    fun 주어진_단어목록에_존재하지_않는_경우_예외발생() {
+        assertThrows<IllegalArgumentException> { Answer("abcde") }
+            .shouldHaveMessage("[ERROR] 목록에 존재하지 않는 단어입니다.")
+    }
+
+    @Test
+    fun 답안과_정답을_비교_CASE_중복되는_문자_중_하나만_일치_할_때() {
+        val answer = Answer("groom")
+
+        assertThat(answer.compareToWord("goose"))
+            .isEqualTo(listOf(EXACT, NONE, EXACT, EXIST, NONE))
+    }
+
+    @Test
+    fun 답안과_정답을_비교_CASE_중복되는_문자가_존재하지만_정답의_개수가_더_많을_때() {
+        val answer = Answer("eerie")
+
+        assertThat(answer.compareToWord("sheen"))
+            .isEqualTo(listOf(EXIST, EXIST, NONE, NONE, NONE))
+    }
+}