[사다리 - 함수형 프로그래밍] 박진형 미션 제출

src/main/java/ladder/Application.java

@@ -0,0 +1,35 @@
+package ladder;
+
+import java.util.Map;
+import java.util.Random;
+import ladder.controller.LadderGameController;
+import ladder.domain.Ladder;
+import ladder.domain.LadderGameResult;
+import ladder.domain.LadderHeight;
+import ladder.domain.LadderResults;
+import ladder.domain.Participants;
+import ladder.view.InputView;
+import ladder.view.OutputView;
+
+public class Application {
+
+    private static final Random RANDOM = new Random();
+
+    public static void main(String[] args) {
+        Participants participants = InputView.inputNames();
+        LadderResults results = InputView.inputLadderResults(participants.size());
+
+        LadderHeight height = InputView.inputHeight();
+
+        Ladder ladder = Ladder.of(participants, height, RANDOM::nextBoolean);
+
+        Map<Integer, Integer> path = ladder.generateResults();
+
+        LadderGameResult gameResult = LadderGameResult.of(participants, results, path);
+
+        OutputView.printLadder(participants, ladder, results);
+        LadderGameController.runInquiry(gameResult);
+
+    }
+
+}

src/main/java/ladder/controller/LadderGameController.java

@@ -0,0 +1,28 @@
+package ladder.controller;
+
+import ladder.domain.LadderGameResult;
+import ladder.view.InputView;
+import ladder.view.OutputView;
+
+public class LadderGameController {
+
+    public static void runInquiry(LadderGameResult gameResult) {
+        String nameQuery;
+        do {
+            nameQuery = InputView.inputNameQuery();
+            printResult(gameResult, nameQuery);
+        } while (!"all".equals(nameQuery));
+    }
+
+    private static void printResult(LadderGameResult gameResult, String nameQuery) {
+        if ("all".equals(nameQuery)) {
+            OutputView.printAllResults(gameResult.getAllResults());
+            return;
+        }
+        try {
+            OutputView.printSingleResult(gameResult.getResultByName(nameQuery));
+        } catch (IllegalArgumentException e) {
+            System.out.println("[ERROR] " + e.getMessage());
+        }
+    }
+}

src/main/java/ladder/domain/Ladder.java

@@ -0,0 +1,54 @@
+package ladder.domain;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.BooleanSupplier;
+
+public class Ladder {
+
+    private final List<Line> lines;
+    private final int width;
+
+    private Ladder(List<Line> lines, int width) {
+        this.lines = lines;
+        this.width = width;
+    }
+
+    public static Ladder of(Participants participants, LadderHeight height, BooleanSupplier strategy) {
+        int participantCount = participants.size();
+        List<Line> lines = generateLines(participantCount, height, strategy);
+
+        return new Ladder(lines, participantCount);
+    }
+
+    public int climb(int startIndex) {
+        int currentIndex = startIndex;
+        for (Line line : lines) {
+            currentIndex = line.move(currentIndex);
+        }
+        return currentIndex;
+    }
+
+    public Map<Integer, Integer> generateResults() {
+        Map<Integer, Integer> results = new LinkedHashMap<>();
+        for (int i = 0; i < width; i++) {
+            results.put(i, climb(i));
+        }
+        return results;
+    }
+
+    private static List<Line> generateLines(int participantCount, LadderHeight height, BooleanSupplier strategy) {
+        List<Line> lines = new ArrayList<>();
+        int pointCount = participantCount - 1;
+        for (int i = 0; i < height.getValue(); i++) {
+            lines.add(Line.from(pointCount, strategy));
+        }
+        return lines;
+    }
+
+    public List<Line> getLines() {
+        return lines;
+    }
+}

src/main/java/ladder/domain/LadderGameResult.java

@@ -0,0 +1,41 @@
+package ladder.domain;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class LadderGameResult {
+
+    private final Map<Name, LadderResult> gameResults;
+
+    private LadderGameResult(Map<Name, LadderResult> gameResults) {
+        this.gameResults = gameResults;
+    }
+
+    public static LadderGameResult of(Participants participants, LadderResults results, Map<Integer, Integer> ladderPath) {
+        Map<Name, LadderResult> mappedResult = new LinkedHashMap<>();
+
+        for (int i = 0; i < participants.size(); i++) {
+            Name participant = participants.getValues().get(i);
+            int arrivalIndex = ladderPath.get(i);
+            LadderResult result = results.getValues().get(arrivalIndex);
+
+            mappedResult.put(participant, result);
+        }
+
+        return new LadderGameResult(mappedResult);
+    }
+
+    public String getResultByName(String name) {
+        return gameResults.entrySet().stream()
+            .filter(entry -> entry.getKey().getName().equals(name))
+            .map(entry -> entry.getValue().getValue())
+            .findFirst()
+            .orElseThrow(() -> new IllegalArgumentException("해당 이름의 참가자가 없습니다."));
+    }
+
+    public Map<Name, LadderResult> getAllResults() {
+        return Collections.unmodifiableMap(gameResults);
+    }
+
+}

src/main/java/ladder/domain/LadderHeight.java

