[4기][3주차] Wordle 과제 제출 - 분수

README.md

@@ -1,4 +1,41 @@
 # 미션 - 워들
+## 기능 요구 사항
+* Letter
+  * [x] Letter 를 생성한다.
+  * [x] 알파벳만 입력 가능하다.
+  * [x] 알파벳이 아니면 에러를 발생한다.
+* Words Generator
+  * [X] `words.txt`에서 Words 를 읽어온다. 
+* Word
+  * [x] Word 를 생성한다.
+    * [x] 5글자의 알파벳만 받는다.
+    * [x] 5글자가 아니면 에러를 발생한다.
+    * [x] 알파벳이 아니면 에러를 발생한다.
+* Words
+  * [x] Words 를 생성한다.
+    * [x] 주어진 Words 가 비어있으면 에러를 발생한다.
+    * [x] 주어진 Words 에 Word 가 없다면 에러를 발생한다.
+  * [x] 정답을 가져온다.
+    * [x] ((현재 날짜 - 2021년 6월 19일) % 배열의 크기) 번째의 단어를 가져온다.
+* 정답
+  * [x] 입력된 답안을 존재하는 Word 인지 비교한다.
+* 답안
+  * [ ] 사용자가 워드를 입력한다.
+    * [ ] 글자는 5글자까지 입력 가능하다.
+    * [ ] 사용자가 정답을 6번까지 입력할 수 있다.
+    * [ ] 입력된 답안은 `words.txt`에 존재하는 단어여야 한다.
+* 출력
+  * [ ] 타일로 결과를 표시한다.
+    * [ ] 위치와 글자가 맞으면 초록색
+    * [ ] 위치가 틀리고, 글자가 맞으면 노란색
+    * [ ] 위치와 글자가 틀리면 회색
+    * [ ] 두 개의 동일한 문자를 입력하고 그중 하나가 회색으로 표시되면 해당 문자 중 하나만 최종 단어에 나타난다.
+
+## 유비쿼터스 언어
+* Word
+  * 5글자의 영문
+* Words
+  * `words.txt`의 리스트
 
 ## 🔍 진행 방식
 

src/main/java/Application.java

@@ -0,0 +1,9 @@
+import controller.GameController;
+import service.GameService;
+
+public class Application {
+    public static void main(String[] args) {
+        GameController gameController = new GameController(new GameService());
+        gameController.start();
+    }
+}

src/main/java/config/FileConfig.java

@@ -0,0 +1,6 @@
+package config;
+
+public class FileConfig {
+
+    public final static String FILE_PATH = "src/main/resources/words.txt";
+}

src/main/java/controller/GameController.java

@@ -0,0 +1,22 @@
+package controller;
+
+import domain.Answer;
+import dto.GameHistory;
+import service.GameService;
+
+import java.util.List;
+
+public class GameController {
+
+    private final GameService gameService;
+
+    public GameController(GameService gameService) {
+        this.gameService = gameService;
+    }
+
+    public void start() {
+        Answer answer = gameService.init();
+        List<GameHistory> gameHistories = gameService.startGame(answer);
+        gameService.endGame(gameHistories);
+    }
+}

src/main/java/domain/Answer.java

@@ -0,0 +1,81 @@
+package domain;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Answer {
+
+    private final Word answer;
+
+    private boolean isSuccess = false;
+
+    public Answer(Word answer) {
+        this.answer = answer;
+    }
+
+    public List<Tile> compare(Word answer) {
+        Map<Letter, Long> letterMap = getLetterMap();
+
+        List<Tile> result = new ArrayList<>();
+
+        for (int i = 0; i < Word.WORD_LENGTH; i++) {
+            Long count = letterMap.get(answer.getWord().get(i));
+
+            Tile tile = getTile(count, this.answer.getWord().get(i), answer.getWord().get(i));
+            result.add(tile);
+
+            letterMap.put(answer.getWord().get(i), letterMap.getOrDefault(answer.getWord().get(i), 0L) - 1);
+        }
+        endGame(result);
+
+        return result;
+    }
+
+    private Map<Letter, Long> getLetterMap() {
+        return this.answer.getWord()
+                .stream()
+                .collect(Collectors.groupingBy(c -> c, Collectors.counting()));
+    }
+
+    private void endGame(List<Tile> result) {
+        int count = Collections.frequency(result, Tile.GREEN);
+
+        if (count == Word.WORD_LENGTH) {
+            this.isSuccess = true;
+        }
+    }
+
+    private Tile getTile(Long count, Letter answerLetter, Letter letter) {
+        if (count == null || count <= 0) {
+            return Tile.GRAY;
+        }
+        if (answerLetter.equals(letter)) {
+            return Tile.GREEN;
+        }
+        return Tile.YELLOW;
+    }
+
+    public boolean isSuccess() {
+        return isSuccess;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Answer that = (Answer) o;
+        return Objects.equals(answer, that.answer);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(answer);
+    }
+
+    @Override
+    public String toString() {
+        return "Answer{" +
+                "answer=" + answer +
+                '}';
+    }
+}

src/main/java/domain/Letter.java

