[사다리 - 4단계] 정민주 미션 제출합니다.

README.md

@@ -9,6 +9,10 @@
 - 사다리의 크기를 입력받아 생성할 수 있다.
 ### step3
 - 사다리를 보여준 후 결과를 출력한다.
+### step4
+- 사다리 게임에 참여하는 사람에 이름을 최대 5글자까지 부여할 수 있다. 사다리를 출력할 때 사람 이름도 같이 출력한다.
+- 사람 이름은 쉼표(,)를 기준으로 구분한다.
+- 개인별 이름을 입력하면 개인별 결과를 출력하고, "all"을 입력하면 전체 참여자의 실행 결과를 출력한
 
 **📠 도메인 분석 내용**
 - 사용자는 "참여 인원 수"를 입력한다 (네이버엔 구현되어있지만 실행예시엔 해당 없음)
@@ -47,23 +51,38 @@
 
 ## 실행결과
 ```
-사다리의 넓이는 몇 개인가요?
-4
+참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)
+neo,brown,brie,tommy
 
-사다리의 높이는 몇 개인가요?
+실행 결과를 입력하세요. (결과는 쉼표(,)로 구분하세요)
+꽝,5000,꽝,3000
+
+최대 사다리 높이는 몇 개인가요?
 5
 
-실행결과
+사다리 결과
 
+  neo brown brie  tommy
     |-----|     |-----|
     |     |-----|     |
     |-----|     |     |
     |     |-----|     |
     |-----|     |-----|
-
-0 -> 0
-1 -> 3
-2 -> 2
-3 -> 1
+    꽝 5000      꽝 3000
+
+결과를 보고 싶은 사람은?
+neo
+
+실행 결과
+꽝
+
+결과를 보고 싶은 사람은?
+all
+
+실행 결과
+neo : 꽝
+brown : 3000
+brie : 꽝
+tommy : 5000
 
 ```

src/main/java/controller/LadderGameController.java

@@ -4,6 +4,8 @@
 import domain.Height;
 import domain.Ladder;
 import domain.RungsBuilder;
+import java.util.List;
+import java.util.Map;
 import service.LadderService;
 import view.InputView;
 import view.OutputView;
@@ -21,24 +23,38 @@ public LadderGameController(RungsBuilder rungsBuilder) {
     }
 
     public void start() {
-        CountOfLine countOfLine = getcountOfLine();
+        List<String> names = getNames();
+        List<String> outcomes = getOutcomes();
+        CountOfLine countOfLine = laddersService.getcountOfLine(names, outcomes);
         Height height = getHeight();
 
-        Ladder ladder = laddersService.createLadder(countOfLine, height);
-        outputView.printStatusOfLadders(ladder.getRightRungStatus(), height.value());
-        outputView.printResult(ladder.getResult());
+        Ladder ladder = laddersService.createLadder(countOfLine, height, names, outcomes);
+        outputView.printStatusOfLadders(names, outcomes, ladder.getRightRungStatus(), height.value());
+        printResult(ladder.getResult());
     }
 
-    private CountOfLine getcountOfLine() {
-        outputView.printInputCountOfLineGuide();
-        final int valueOfCountOfLine = inputView.getUserIntegerInput();
-        return new CountOfLine(valueOfCountOfLine);
+    private List<String> getNames() {
+        outputView.printInputNamesGuide();
+        return inputView.getStringList();
     }
 
+    private List<String> getOutcomes() {
+        outputView.printInputOutcomesGuid();
+        return inputView.getStringList();
+    }
+
+
     private Height getHeight() {
         outputView.printInputHeightGuide();
         final int valueOfHeight = inputView.getUserIntegerInput();
         return new Height(valueOfHeight);
     }
 
+    private void printResult(Map<String, String> result) {
+        outputView.printInputTargetName();
+        final String targetName = inputView.getString();
+        final Map<String, String> resultToPrint = laddersService.getResultToPrint(result, targetName);
+        outputView.printResult(resultToPrint);
+    }
+
 }

src/main/java/domain/Ladder.java

@@ -1,7 +1,9 @@
 package domain;
 
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.IntStream;
 import util.Errors;
 
