[BCSD Lab] 박태진, 4차시 미션 제출합니다

src/main/java/App.java

@@ -0,0 +1,125 @@
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.Scanner;
+
+import domain.Columns;
+import domain.Ladder;
+import domain.LadderHeight;
+import domain.Participants;
+import domain.RungLength;
+import service.LadderNavigator;
+import service.RandomConnectionGenerator;
+import view.LadderRenderer;
+
+public class App {
+    public static void main(String[] args) {
+        try (Scanner scanner = new Scanner(System.in)) {
+            Participants participants = readParticipants(scanner);
+            List<String> labels = readLabels(scanner, participants.size());
+            int heightCount = readHeight(scanner);
+            Ladder ladder = buildLadder(participants.size(), heightCount);
+            renderLadder(participants.names(), labels, ladder);
+            queryAndPrintResults(scanner, participants, labels, ladder);
+        }
+    }
+
+    private static Participants readParticipants(Scanner scanner) {
+        while (true) {
+            List<String> names = readCommaSeparated(scanner, "참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)");
+            try { return Participants.of(names); }
+            catch (IllegalArgumentException e) { System.out.println(e.getMessage()); }
+        }
+    }
+
+    private static List<String> readLabels(Scanner scanner, int count) {
+        while (true) {
+            List<String> labels = readCommaSeparated(scanner, "실행 결과를 입력하세요. (결과는 쉼표(,)로 구분하세요)");
+            if (labels.size() != count) { System.out.println("결과의 개수는 참여자 수(" + count + ")와 같아야 합니다"); continue; }
+            return labels;
+        }
+    }
+
+    private static List<String> readCommaSeparated(Scanner scanner, String prompt) {
+        System.out.println(prompt);
+        return Arrays.stream(scanner.nextLine().trim().split(","))
+                .map(String::trim)
+                .filter(s -> !s.isEmpty())
+                .toList();
+    }
+
+    private static int readHeight(Scanner scanner) {
+        System.out.println();
+        System.out.println("최대 사다리 높이는 몇 개인가요?");
+        return Integer.parseInt(scanner.nextLine().trim());
+    }
+
+    private static Ladder buildLadder(int numNames, int heightCount) {
+        Columns columns = Columns.of(numNames);
+        LadderHeight height = LadderHeight.of(heightCount);
+        RandomConnectionGenerator generator = new RandomConnectionGenerator(new Random());
+        return generator.generateLadder(height, columns);
+    }
+
+    private static void renderLadder(List<String> names, List<String> labels, Ladder ladder) {
+        Columns columns = Columns.of(names.size());
+        RungLength rungLength = RungLength.defaultFive();
+        LadderRenderer renderer = new LadderRenderer();
+        System.out.println("\n사다리 결과\n");
+        System.out.println(renderer.renderNamesHeader(names, rungLength));
+        renderer.print(ladder, columns, rungLength);
+        System.out.println(renderer.renderBottomLabels(labels, rungLength));
+    }
+
+    private static void queryAndPrintResults(Scanner scanner, Participants participants, List<String> labels, Ladder ladder) {
+        Columns columns = Columns.of(participants.size());
+        LadderNavigator navigator = new LadderNavigator();
+        while (true) {
+            String who = promptWho(scanner);
+            if (handleSelection(navigator, ladder, columns, participants, labels, who)) break;
+        }
+    }
+
+    private static String promptWho(Scanner scanner) {
+        System.out.println();
+        System.out.println("결과를 보고 싶은 사람은?");
+        String who = scanner.nextLine().trim();
+        System.out.println("\n실행 결과");
+        return who;
+    }
+
+    private static boolean handleSelection(
+            LadderNavigator navigator,
+            Ladder ladder,
+            Columns columns,
+            Participants participants,
+            List<String> labels,
+            String who
+    ) {
+        if (who.equalsIgnoreCase("all")) { handleAllRequest(navigator, ladder, columns, participants, labels); return true; }
+        int index = participants.indexOf(who);
+        if (index < 0) { System.out.println("존재하지 않는 이름입니다"); return false; }
+        printSingleResult(navigator, ladder, columns, index, labels);
+        return false;
+    }
+
+    private static void handleAllRequest(LadderNavigator navigator, Ladder ladder, Columns columns, Participants participants, List<String> labels) {
+        printAllResults(navigator, ladder, columns, participants, labels);
+    }
+
+    private static void printAllResults(LadderNavigator navigator, Ladder ladder, Columns columns, Participants participants, List<String> labels) {
+        for (int i = 0; i < columns.count(); i++) { printSingleMapping(navigator, ladder, columns, participants, labels, i); }
+    }
+
+    private static void printSingleResult(LadderNavigator navigator, Ladder ladder, Columns columns, int index, List<String> labels) {
+        int dest = navigator.traverse(ladder, columns, index);
+        System.out.println(labels.get(dest));
+    }
+
+    private static void printSingleMapping(LadderNavigator navigator, Ladder ladder, Columns columns, Participants participants, List<String> labels, int i) {
+        int dest = navigator.traverse(ladder, columns, i);
+        String name = participants.get(i);
+        String label = labels.get(dest);
+        System.out.println(name + " : " + label);
+    }
+}

src/main/java/domain/Columns.java

@@ -0,0 +1,30 @@
+package domain;
+
+public final class Columns {
+    private final int count;
+
+    private Columns(int count) {
+        this.count = count;
+    }
+
+    public static Columns of(int count) {
+        if (count < 2) {
+            throw new IllegalArgumentException("열의 개수는 2 이상이어야 합니다");
+        }
+        return new Columns(count);
+    }
+
+    public static Columns fixedFour() {
+        return of(4);
+    }
+
+    public int count() {
+        return count;
+    }
+
+    public int numberOfSegments() {
+        return count - 1;
+    }
+}
+
+

