Step3 ladder execute

src/main/java/ladder/controller/LadderGame.java

@@ -0,0 +1,30 @@
+package ladder.controller;
+
+import ladder.domain.*;
+import ladder.view.Input;
+import ladder.view.Output;
+
+public class LadderGame {
+    public static void main(String[] args) {
+        UsersNameReader usersNameReader = Input.getUsersName();
+        Users users = usersNameReader.convertNamesToUsers();
+
+        ExpectingResultReader expectingResultReader =
+                ExpectingResultReader.newInstance(Input.getExectingResult());
+
+        LadderMaterial ladderMaterial = LadderMaterial.newInstance(users.getNumberOfUsers(), Input.getHeightOfLadder());
+        BridgeGenerator bridgeGenerator = BridgeGenerator.newInstance(ladderMaterial);
+        bridgeGenerator.create();
+
+        WinnerDTO winnerDto = WinnerDTO.newInstance();
+        winnerDto.add(users, expectingResultReader.convertToResultData(), bridgeGenerator.getBridgeStates());
+
+        WinningChecker winningChecker = WinningChecker.newInstance();
+        Winners winners = Winners.newInstance(winningChecker.checkWinners(winnerDto));
+
+        Output.showUserNames(users);
+        Output.showResult(bridgeGenerator.getBridgeStates());
+        Output.showExpecting(expectingResultReader.toString());
+        Output.showWinners(winners);
+    }
+}

src/main/java/ladder/domain/BridgeGenerator.java

@@ -0,0 +1,55 @@
+package ladder.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+public class BridgeGenerator {
+    private final LadderMaterial ladderParts;
+    private final List<Line> bridgeStates = new ArrayList<>();
+
+    public BridgeGenerator(LadderMaterial ladderParts) {
+        this.ladderParts = ladderParts;
+    }
+
+    public static BridgeGenerator newInstance(LadderMaterial ladderParts) {
+        return new BridgeGenerator(ladderParts);
+    }
+
+    public void create() {
+        for (int i = 0; i < ladderParts.getHeigthOfLadder(); i += 1) {
+            Line line = Line.newInstance(makeRandomStates());
+            bridgeStates.add(line);
+        }
+    }
+
+    private List<Boolean> makeRandomStates() {
+        Random random = new Random();
+
+        List<Boolean> states = new ArrayList<>();
+        for (int i = 0; i < ladderParts.getNumberOfUsers() - 1; i += 1) {
+            addState(random, states, i);
+        }
+
+        return states;
+    }
+
+    private void addState(Random random, List<Boolean> states, int index) {
+        if (states.size() == 0) {
+            states.add(random.nextInt() % 2 == 0);
+            return;
+        }
+
+        if (!states.get(index - 1)) {
+            states.add(random.nextInt() % 2 == 0);
+            return;
+        }
+
+        states.add(false);
+    }
+
+    public List<Line> getBridgeStates() {
+        return Collections.unmodifiableList(this.bridgeStates);
+    }
+}

src/main/java/ladder/domain/ExpectingResultReader.java

@@ -0,0 +1,28 @@
+package ladder.domain;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ExpectingResultReader {
+    private final String result;
+
+    public ExpectingResultReader(String result) {
+        this.result = result;
+    }
+
+    public static ExpectingResultReader newInstance(String result) {
+        return new ExpectingResultReader(result);
+    }
+
+    public List<Integer> convertToResultData() {
+        return Arrays.stream(this.result.replaceAll("꽝", "0").split(",")).mapToInt(Integer::parseInt).boxed().collect(Collectors.toList());
+    }
+
+    @Override
+    public String toString() {
+        String[] results = this.result.split(",");
+
+        return String.join("   ", results);
+    }
+}

src/main/java/ladder/domain/LadderMaterial.java

@@ -0,0 +1,23 @@
+package ladder.domain;
+
+public class LadderMaterial {
+    private final int numberOfUsers;
+    private final int heigthOfLadder;
+
+    public LadderMaterial(int numberOfUsers, int heigthOfLadder) {
+        this.numberOfUsers = numberOfUsers;
+        this.heigthOfLadder = heigthOfLadder;
+    }
+
+    public static LadderMaterial newInstance(int numberOfUsers, int heigthOfLadder) {
+        return new LadderMaterial(numberOfUsers, heigthOfLadder);
+    }
+
+    public int getNumberOfUsers() {
+        return this.numberOfUsers;
+    }
+
+    public int getHeigthOfLadder() {
+        return this.heigthOfLadder;
+    }
+}

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

