[1단계 - 사다리 생성] 페드로(류형욱) 미션 제출합니다

.gitignore

@@ -30,3 +30,5 @@ out/
 
 ### VS Code ###
 .vscode/
+
+.gitmessage.txt

docs/README.md

@@ -0,0 +1,41 @@
+## 주요 기능
+
+1. 참여할 사람 이름 입력
+2. 사다리 높이 입력
+3. 이름과 높이로 사다리 생성
+4. 실행 결과 출력
+
+### 참여할 사람 이름 입력
+- [x] 이름 입력 안내 문구 출력
+- [x] 사용자로부터 이름을 입력받는 기능
+- [x] `,` 를 기준으로 이름을 분할하는 기능
+- [x] 중복된 이름이 존재하는지 확인하는 기능
+
+### 사다리 높이 입력
+- [x] 높이 입력 안내 문구 출력
+- [x] 사용자로부터 사다리 높이를 입력받는 기능
+
+### 이름과 높이로 사다리 생성
+- [x] 지정된 높이와 폭의 사다리를 생성하는 기능
+- [x] 특정 위치에서 경로의 연결 여부를 랜덤하게 선택하는 기능
+- [x] 생성된 유효한 가로줄로 사다리를 구성하는 기능
+
+### 가로줄 생성
+- [x] 유효한 가로줄인지 검증하는 기능
+  - 한 가로줄 내에 연속된 경로가 없어야 한다.
+  - 오른쪽 경로 오른쪽에 항상 왼쪽 경로가 있어야 한다.
+  - 왼쪽 경로 왼쪽에 항상 오른쪽 경로가 있어야 한다.
+
+### 실행 결과 출력
+
+- [x] “실행 결과” 문구 출력
+- [x] 참여자 이름 출력
+- [x] 사다리 출력
+
+### 예외 처리
+
+- [x] 유효한 참여자 이름이 아닐 경우 예외 발생
+    - 이름의 길이는 1 이상 5이하여야 함
+    - 이름에 포함되는 문자는 영문자와 숫자만 허용함
+- [x] 유효한 사다리 높이가 아닐 경우 예외 발생
+    - 높이는 항상 자연수여야 함

src/main/java/ladder/Application.java

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

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

@@ -0,0 +1,40 @@
+package ladder.controller;
+
+import ladder.model.Ladder;
+import ladder.model.Players;
+import ladder.view.InputView;
+import ladder.view.OutputView;
+
+import java.util.List;
+
+public class LadderController {
+    private Players ladderPlayers;
+    private Ladder ladder;
+
+    public void start() {
+        init();
+        printResult();
+    }
+
+    private void init() {
+        ladderPlayers = Players.from(readPlayerNames());
+
+        int height = readLadderHeight();
+        int width = ladderPlayers.getSize();
+        ladder = Ladder.of(height, width);
+    }
+
+    private List<String> readPlayerNames() {
+        return InputView.inputPlayerNames();
+    }
+
+    private int readLadderHeight() {
+        return InputView.inputLadderHeight();
+    }
+
+    private void printResult() {
+        OutputView.printResultDescription();
+        OutputView.printPlayerNames(ladderPlayers.getPlayerNames());
+        OutputView.printLadder(ladder.toLineDtoList());
+    }
+}

src/main/java/ladder/dto/LineDto.java

@@ -0,0 +1,21 @@
+package ladder.dto;
+
+import ladder.model.Line;
+
+import java.util.List;
+
+public class LineDto {
+    private final List<Boolean> connected;
+
+    private LineDto(List<Boolean> connected) {
+        this.connected = connected;
+    }
+
+    public static LineDto from(Line line) {
+        return new LineDto(line.getConnected());
+    }
+
+    public List<Boolean> getConnected() {
+        return connected;
+    }
+}

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

@@ -0,0 +1,72 @@
+package ladder.model;
+
+import java.util.stream.IntStream;
+import ladder.dto.LineDto;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class Ladder {
+    private static final Random random = new Random();
+    private final List<Line> ladder;
+
+    private Ladder(List<Line> ladder) {
+        this.ladder = ladder;
+    }
+
+    public static Ladder of(int height, int width) {
+        validate(height, width);
+
+        List<Line> ladder = IntStream.range(0, height)
+                .mapToObj(idx -> new Line(makeRandomRow(width)))
+                .toList();
+
+        return new Ladder(ladder);
+    }
+
+    private static void validate(int height, int width) {
+        if (notNaturalNumber(height) || notNaturalNumber(width)) {
+            throw new IllegalArgumentException("사다리 높이와 너비는 자연수여야 합니다.");
+        }
+    }
+
+    private static boolean notNaturalNumber(int value) {
+        return value <= 0;
+    }
+
+    private static List<LadderPath> makeRandomRow(int width) {
+        List<LadderPath> randomPath = new ArrayList<>(generatePairableRandomPath(width));
+
+        if (randomPath.size() < width) {
+            randomPath.add(LadderPath.STAY);
+        }
+
+        return randomPath;
+    }
+
+    private static List<LadderPath> generatePairableRandomPath(int maxWidth) {
+        List<LadderPath> randomPathWithPair = new ArrayList<>();
+
+        while (randomPathWithPair.size() < maxWidth - 1) {
+            randomPathWithPair.addAll(generateRandomPath());
+        }
+
+        return randomPathWithPair;
+    }
+
+    private static List<LadderPath> generateRandomPath() {
+        boolean isConnectedPath = random.nextBoolean();
+
+        if (isConnectedPath) {
+            return List.of(LadderPath.RIGHT, LadderPath.LEFT);
+        }
+        return List.of(LadderPath.STAY);
+    }
+
+    public List<LineDto> toLineDtoList() {
+        return ladder.stream()
+                .map(LineDto::from)
+                .toList();
+    }
+}

