Step2, 3

build.gradle

@@ -9,6 +9,8 @@ repositories {
 }
 
 dependencies {
+    implementation 'org.projectlombok:lombok:1.18.26'
+    annotationProcessor 'org.projectlombok:lombok:1.18.26'
     testImplementation 'org.assertj:assertj-core:3.22.0'
     testImplementation 'org.junit.jupiter:junit-jupiter:5.8.2'
 }

src/main/java/nextstep/fp/Lambda.java

@@ -26,31 +26,10 @@ public void run() {
         }).start();
     }
 
-    public static int sumAll(List<Integer> numbers) {
-        int total = 0;
-        for (int number : numbers) {
-            total += number;
-        }
-        return total;
-    }
-
-    public static int sumAllEven(List<Integer> numbers) {
-        int total = 0;
-        for (int number : numbers) {
-            if (number % 2 == 0) {
-                total += number;
-            }
-        }
-        return total;
-    }
-
-    public static int sumAllOverThree(List<Integer> numbers) {
-        int total = 0;
-        for (int number : numbers) {
-            if (number > 3) {
-                total += number;
-            }
-        }
-        return total;
+    public static int sumAll(List<Integer> numbers, SumStrategy sumStrategy) {
+        return numbers.stream()
+                .filter(sumStrategy::option)
+                .mapToInt(value -> value)
+                .sum();
     }
 }

src/main/java/nextstep/fp/StreamStudy.java

@@ -5,6 +5,7 @@
 import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.util.Arrays;
+import java.util.Comparator;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -15,19 +16,21 @@ public static long countWords() throws IOException {
                 .get("src/main/resources/fp/war-and-peace.txt")), StandardCharsets.UTF_8);
         List<String> words = Arrays.asList(contents.split("[\\P{L}]+"));
 
-        long count = 0;
-        for (String w : words) {
-            if (w.length() > 12) count++;
-        }
-        return count;
+        return words.stream()
+                .filter(w -> w.length() > 12)
+                .count();
     }
 
     public static void printLongestWordTop100() throws IOException {
         String contents = new String(Files.readAllBytes(Paths
                 .get("src/main/resources/fp/war-and-peace.txt")), StandardCharsets.UTF_8);
         List<String> words = Arrays.asList(contents.split("[\\P{L}]+"));
 
-        // TODO 이 부분에 구현한다.
+        words.stream()
+                .filter(w -> w.length() > 12) // 단어 길이 12 이상
+                .sorted((o1, o2) -> o2.length() - o1.length()) // 긴 순서
+                .distinct()
+                .forEach(s -> System.out.println(s.toLowerCase()));
     }
 
     public static List<Integer> doubleNumbers(List<Integer> numbers) {
@@ -39,6 +42,9 @@ public static long sumAll(List<Integer> numbers) {
     }
 
     public static long sumOverThreeAndDouble(List<Integer> numbers) {
-        return 0;
+        return numbers.stream()
+                .filter(i -> i > 3)
+                .map(i -> 2 * i)
+                .reduce(0, (x, y) -> x + y);
     }
 }

src/main/java/nextstep/fp/SumStrategy.java

@@ -0,0 +1,5 @@
+package nextstep.fp;
+
+public interface SumStrategy {
+    boolean option(int number);
+}

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

@@ -0,0 +1,41 @@
+package nextstep.ladder;
+
+import nextstep.ladder.domain.Ladder;
+import nextstep.ladder.domain.LadderResults;
+import nextstep.ladder.domain.User;
+import nextstep.ladder.domain.Users;
+import nextstep.ladder.view.InputView;
+import nextstep.ladder.view.OutputView;
+
+import java.util.List;
+import java.util.Random;
+import java.util.stream.Collectors;
+
+public class LadderApplication {
+
+    public static void main(String[] args) {
+
+        List<String> names = InputView.inputUserNames();
+        Users users = new Users(names);
+
+        List<String> results = InputView.inputLadderResult();
+        LadderResults ladderResults = new LadderResults(results);
+
+        int height = InputView.inputLadderHeight();
+
+        Ladder ladder = Ladder.createLadder(users.getUsers().size(), height, () -> new Random().nextBoolean());
+        OutputView.display(users, ladder, ladderResults);
+
+        List<User> usersAfter = users.getUsers().stream()
+                .map(user -> user.rideLadder(ladder))
+                .collect(Collectors.toList());
+
+        String name = InputView.inputUserName();
+
+        if (name.equals("all")) {
+            OutputView.announceAllUsers(usersAfter, ladderResults);
+            return;
+        }
+        OutputView.announceUser(name, usersAfter, ladderResults);
+    }
+}

src/main/java/nextstep/ladder/domain/BridgeStrategy.java

@@ -0,0 +1,6 @@
+package nextstep.ladder.domain;
+
+@FunctionalInterface
+public interface BridgeStrategy {
+    Boolean bridgeBuild();
+}

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

@@ -0,0 +1,44 @@
+package nextstep.ladder.domain;
+
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+public class Ladder {
+    private List<Line> lines = new ArrayList<>();
+
+    public static Ladder createLadder(int countOfUsers, int height, BridgeStrategy strategy) {
+        return new Ladder(countOfUsers, height, strategy);
+    }
+
+    private Ladder(int countOfUsers, int height, BridgeStrategy strategy) {
+        for (int i = 0; i < height; i++) {
+            Line line = Line.createLine(countOfUsers, strategy);
+            lines.add(line);
+        }
+    }
+
+    public String status() {
+        String result = "";
+        int height = lines.size();
+        for (int i = 0; i < height; i++) {
+            Line line = lines.get(i);
+            result += line.status();
+        }
+        return result;
+    }
+
+    public int findLastPosition(int position) {
+        if (lines.isEmpty()) {
+            return position;
+        }
+
+        int currentPosition = position;
+        for (Line line : lines) {
+            currentPosition = line.getNextPosition(currentPosition);
+        }
+        return currentPosition;
+    }
+}