@@ -0,0 +1,25 @@
+package ladder.domain;
+
+public class LadderHeight {
+    private final int value;
+
+    private LadderHeight(int value) {
+        this.value = value;
+    }
+
+    public static LadderHeight from(int value) {
+        validate(value);
+        return new LadderHeight(value);
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    private static void validate(int value) {
+        if (value < 1) {
+            throw new IllegalArgumentException("참여할 사람은 최소 2명 이상이어야 합니다.");
+        }
+    }
+
+}

src/main/java/ladder/domain/LadderResult.java

@@ -0,0 +1,27 @@
+package ladder.domain;
+
+public class LadderResult {
+    private final String value;
+
+    private LadderResult(String value) {
+        validate(value);
+        this.value = value;
+    }
+
+    public static LadderResult from(String value) {
+        return new LadderResult(value.trim());
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    private void validate(String value) {
+        if (value == null || value.isBlank()) {
+            throw new IllegalArgumentException("실행 결과는 빈 값일 수 없습니다.");
+        }
+        if (value.length() > 5) {
+            throw new IllegalArgumentException("실행 결과는 최대 5글자입니다.");
+        }
+    }
+}

src/main/java/ladder/domain/LadderResults.java

@@ -0,0 +1,26 @@
+package ladder.domain;
+
+import java.util.List;
+
+public class LadderResults {
+    private final List<LadderResult> results;
+
+    private LadderResults(List<LadderResult> results) {
+        this.results = results;
+    }
+
+    public static LadderResults of(List<String> rawResults, int participantCount) {
+        if (rawResults.size() != participantCount) {
+            throw new IllegalArgumentException("참가자 수와 결과의 개수가 일치해야 합니다.");
+        }
+
+        List<LadderResult> results = rawResults.stream()
+            .map(LadderResult::from)
+            .toList();
+        return new LadderResults(results);
+    }
+
+    public List<LadderResult> getValues() {
+        return results;
+    }
+}

src/main/java/ladder/domain/Line.java

@@ -0,0 +1,47 @@
+package ladder.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BooleanSupplier;
+
+public class Line {
+
+    private final List<Point> points;
+
+    private Line(List<Point> points) {
+        this.points = points;
+    }
+
+    public static Line from(int size, BooleanSupplier strategy) {
+        return new Line(generatePoints(size, strategy));
+    }
+
+    public List<Point> getPoints() {
+        return points;
+    }
+
+    public int move(int index) {
+        if (index < points.size() && points.get(index).hasBridge()) {
+            return index + 1;
+        }
+        if (index > 0 && points.get(index - 1).hasBridge()) {
+            return index - 1;
+        }
+        return index;
+    }
+
+    private static List<Point> generatePoints(int size, BooleanSupplier strategy) {
+        List<Point> points = new ArrayList<>();
+        boolean lastBridge = false;
+        for (int i = 0; i < size; i++) {
+            lastBridge = addPoint(points, lastBridge, strategy);
+        }
+        return points;
+    }
+
+    private static boolean addPoint(List<Point> points, boolean lastBridge, BooleanSupplier strategy) {
+        boolean currentBridge = !lastBridge && strategy.getAsBoolean();
+        points.add(Point.from(currentBridge));
+        return currentBridge;
+    }
+}

src/main/java/ladder/domain/Name.java

@@ -0,0 +1,29 @@
+package ladder.domain;
+
+public class Name {
+
+    private final String name;
+
+    private Name(String name) {
+        this.name = name;
+    }
+
+    public static Name from(String name) {
+        String trimmedName = name.trim();
+        validate(trimmedName);
+        return new Name(trimmedName);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    private static void validate(String name) {
+        if (name == null || name.isBlank()) {
+            throw new IllegalArgumentException("이름은 빈 값일 수 없습니다.");
+        }
+        if (name.length() > 5) {
+            throw new IllegalArgumentException("이름은 최대 5글자입니다.");
+        }
+    }
+}

src/main/java/ladder/domain/Participants.java

@@ -0,0 +1,43 @@
+package ladder.domain;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Participants {
+
+    private final List<Name> participants;
+
+    private Participants(List<Name> participants) {
+        validate(participants);
+        this.participants = participants;
+    }
+
+    public static Participants from(List<String> names) {
+        List<Name> nameList = names.stream()
+            .map(Name::from)
+            .collect(Collectors.toList());
+        return new Participants(nameList);
+    }
+
+    private void validate(List<Name> participants) {
+        if (participants.size() < 2) {
+            throw new IllegalArgumentException("참여할 사람은 최소 2명 이상이어야 합니다.");
+        }
+        long distinctCount = participants.stream()
+            .map(Name::toString)
+            .distinct()
+            .count();
+        if (distinctCount != participants.size()) {
+            throw new IllegalArgumentException("이름은 중복될 수 없습니다.");
+        }
+    }
+
+    public int size() {
+        return participants.size();
+    }
+
+    public List<Name> getValues() {
+        return participants;
+    }
+
+}

src/main/java/ladder/domain/Point.java

@@ -0,0 +1,24 @@
+package ladder.domain;
+
+public class Point {
+
+    private static final Point BRIDGE = new Point(true);
+    private static final Point EMPTY = new Point(false);
+
+    private final boolean hasBridge;
+
+    private Point(boolean hasBridge) {
+        this.hasBridge = hasBridge;
+    }
+
+    public static Point from(boolean hasBridge) {
+        if (hasBridge) {
+            return BRIDGE;
+        }
+        return EMPTY;
+    }
+
+    public boolean hasBridge() {
+        return hasBridge;
+    }
+}