@@ -0,0 +1,50 @@
+package ladder.domain;
+
+import java.util.List;
+
+public class Line {
+    private final List<Boolean> bridgeStates;
+
+    public static Line newInstance(List<Boolean> bridgeStates) {
+        return new Line(bridgeStates);
+    }
+
+    public Line(List<Boolean> bridgeStates) {
+        this.bridgeStates = bridgeStates;
+    }
+
+    public Boolean get(int index) {
+        return bridgeStates.get(index);
+    }
+
+    public int size() {
+        return bridgeStates.size();
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder result = new StringBuilder();
+
+        for (Boolean state : bridgeStates) {
+            appendColumn(result);
+            appendBridge(result, state);
+        }
+        appendColumn(result);
+
+        return "  " + String.valueOf(result);
+    }
+
+    private void appendColumn(StringBuilder result) {
+        result.append("|");
+    }
+
+    private void appendBridge(StringBuilder result, Boolean state) {
+        if (state) {
+            result.append("------");
+        }
+
+        if (!state) {
+            result.append("      ");
+        }
+    }
+}

src/main/java/ladder/domain/User.java

@@ -0,0 +1,25 @@
+package ladder.domain;
+
+public class User {
+    private final String name;
+    private final int MAX_NUMBER_OF_CHARACTERS = 5;
+
+    private User(String name) {
+        this.name = name;
+    }
+
+    public static User newInstance(String name) {
+        return new User(name);
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    @Override
+    public String toString() {
+        int blankCount = MAX_NUMBER_OF_CHARACTERS - name.length();
+
+        return " ".repeat(Math.max(0, blankCount)) + name;
+    }
+}

src/main/java/ladder/domain/Users.java

@@ -0,0 +1,33 @@
+package ladder.domain;
+
+import java.util.List;
+
+public class Users {
+    private final List<User> users;
+
+    private Users(List<User> users) {
+        this.users = users;
+    }
+
+    public static Users newInstance(List<User> users) {
+        return new Users(users);
+    }
+
+    public User get(int index) {
+        return this.users.get(index);
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder result = new StringBuilder();
+        for (User user : this.users) {
+            result.append(user.toString()).append("  ");
+        }
+
+        return result.toString();
+    }
+
+    public int getNumberOfUsers() {
+        return users.size();
+    }
+}

src/main/java/ladder/domain/UsersNameReader.java

@@ -0,0 +1,44 @@
+package ladder.domain;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class UsersNameReader {
+    private final String names;
+
+    private UsersNameReader(String names) {
+        this.validator(names);
+        this.names = names;
+    }
+
+    public static UsersNameReader newInstace(String names) {
+        return new UsersNameReader(names);
+    }
+
+    private void validator(String names) {
+        Optional<String> optNames = Optional.ofNullable(names);
+        if (optNames.isEmpty()) {
+            throw new IllegalArgumentException();
+        }
+
+        for (String name : names.split(",")) {
+            checkNameLength(name);
+        };
+    }
+
+    private void checkNameLength(String name) {
+        if (name.length() > 5 || name.length() < 1) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public Users convertNamesToUsers() {
+        List<User> userNames = Arrays.stream(this.names.split(","))
+                .map(User::newInstance)
+                .collect(Collectors.toList());
+
+        return Users.newInstance(userNames);
+    }
+}

src/main/java/ladder/domain/WinnerDTO.java

@@ -0,0 +1,31 @@
+package ladder.domain;
+
+import java.util.List;
+
+public class WinnerDTO {
+    private Users users;
+    private List<Integer> resultData;
+    private List<Line> bridgeStates;
+
+    public static WinnerDTO newInstance() {
+        return new WinnerDTO();
+    }
+
+    public void add(Users users, List<Integer> resultData, List<Line> bridgeStates) {
+        this.users = users;
+        this.resultData = resultData;
+        this.bridgeStates = bridgeStates;
+    }
+
+    public Users getUsers() {
+        return this.users;
+    }
+
+    public List<Integer> getResultData() {
+        return this.resultData;
+    }
+
+    public List<Line> getBridgeStates() {
+        return this.bridgeStates;
+    }
+}

src/main/java/ladder/domain/Winners.java

@@ -0,0 +1,19 @@
+package ladder.domain;
+
+import java.util.Map;
+
+public class Winners {
+    private final Map<String, Integer> winners;
+
+    public Winners(Map<String, Integer> winners) {
+        this.winners = winners;
+    }
+
+    public static Winners newInstance(Map<String, Integer> winners) {
+        return new Winners(winners);
+    }
+
+    public Map<String, Integer> getWinners() {
+        return this.winners;
+    }
+}