Step2 PR 요청드립니다.

README.md

@@ -23,4 +23,15 @@
     * map(String::toLowerCase) 적용 -> forEach(System.out::println) 으로 출
 * [X] Optional 실습 1 : Optional을 활용해 조건에 따른 반환
 * [X] Optional 실습 2 : Optional에서 값을 반환
-* [X] Optional 실습 3 : Optional에서 exception 처리
+* [X] Optional 실습 3 : Optional에서 exception 처리
+
+# STEP 2
+* [X] 참여할 사람 명단 입력받기
+  * [X] 쉼표 구분자를 파싱하기
+* [X] 최대 사다리 높이 입력받기
+* [X] 실행결과 출력하기
+* [X] 사다리 만들기
+  * [X] 사다리 한 줄(Line) 만들기
+  * [X] 사다리 다리 구성하기 (Bridge)
+    * [X] 캐시 전략 사용하기
+  * [X] 사다리 다리 리스트 구성하기

src/main/java/nextstep/ladder/LadderApplication.java

@@ -0,0 +1,11 @@
+package nextstep.ladder;
+
+import nextstep.ladder.controller.LadderController;
+
+public class LadderApplication {
+
+    public static void main(String[] args) {
+        LadderController ladderController = new LadderController();
+        ladderController.game();
+    }
+}

src/main/java/nextstep/ladder/controller/LadderController.java

@@ -0,0 +1,22 @@
+package nextstep.ladder.controller;
+
+import nextstep.ladder.model.Ladder;
+import nextstep.ladder.model.Lines;
+import nextstep.ladder.model.LinesGenerator;
+import nextstep.ladder.model.Participants;
+import nextstep.ladder.view.InputView;
+import nextstep.ladder.view.OutputView;
+
+public class LadderController {
+
+    private final LinesGenerator linesGenerator = new LinesGenerator();
+
+    public void game() {
+        Participants participants = new Participants(InputView.inputGameParticipants());
+        int height = InputView.inputLadderHeight();
+        Lines lines = new Lines(linesGenerator.generatorLines(participants.getNumbersOfParticipants(), height));
+
+        Ladder ladder = new Ladder(participants, lines, height);
+        OutputView.printLadder(ladder);
+    }
+}

src/main/java/nextstep/ladder/model/Bridge.java

@@ -0,0 +1,41 @@
+package nextstep.ladder.model;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class Bridge {
+    private final boolean value;
+
+    private static final Map<Boolean, Bridge> cacheBridge = new HashMap<>();
+
+    static {
+        cacheBridge.put(Boolean.TRUE, new Bridge(true));
+        cacheBridge.put(Boolean.FALSE, new Bridge(false));
+    }
+
+    private Bridge(boolean value) {
+        this.value = value;
+    }
+
+    public static Bridge of(boolean value) {
+        return cacheBridge.get(value);
+    }
+
+    public boolean canCrossBridge() {
+        return value;
+    }
+
+    public Bridge next() {
+        if (this.value) {
+            return of(false);
+        }
+        return of(ThreadLocalRandom.current().nextBoolean());
+    }
+
+    public void compareToNextBridge(Bridge next) {
+        if (this.value && next.value) {
+            throw new IllegalArgumentException("연속해서 true인 Bridge가 있습니다.");
+        }
+    }
+}

src/main/java/nextstep/ladder/model/BridgesGenerator.java

@@ -0,0 +1,7 @@
+package nextstep.ladder.model;
+
+import java.util.List;
+
+public interface BridgesGenerator {
+    List<Bridge> generateBridges(Integer numbersOfPeople);
+}

src/main/java/nextstep/ladder/model/BridgesGeneratorByCreatingCandidates.java

