[그리디] 하수한 사다리 미션 제출합니다.

README.md

@@ -0,0 +1,28 @@
+# java-ladder-func-playground
+
+사다리 미션
+
+## 개요
+사다리 미션은 간단한 콘솔 애플리케이션으로, 사용자로부터 참여할 사람의 이름과 실행 결과, 최대 사다리 높이를 입력 받습니다.\
+그리고 생성된 사다리에 대해 사용자는 참가자의 이름을 입력하여 해당 참가자에 대한 실행 결과를 확인할 수 있고, `all`을 입력하여 전체 결과를 확인할 수 있습니다.
+
+## 프로젝트 구조
+```
+controller/
+- LadderController.java : 전반적인 게임 Flow(입력, 실행, 출력)를 담당하는 클래스
+model/
+- ladder/
+  - Connection.java : 사다리 가로 줄의 지점 간 연결을 정의하는 클래스
+  - Ladder.java : 전체 사다리를 정의하는 클래스
+  - LadderFactory.java : 사다리 생성을 담당하는 클래스
+  - Line.java : 사다리의 가로 줄을 정의하는 클래스
+- Game.java : 게임 실행을 담당하는 클래스
+- GameConfiguration.java : 게임 설정을 정의하는 클래스
+- GameConfigurationBuilder.java : 게임 설정 Builder 클래스
+- GameResult.java : 게임 결과를 정의하는 클래스
+- Participant.java : 각 참가자를 정의하는 클래스
+view/
+- InputView.java : 사용자 입력 처리 기능 수행
+- OutputView.java : 사용자에게 정보 출력 기능 수행
+Main.java : Main entrypoint
+```

src/main/java/io/suhan/ladder/Main.java

@@ -0,0 +1,10 @@
+package io.suhan.ladder;
+
+import io.suhan.ladder.controller.LadderController;
+
+public class Main {
+    public static void main(String[] args) {
+        LadderController controller = new LadderController();
+        controller.run();
+    }
+}

src/main/java/io/suhan/ladder/controller/LadderController.java

