[Wordle] 파랑(이하은) 미션 제출합니다.

README.md

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

src/main/kotlin/wordle/Application.kt

@@ -0,0 +1,25 @@
+package wordle
+
+import wordle.domain.Game
+import wordle.domain.Word
+import wordle.util.WordsReader
+import wordle.view.InputView
+import wordle.view.OutputView
+
+fun main() {
+    val game = Game(WordsReader.getWords())
+    OutputView.printStartMessage()
+    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,22 @@
+package wordle.domain
+
+class Game(private val words: Words) {
+
+    constructor(words: List<Word>) : this(Words(words))
+
+    var count: Int = 0
+        private set
+
+    var results: MutableList<List<Tile>> = ArrayList()
+        private set
+
+    fun isGameOver(answer: Word): Boolean {
+        return count == 6 || words.isCorrect(answer)
+    }
+
+    fun match(answer: Word) {
+        count++
+        require(words.contains(answer)) { "등록된 단어가 아닙니다." }
+        results.add(words.check(answer))
+    }
+}

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

@@ -0,0 +1,6 @@
+package wordle.domain
+
+enum class Tile(val symbol: String) {
+
+    YELLOW("🟨"), GREEN("🟩"), GRAY("⬜")
+}

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

@@ -0,0 +1,13 @@
+package wordle.domain
+
+data class Word(val value: String) {
+
+    init {
+        require(value.length == 5) { "단어의 길이는 5글자여야 합니다." }
+        require(Regex("[a-zA-Z]*").matches(value)) { "단어에 영어가 아닌 글자나 공백이 포함될 수 없습니다." }
+    }
+
+    fun isSameChar(other: Word, index: Int): Boolean {
+        return this.value[index] == other.value[index]
+    }
+}

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

@@ -0,0 +1,70 @@
+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 date: LocalDate = LocalDate.now()
+        val standardDate: LocalDate = LocalDate.of(2021, 6, 19)
+        val days: Int = ChronoUnit.DAYS.between(standardDate, date).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: ArrayList<Tile> = ArrayList()
+        repeat(5) { result.add(Tile.GRAY) }
+
+        repeat(5) { i -> result[i] = findTileBySameCheck(word, i) }
+        repeat(5) { i -> result[i] = findTileByContainCheck(result, word, i) }
+        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)
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+package wordle.util
+
+import wordle.domain.Word
+import java.io.FileReader
+
+object WordsReader {
+
+    fun getWords(): List<Word> {
+        val path = "src/main/resources/words.txt"
+        val reader = FileReader(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,29 @@
+package wordle.view
+
+import wordle.domain.Tile
+
+object OutputView {
+
+    fun printStartMessage() {
+        println(
+            "WORDLE을 6번 만에 맞춰 보세요.\n" +
+                "시도의 결과는 타일의 색 변화로 나타납니다."
+        )
+    }
+
+    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/wordle/domain/GameTest.kt

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

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

@@ -0,0 +1,35 @@
+package wordle.domain
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.inspectors.forAll
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class WordTest {
+
+    @Test
+    fun `5글자가 아닌 word를 생성하면 예외가 발생한다`() {
+        val exception = shouldThrow<IllegalArgumentException> {
+            Word("test")
+        }
+        exception.message shouldBe "단어의 길이는 5글자여야 합니다."
+    }
+
+    @Test
+    fun `영어가 아닌 글자가 포함된 word를 생성하면 예외가 발생한다`() {
+        listOf("ap pl", "ap피le").forAll {
+            val exception = shouldThrow<IllegalArgumentException> {
+                Word(it)
+            }
+            exception.message shouldBe "단어에 영어가 아닌 글자나 공백이 포함될 수 없습니다."
+        }
+    }
+
+    @Test
+    fun `해당 글자가 단어의 특정 인덱스와 일치하는지 확인한다`() {
+        val word = Word("style")
+        val other = Word("soooo")
+        word.isSameChar(other, 0) shouldBe true
+        word.isSameChar(other, 1) shouldBe false
+    }
+}

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

@@ -0,0 +1,36 @@
+package wordle.domain
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class WordsTest {
+
+    @Test
+    fun `단어가 리스트 안에 존재하는지 확인해준다`() {
+        val apple = Word("apple")
+        val happy = Word("happy")
+        val doggy = Word("doggy")
+        val words = Words(listOf(apple, happy))
+
+        words.contains(apple) shouldBe true
+        words.contains(doggy) shouldBe false
+    }
+
+    @Test
+    fun `단어가 정답인지 확인해준다`() {
+        val words = Words(listOf(Word("apple")))
+
+        words.isCorrect(Word("apple")) shouldBe true
+        words.isCorrect(Word("happy")) shouldBe false
+    }
+
+    @Test
+    fun `단어를 정답과 비교하여 결과 타일을 반환한다`() {
+        val words = Words(listOf(Word("apple")))
+        val word = Word("hello")
+
+        val checkList = words.check(word)
+
+        checkList shouldBe listOf(Tile.GRAY, Tile.YELLOW, Tile.GRAY, Tile.GREEN, Tile.GRAY)
+    }
+}

src/test/kotlin/wordle/util/WordsReaderTest.kt

@@ -0,0 +1,13 @@
+package wordle.util
+
+import io.kotest.matchers.shouldBe
+import org.junit.jupiter.api.Test
+
+class WordsReaderTest {
+
+    @Test
+    fun `파일을 읽어서 List를 반환해준다`() {
+        val words = WordsReader.getWords()
+        words.size shouldBe 2309
+    }
+}