Step3

src/main/java/nextstep/ladder/Main.java

@@ -1,15 +1,29 @@
 package nextstep.ladder;
 
-import nextstep.ladder.domain.Ladder;
+import nextstep.ladder.domain.*;
 import nextstep.ladder.view.InputView;
 import nextstep.ladder.view.ResultView;
 
 public class Main {
     public static void main(String[] args) {
         InputView inputView = new InputView();
 
-        Ladder ladder = new Ladder(inputView.people(), inputView.height());
-        ResultView.printResult(ladder);
+        People people = inputView.people();
+        ExecuteResults executeResults = inputView.executeResults();
+        InputOutput inputOutput = new InputOutput(people, executeResults);
+
+        int verticalLineCount = people.value().size();
+        int height = inputView.height();
+
+        Ladder ladder = new Ladder(verticalLineCount, height);
+
+        ResultView.printLadder(inputOutput, ladder);
+
+        Match match = new Match(inputOutput, ladder);
+        Result result = match.makeResult();
+        String person = inputView.person();
+
+        ResultView.printResult(result, person);
 
         inputView.close();
     }

src/main/java/nextstep/ladder/README.md

@@ -11,6 +11,19 @@
     -[x] 라인을 생성 할지/말지 판단하는 1/2 랜덤 함수 사용
     -[x] 가로 라인 확인 (겹치지 않기 위해)
 -[x] 사다리(Ladder) 객체 구현
--[ ] 실행결과 출력
+-[x] 실행결과 출력
     - [x] 이름 출력
     - [x] 사다리 출력
+
+## 3단계 - 사다리(게임 실행)
+
+-[x] 실행 결과 입력 추가 (,로 구분)
+    - [x] 입력받은 실행 결과 수와 참여할 사람 이름의 수가 불일치 할 경우 예외처리
+-[x] 사다리 출력시 입력 받은 실행 결과를 포함하여 출력
+-[x] 사다리 결과 로직 구현
+-[x] 결과를 보고 싶은 사람 입력
+- all 아닐 경우
+- [x] 입력받은 결과를 보고 싶은 사람의 실행 결과 출력
+- [x] 입력 받은 사람 이름이 참여할 사람 이름 목록에 없을 경우 예외처리
+- all 일 경우
+- [x] 모든 사람의 실행 결과 출력

src/main/java/nextstep/ladder/domain/ExecuteResult.java

@@ -0,0 +1,25 @@
+package nextstep.ladder.domain;
+
+public class ExecuteResult {
+    private static final int NAME_LENGTH_MAX = 5;
+
+    private final String name;
+
+    public ExecuteResult(String name) {
+        if (name.length() > NAME_LENGTH_MAX) {
+            throw new IllegalArgumentException("글자수는 최대 5글자까지 부여할 수 있습니다.");
+        }
+        this.name = name;
+    }
+
+    public String name() {
+        return this.name;
+    }
+
+    @Override
+    public String toString() {
+        return "ExecuteResult{" +
+                "name='" + name + '\'' +
+                '}';
+    }
+}

src/main/java/nextstep/ladder/domain/ExecuteResults.java

@@ -0,0 +1,23 @@
+package nextstep.ladder.domain;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ExecuteResults {
+
+    private final List<ExecuteResult> executeResults;
+
+    public ExecuteResults(String[] executeResults) {
+        if (executeResults.length == 0) {
+            throw new IllegalStateException("실행 결과가 입력되지 않았습니다.");
+        }
+        this.executeResults = Arrays.stream(executeResults).
+                map(ExecuteResult::new).
+                collect(Collectors.toList());
+    }
+
+    public List<ExecuteResult> value() {
+        return executeResults;
+    }
+}

src/main/java/nextstep/ladder/domain/InputOutput.java

@@ -0,0 +1,23 @@
+package nextstep.ladder.domain;
+
+public class InputOutput {
+
+    private final People people;
+    private final ExecuteResults executeResults;
+
+    public InputOutput(People people, ExecuteResults executeResults) {
+        if (people.value().size() != executeResults.value().size()) {
+            throw new IllegalArgumentException("참여할 사람 수와 실행 결과 수는 일치해야 합니다.");
+        }
+        this.people = people;
+        this.executeResults = executeResults;
+    }
+
+    public People people() {
+        return people;
+    }
+
+    public ExecuteResults executeResults() {
+        return executeResults;
+    }
+}

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

@@ -2,29 +2,63 @@
 
 import java.util.List;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 public class Ladder {
 
-    private final People people;
+    private static final int BEGIN_INDEX = 0;
+
+    private final int verticalLineCount;
     private final Lines lines;
 
-    public Ladder(People people, int height) {
-        this.people = people;
-        this.lines = new Lines(generateLadder(height));
+    public Ladder(int verticalLineCount, Lines lines) {
+        this.verticalLineCount = verticalLineCount;
+        this.lines = lines;
     }
 
-    private List<Line> generateLadder(int height) {
-        return Stream.generate(() -> new Line(people.value().size()))
-                .limit(height)
-                .collect(Collectors.toList());
+    public Ladder(int verticalLineCount, int height) {
+        this(verticalLineCount, new Lines(generateLines(verticalLineCount, height)));
     }
 
-    public People people() {
-        return people;
+    private static List<Line> generateLines(int verticalLineCount, int height) {
+        return Stream.generate(() -> new Line(verticalLineCount))
+                .limit(height)
+                .collect(Collectors.toList());
     }
 
     public Lines lines() {
         return lines;
     }
+
+    public String[][] result() {
+        List<Line> lines = this.lines.value();
+
+        int width = verticalLineCount * 2 - 1;
+        int height = this.lines.value().size();
+
+        String[][] ladder = new String[height][width];
+
+        IntStream.range(BEGIN_INDEX, height)
+                .forEach(i -> IntStream.range(BEGIN_INDEX, width)
+                        .forEach(j -> {
+                            if (isVerticalLine(j)) {
+                                ladder[i][j] = "v";
+                                return;
+                            }
+                            if (isHorizontalLine(lines, i, j)) {
+                                ladder[i][j] = "h";
+                            }
+                        }));
+        return ladder;
+    }
+
+    private boolean isVerticalLine(int j) {
+        return j % 2 == 0;
+    }
+
+    private Boolean isHorizontalLine(List<Line> lines, int i, int j) {
+        return lines.get(i).value().get((j - 1) / 2);
+    }
+
 }

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

@@ -10,44 +10,47 @@ public class Line {
     private static final boolean EMPTY_POINT = false;
     private static final double HALF = 0.5;
 
-    private final List<Boolean> points;
+    private final List<Boolean> horizontalLines;
 
-    public Line(int countOfPerson) {
-        points = generateLine(countOfPerson);
+    public Line(List<Boolean> horizontalLines) {
+        this.horizontalLines = horizontalLines;
     }
 
-    public List<Boolean> generateLine(int countOfPerson) {
-        List<Boolean> points = new ArrayList<>();
+    public Line(int countOfPerson) {
+        this(generateLine(countOfPerson));
+    }
 
-        IntStream.range(BEGIN_INDEX, countOfPerson)
-                .forEach(idx -> points.add(createPoint(idx, points)));
+    public static List<Boolean> generateLine(int countOfPerson) {
+        List<Boolean> horizontalLines = new ArrayList<>();
 
-        return points;
+        IntStream.range(BEGIN_INDEX, countOfPerson - 1)
+                .forEach(idx -> horizontalLines.add(createPoint(idx, horizontalLines)));
+        return horizontalLines;
     }
 
-    private Boolean createPoint(int idx, List<Boolean> points) {
+    private static Boolean createPoint(int idx, List<Boolean> horizontalLines) {
         if (BEGIN_INDEX == idx) {
-            return EMPTY_POINT;
+            return isCurrPointNonEmpty();
         }
-        return isPrevPointEmpty(idx, points) && isCurrPointNonEmpty();
+        return isPrevPointEmpty(idx, horizontalLines) && isCurrPointNonEmpty();
     }
 
-    private boolean isPrevPointEmpty(int idx, List<Boolean> points) {
-        return EMPTY_POINT == points.get(idx - 1);
+    private static boolean isPrevPointEmpty(int idx, List<Boolean> horizontalLines) {
+        return EMPTY_POINT == horizontalLines.get(idx - 1);
     }
 
-    private boolean isCurrPointNonEmpty() {
+    private static boolean isCurrPointNonEmpty() {
         return HALF < Math.random();
     }
 
-    public List<Boolean> points() {
-        return points;
+    public List<Boolean> value() {
+        return horizontalLines;
     }
 
     @Override
     public String toString() {
         return "Line{" +
-                "points=" + points +
+                "horizontalLines=" + horizontalLines +
                 '}';
     }
 }

src/main/java/nextstep/ladder/domain/Match.java

@@ -0,0 +1,61 @@
+package nextstep.ladder.domain;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Match {
+
+    private static final int BEGIN_IDX = 0;
+
+    private final InputOutput inputOutput;
+    private final Ladder ladder;
+
+    public Match(InputOutput inputOutput, Ladder ladder) {
+        this.inputOutput = inputOutput;
+        this.ladder = ladder;
+    }
+
+    public Match(Ladder ladder) {
+        this(null, ladder);
+    }
+
+    public Result makeResult() {
+        List<Person> people = inputOutput.people().value();
+        List<ExecuteResult> executeResults = inputOutput.executeResults().value();
+
+        return new Result(IntStream.range(BEGIN_IDX, people.size())
+                .boxed()
+                .collect(Collectors.toMap(i -> people.get(i).name(), i -> executeResults.get(findOutputIdx(i)).name(),
+                        (v1, v2) -> v1, LinkedHashMap::new)));
+    }
+
+    int findOutputIdx(int startIdx) {
+        int currentIdx = startIdx * 2;
+        String[][] ladder = this.ladder.result();
+        int rowCount = ladder.length;
+        int columnLength = ladder[BEGIN_IDX].length;
+
+        currentIdx = IntStream.range(BEGIN_IDX, rowCount)
+                .reduce(currentIdx, (idx, i) -> {
+                    String[] row = ladder[i];
+                    if (isMovableToLeft(idx, row)) {
+                        return idx - 2;
+                    }
+                    if (isMovableToRight(idx, row, columnLength)) {
+                        return idx + 2;
+                    }
+                    return idx;
+                });
+        return currentIdx / 2;
+    }
+
+    private boolean isMovableToLeft(int idx, String[] row) {
+        return idx > BEGIN_IDX && "h".equals(row[idx - 1]);
+    }
+
+    private boolean isMovableToRight(int idx, String[] row, int columnLength) {
+        return idx < columnLength - 1 && "h".equals(row[idx + 1]);
+    }
+}

src/main/java/nextstep/ladder/domain/Person.java

@@ -1,5 +1,7 @@
 package nextstep.ladder.domain;
 
+import java.util.Objects;
+
 public class Person {
 
     private static final int NAME_LENGTH_MAX = 5;
@@ -17,6 +19,19 @@ public String name() {
         return this.name;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Person person = (Person) o;
+        return Objects.equals(name, person.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name);
+    }
+
     @Override
     public String toString() {
         return "Person{" +

src/main/java/nextstep/ladder/domain/Result.java

@@ -0,0 +1,23 @@
+package nextstep.ladder.domain;
+
+import java.util.Map;
+
+public class Result {
+
+    private final Map<String, String> result;
+
+    public Result(Map<String, String> result) {
+        this.result = result;
+    }
+
+    public String get(String person) {
+        if (result.get(person) == null) {
+            throw new IllegalArgumentException("해당하는 사람이 존재하지 않습니다.");
+        }
+        return result.get(person);
+    }
+
+    public Map<String, String> value() {
+        return this.result;
+    }
+}