[사다리 게임] 베디 미션 제출합니다

README.md

@@ -2,4 +2,70 @@
 사다리타기 미션 저장소
 
 ## 우아한테크코스 코드리뷰
-* [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+* [온라인 코드 리뷰 과정](https://github.com/woowacourse/woowacourse-docs/blob/master/maincourse/README.md)
+
+# 문자열 덧셈 계산기
+
+## 요구사항
+
+- 쉼표(,) 또는 콜론(:)을 구분자로 가지는 문자열을 전달하는 경우 구분자를 기준으로 분리한 각 숫자의 합을 반환 (예: “” => 0, "1,2" => 3, "1,2,3" => 6, “1,2:3” => 6)
+- 앞의 기본 구분자(쉼표, 콜론)외에 커스텀 구분자를 지정할 수 있다. 커스텀 구분자는 문자열 앞부분의 “//”와 “\n” 사이에 위치하는 문자를 커스텀 구분자로 사용한다. 예를 들어 “//;\n1;2;3”과 같이 값을 입력할 경우 커스텀 구분자는 세미콜론(;)이며, 결과 값은 6이 반환되어야 한다.
+- 문자열 계산기에 숫자 이외의 값 또는 음수를 전달하는 경우 RuntimeException 예외를 throw한다.
+
+## 기능
+
+- 구분자를 기준으로 숫자를 분리한다.
+- 커스텀 구분자를 기준으로 숫자를 분리한다.
+- 분리된 숫자들을 더해준다.
+- 숫자 이외의 값 또는 음수가 있을 경우 RuntimeException을 throw한다.
+
+# 사다리 게임 - 1단계
+
+## 요구사항
+
+- 사다리 게임에 참여하는 사람에 이름을 최대5글자까지 부여할 수 있다. 사다리를 출력할 때 사람 이름도 같이 출력한다.
+- 사람 이름은 쉼표(,)를 기준으로 구분한다.
+- 사람 이름을 5자 기준으로 출력하기 때문에 사다리 폭도 넓어져야 한다.
+- 사다리 타기가 정상적으로 동작하려면 라인이 겹치지 않도록 해야 한다.
+  - `|-----|-----|` 모양과 같이 가로 라인이 겹치는 경우 어느 방향으로 이동할지 결정할 수 없다
+
+## 필요한 기능
+
+- 문자열을 입력받아 객체를 생성
+  - 문자열을 입력받는다.
+  - 입력받은 문자열을 쉼표(',')를 기준으로 구분한다.
+  - 객체를 생성한다.
+  - 일급 컬렉션에 담아준다.
+- 사다리 높이를 입력받아 사다리를 만든다.
+  - 사다리 높이를 입력받는다.
+  - 사다리 높이 만큼 세로 라인 길이를 설정한다.
+  - 사람의 수 만큼 가로 라인을 설정한다.
+  - 겹치지 않게 가로 라인을 만든다.
+- 사다리를 출력해준다.
+
+## 가능한 예외
+
+문자열을 입력받아 객체를 생성
+
+- 문자열을 입력받아 객체를 생성
+  - 쉼표로 구분하지 않는 경우
+  - 구분된 문자열의 길이가 5를 초과하는 경우
+  - 문자열이 공백인 경우
+  - 문자열이 NULL인 경우
+- 사다리 높이를 입력받아 사다리를 만든다.
+  - 높이가 음수인 경우
+  - 가로라인이 연속되는 경우
+
+
+-----------------------------------------------
+
+1. 사람의 이름을 입력받는다.
+2. 입력 받은 이름을 컴마(,) 기준으로 나눠준다.
+3. 사람 객체를 생성한다.
+4. 사람 컨테이너 객체를 만든다. 
+5. 사다리의 높이를 입력 받는다.
+6. 사다리 객체를 사람수와 사다리 높이를 인자로 받아서 생성하다.
+7. 사다리 높이만큼 Line 클래스 리스트를 만들어준다.
+  1. Line은 가로라인을 boolean List로 가지고 있는다 (사람 수 - 1)
+  2. 가로 라인을 그어준다. 이 때 연속되면 안된다
+8. 사다리를 출력해준다.

src/main/java/calculator/Positive.java

@@ -0,0 +1,20 @@
+package calculator;
+
+public class Positive {
+    private final int number;
+
+    public Positive(final String number) {
+        this(Integer.parseInt(number));
+    }
+
+    public Positive(final int number) {
+        if (number < 0) {
+            throw new RuntimeException();
+        }
+        this.number = number;
+    }
+
+    int getNumber() {
+        return number;
+    }
+}

src/main/java/calculator/StringCalculator.java

@@ -0,0 +1,26 @@
+package calculator;
+
+public class StringCalculator {
+    static int calculate(String[] numbers) {
+        if (isValidSize(numbers)) {
+            return 0;
+        }
+        return plus(numbers);
+    }
+
+    private static boolean isValidSize(String[] numbers) {
+        return numbers == null || numbers.length == 0;
+    }
+
+    private static int plus(String[] numbers) {
+        int sum = 0;
+        for (String number : numbers) {
+            sum += toPositive(number).getNumber();
+        }
+        return sum;
+    }
+
+    private static Positive toPositive(String number) {
+        return new Positive(number);
+    }
+}

src/main/java/calculator/StringSplitter.java

@@ -0,0 +1,24 @@
+package calculator;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class StringSplitter {
+    private static final String CUSTOM_DELIMITER_REGEX = "//(.)\n(.*)";
+    private static final String DEFAULT_DELIMITER = ",|;";
+
+    static String[] split(String numbers) {
+        Matcher m = Pattern.compile(CUSTOM_DELIMITER_REGEX).matcher(numbers);
+
+        return m.find() ? splitCustom(m) : splitDefault(numbers);
+    }
+
+    private static String[] splitDefault(String numbers) {
+        return numbers.split(DEFAULT_DELIMITER);
+    }
+
+    private static String[] splitCustom(Matcher m) {
+        String customDelimiter = m.group(1);
+        return m.group(2).split(Pattern.quote(customDelimiter));
+    }
+}

src/main/java/ladder/LadderConsoleApp.java

@@ -0,0 +1,10 @@
+package ladder;
+
+import ladder.controller.LadderGameController;
+
+public class LadderConsoleApp {
+    public static void main(String[] args) {
+        LadderGameController ladderGameController = new LadderGameController();
+        ladderGameController.run();
+    }
+}

src/main/java/ladder/controller/LadderGameController.java

@@ -0,0 +1,45 @@
+package ladder.controller;
+
+import ladder.domain.*;
+import ladder.domain.generator.PlayerGenerator;
+import ladder.domain.generator.PlayerRewardsGenerator;
+import ladder.view.InputConsoleView;
+import ladder.view.OutputConsoleView;
+
+import java.util.List;
+
+public class LadderGameController {
+    public void run() {
+        GamePlayers gamePlayers = new GamePlayers(generatePlayers(inputNames()));
+        PlayerRewards playerRewards = generateRewards(inputRewards());
+        Ladder ladder = new Ladder(inputHeight(), gamePlayers.size());
+        GameResult gameResult = new GameResult(ladder, gamePlayers, playerRewards);
+
+        OutputConsoleView.printLadderGame(ladder, gamePlayers, playerRewards);
+        String name;
+        while (!(name = InputConsoleView.inputResultName()).equals("all")) {
+            OutputConsoleView.printResult(gameResult, name);
+        }
+        OutputConsoleView.printResult(gameResult);
+    }
+
+    private List<Player> generatePlayers(String names) {
+        return new PlayerGenerator(names).generate();
+    }
+
+    private String inputNames() {
+        return InputConsoleView.inputNames();
+    }
+
+    private int inputHeight() {
+        return InputConsoleView.inputHeight();
+    }
+
+    private String inputRewards() {
+        return InputConsoleView.inputRewards();
+    }
+
+    private PlayerRewards generateRewards(String results) {
+        return new PlayerRewardsGenerator(results).generate();
+    }
+}

src/main/java/ladder/domain/GamePlayers.java

@@ -0,0 +1,45 @@
+package ladder.domain;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public final class GamePlayers {
+    private final List<Player> players;
+
+    public GamePlayers(final List<Player> players) {
+        validate(players);
+        this.players = new ArrayList<>(players);
+    }
+
+    private void validate(List<Player> players) {
+        validateSize(players);
+        validateDuplication(players);
+    }
+
+    private void validateSize(List<Player> players) {
+        if (players.isEmpty()) {
+            throw new IllegalArgumentException("두 명 이상 입력 해주세요.");
+        }
+    }
+
+    private void validateDuplication(List<Player> players) {
+        Set<Player> set = new HashSet<>(players);
+        if (set.size() != players.size()) {
+            throw new IllegalArgumentException("이름 중복은 안됩니다.");
+        }
+    }
+
+    String getPlayerName(int index) {
+        return players.get(index).getName();
+    }
+
+    public int size() {
+        return players.size();
+    }
+
+    public List<Player> getPlayers() {
+        return players;
+    }
+}

src/main/java/ladder/domain/GameResult.java

@@ -0,0 +1,35 @@
+package ladder.domain;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class GameResult {
+    private final Map<String, String> results;
+
+    public GameResult(Ladder ladder, GamePlayers gamePlayers, PlayerRewards playerRewards) {
+        this.results = new HashMap<>();
+        init(ladder, gamePlayers, playerRewards);
+    }
+
+    private void init(Ladder ladder, GamePlayers gamePlayers, PlayerRewards playerRewards) {
+        validate(gamePlayers.size(), playerRewards.size());
+        for (int i = 0; i < gamePlayers.size(); i++) {
+            int result = ladder.moveLadder(i);
+            results.put(gamePlayers.getPlayerName(i), playerRewards.getReward(result));
+        }
+    }
+
+    private void validate(int countOfPlayers, int countOfRewards) {
+        if (countOfPlayers != countOfRewards) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public String get(String playerName) {
+        return results.get(playerName);
+    }
+
+    public Map<String, String> getAll() {
+        return new HashMap<>(results);
+    }
+}

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

@@ -0,0 +1,50 @@
+package ladder.domain;
+
+import ladder.domain.generator.LineGenerator;
+import ladder.domain.generator.LineRandomGenerator;
+
+import java.util.List;
+
+public final class Ladder {
+    private static final int MIN_HEIGHT = 1;
+    private static final int MIN_PLAYER_COUNT = 2;
+
+    private final List<Line> lines;
+
+    public Ladder(int height, int countOfPlayers) {
+        this(height, countOfPlayers, new LineRandomGenerator(countOfPlayers, height));
+    }
+
+    public Ladder(int height, int countOfPlayers, LineGenerator lineGenerator) {
+        validate(height, countOfPlayers);
+        this.lines = lineGenerator.generate();
+    }
+
+    private void validate(int height, int countOfPlayers) {
+        validateHeight(height);
+        validateCount(countOfPlayers);
+    }
+
+    private void validateHeight(int height) {
+        if (height < MIN_HEIGHT) {
+            throw new IllegalArgumentException("높이는 1이상 이어야 합니다.");
+        }
+    }
+
+    private void validateCount(int countOfPlayers) {
+        if (countOfPlayers < MIN_PLAYER_COUNT) {
+            throw new IllegalArgumentException("사람수는 2명 이상 이어야 합니다.");
+        }
+    }
+
+    public int moveLadder(int position) {
+        for (Line line : lines) {
+            position += line.move(position);
+        }
+        return position;
+    }
+
+    public List<Line> getLines() {
+        return lines;
+    }
+}