[그리디] 김태우 사다리 미션 제출합니다.

src/README.md

@@ -0,0 +1,54 @@
+# 사다리 게임
+
+## 💡 기능 요구사항
+
+1. 사다리 게임에 참여하는 사람에 이름을 최대 5글자까지 부여할 수 있다.
+2. 사다리를 출력할 때 사람 이름도 같이 출력한다.
+3. 사람 이름은 쉼표(,)를 기준으로 구분한다.
+4. 개인별 이름을 입력하면 개인별 결과를 출력한다.
+5. `"all"`을 입력하면 전체 참여자의 실행 결과를 출력한다.
+
+---
+
+## 클래스 소개
+
+| 클래스                        | 역할|
+|----------------------------|---|
+| `Name`                     | 이름 단위를 표현 |
+| `Names`                    | 이름들의 일급 컬렉션 |
+| `Players`                  | 참가자 이름 목록 관리 및 중복 제거 |
+| `Results`                  | 실행 결과 목록 관리 |
+| `Height`                   | 사다리 높이 검증 및 저장 |
+| `Connect`                  | `CONNECTED` / `DISCONNECTED` 상태 Enum |
+| `Point`                    | 연결 여부(`Connect`) 표현 |
+| `Line`                     | 한 줄의 연결 상태(`Point`) 관리 |
+| `Ladder`                   | 사다리 전체를 구성 (여러 Line의 집합) |
+| `LadderGame`               | 이동 로직 및 결과 매핑 수행 |
+| `LadderController`         | 전체 게임 실행 흐름 제어 |
+| `InputView` / `OutputView` | 입출력 담당 |
+| `Main`                     | 프로그램 실행의 진입점 담당 |
+
+---
+
+## 프로그램 실행 흐름
+
+1. **입력 단계**
+    - 참여자 이름, 실행 결과, 사다리 높이를 순서대로 입력받는다.
+    - 이름과 결과의 개수가 다르면 예외를 발생시킨다.
+    - 이름이 5글자를 초과하면 예외를 발생한다.
+    - 사다리 높이가 양수가 아니거나 숫자가 아닌 입력이 들어오면 예외를 발생시킨다.
+
+---
+
+2. **사다리 생성 단계**
+    - 입력받은 높이와 인원 수를 기반으로 `Ladder` 객체를 생성한다.
+    - 내부적으로 `Line.create()`를 호출하여 각 Line의 연결 상태를 무작위로 생성한다.
+    - 높이가 0인 경우에도 1줄의 사다리가 생성된다.
+
+---
+
+3. **결과 조회 단계**
+    - 사용자가 이름을 입력하면 해당 참가자의 결과를 출력한다.
+    - `"all"`을 입력하면 전체 참가자의 결과를 한 번에 출력한다.
+
+---

src/main/java/Main.java

@@ -0,0 +1,22 @@
+import controller.LadderController;
+import domain.LadderGame;
+import domain.Players;
+import domain.Results;
+import view.InputView;
+import view.OutputView;
+
+public class Main {
+    public static void main(String[] args) {
+        InputView inputView = new InputView();
+        OutputView outputView = new OutputView();
+        LadderController controller = new LadderController(inputView, outputView);
+
+        Players players = controller.inputPlayers();
+        Results results = controller.inputResults(players);
+        int height = controller.inputHeight();
+
+        LadderGame game = controller.startLadderGame(height, players, results);
+        controller.showResult(game, players);
+
+    }
+}

src/main/java/controller/LadderController.java

@@ -0,0 +1,104 @@
+package controller;
+
+import domain.Ladder;
+import domain.LadderGame;
+import domain.PlayerName;
+import domain.Players;
+import domain.ResultName;
+import domain.Results;
+import view.InputView;
+import view.OutputView;
+
+import java.util.Arrays;
+import java.util.InputMismatchException;
+import java.util.List;
+import java.util.Random;
+
+public class LadderController {
+    private final InputView inputView;
+    private final OutputView outputView;
+
+    public LadderController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+    }
+
+    public Players inputPlayers() {
+        outputView.printAskPlayers();
+        while (true) {
+            try {
+                String input = inputView.readString();
+                List<PlayerName> players = Arrays.stream(input.split(","))
+                        .map(String::trim)
+                        .map(PlayerName::new)
+                        .toList();
+                return new Players(players);
+            } catch (IllegalArgumentException e) {
+                outputView.printException(e);
+                outputView.printRetryInputMessage();
+            }
+        }
+    }
+
+    public Results inputResults(Players players) {
+        outputView.printAskResults();
+        while (true) {
+            try {
+                String input = inputView.readString();
+                List<ResultName> result = Arrays.stream(input.split(","))
+                        .map(String::trim)
+                        .map(ResultName::new)
+                        .toList();
+                Results results = new Results(result);
+                LadderGame.validatePlayerAndResultCount(players, results);
+                return results;
+            } catch (IllegalArgumentException e) {
+                outputView.printException(e);
+                outputView.printRetryInputMessage();
+            }
+        }
+    }
+
+    public int inputHeight() {
+        outputView.printAskHeight();
+        while (true) {
+            try {
+                int height = inputView.readInt();
+                if (height < 0) {
+                    throw new IllegalArgumentException("높이는 양수여야 합니다.");
+                }
+                return height;
+            } catch (InputMismatchException | IllegalArgumentException e) {
+                outputView.printException(e);
+                outputView.printRetryInputMessage();
+            }
+        }
+    }
+
+    public LadderGame startLadderGame(int height, Players players, Results results) {
+        Ladder ladder = new Ladder(height, players.size(), new Random());
+        LadderGame game = new LadderGame(ladder, players, results);
+        outputView.printLadderResultTitle();
+        outputView.printLadder(ladder, players.getPlayers(), results.getResults());
+        return game;
+    }
+
+    public void showResult(LadderGame game, Players players) {
+        boolean run = true;
+        while (run) {
+            outputView.printAskResultByPlayer();
+            String name = inputView.readString();
+            run = validateRun(game, players, name);
+        }
+    }
+
+    private boolean validateRun(LadderGame game, Players players, String name) {
+        if (name.equals("all")) {
+            outputView.printAllResults(game.findAll(), players);
+            return false;
+        }
+        String result = game.findResultByPlayer(name);
+        outputView.printSingleResult(result);
+        return true;
+    }
+}