@@ -30,9 +32,9 @@ private void validateLaddersHeight(List<Line> lines) {
     }
 
     private void validatePointStatus(List<Line> lines) {
-        for (int index = 0; index < lines.size()-1; index++) {
+        for (int index = 0; index < lines.size() - 1; index++) {
             Line nowLine = lines.get(index);
-            Line nextLine = lines.get(index+1);
+            Line nextLine = lines.get(index + 1);
             validateRungInSamePosition(nowLine, nextLine);
         }
     }
@@ -60,13 +62,15 @@ public int getHeight() {
         return this.lines.get(0).getHeight();
     }
 
-    public List<Integer> getResult() {
-        List<Integer> result = new ArrayList<>();
+    public Map<String, String> getResult() {
+        Map<String, String> result = new LinkedHashMap<>();
         int height = this.getHeight();
 
         for (int nowIndex = 0; nowIndex < lines.size(); nowIndex++) {
             int finalIndex = calculateTargetIndex(nowIndex, height);
-            result.add(finalIndex);
+            final String name = getNameOfLine(nowIndex);
+            final String outcome = getOutcomeOfLine(finalIndex);
+            result.put(name, outcome);
         }
         return result;
     }
@@ -89,4 +93,12 @@ private int getNextIndex(int currentIndex, int position) {
         }
         return currentIndex;
     }
+
+    private String getNameOfLine(int index) {
+        return lines.get(index).getName();
+    }
+
+    private String getOutcomeOfLine(int index) {
+        return lines.get(index).getOutcome();
+    }
 }

src/main/java/domain/Line.java

