[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,33 @@
+package wordle.controller
+
+import wordle.domain.Answer
+import wordle.domain.Game
+import wordle.domain.Words
+import wordle.view.printErrorMessage
+import wordle.view.printResults
+import wordle.view.printStartMessage
+import wordle.view.requestInput
+import java.time.LocalDate
+
+class WordleController {
+
+    fun run() {
+        val game = Game(Words.pick(LocalDate.now()))
+        printStartMessage(game.fixedCount)
+
+        while (game.isPlaying) {
+            val answer = requestAnswer()
+            game.playRound(answer)
+            printResults(game.results, game.isPlaying, game.findTryCount(), game.fixedCount)
+        }
+    }
+
+    private fun requestAnswer(): Answer {
+        return try {
+            Answer(requestInput())
+        } catch (e: IllegalArgumentException) {
+            printErrorMessage(e.message)
+            requestAnswer()
+        }
+    }
+}

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

@@ -0,0 +1,46 @@
+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)
+        (0 until WORD_SIZE).map { markExact(it, word, result, wordTable) }
+        (0 until WORD_SIZE).map { markExist(it, 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 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 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 fixedCount = 6
+    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 { it == 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,24 @@
+package wordle.domain
+
+import java.io.File
+import java.time.LocalDate
+import java.time.temporal.ChronoUnit
+
+const val WORD_SIZE = 5
+
+class Words {
+
+    companion object {
+        private val VALUE: List<String> = File("src/main/resources/words.txt").readLines()
+        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,44 @@
+package wordle.view
+
+import wordle.domain.Mark
+import wordle.domain.Results
+
+fun printStartMessage(fixedCount: Int) {
+    println("WORDLE 을 $fixedCount 번 만에 맞춰 보세요.\n시도의 결과는 타일의 색 변화로 나타납니다.")
+}
+
+fun requestInput(): String {
+    println("정답을 입력해 주세요.")
+    return readln()
+}
+
+fun printResults(results: Results, isPlaying: Boolean, tryCount: Int, fixedCount: Int) {
+    println()
+    if (!isPlaying) {
+        printTryCount(tryCount, fixedCount)
+    }
+    results.value.forEach {
+        printResult(it)
+    }
+    println()
+}
+
+fun printTryCount(tryCount: Int, fixedCount: Int) {
+    println("$tryCount/$fixedCount\n")
+}
+
+private fun printResult(result: List<Mark>) {
+    val stringBuilder = StringBuilder()
+    result.forEach {
+        when (it) {
+            Mark.NONE -> stringBuilder.append("⬜")
+            Mark.EXIST -> stringBuilder.append("🟨")
+            Mark.EXACT -> stringBuilder.append("🟩")
+        }
+    }
+    println(stringBuilder.toString())
+}
+
+fun printErrorMessage(message: String?) {
+    println(message)
+}

src/test/kotlin/practice/DslTest.kt

@@ -0,0 +1,51 @@
+package practice
+
+import org.assertj.core.api.AssertionsForInterfaceTypes.assertThat
+import org.junit.jupiter.api.Test
+
+class DslTest {
+
+    @Test
+    fun `자기소개 프러퍼티 버전`() {
+        val person = introduce {
+            name = "최수연"
+            age = 26
+        }
+        assertThat(person.name).isEqualTo("최수연")
+        assertThat(person.age).isEqualTo(26)
+    }
+
+    @Test
+    fun `자기소개 함수 버전`() {
+        val person = introduce {
+            name("최수연")
+            age(26)
+        }
+        assertThat(person.name).isEqualTo("최수연")
+        assertThat(person.age).isEqualTo(26)
+    }
+}
+
+private fun introduce(builder: PersonBuilder.() -> Unit): Person {
+// 람다에서 함수 형식을 지정가능
+    return PersonBuilder().apply(builder).build()
+}
+
+class PersonBuilder {
+    lateinit var name: String
+    var age: Int = 0
+
+    fun name(value: String) {
+        name = value
+    }
+
+    fun age(value: Int) {
+        age = value
+    }
+
+    fun build(): Person {
+        return Person(name, age)
+    }
+}
+
+data class Person(val name: String, val age: Int)

src/test/kotlin/study/DslTest.kt

@@ -0,0 +1,82 @@
+package study
+
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.groups.Tuple
+import org.junit.jupiter.api.Test
+
+class DslTest {
+    @Test
+    fun `페퍼 자기소개 프러퍼티 버전`() {
+        val profile = introduce {
+            name("최수연")
+            company("우아한테크코스")
+            skills {
+                soft("A passion for problem solving")
+                soft("Good communication skills")
+                hard("Kotlin")
+            }
+            languages {
+                "Korean" level 5
+                "English" level 3
+            }
+        }
+        assertThat(profile.name).isEqualTo("최수연")
+        assertThat(profile.company).isEqualTo("우아한테크코스")
+        assertThat(profile.skills.soft).contains("A passion for problem solving", "Good communication skills")
+        assertThat(profile.skills.hard).contains("Kotlin")
+        assertThat(profile.languages.languages).extracting("type", "level")
+            .contains(
+                Tuple.tuple("Korean", 5),
+                Tuple.tuple("English", 3)
+            )
+    }
+}
+
+fun introduce(builder: ProfileBuilder.() -> Unit): Profile {
+    return ProfileBuilder().apply(builder).build()
+}
+
+class ProfileBuilder {
+    private lateinit var name: String
+    private lateinit var company: String
+    private lateinit var skills: Skills
+    private lateinit var languages: Languages
+
+    fun name(value: String) {
+        name = value
+    }
+
+    fun company(value: String) {
+        company = value
+    }
+
+    fun skills(skillValue: Skills.() -> Unit) {
+        skills = Skills(mutableListOf(), mutableListOf()).apply(skillValue)
+    }
+
+    fun languages(languageSkill: Languages.() -> Unit) {
+        languages = Languages(mutableListOf()).apply(languageSkill)
+    }
+
+    fun build(): Profile {
+        return Profile(name, company, skills, languages)
+    }
+}
+
+data class Profile(val name: String, val company: String, val skills: Skills, val languages: Languages)
+
+data class Skills(val hard: MutableList<String>, val soft: MutableList<String>) {
+    fun hard(value: String) {
+        hard.add(value)
+    }
+
+    fun soft(value: String) {
+        soft.add(value)
+    }
+}
+
+data class Languages(val languages: MutableList<Language>) {
+    infix fun String.level(value: Int) = languages.add(Language(this, value))
+}
+
+data class Language(val type: String, val level: Int)