src/main/java/domain/Connect.java

@@ -0,0 +1,44 @@
+package domain;
+
+public enum Connect {
+    CONNECTED(true) {
+        @Override
+        public int moveRight(int index) {
+            return index + 1;
+        }
+
+        @Override
+        public int moveLeft(int index) {
+            return index - 1;
+        }
+    },
+    DISCONNECTED(false) {
+        @Override
+        public int moveRight(int index) {
+            return index;
+        }
+
+        @Override
+        public int moveLeft(int index) {
+            return index;
+        }
+    };
+
+    private final boolean value;
+
+    Connect(boolean value) {
+        this.value = value;
+    }
+
+    public abstract int moveRight(int index);
+
+    public abstract int moveLeft(int index);
+
+    public boolean isConnected() {
+        return value;
+    }
+
+    public static Connect from(boolean value) {
+        return value ? CONNECTED : DISCONNECTED;
+    }
+}

src/main/java/domain/Ladder.java

@@ -0,0 +1,25 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class Ladder {
+    private final List<Line> lines;
+
+    public Ladder(int height, int playerCount, Random random) {
+        List<Line> temp = new ArrayList<>();
+
+        for (int i = 0; i < height; i++) {
+            temp.add(Line.create(playerCount, random));
+        }
+        if (height == 0) {
+            temp.add(Line.create(playerCount, random));
+        }
+        this.lines = List.copyOf(temp);
+    }
+
+    public List<Line> getLines() {
+        return lines;
+    }
+}

src/main/java/domain/LadderGame.java

@@ -0,0 +1,52 @@
+package domain;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class LadderGame {
+    private final Ladder ladder;
+    private final Players players;
+    private final Results results;
+
+    public LadderGame(Ladder ladder, Players players, Results results) {
+        this.ladder = ladder;
+        this.players = players;
+        this.results = results;
+    }
+
+    public static void validatePlayerAndResultCount(Players players, Results results) {
+        if (players.size() != results.size()) {
+            throw new IllegalArgumentException("참가자와 결과 수는 같아야 합니다.");
+        }
+    }
+
+    private int move(int position) {
+        for (Line line : ladder.getLines()) {
+            position = line.moveOf(position);
+        }
+        return position;
+    }
+
+
+    public String findResultByPlayer(String name) {
+        List<PlayerName> player = players.getPlayers();
+        List<ResultName> result = results.getResults();
+
+        int index = player.indexOf(new PlayerName(name));
+        if (index < 0) {
+            throw new IllegalArgumentException("존재하지 않는 플레이어입니다.");
+        }
+        index = move(index);
+        return result.get(index).value();
+    }
+
+    public Map<String, String> findAll() {
+        Map<String, String> map = new HashMap<>();
+        List<PlayerName> player = players.getPlayers();
+        for (PlayerName name : player) {
+            map.put(name.value(), findResultByPlayer(name.value()));
+        }
+        return map;
+    }
+}

src/main/java/domain/Line.java

@@ -0,0 +1,61 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class Line {
+    private final List<Connect> points;
+
+    private Line(List<Connect> points) {
+        this.points = List.copyOf(points);
+    }
+
+    static Line of(List<Connect> points) {
+        return new Line(points);
+    }
+
+    public static Line create(int playerCount, Random random) {
+        List<Connect> points = new ArrayList<>();
+        Connect prev = Connect.DISCONNECTED;
+
+        for (int i = 0; i < playerCount - 1; i++) {
+            Connect next = Connect.from(random.nextBoolean());
+            next = checkPrev(prev, next);
+            points.add(next);
+            prev = next;
+        }
+        return new Line(points);
+    }
+
+    private static Connect checkPrev(Connect prev, Connect next) {
+        if (prev.isConnected()) {
+            return Connect.DISCONNECTED;
+        }
+        return next;
+    }
+
+    private Connect rightOf(int index) {
+        if (index >= points.size()) return Connect.DISCONNECTED;
+        return points.get(index);
+    }
+
+    private Connect leftOf(int index) {
+        if (index <= 0) return Connect.DISCONNECTED;
+        return points.get(index - 1);
+    }
+
+    public int moveOf(int index) {
+        Connect right = rightOf(index);
+        if (right.isConnected()) return right.moveRight(index);
+
+        Connect left = leftOf(index);
+        if (left.isConnected()) return left.moveLeft(index);
+
+        return index;
+    }
+
+    public List<Connect> getPoints() {
+        return points;
+    }
+}