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

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,57 @@
+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.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();
+
+            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<String> outcomes = InputView.getOutcomes();
+        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) -> result.getResults().keySet().stream()
+                        .filter((participant) -> participant.getName().equals(input))
+                        .findFirst()
+                        .ifPresentOrElse(
+                                (target) -> OutputView.printGameResultOf(target, result),
+                                () -> System.out.println("존재하지 않는 참가자입니다.")
+                        )
+                );
+
+        OutputView.printGameResult(result);
+    }
+}

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;
+
+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.getWidth(), configuration.getHeight()));
+    }
+
+    public static Game of(GameConfiguration configuration, Ladder ladder) {
+        return new Game(configuration, ladder);
+    }
+
+    public GameResult execute() {
+        List<Participant> participants = configuration.getParticipants();
+        List<String> outcomes = configuration.getOutcomes();
+        Map<Participant, String> result = new LinkedHashMap<>();
+
+        OutputView.printLadderResult(this);
+
+        for (int start = 0; start < configuration.getWidth(); start++) {
+            int end = traverse(start);
+            Participant participant = participants.get(start);
+            String outcome = outcomes.get(end);
+
+            result.put(participant, outcome);
+        }
+
+        return new GameResult(result);
+    }
+
+    private int traverse(int start) {
+        int col = start;
+
+        for (Line line : ladder.getLines()) {
+            col = findNextColumn(line, col);
+        }
+
+        return col;
+    }
+
+    private int findNextColumn(Line line, int col) {
+
+        return line.getConnections().stream()
+                .filter((connection) -> connection.getLeft() == col || connection.getRight() == col)
+                .findFirst()
+                .map((connection) -> getConnectedColumn(connection, col))
+                .orElse(col);
+    }
+
+    private int getConnectedColumn(Connection connection, int col) {
+        if (connection.getLeft() == col) {
+            return connection.getRight();
+        }
+
+        return connection.getLeft();
+    }
+
+    public Ladder getLadder() {
+        return ladder;
+    }
+
+    public GameConfiguration getConfiguration() {
+        return configuration;
+    }
+}

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

@@ -0,0 +1,34 @@
+package io.suhan.ladder.model;
+
+import java.util.Collections;
+import java.util.List;
+
+public class GameConfiguration {
+    private final List<Participant> participants;
+    private final List<String> outcomes;
+    private final int width;
+    private final int height;
+
+    public GameConfiguration(List<Participant> participants, List<String> outcomes, int width, int height) {
+        this.participants = participants;
+        this.outcomes = outcomes;
+        this.width = width;
+        this.height = height;
+    }
+
+    public List<Participant> getParticipants() {
+        return Collections.unmodifiableList(participants);
+    }
+
+    public List<String> getOutcomes() {
+        return Collections.unmodifiableList(outcomes);
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+}

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

@@ -0,0 +1,43 @@
+package io.suhan.ladder.model;
+
+import java.util.List;
+
+public class GameConfigurationBuilder {
+    private List<Participant> participants;
+    private List<String> outcomes;
+    private int height;
+
+    public GameConfigurationBuilder participants(List<Participant> participants) {
+        if (participants == null || participants.isEmpty()) {
+            throw new IllegalArgumentException("참가자 목록은 비어 있을 수 없습니다.");
+        }
+
+        this.participants = participants;
+
+        return this;
+    }
+
+    public GameConfigurationBuilder outcomes(List<String> outcomes) {
+        if (outcomes == null || 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,20 @@
+package io.suhan.ladder.model;
+
+import java.util.Collections;
+import java.util.Map;
+
+public class GameResult {
+    private final Map<Participant, String> results;
+
+    public GameResult(Map<Participant, String> results) {
+        this.results = results;
+    }
+
+    public Map<Participant, String> getResults() {
+        return Collections.unmodifiableMap(results);
+    }
+
+    public String getOutcome(Participant participant) {
+        return results.get(participant);
+    }
+}

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

@@ -0,0 +1,18 @@
+package io.suhan.ladder.model;
+
+public class Participant {
+    public static final int PARTICIPANT_NAME_MAX_LENGTH = 5;
+    private final String name;
+
+    public Participant(String name) {
+        if (name.length() > PARTICIPANT_NAME_MAX_LENGTH) {
+            throw new IllegalArgumentException("참가자의 이름은 최대 " + PARTICIPANT_NAME_MAX_LENGTH + "자만 가능합니다.");
+        }
+
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

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

@@ -0,0 +1,19 @@
+package io.suhan.ladder.model.ladder;
+
+public class Connection {
+    private final int left;
+    private final int right;
+
+    public Connection(int left, int right) {
+        this.left = left;
+        this.right = right;
+    }
+
+    public int getLeft() {
+        return left;
+    }
+
+    public int getRight() {
+        return right;
+    }
+}

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

@@ -0,0 +1,16 @@
+package io.suhan.ladder.model.ladder;
+
+import java.util.Collections;
+import java.util.List;
+
+public class Ladder {
+    private final List<Line> lines;
+
+    public Ladder(List<Line> lines) {
+        this.lines = lines;
+    }
+
+    public List<Line> getLines() {
+        return Collections.unmodifiableList(lines);
+    }
+}

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

@@ -0,0 +1,53 @@
+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<>();
+
+        // TODO: depth 줄이기
+        for (int i = 0; i < width - 1; i++) {
+            if (shouldConnect(random)) {
+                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,16 @@
+package io.suhan.ladder.model.ladder;
+
+import java.util.Collections;
+import java.util.List;
+
+public class Line {
+    private final List<Connection> connections;
+
+    public Line(List<Connection> connections) {
+        this.connections = connections;
+    }
+
+    public List<Connection> getConnections() {
+        return Collections.unmodifiableList(connections);
+    }
+}