@@ -0,0 +1,49 @@
+package nextstep.ladder.model;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class BridgesGeneratorByCreatingCandidates implements BridgesGenerator {
+
+    private static List<List<Bridge>> candidates = new ArrayList<>();
+
+    static void generateLadders(int numbersOfPeople) {
+        List<List<Bridge>> result = new ArrayList<>(List.of(List.of(Bridge.of(false)), List.of(Bridge.of(true))));
+
+        for (int i = 2; i < numbersOfPeople ; i++) {
+            result = dp(result);
+        }
+
+        candidates = result;
+    }
+
+    static List<List<Bridge>> dp(List<List<Bridge>> result) {
+        return result.stream()
+                .flatMap(ladder -> {
+                    List<Bridge> withFalse = new ArrayList<>(ladder);
+                    withFalse.add(Bridge.of(false));
+                    List<Bridge> withTrue = new ArrayList<>(ladder);
+                    if (!ladder.get(ladder.size() - 1).canCrossBridge()) {
+                        withTrue.add(Bridge.of(true));
+                        return Stream.of(withFalse, withTrue);
+                    }
+                    return Stream.of(withFalse);
+                })
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public List<Bridge> generateBridges(Integer numbersOfPeople) {
+        if (candidates.isEmpty()) {
+            generateLadders(numbersOfPeople);
+        }
+        Collections.shuffle(candidates);
+        return candidates.get(0);
+    }
+
+
+
+}

src/main/java/nextstep/ladder/model/BridgesGeneratorBySequentialRandom.java

@@ -0,0 +1,19 @@
+package nextstep.ladder.model;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class BridgesGeneratorBySequentialRandom implements BridgesGenerator {
+
+    @Override
+    public List<Bridge> generateBridges(Integer numbersOfPeople) {
+        List<Bridge> bridges = new LinkedList<>();
+        Bridge currentBridge = Bridge.of(ThreadLocalRandom.current().nextBoolean());
+        for (int i = 0; i < numbersOfPeople - 1; i++) {
+            bridges.add(currentBridge);
+            currentBridge = currentBridge.next();
+        }
+        return bridges;
+    }
+}

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

@@ -0,0 +1,31 @@
+package nextstep.ladder.model;
+
+public class Ladder {
+
+    private static final int MIN_HEIGHT = 1;
+
+    private final Participants participants;
+    private final Lines lines;
+    private final Integer height;
+
+    public Ladder(Participants participants, Lines lines, Integer height) {
+        validateHeight(height);
+        this.participants = participants;
+        this.lines = lines;
+        this.height = height;
+    }
+
+    private void validateHeight(Integer height) {
+        if (height < MIN_HEIGHT) {
+            throw new IllegalArgumentException("높이는 최소 1 이상이어야 합니다.");
+        }
+    }
+
+    public Participants getParticipants() {
+        return participants;
+    }
+
+    public Lines getLines() {
+        return lines;
+    }
+}

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

@@ -0,0 +1,45 @@
+package nextstep.ladder.model;
+
+import java.util.List;
+
+public class Line {
+
+    private static final Integer MIN_NUMBERS_OF_PEOPLE = 2;
+
+    private final List<Bridge> bridges;
+
+    public Line(Integer numbersOfPeople, List<Bridge> bridges) {
+        validateLine(numbersOfPeople, bridges);
+        this.bridges = bridges;
+    }
+
+    private void validateLine(Integer numbersOfPeople, List<Bridge> bridges) {
+        validateBridgeCount(numbersOfPeople, bridges);
+        validateContinuousTrueBridge(bridges);
+        validateNumbersOfPeople(numbersOfPeople);
+    }
+
+    private void validateBridgeCount(Integer numbersOfPeople, List<Bridge> bridges) {
+        if (bridges.size() != numbersOfPeople - 1) {
+            throw new IllegalArgumentException("다리의 개수는 사람의 수보다 1 작아야합니다");
+        }
+    }
+
+    private void validateContinuousTrueBridge(List<Bridge> bridges) {
+        bridges.stream()
+                .reduce((prevBridge, currentBridge) -> {
+                    prevBridge.compareToNextBridge(currentBridge);
+                    return currentBridge;
+                });
+    }
+
+    private void validateNumbersOfPeople(Integer numbersOfPeople) {
+        if (numbersOfPeople < MIN_NUMBERS_OF_PEOPLE) {
+            throw new IllegalArgumentException("사람은 최소 2명 이상이어야 합니다.");
+        }
+    }
+
+    public List<Bridge> getBridges() {
+        return bridges;
+    }
+}

src/main/java/nextstep/ladder/model/Lines.java

@@ -0,0 +1,16 @@
+package nextstep.ladder.model;
+
+import java.util.List;
+
+public class Lines {
+
+    private final List<Line> lines;
+
+    public Lines(List<Line> lines) {
+        this.lines = lines;
+    }
+
+    public List<Line> getLines() {
+        return lines;
+    }
+}

src/main/java/nextstep/ladder/model/LinesGenerator.java

@@ -0,0 +1,16 @@
+package nextstep.ladder.model;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class LinesGenerator {
+
+    private final BridgesGenerator bridgesGenerator = new BridgesGeneratorBySequentialRandom();
+
+    public List<Line> generatorLines(Integer numbersOfPeople, Integer height) {
+        return IntStream.range(0, height)
+                .mapToObj(index -> new Line(numbersOfPeople, bridgesGenerator.generateBridges(numbersOfPeople)))
+                .collect(Collectors.toList());
+    }
+}

src/main/java/nextstep/ladder/model/Participant.java

@@ -0,0 +1,24 @@
+package nextstep.ladder.model;
+
+public class Participant {
+
+    private static final Integer MIN_NAME_LENGTH = 1;
+    private static final Integer MAX_NAME_LENGTH = 5;
+
+    private final String name;
+
+    public Participant(String name) {
+        validateNameLength(name);
+        this.name = name;
+    }
+
+    private void validateNameLength(String name) {
+        if (name.length() < MIN_NAME_LENGTH || name.length() > MAX_NAME_LENGTH) {
+            throw new IllegalArgumentException("0글자 이하이거나 5글자를 초과하는 참가자 이름이 포함되어 있습니다.");
+        }
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/nextstep/ladder/model/Participants.java

@@ -0,0 +1,33 @@
+package nextstep.ladder.model;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Participants {
+
+    private static final String DELIMITER = ",";
+
+    private final List<Participant> participants;
+
+    public Participants(String inputParticipants) {
+        this.participants = createParticipants(parseInputParticipants(inputParticipants));
+    }
+
+    private List<String> parseInputParticipants(String inputParticipants) {
+        return List.of(inputParticipants.split(DELIMITER));
+    }
+
+    private List<Participant> createParticipants(List<String> inputParticipants) {
+        return inputParticipants.stream()
+                .map(Participant::new)
+                .collect(Collectors.toList());
+    }
+
+    public Integer getNumbersOfParticipants() {
+        return participants.size();
+    }
+
+    public List<Participant> getParticipants() {
+        return participants;
+    }
+}

src/main/java/nextstep/ladder/view/InputView.java

@@ -0,0 +1,17 @@
+package nextstep.ladder.view;
+
+import java.util.Scanner;
+
+public class InputView {
+    private static final Scanner scanner = new Scanner(System.in);
+
+    public static String inputGameParticipants() {
+        System.out.println("참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)");
+        return scanner.nextLine();
+    }
+
+    public static int inputLadderHeight() {
+        System.out.println("최대 사다리 높이는 몇 개인가요?");
+        return Integer.parseInt(scanner.nextLine());
+    }
+}