고생하셨습니다.

dd-jiyun · web-flow · commit 021c50456afe · 2025-06-10T00:34:52.000+09:00
🎉 PR 머지 완료! 🎉
diff --git a/README.md b/README.md
@@ -11,26 +11,26 @@
 
 - 사다리의 높이와 넓이를 입력받아 생성한다.
     - 넓이와 높이는 2 이상 24 이하 여야한다.
-- 클래스는 3개 이상의 인스턴스 변수 가질 수 없다.
-- 모든 엔티티 작게 유지해야 한다.
+- 사다리의 시작 지점과 도착 지점을 출력한다.
 
 ## 구현 기능
 
 ### 사다리
 
-- 여러 개의 라인을 가진다.
-- 전체 사다리 구조를 나타내며, 사다리가 완성될 때까지 여러 번 라인을 생성해 재시도한다.
+- 여러 개의 라인을 가지며 전체 사다리 구조를 나타낸다.
+- 라인을 반복 생성하며, 인접 라인 간 연결이 최소 한 번 이상 존재하는 유효한 사다리를 생성한다.
 - 완성된 사다리를 반환하며, 유효하지 않으면 예외를 발생시킨다.
+- 시작 인덱스를 받아 각 라인의 연결을 따라 최종 위치를 계산한다.
 
 ### 라인 생성기
 
-- 포인트 생성기를 사용해 한 줄의 포인트들을 생성한다.
+- 포인트 간 연결 여부를 생성하고, 라인을 구성한다.
 - 인접 포인트 간 연결이 겹치지 않도록 제어한다.
 
 ### 라인
 
 - 한 줄을 구성하는 포인트들의 리스트를 가진다.
-- 각 포인트의 오른쪽 연결 상태를 관리한다.
+- 각 포인트의 오른쪽 연결 상태를 관리하고, 이동 방향을 계산한다.
 
 ### 포인트 생성기
 
@@ -45,16 +45,22 @@
 
 ```text
 사다리의 넓이는 몇 인가요?
-4
+5
 
 사다리의 높이는 몇 인가요?
 5
-실행결과
 
-     |-----|     |-----|
-     |-----|     |-----|
-     |     |-----|     |
-     |     |     |     |
-     |     |     |-----|
+실행결과
 
+     |-----|     |-----|     |
+     |     |     |     |-----|
+     |-----|     |     |     |
+     |     |-----|     |-----|
+     |-----|     |-----|     |
+
+0 -> 1
+1 -> 3
+2 -> 2
+3 -> 0
+4 -> 4
 ```
diff --git a/src/main/java/controller/LadderController.java b/src/main/java/controller/LadderController.java
@@ -3,6 +3,8 @@
 import domain.Height;
 import domain.Width;
 import domain.dto.RequestLadder;
+import domain.dto.ResponseLadder;
+import domain.dto.ResponseLadderResult;
 import domain.ladder.Ladder;
 import domain.ladder.LadderFactory;
 import strategy.LineGenerator;