src/main/java/domain/Connection.java

@@ -0,0 +1,8 @@
+package domain;
+
+public enum Connection {
+    CONNECTED,
+    EMPTY
+}
+
+

src/main/java/domain/Ladder.java

@@ -0,0 +1,23 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public final class Ladder {
+    private final List<Row> rows;
+
+    private Ladder(List<Row> rows) {
+        this.rows = Collections.unmodifiableList(new ArrayList<>(rows));
+    }
+
+    public static Ladder of(List<Row> rows) {
+        return new Ladder(rows);
+    }
+
+    public List<Row> rows() {
+        return rows;
+    }
+}
+
+

src/main/java/domain/LadderHeight.java

@@ -0,0 +1,22 @@
+package domain;
+
+public final class LadderHeight {
+    private final int count;
+
+    private LadderHeight(int count) {
+        this.count = count;
+    }
+
+    public static LadderHeight of(int count) {
+        if (count < 1) {
+            throw new IllegalArgumentException("행의 개수는 1 이상이어야 합니다");
+        }
+        return new LadderHeight(count);
+    }
+
+    public int count() {
+        return count;
+    }
+}
+
+

src/main/java/domain/Participants.java

@@ -0,0 +1,58 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public final class Participants {
+    private final List<String> names;
+
+    private Participants(List<String> names) {
+        this.names = Collections.unmodifiableList(new ArrayList<>(names));
+    }
+
+    public static Participants of(List<String> rawNames) {
+		List<String> names = normalizeNames(rawNames);
+		requireNonEmpty(names);
+		requireMaxLength(names, 5);
+		return new Participants(names);
+    }
+
+	private static List<String> normalizeNames(List<String> rawNames) {
+		List<String> result = new ArrayList<>();
+		for (String n : rawNames) {
+			String v = n == null ? "" : n.trim();
+			if (!v.isEmpty()) { result.add(v); }
+		}
+		return result;
+	}
+
+	private static void requireNonEmpty(List<String> names) {
+		if (names.isEmpty()) { throw new IllegalArgumentException("이름을 한 개 이상 입력해 주세요"); }
+	}
+
+	private static void requireMaxLength(List<String> names, int max) {
+		boolean tooLongExists = names.stream().anyMatch(n -> n.length() > max);
+		if (tooLongExists) {
+			throw new IllegalArgumentException("각 이름은 최대 " + max + "글자까지 가능합니다");
+		}
+	}
+
+    public int size() {
+        return names.size();
+    }
+
+    public int indexOf(String name) {
+        return names.indexOf(name);
+    }
+
+    public String get(int index) {
+        return names.get(index);
+    }
+
+    public List<String> names() {
+        return names;
+    }
+}
+
+

src/main/java/domain/Row.java

@@ -0,0 +1,34 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public final class Row {
+    private final List<Connection> connections;
+
+    private Row(List<Connection> connections) {
+        this.connections = Collections.unmodifiableList(new ArrayList<>(connections));
+    }
+
+    public static Row of(List<Connection> connections) {
+        validate(connections);
+        return new Row(connections);
+    }
+
+    private static void validate(List<Connection> connections) {
+        Connection previous = Connection.EMPTY;
+        for (Connection current : connections) {
+            if (previous == Connection.CONNECTED && current == Connection.CONNECTED) {
+                throw new IllegalArgumentException("인접한 연결은 허용되지 않습니다");
+            }
+            previous = current;
+        }
+    }
+
+    public List<Connection> connections() {
+        return connections;
+    }
+}
+
+

src/main/java/domain/RungLength.java

@@ -0,0 +1,34 @@
+package domain;
+
+public final class RungLength {
+    private final int length;
+
+    private RungLength(int length) {
+        this.length = length;
+    }
+
+    public static RungLength of(int length) {
+        if (length < 1) {
+            throw new IllegalArgumentException("길이는 1 이상이어야 합니다");
+        }
+        return new RungLength(length);
+    }
+
+    public static RungLength defaultFive() {
+        return of(5);
+    }
+
+    public int length() {
+        return length;
+    }
+
+    public String dashes() {
+        return "-".repeat(length);
+    }
+
+    public String spaces() {
+        return " ".repeat(length);
+    }
+}
+
+

src/main/java/service/LadderNavigator.java

@@ -0,0 +1,37 @@
+package service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import domain.Columns;
+import domain.Connection;
+import domain.Ladder;
+import domain.Row;
+
+public final class LadderNavigator {
+    public int traverse(Ladder ladder, Columns columns, int startColumn) {
+        int currentColumn = startColumn;
+        for (Row row : ladder.rows()) {
+            if (currentColumn < columns.numberOfSegments()
+                    && row.connections().get(currentColumn) == Connection.CONNECTED) {
+                currentColumn += 1;
+                continue;
+            }
+            if (currentColumn > 0
+                    && row.connections().get(currentColumn - 1) == Connection.CONNECTED) {
+                currentColumn -= 1;
+            }
+        }
+        return currentColumn;
+    }
+
+    public List<Integer> traverseAll(Ladder ladder, Columns columns) {
+        List<Integer> results = new ArrayList<>();
+        for (int start = 0; start < columns.count(); start++) {
+            results.add(traverse(ladder, columns, start));
+        }
+        return results;
+    }
+}
+
+