@@ -0,0 +1,71 @@
+package io.suhan.ladder.controller;
+
+import io.suhan.ladder.model.Game;
+import io.suhan.ladder.model.GameConfiguration;
+import io.suhan.ladder.model.GameConfigurationBuilder;
+import io.suhan.ladder.model.GameResult;
+import io.suhan.ladder.model.Outcome;
+import io.suhan.ladder.model.Participant;
+import io.suhan.ladder.view.InputView;
+import io.suhan.ladder.view.OutputView;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class LadderController {
+    public void run() {
+        try {
+            GameConfiguration configuration = readConfiguration();
+            Game game = Game.of(configuration);
+
+            GameResult result = game.execute();
+
+            OutputView.printLadderResult(game);
+
+            handleOutcomeQuery(result);
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+    private GameConfiguration readConfiguration() {
+        // method chaining으로 구성하려고 하였으나 Input 검증으로 인해 각각 따로 받음
+        GameConfigurationBuilder builder = new GameConfigurationBuilder();
+
+        List<Participant> participants = InputView.getParticipants().stream().map(Participant::new).toList();
+        builder.participants(participants);
+
+        List<Outcome> outcomes = InputView.getOutcomes().stream().map(Outcome::new).toList();
+        builder.outcomes(outcomes);
+
+        int height = InputView.getLadderHeight();
+        builder.height(height);
+
+        return builder.build();
+    }
+
+    private void handleOutcomeQuery(GameResult result) {
+        Stream.generate(InputView::getParticipantForResult)
+                .takeWhile((input) -> !input.equals("all"))
+                .forEach((input) -> handleSingleQuery(result, input));
+
+        OutputView.printGameResult(result);
+    }
+
+    private void handleSingleQuery(GameResult result, String input) {
+        Participant participant = findParticipantByName(result, input);
+
+        if (participant == null) {
+            System.out.println("존재하지 않는 참가자입니다.");
+            return;
+        }
+
+        OutputView.printGameResultOf(participant, result);
+    }
+
+    private Participant findParticipantByName(GameResult result, String name) {
+        return result.results().keySet().stream()
+                .filter((participant -> participant.name().equals(name)))
+                .findFirst()
+                .orElse(null);
+    }
+}

src/main/java/io/suhan/ladder/model/Game.java

@@ -0,0 +1,81 @@
+package io.suhan.ladder.model;
+
+import io.suhan.ladder.model.ladder.Connection;
+import io.suhan.ladder.model.ladder.Ladder;
+import io.suhan.ladder.model.ladder.LadderFactory;
+import io.suhan.ladder.model.ladder.Line;
+import io.suhan.ladder.view.OutputView;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public class Game {
+    private final Ladder ladder;
+    private final GameConfiguration configuration;
+
+    private Game(GameConfiguration configuration, Ladder ladder) {
+        this.configuration = configuration;
+        this.ladder = ladder;
+    }
+
+    public static Game of(GameConfiguration configuration) {
+        return new Game(configuration, LadderFactory.createLadder(configuration.width(), configuration.height()));
+    }
+
+    public static Game of(GameConfiguration configuration, Ladder ladder) {
+        return new Game(configuration, ladder);
+    }
+
+    public GameResult execute() {
+        List<Participant> participants = configuration.participants();
+        List<Outcome> outcomes = configuration.outcomes();
+        Map<Participant, Outcome> result = new LinkedHashMap<>();
+
+        for (int start = 0; start < configuration.width(); start++) {
+            int end = traverse(start);
+            Participant participant = participants.get(start);
+            Outcome outcome = outcomes.get(end);
+
+            result.put(participant, outcome);
+        }
+
+        return new GameResult(result);
+    }
+
+    private int traverse(int start) {
+        int col = start;
+
+        for (Line line : ladder.lines()) {
+            col = findNextColumn(line, col);
+        }
+
+        return col;
+    }
+
+    private int findNextColumn(Line line, int col) {
+        Optional<Connection> connected = line.connections().stream()
+                .filter((connection) -> connection.left() == col || connection.right() == col)
+                .findFirst();
+
+        return connected
+                .map((connection) -> getConnectedColumn(connection, col))
+                .orElse(col);
+    }
+
+    private int getConnectedColumn(Connection connection, int col) {
+        if (connection.left() == col) {
+            return connection.right();
+        }
+
+        return connection.left();
+    }
+
+    public Ladder getLadder() {
+        return ladder;
+    }
+
+    public GameConfiguration getConfiguration() {
+        return configuration;
+    }
+}

src/main/java/io/suhan/ladder/model/GameConfiguration.java

@@ -0,0 +1,16 @@
+package io.suhan.ladder.model;
+
+import java.util.Collections;
+import java.util.List;
+
+public record GameConfiguration(List<Participant> participants, List<Outcome> outcomes, int width, int height) {
+    @Override
+    public List<Participant> participants() {
+        return Collections.unmodifiableList(participants);
+    }
+
+    @Override
+    public List<Outcome> outcomes() {
+        return Collections.unmodifiableList(outcomes);
+    }
+}

src/main/java/io/suhan/ladder/model/GameConfigurationBuilder.java

@@ -0,0 +1,51 @@
+package io.suhan.ladder.model;
+
+import java.util.List;
+
+public class GameConfigurationBuilder {
+    private List<Participant> participants;
+    private List<Outcome> outcomes;
+    private int height;
+
+    public GameConfigurationBuilder participants(List<Participant> participants) {
+        if (participants == null) {
+            throw new IllegalStateException("참가자 목록이 설정되지 않았습니다.");
+        }
+
+        if (participants.isEmpty()) {
+            throw new IllegalArgumentException("참가자 목록은 비어 있을 수 없습니다.");
+        }
+
+        this.participants = participants;
+
+        return this;
+    }
+
+    public GameConfigurationBuilder outcomes(List<Outcome> outcomes) {
+        if (outcomes == null) {
+            throw new IllegalStateException("결과 목록이 설정되지 않았습니다.");
+        }
+
+        if (outcomes.size() != participants.size()) {
+            throw new IllegalArgumentException("참가자의 수와 실행 결과의 수는 같아야 합니다.");
+        }
+
+        this.outcomes = outcomes;
+
+        return this;
+    }
+
+    public GameConfigurationBuilder height(int height) {
+        if (height <= 0) {
+            throw new IllegalArgumentException("높이는 양수여야 합니다.");
+        }
+
+        this.height = height;
+
+        return this;
+    }
+
+    public GameConfiguration build() {
+        return new GameConfiguration(participants, outcomes, participants.size(), height);
+    }
+}

src/main/java/io/suhan/ladder/model/GameResult.java

@@ -0,0 +1,15 @@
+package io.suhan.ladder.model;
+
+import java.util.Collections;
+import java.util.Map;
+
+public record GameResult(Map<Participant, Outcome> results) {
+    @Override
+    public Map<Participant, Outcome> results() {
+        return Collections.unmodifiableMap(results);
+    }
+
+    public Outcome getOutcome(Participant participant) {
+        return results.get(participant);
+    }
+}

src/main/java/io/suhan/ladder/model/Outcome.java

@@ -0,0 +1,9 @@
+package io.suhan.ladder.model;
+
+public record Outcome(String value) {
+    public Outcome {
+        if (value.isBlank()) {
+            throw new IllegalArgumentException("결과는 공백일 수 없습니다.");
+        }
+    }
+}

src/main/java/io/suhan/ladder/model/Participant.java

@@ -0,0 +1,15 @@
+package io.suhan.ladder.model;
+
+public record Participant(String name) {
+    public static final int PARTICIPANT_NAME_MAX_LENGTH = 5;
+
+    public Participant {
+        if (name.length() > PARTICIPANT_NAME_MAX_LENGTH) {
+            throw new IllegalArgumentException("참가자의 이름은 최대 " + PARTICIPANT_NAME_MAX_LENGTH + "자만 가능합니다.");
+        }
+
+        if (name.isBlank()) {
+            throw new IllegalArgumentException("참가자의 이름은 공백일 수 없습니다.");
+        }
+    }
+}

src/main/java/io/suhan/ladder/model/ladder/Connection.java

@@ -0,0 +1,3 @@
+package io.suhan.ladder.model.ladder;
+
+public record Connection(int left, int right) { }

src/main/java/io/suhan/ladder/model/ladder/Ladder.java

@@ -0,0 +1,11 @@
+package io.suhan.ladder.model.ladder;
+
+import java.util.Collections;
+import java.util.List;
+
+public record Ladder(List<Line> lines) {
+    @Override
+    public List<Line> lines() {
+        return Collections.unmodifiableList(lines);
+    }
+}

src/main/java/io/suhan/ladder/model/ladder/LadderFactory.java

@@ -0,0 +1,52 @@
+package io.suhan.ladder.model.ladder;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class LadderFactory {
+    private static final Random DEFAULT_RANDOM = new Random();
+
+    public static Ladder createLadder(int width, int height) {
+        return createLadder(width, height, DEFAULT_RANDOM);
+    }
+
+    public static Ladder createLadder(int width, int height, Random random) {
+        List<Line> lines = createLines(width, height, random);
+
+        return new Ladder(lines);
+    }
+
+    private static List<Line> createLines(int width, int height, Random random) {
+        List<Line> lines = new ArrayList<>();
+
+        for (int i = 0; i < height; i++) {
+            lines.add(createLine(width, random));
+        }
+
+        return lines;
+    }
+
+    private static Line createLine(int width, Random random) {
+        List<Connection> connections = createConnections(width, random);
+
+        return new Line(connections);
+    }
+
+    private static List<Connection> createConnections(int width, Random random) {
+        List<Connection> connections = new ArrayList<>();
+
+        for (int i = 0; i < width - 1; i++) {
+            if (!shouldConnect(random)) continue;
+
+            connections.add(new Connection(i, i + 1));
+            i += 1; // skip the right next line
+        }
+
+        return connections;
+    }
+
+    private static boolean shouldConnect(Random random) {
+        return random.nextBoolean();
+    }
+}

src/main/java/io/suhan/ladder/model/ladder/Line.java

@@ -0,0 +1,11 @@
+package io.suhan.ladder.model.ladder;
+
+import java.util.Collections;
+import java.util.List;
+
+public record Line(List<Connection> connections) {
+    @Override
+    public List<Connection> connections() {
+        return Collections.unmodifiableList(connections);
+    }
+}