@@ -23,7 +25,7 @@ public void play() {
         LadderFactory factory = new LadderFactory();
         Ladder ladder = factory.draw(width, height, lineGenerator);
 
-        drawLadder(ladder);
+        drawLadder(ladder, width);
     }
 
     private RequestLadder inputLadderSettings() {
@@ -37,8 +39,13 @@ private LineGenerator createLineGenerator() {
         return new RandomLineGenerator(pointGenerator);
     }
 
-    private void drawLadder(final Ladder ladder) {
+    private void drawLadder(final Ladder ladder, final Width width) {
         OutputView.printLadderResultTitle();
-        OutputView.drawLadder(ladder);
+
+        ResponseLadder responseLadder = ResponseLadder.from(ladder);
+        OutputView.drawLadder(responseLadder);
+
+        ResponseLadderResult responseResult = ResponseLadderResult.of(ladder, width);
+        OutputView.printLadderResult(responseResult);
     }
 }
diff --git a/src/main/java/domain/Direction.java b/src/main/java/domain/Direction.java
@@ -0,0 +1,18 @@
+package domain;
+
+public enum Direction {
+    LEFT(-1),
+    DOWN(0),
+    RIGHT(1)
+    ;
+
+    private final int offset;
+
+    Direction(final int offset) {
+        this.offset = offset;
+    }
+
+    public int moveFrom(final int index) {
+        return index + offset;
+    }
+}
diff --git a/src/main/java/domain/Line.java b/src/main/java/domain/Line.java
@@ -18,6 +18,24 @@ public boolean hasConnectionAt(final int index) {
         return points.get(index).right();
     }
 
+    public Direction directionAt(final int index) {
+        if (canMoveRight(index)) {
+            return Direction.RIGHT;
+        }
+        if (canMoveLeft(index)) {
+            return Direction.LEFT;
+        }
+        return Direction.DOWN;
+    }
+
+    private boolean canMoveRight(final int index) {
+        return index < points.size() - 1 && points.get(index).right();
+    }
+
+    private boolean canMoveLeft(final int index) {
+        return 0 < index && points.get(index - 1).right();
+    }
+
     public List<Point> getPoints() {
         return points;
     }
diff --git a/src/main/java/domain/dto/ResponseLadder.java b/src/main/java/domain/dto/ResponseLadder.java
@@ -0,0 +1,16 @@
+package domain.dto;
+
+import domain.ladder.Ladder;
+import java.util.List;
+
+public record ResponseLadder(
+        List<ResponseLine> lines
+) {
+
+    public static ResponseLadder from(final Ladder ladder) {
+        List<ResponseLine> lines = ladder.getLines().stream()
+                .map(ResponseLine::from)
+                .toList();
+        return new ResponseLadder(lines);
+    }
+}
diff --git a/src/main/java/domain/dto/ResponseLadderResult.java b/src/main/java/domain/dto/ResponseLadderResult.java
@@ -0,0 +1,20 @@
+package domain.dto;
+
+import domain.Width;
+import domain.ladder.Ladder;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public record ResponseLadderResult(
+        List<String> results
+) {
+
+    private static final String LADDER_RESULT_ARROW = " -> ";
+
+    public static ResponseLadderResult of(final Ladder ladder, final Width width) {
+        List<String> result = IntStream.range(0, width.value())
+                .mapToObj(start -> start + LADDER_RESULT_ARROW + ladder.move(start))
+                .toList();
+        return new ResponseLadderResult(result);
+    }
+}
diff --git a/src/main/java/domain/dto/ResponseLine.java b/src/main/java/domain/dto/ResponseLine.java
@@ -0,0 +1,18 @@
+package domain.dto;
+
+import domain.Line;
+import domain.Point;
+import java.util.List;
+
+public record ResponseLine(
+        List<Boolean> connections
+) {
+
+    public static ResponseLine from(final Line line) {
+        List<Boolean> connections = line.getPoints().stream()
+                .limit(line.getPoints().size() - 1)
+                .map(Point::right)
+                .toList();
+        return new ResponseLine(connections);
+    }
+}
diff --git a/src/main/java/domain/ladder/Ladder.java b/src/main/java/domain/ladder/Ladder.java
@@ -1,7 +1,9 @@
 package domain.ladder;
 
+import domain.Direction;
 import domain.Line;
 import domain.Width;
+import java.util.Collections;
 import java.util.List;
 import java.util.stream.IntStream;
 
@@ -10,7 +12,7 @@ public class Ladder {
     private final List<Line> lines;
 
     private Ladder(final List<Line> lines) {
-        this.lines = List.copyOf(lines);
+        this.lines = lines;
     }
 
     public static Ladder from(final List<Line> lines) {
@@ -27,7 +29,16 @@ private boolean isConnectedBetween(final int index) {
                 .anyMatch(line -> line.hasConnectionAt(index));
     }
 
+    public int move(final int startIndex) {
+        int position = startIndex;
+        for (Line line : lines) {
+            Direction direction = line.directionAt(position);
+            position = direction.moveFrom(position);
+        }
+        return position;
+    }
+
     public List<Line> getLines() {
-        return lines;
+        return Collections.unmodifiableList(lines);
     }
 }
diff --git a/src/main/java/view/OutputView.java b/src/main/java/view/OutputView.java
@@ -1,13 +1,13 @@
 package view;
 
-import domain.Line;
-import domain.Point;
-import domain.ladder.Ladder;
-import java.util.List;
+import domain.dto.ResponseLadder;
+import domain.dto.ResponseLadderResult;
+import domain.dto.ResponseLine;
 
 public final class OutputView {
 
     private static final String LADDER_RESULT_TITLE = "실행결과";
+
     private static final String BLANK = "     ";
     private static final String VERTICAL = "|";
     private static final String HORIZONTAL = "-----";
@@ -21,29 +21,36 @@ public static void printLadderResultTitle() {
         System.out.println();
     }
 
-    public static void drawLadder(final Ladder ladder) {
-        for (Line line : ladder.getLines()) {
+    public static void drawLadder(final ResponseLadder ladder) {
+        for (ResponseLine line : ladder.lines()) {
             drawLine(line);
         }
     }
 
-    private static void drawLine(final Line line) {
+    private static void drawLine(final ResponseLine line) {
         StringBuilder builder = new StringBuilder();
         builder.append(BLANK);
 
-        List<Point> points = line.getPoints();
-        for (int i = 0; i < points.size() - 1; i++) {
+        for (boolean connected : line.connections()) {
             builder.append(VERTICAL);
-            builder.append(drawHorizontalIfConnected(points.get(i)));
+            builder.append(drawHorizontalIfConnected(connected));
         }
+
         builder.append(VERTICAL);
         System.out.println(builder);
     }
 
-    private static String drawHorizontalIfConnected(final Point point) {
-        if (point.right()) {
+    private static String drawHorizontalIfConnected(final boolean connected) {
+        if (connected) {
             return HORIZONTAL;
         }
         return BLANK;
     }
+
+    public static void printLadderResult(final ResponseLadderResult result) {
+        System.out.println();
+        for (String line : result.results()) {
+            System.out.println(line);
+        }
+    }
 }
diff --git a/src/test/java/domain/LineTest.java b/src/test/java/domain/LineTest.java
@@ -28,6 +28,33 @@ void shouldGeneratePoint_whenGivenWidth() {
                 .containsExactly(true, false, true, false);
     }
 
+    @Test
+    @DisplayName("특정 위치에 연결이 있는지 확인한다.")
+    void shouldCheckCorrectConnection() {
+        // given
+        LineGenerator generator = new FixedLineGenerator(List.of(new boolean[]{true, false, true}));
+        Line line = generator.generate(3);
+
+        // when & then
+        assertThat(line.hasConnectionAt(0)).isTrue();
+        assertThat(line.hasConnectionAt(1)).isFalse();
+        assertThat(line.hasConnectionAt(2)).isTrue();
+    }
+
+    @Test
+    @DisplayName("특정 위치에서 이동 방향을 올바르게 반환한다.")
+    void shouldReturnCorrectDirection() {
+        // given
+        LineGenerator generator = new FixedLineGenerator(List.of(new boolean[]{true, false, true, false}));
+        Line line = generator.generate(4);
+
+        // when & then
+        assertThat(line.directionAt(0)).isEqualTo(Direction.RIGHT);
+        assertThat(line.directionAt(1)).isEqualTo(Direction.LEFT);
+        assertThat(line.directionAt(2)).isEqualTo(Direction.RIGHT);
+        assertThat(line.directionAt(3)).isEqualTo(Direction.LEFT);
+    }
+
     @Test
     @DisplayName("반환된 리스트는 수정 불가능하다.")
     void shouldReturnUnmodifiableList() {
diff --git a/src/test/java/domain/ladder/LadderTest.java b/src/test/java/domain/ladder/LadderTest.java