src/main/java/nextstep/ladder/domain/LadderResult.java

@@ -0,0 +1,10 @@
+package nextstep.ladder.domain;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class LadderResult {
+    private String result;
+}

src/main/java/nextstep/ladder/domain/LadderResults.java

@@ -0,0 +1,25 @@
+package nextstep.ladder.domain;
+
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+public class LadderResults {
+    private List<LadderResult> ladderResultList = new ArrayList<>();
+
+    public LadderResults(List<String> results) {
+        for (String result : results) {
+            ladderResultList.add(new LadderResult(result));
+        }
+    }
+
+    public String status() {
+        String result = "";
+        for (LadderResult ladderResult : ladderResultList) {
+            result += ladderResult.getResult() + " ";
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,109 @@
+package nextstep.ladder.domain;
+
+import lombok.Getter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+@Getter
+public class Line {
+
+    private List<Boolean> bridges = new ArrayList<>();
+
+    public static Line createLine(int countOfPerson, BridgeStrategy strategy) {
+        Line line = new Line(countOfPerson, strategy);
+        validate(line);
+        return line;
+    }
+
+    private static void validate(Line line) {
+        if (line.isInvalidBridge()) {
+            throw new RuntimeException("올바르지 않은 라인입니다.");
+        }
+    }
+
+    private Line(int countOfPerson, BridgeStrategy strategy) {
+        for (int i = 0; i < countOfPerson - 1; i++) {
+            Optional<Integer> prevIndex = Optional.ofNullable(i)
+                    .map(o -> o - 1);
+
+            Boolean expected = build(strategy);
+            bridges.add(decide(prevIndex, expected));
+        }
+    }
+
+    private static Boolean build(BridgeStrategy strategy) {
+        return strategy.bridgeBuild();
+    }
+
+    private Boolean decide(Optional<Integer> prevIndex, Boolean expected) {
+        return prevIndex.filter(i -> i >= 0)
+                .map(i -> bridges.get(i))
+                .map(b -> Boolean.TRUE.equals(b) ? Boolean.valueOf(false) : expected)
+                .orElse(expected);
+    }
+
+    public int getNextPosition(int position) {
+        // bridges[position - 1] == T 이면 왼쪽으로
+        Boolean toLeft = ableToLeft(position);
+
+        // bridges[position] == T 이면 오른쪽으로
+        Boolean toRight = ableToRight(position);
+
+        if (toLeft && toRight) {
+            throw new RuntimeException("사다리 상태를 다시 확인해주세요.");
+        }
+
+        if (toLeft) {
+            return position - 1;
+        }
+
+        if (toRight) {
+            return position + 1;
+        }
+
+        return position;
+    }
+
+    public Boolean ableToRight(int position) {
+        return Optional.ofNullable(position)
+                .filter(o -> o < bridges.size())
+                .map(o -> bridges.get(o))
+                .filter(b -> b)
+                .orElse(false);
+    }
+
+    public Boolean ableToLeft(int position) {
+        return Optional.ofNullable(position)
+                .map(o -> o - 1)
+                .filter(o -> o >= 0)
+                .map(o -> bridges.get(o))
+                .filter(b -> b)
+                .orElse(false);
+    }
+
+    public boolean isValidBridge() {
+        boolean valid = true;
+        for (int i = 0; i < bridges.size(); i++) {
+            if (ableToLeft(i) && ableToRight(i)) {
+                valid = false;
+            }
+        }
+        return valid;
+    }
+    public boolean isInvalidBridge() {
+        return !isValidBridge();
+    }
+
+
+    public String status() {
+        String result = "";
+        for (Boolean bridge : bridges) {
+            result += "|";
+            result += bridge ? "-----" : "     ";
+        }
+        result += "|\n";
+        return result;
+    }
+}

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

@@ -0,0 +1,31 @@
+package nextstep.ladder.domain;
+
+import lombok.Getter;
+
+@Getter
+public class User {
+    private String name;
+    private int position;
+
+
+    public User(String name, int position) {
+        validateName(name);
+
+        this.name = name;
+        this.position = position;
+    }
+
+    private static void validateName(String name) {
+        if (name.length() > 5) {
+            throw new IllegalArgumentException("이름은 5글자까지 가능합니다.");
+        }
+        if (name.equals("all")) {
+            throw new IllegalArgumentException("all은 부적절한 이름입니다.");
+        }
+    }
+
+    public User rideLadder(Ladder ladder) {
+        int lastPosition = ladder.findLastPosition(position);
+        return new User(name, lastPosition);
+    }
+}

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

@@ -0,0 +1,26 @@
+package nextstep.ladder.domain;
+
+import lombok.Getter;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Getter
+public class Users {
+    private List<User> users = new ArrayList<>();
+
+    public Users(List<String> names) {
+        for (int i = 0; i < names.size(); i++) {
+            User user = new User(names.get(i), i);
+            users.add(user);
+        }
+    }
+
+    public String status() {
+        String result = "";
+        for (User user : users) {
+            result += user.getName() + " ";
+        }
+        return result;
+    }
+}