@@ -0,0 +1,43 @@
+package domain;
+
+import java.util.Objects;
+
+public class Letter {
+    private final String letter;
+
+    public Letter(Character letter) {
+        if (this.isNotAlphabet(letter)) {
+            throw new IllegalArgumentException(letter + "는 알파벳이 아닙니다.");
+        }
+
+        this.letter = String.valueOf(letter);
+    }
+
+    private boolean isNotAlphabet(Character letter) {
+        return !(letter >= 'A' && letter <= 'Z') && !(letter >= 'a' && letter <= 'z');
+    }
+
+    public String getLetter() {
+        return letter;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Letter letter1 = (Letter) o;
+        return Objects.equals(letter, letter1.letter);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(letter);
+    }
+
+    @Override
+    public String toString() {
+        return "Letter{" +
+                "letter='" + letter + '\'' +
+                '}';
+    }
+}

src/main/java/domain/Tile.java

@@ -0,0 +1,15 @@
+package domain;
+
+public enum Tile {
+    GREEN("\uD83D\uDFE9"), YELLOW("\uD83D\uDFE8"), GRAY("⬜");
+
+    private final String tile;
+
+    Tile(String tile) {
+        this.tile = tile;
+    }
+
+    public String getTile() {
+        return tile;
+    }
+}

src/main/java/domain/Word.java

@@ -0,0 +1,49 @@
+package domain;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class Word {
+    public static final int WORD_LENGTH = 5;
+
+    private final List<Letter> word;
+
+    public Word(String word) {
+        if (this.isNotMatchWord(word)) {
+            throw new IllegalArgumentException(word + "는 5글자의 알파벳이 아닙니다.");
+        }
+
+        this.word = word.chars().mapToObj(c -> (char) c)
+                        .map(Letter::new)
+                        .collect(Collectors.toList());
+    }
+
+    private boolean isNotMatchWord(String word){
+        return word.length() != WORD_LENGTH;
+    }
+
+    public List<Letter> getWord() {
+        return word;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Word word1 = (Word) o;
+        return Objects.equals(word, word1.word);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(word);
+    }
+
+    @Override
+    public String toString() {
+        return "Word{" +
+                "word=" + word +
+                '}';
+    }
+}

src/main/java/domain/Words.java

@@ -0,0 +1,34 @@
+package domain;
+
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Words {
+    public static final LocalDate DEFAULT_DATE = LocalDate.of(2021, 6, 19);
+    private final List<Word> words;
+
+    public Words(List<String> words) {
+        this.words = convert(words);
+    }
+
+    private List<Word> convert(List<String> words) {
+        if (words.size() == 0) {
+            throw new IllegalArgumentException("파일이 비어 있습니다.");
+        }
+
+        return words.stream().map(Word::new).collect(Collectors.toList());
+    }
+
+    public Answer getAnswer(LocalDate now) {
+        long betweenDay = ChronoUnit.DAYS.between(DEFAULT_DATE, now);
+
+        Word answer = this.words.get((int) (betweenDay % words.size()));
+        return new Answer(answer);
+    }
+
+    public List<Word> getWords() {
+        return words;
+    }
+}

src/main/java/dto/GameHistory.java

@@ -0,0 +1,20 @@
+package dto;
+
+import domain.Tile;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class GameHistory {
+
+    private final List<Tile> gameHistory;
+
+    public GameHistory(List<Tile> gameHistory) {
+        this.gameHistory = gameHistory;
+    }
+
+    public String getGameResult() {
+        return gameHistory.stream().map(Tile::getTile)
+                .collect(Collectors.joining());
+    }
+}

src/main/java/service/GameService.java

@@ -0,0 +1,54 @@
+package service;
+
+import config.FileConfig;
+import domain.Answer;
+import domain.Tile;
+import domain.Word;
+import domain.Words;
+import dto.GameHistory;
+import support.WordsGenerator;
+import view.InputView;
+import view.OutputView;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+
+public class GameService {
+    public static final int GAME_TOTAL_ROUND = 6;
+
+    public Answer init() {
+        InputView.inputStartGame();
+        Words words = new Words(WordsGenerator.read(FileConfig.FILE_PATH));
+        return words.getAnswer(LocalDate.now());
+    }
+
+    public List<GameHistory> startGame(Answer answer) {
+        List<GameHistory> gameHistories = new ArrayList<>();
+
+        int count = 0;
+        while (isGameProgress(answer, count)) {
+            Word inputWord = new Word(InputView.inputWord());
+            List<Tile> tiles = answer.compare(inputWord);
+            gameHistories.add(new GameHistory(tiles));
+            print(answer, gameHistories);
+            count++;
+        }
+
+        return gameHistories;
+    }
+
+    private static boolean isGameProgress(Answer answer, int count) {
+        return count < GAME_TOTAL_ROUND && !answer.isSuccess();
+    }
+
+    private void print(Answer answer, List<GameHistory> gameHistories) {
+        if (!answer.isSuccess()) {
+            OutputView.outputTiles(gameHistories);
+        }
+    }
+
+    public void endGame(List<GameHistory> gameHistories) {
+        OutputView.outputEndGame(gameHistories);
+    }
+}