@@ -6,28 +6,34 @@
 
 public class Line {
 
+    private final String name;
+    private final String outcome;
+
     private final List<Point> points;
 
-    private Line(List<Point> points) {
+    private Line(String name, String outcome, List<Point> points) {
+        this.name = name;
+        this.outcome = outcome;
         this.points = points;
     }
 
-    public static Line of(List<Boolean> leftRungsStatus, List<Boolean> rightRungsStatus) {
+    public static Line of(String name, String outcome, List<Boolean> leftRungsStatus, List<Boolean> rightRungsStatus) {
         validateHeight(leftRungsStatus, rightRungsStatus);
 
         int maxPosition = leftRungsStatus.size();
         List<Point> points = new ArrayList<>();
         for (int position = 0; position < maxPosition; position++) {
             points.add(new Point(leftRungsStatus.get(position), rightRungsStatus.get(position)));
         }
-        return new Line(points);
+        return new Line(name, outcome, points);
     }
 
     private static void validateHeight(List<Boolean> leftRungsStatus, List<Boolean> rightRungsStatus) {
         if (leftRungsStatus.size() != rightRungsStatus.size()) {
             throw new IllegalArgumentException(Errors.RUNG_STATUS_LENGTH_MUST_MATCH);
         }
     }
+
     public List<Boolean> getRightStatus() {
         List<Boolean> rightStatus = new ArrayList<>();
         for (Point point : points) {
@@ -40,6 +46,14 @@ public int getHeight() {
         return this.points.size();
     }
 
+    public String getName() {
+        return name;
+    }
+
+    public String getOutcome() {
+        return outcome;
+    }
+
     public boolean isConnectedToLeftLineAt(int position) {
         final Point nowPoint = this.points.get(position);
         return nowPoint.isConnectedToLeftLadder();

src/main/java/service/LadderService.java

@@ -7,8 +7,10 @@
 import domain.RungsBuilder;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
+import util.Errors;
 
 public class LadderService {
 
@@ -18,17 +20,19 @@ public LadderService(RungsBuilder rungsBuilder) {
         this.rungsBuilder = rungsBuilder;
     }
 
-    public Ladder createLadder(CountOfLine countOfLine, Height height) {
-        final List<Line> lineCollection = createLineCollection(countOfLine, height);
+    public Ladder createLadder(CountOfLine countOfLine, Height height, List<String> names, List<String> outcomes) {
+        final List<Line> lineCollection = createLineCollection(countOfLine, height, names, outcomes);
         return new Ladder(lineCollection);
     }
 
-    private List<Line> createLineCollection(CountOfLine countOfLine, Height height) {
+    private List<Line> createLineCollection(CountOfLine countOfLine, Height height, List<String> names, List<String> outcomes) {
         final List<Line> lineCollection = new ArrayList<>();
 
         for (int index = 0; index < countOfLine.value(); index++) {
             final List<Boolean> prevLineRightStatus = getPrevLineRightStatus(lineCollection, index, height);
-            final Line nowLine = createNowLine(index, height, countOfLine, prevLineRightStatus);
+            final String name = names.get(index);
+            final String outcome = outcomes.get(index);
+            final Line nowLine = createNowLine(index, height, countOfLine, prevLineRightStatus, name, outcome);
             lineCollection.add(nowLine);
         }
         return lineCollection;
@@ -43,13 +47,13 @@ private List<Boolean> getPrevLineRightStatus(List<Line> lineCollection, int inde
     }
 
     private Line createNowLine(int index, Height height, CountOfLine countOfLine,
-                               List<Boolean> nowLineLeftStatus) {
+                               List<Boolean> nowLineLeftStatus, String name, String outcome) {
         final List<Boolean> nowLineRightStatus = createNowLineRightStatus(index, countOfLine, height,
                                                                           nowLineLeftStatus);
         if (index == 0) {
             nowLineLeftStatus = createEmptyStatus(height);
         }
-        return Line.of(nowLineLeftStatus, nowLineRightStatus);
+        return Line.of(name, outcome, nowLineLeftStatus, nowLineRightStatus);
     }
 
     private List<Boolean> createNowLineRightStatus(int index, CountOfLine countOfLine, Height height,
@@ -65,4 +69,34 @@ private List<Boolean> createEmptyStatus(Height height) {
             .mapToObj(i -> false)
             .collect(Collectors.toList());
     }
+
+    public Map<String, String> getResultToPrint(Map<String, String> result, String targetName) {
+        if (isAllMode(targetName)) {
+            return result;
+        }
+        validateTargetName(result, targetName);
+        return Map.of(targetName, result.get(targetName));
+    }
+
+    private boolean isAllMode(String targetName) {
+        return targetName.equals("all");
+    }
+
+    private void validateTargetName(Map<String, String> result, String targetName) {
+        if (!result.containsKey(targetName)) {
+            throw new IllegalArgumentException(Errors.TARGET_NAME_MUST_BE_IN_NAMES);
+        }
+    }
+
+    public CountOfLine getcountOfLine(List<String> names, List<String> outcomes) {
+        validateCountOfLine(names, outcomes);
+        final int valueOfCountOfLine = names.size();
+        return new CountOfLine(valueOfCountOfLine);
+    }
+
+    private void validateCountOfLine(List<String> names, List<String> outcomes) {
+        if (names.size() != outcomes.size()) {
+            throw new IllegalArgumentException(Errors.NAMES_AND_OUTCOMES_SIZE_IS_NOT_SAME);
+        }
+    }
 }

src/main/java/util/Errors.java

@@ -12,5 +12,7 @@ private Errors() {
     public static final String INPUT_IS_NOT_INTEGER = "정수가 입력되어야 합니다.";
     public static final String RUNG_STATUS_LENGTH_MUST_MATCH = "Line의 left rung status의 길이와 right rung status의 길이는 일치해야합니다.";
     public static final String ADJACENT_POINTER_STATUS_MATCH = "인접한 line의 경우 좌측 line의 pointe의 right status와 우측 line의 left status 값은 일치해야합니다.";
+    public static final String NAMES_AND_OUTCOMES_SIZE_IS_NOT_SAME = "참여할 사람의 수와 결과의 수는 동일해야합니다.";
+    public static final String TARGET_NAME_MUST_BE_IN_NAMES = "결과를 조회하고 싶은 이름이 참여자 명단에 없습니다.";
 
 }

src/main/java/view/InputView.java

@@ -1,6 +1,8 @@
 package view;
 
+import java.util.Arrays;
 import java.util.InputMismatchException;
+import java.util.List;
 import java.util.Scanner;
 import util.Errors;
 
@@ -17,5 +19,14 @@ public int getUserIntegerInput() {
         }
     }
 
+    public List<String> getStringList() {
+        final String input = getString();
+        return Arrays.asList(input.split(","));
+    }
+
+    public String getString() {
+        scanner = new Scanner(System.in);
+        return scanner.nextLine();
+    }
 
 }