[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,22 @@
+package wordle.controller
+
+import wordle.domain.Answer
+import wordle.domain.Game
+import wordle.domain.Words
+import wordle.view.printInputMessage
+import wordle.view.printResults
+import wordle.view.printStartMessage
+import java.time.LocalDate
+
+class WordleController {
+
+    fun run() {
+        printStartMessage()
+        val game = Game(Words.pick(LocalDate.now()))
+        while (game.isPlaying) {
+            val answer = Answer(printInputMessage())
+            game.playRound(answer)
+            printResults(game.results, game.isPlaying, game.findTryCount())
+        }
+    }
+}

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

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

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

@@ -0,0 +1,23 @@
+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: MutableList<Mark>) =
+        results.isLimit() || result.all { mark -> mark == Mark.EXACT }
+
+    fun findTryCount(): Int {
+        return results.value.size
+    }
+}

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,16 @@
+package wordle.domain
+
+private const val LIMIT_SIZE = 6
+
+class Results {
+
+    val value: MutableList<List<Mark>> = mutableListOf()
+
+    fun add(result: List<Mark>) {
+        value.add(result)
+    }
+
+    fun isLimit(): Boolean {
+        return value.size >= LIMIT_SIZE
+    }
+}

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

@@ -0,0 +1,25 @@
+package wordle.domain
+
+import java.nio.file.Files
+import java.nio.file.Paths
+import java.time.LocalDate
+import java.time.temporal.ChronoUnit
+
+const val WORD_SIZE = 5
+
+class Words {
+
+    companion object {
+        private val VALUE: List<String> = Files.readAllLines(Paths.get("src/main/resources/words.txt"))
+        private val BASIC_DATE = LocalDate.of(2021, 6, 19)
+
+        fun contains(word: String): Boolean {
+            return VALUE.contains(word)
+        }
+
+        fun pick(date: LocalDate): String {
+            val index = ChronoUnit.DAYS.between(BASIC_DATE, date) % VALUE.size
+            return VALUE[index.toInt()]
+        }
+    }
+}

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

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

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

@@ -0,0 +1,38 @@
+package wordle.domain
+
+import io.kotest.matchers.throwable.shouldHaveMessage
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import wordle.domain.Mark.*
+
+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))
+    }
+}

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

@@ -0,0 +1,49 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertAll
+
+internal class GameTest {
+
+    @Test
+    fun 게임을_한_라운드씩_진행() {
+        val game = Game("fetus")
+        repeat(3) { game.playRound(Answer("apple")) }
+
+        assertAll(
+            {assertThat(game.findTryCount()).isEqualTo(3)},
+            {assertThat(game.isPlaying).isTrue()}
+        )
+    }
+
+    @Test
+    fun 게임을_한_라운드씩_진행하다_6라운드에_도달하면_게임종료() {
+        val game = Game("fetus")
+        repeat(6) { game.playRound(Answer("apple")) }
+
+        assertAll(
+            {assertThat(game.findTryCount()).isEqualTo(6)},
+            {assertThat(game.isPlaying).isFalse()}
+        )
+    }
+
+    @Test
+    fun 게임을_한_라운드씩_진행하다_정답을_맞추면_게임종료() {
+        val game = Game("fetus")
+        repeat(3) { game.playRound(Answer("fetus")) }
+
+        assertAll(
+            {assertThat(game.findTryCount()).isEqualTo(3)},
+            {assertThat(game.isPlaying).isFalse()}
+        )
+    }
+
+    @Test
+    fun 몇_번째_시도인지_계산() {
+        val game = Game("fetus")
+        repeat(6) { game.playRound(Answer("apple")) }
+
+        assertThat(game.findTryCount()).isEqualTo(6)
+    }
+}

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

@@ -0,0 +1,15 @@
+package wordle.domain
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import java.time.LocalDate
+
+internal class WordsTest {
+
+    @Test
+    fun 오늘의_단어를_선택() {
+        val date = LocalDate.of(2022, 5, 12)
+
+        assertThat(Words.pick(date)).isEqualTo("fetus")
+    }
+}