src/main/java/ladder/model/LadderPath.java

@@ -0,0 +1,5 @@
+package ladder.model;
+
+public enum LadderPath {
+    STAY, LEFT, RIGHT;
+}

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

@@ -0,0 +1,56 @@
+package ladder.model;
+
+import java.util.List;
+import java.util.stream.IntStream;
+
+import static ladder.model.LadderPath.*;
+
+public class Line {
+    private final List<LadderPath> row;
+
+    public Line(List<LadderPath> row) {
+        validate(row);
+        this.row = row;
+    }
+
+    private void validate(List<LadderPath> row) {
+        if (isLeftOnFirst(row) || isRightOnEnd(row)) {
+            throw new IllegalArgumentException("유효한 가로줄이 아닙니다.");
+        }
+        if (!isLeftAlwaysExistAfterRight(row) || !isRightAlwaysExistBeforeLeft(row)) {
+            throw new IllegalArgumentException("유효한 가로줄이 아닙니다.");
+        }
+    }
+
+    private boolean isLeftOnFirst(List<LadderPath> row) {
+        return row.get(0) == LEFT;
+    }
+
+    private boolean isRightOnEnd(List<LadderPath> row) {
+        return row.get(row.size() - 1) == RIGHT;
+    }
+
+    private boolean isLeftAlwaysExistAfterRight(List<LadderPath> row) {
+        return IntStream.range(0, row.size())
+                .filter(idx -> row.get(idx).equals(RIGHT))
+                .map(idx -> idx + 1)
+                .allMatch(idx -> row.get(idx).equals(LEFT));
+    }
+
+    private boolean isRightAlwaysExistBeforeLeft(List<LadderPath> row) {
+        return IntStream.range(0, row.size())
+                .filter(idx -> row.get(idx).equals(LEFT))
+                .map(idx -> idx - 1)
+                .allMatch(idx -> row.get(idx).equals(RIGHT));
+    }
+
+    public int size() {
+        return row.size();
+    }
+
+    public List<Boolean> getConnected() {
+        return IntStream.range(0, row.size() - 1)
+                .mapToObj(idx -> row.get(idx).equals(RIGHT))
+                .toList();
+    }
+}

src/main/java/ladder/model/Player.java

@@ -0,0 +1,41 @@
+package ladder.model;
+
+public class Player {
+    private static final int MAX_NAME_LENGTH = 5;
+    private static final String NAME_PATTERN = "^[a-zA-Z0-9]*$";
+
+    private final String name;
+
+    public Player(String name) {
+        validate(name);
+        this.name = name;
+    }
+
+    private void validate(String name) {
+        if (isNameLengthLongerThanMaxLength(name)) {
+            throw new IllegalArgumentException("이름의 길이는 5를 초과할 수 없다.");
+        }
+        if (isNameEmpty(name)) {
+            throw new IllegalArgumentException("이름이 비어 있습니다.");
+        }
+        if (!isNameFormatValid(name)) {
+            throw new IllegalArgumentException("이름은 영문자와 숫자로 구성되어야 합니다.");
+        }
+    }
+
+    private boolean isNameLengthLongerThanMaxLength(String name) {
+        return name.length() > MAX_NAME_LENGTH;
+    }
+
+    private boolean isNameEmpty(String name) {
+        return name.isEmpty();
+    }
+
+    private boolean isNameFormatValid(String name) {
+        return name.matches(NAME_PATTERN);
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/ladder/model/Players.java

@@ -0,0 +1,40 @@
+package ladder.model;
+
+import java.util.HashSet;
+import java.util.List;
+
+public class Players {
+    private final List<Player> players;
+
+    private Players(List<Player> players) {
+        this.players = players;
+    }
+
+    public static Players from(List<String> playerNames) {
+        validate(playerNames);
+        return new Players(playerNames.stream()
+                .map(Player::new)
+                .toList()
+        );
+    }
+
+    private static void validate(List<String> playerNames) {
+        if (isDuplicated(playerNames)) {
+            throw new IllegalArgumentException("중복되는 이름이 존재합니다.");
+        }
+    }
+
+    private static boolean isDuplicated(List<String> playerNames) {
+        return new HashSet<>(playerNames).size() != playerNames.size();
+    }
+
+    public int getSize() {
+        return players.size();
+    }
+
+    public List<String> getPlayerNames() {
+        return players.stream()
+                .map(Player::getName)
+                .toList();
+    }
+}

src/main/java/ladder/utils/ConsoleReader.java

@@ -0,0 +1,20 @@
+package ladder.utils;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class ConsoleReader {
+    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+
+    private ConsoleReader() {
+    }
+
+    public static String readLine() {
+        try {
+            return br.readLine();
+        } catch (IOException e) {
+            throw new IllegalArgumentException("입력 받는 중 예외가 발생했습니다.");
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+package ladder.view;
+
+import java.util.List;
+import ladder.utils.ConsoleReader;
+
+public class InputView {
+    private static final String INPUT_NAME_DESCRIPTION = "참여할 사람 이름을 입력하세요. (이름은 쉼표(,)로 구분하세요)";
+    private static final String INPUT_HEIGHT_DESCRIPTION = "최대 사다리 높이는 몇 개인가요?";
+    private static final String NAME_DELIMITER = ",";
+
+    private InputView() {
+    }
+
+    public static List<String> inputPlayerNames() {
+        System.out.println(INPUT_NAME_DESCRIPTION);
+        String rawNames = ConsoleReader.readLine();
+
+        return List.of(rawNames.split(NAME_DELIMITER));
+    }
+
+    public static int inputLadderHeight() {
+        System.out.println(INPUT_HEIGHT_DESCRIPTION);
+        return Integer.parseInt(ConsoleReader.readLine());
+    }
+}