[BE] 나아연 👥 오늘의 짝꿍은?

docs/README.md

@@ -0,0 +1,31 @@
+## 📑 기능 요구 사항
+
+**입력**
+
+- [x] 참석자들의 이름을 입력 받는다
+    - [x] `,` 로 구분한다.
+    - [x] 한글이 아니라면 예외가 발생한다.
+    - [x] 이름은 중복될 수 없다.
+- [x] 최대 짝(그룹) 인원 수를 입력 받는다.
+    - [x] 숫자가 아니라면 예외가 발생한다.
+    - [x] 이름 수 < 최대 짝(그룹) 인원 수인 경우 예외가 발생한다.
+- [x] 재추천 여부를 입력 받는다.
+    - [x] `y` 또는 `n` 가 아니라면 예외가 발생한다.
+
+**출력**
+
+- [x] 짝 추천 결과를 출력한다
+    - [x] `[ 이름1 | ... | 이름2 ]` 형식으로 출력한다.
+- [x] 예외는 `[ERROR]`와 메시지를 함께 출력한다.
+
+**사람**
+
+- [x] 이름은 5글자 이내이다.
+
+**짝**
+
+- [x] 최대 짝 수는 사람 수보다 작거나 같아야 한다.
+
+**매칭**
+
+- [x] 랜덤으로 매칭한다.

src/main/java/leets/leets_mate/LeetsMateApplication.java

@@ -1,42 +1,11 @@
 package leets.leets_mate;
 
-import java.util.*;
+import leets.leets_mate.controller.Computer;
 
 public class LeetsMateApplication {
 
-    // 동작 함수입니다.
-    public void run() {
-    }
-
-    // 문자열로된 멤버들을 리스트로 분리하는 함수입니다.
-    public List<String> parseMembers(String members) {
-        return new ArrayList<>();
-    }
-
-    // 총 멤버수를 반환합니다.
-    public int memberNumber(List<String> members) {
-        return 0;
-    }
-
-    // 멤버 문자열에 영어가 있는지 검사합니다. 영어가 있다면 예외 출력
-    public void checkHasNoEnglish(String members) {
-    }
-
-    // 멤버수와 최대 짝수 데이터가 유효한지 검사하는 함수입니다. 유효하지 않다면 예외 출력
-    public void checkDataValidity(int memberCount, int maximumGroupSize) {
-    }
-
-    // 랜덤 짝꿍 추첨하는 함수 입니다.
-    public List<List<String>> generateRandomGroups(List<String> memberList, int maximumGroupSize) {
-        return new ArrayList<>();
-    }
-
-    // 결과를 프린트 하는 함수입니다.
-    public void printResult(List<List<String>> result) {
-    }
-
     public static void main(String[] args) {
-        LeetsMateApplication app = new LeetsMateApplication();
-        app.run();
+        Computer computer = new Computer();
+        computer.run();
     }
 }

src/main/java/leets/leets_mate/controller/Computer.java

@@ -0,0 +1,69 @@
+package leets.leets_mate.controller;
+
+import leets.leets_mate.domain.*;
+import leets.leets_mate.view.InputView;
+import leets.leets_mate.view.OutputView;
+
+import java.util.List;
+
+public class Computer {
+
+    private final InputView inputView = new InputView();
+    private final OutputView outputView = new OutputView();
+
+    public void run() {
+        outputView.printStartNotice();
+        Names names = readNames();
+        PairCount pairCount = readPairCount(names.countNames());
+
+        PairMatcher pairMatcher = new PairMatcher(pairCount, new RandomNumbersGenerator());
+        matchPairs(pairMatcher, names);
+        outputView.printEndNotice();
+    }
+
+    private void matchPairs(PairMatcher pairMatcher, Names names) {
+        List<Pair> pairs = pairMatcher.match(names);
+        printPairMatchResult(pairs);
+
+        RetryOpinion retryOpinion = readRetry();
+        if (retryOpinion.isContinue()) {
+            outputView.printBreakLine();
+            matchPairs(pairMatcher, names);
+        }
+    }
+
+    private void printPairMatchResult(List<Pair> pairs) {
+        outputView.printPairMatchResultNotice();
+        pairs.forEach(pair -> outputView.printPairMatchResult(pair.names()));
+        outputView.printPairMatchFinishNotice();
+    }
+
+    private Names readNames() {
+        List<String> rawNames = inputView.readNames();
+        try {
+            List<Name> names = rawNames.stream()
+                    .map(Name::new)
+                    .toList();
+            return new Names(names);
+        } catch (IllegalArgumentException e) {
+            outputView.printError(e.getMessage());
+            return readNames();
+        }
+    }
+
+    private PairCount readPairCount(int namesCount) {
+        int pairCount = inputView.readPairCount();
+        try {
+            new PairCountValidator().validate(pairCount, namesCount);
+            return new PairCount(pairCount);
+        } catch (IllegalArgumentException e) {
+            System.out.println(e.getMessage());
+            return readPairCount(namesCount);
+        }
+    }
+
+    private RetryOpinion readRetry() {
+        String input = inputView.readRetry();
+        return RetryOpinion.match(input);
+    }
+}

src/main/java/leets/leets_mate/domain/Name.java

@@ -0,0 +1,39 @@
+package leets.leets_mate.domain;
+
+import java.util.Objects;
+
+public class Name {
+
+    private static final int MAX_LENGTH = 5;
+    private static final String ERROR_FORMAT = "[ERROR] 이름은 %d자 이하여야 합니다.";
+
+    private final String name;
+
+    public Name(String name) {
+        validate(name);
+        this.name = name;
+    }
+
+    private void validate(String name) {
+        if (name.length() > MAX_LENGTH) {
+            throw new IllegalArgumentException(String.format(ERROR_FORMAT, MAX_LENGTH));
+        }
+    }
+
+    public String asString() {
+        return name;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Name name = (Name) o;
+        return Objects.equals(this.name, name.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name);
+    }
+}

src/main/java/leets/leets_mate/domain/Names.java

@@ -0,0 +1,50 @@
+package leets.leets_mate.domain;
+
+import java.util.List;
+import java.util.Objects;
+
+public class Names {
+
+    private static final int MIN_SIZE = 2;
+    private static final String ERROR_FORMAT = "[ERROR] 이름은 %d개 이상이어야 합니다.";
+
+    private final List<Name> names;
+
+    public Names(List<Name> names) {
+        validate(names);
+        this.names = names;
+    }
+
+    private void validate(List<Name> names) {
+        if (names.size() < MIN_SIZE) {
+            throw new IllegalArgumentException(String.format(ERROR_FORMAT, MIN_SIZE));
+        }
+    }
+
+    public int countNames() {
+        return names.size();
+    }
+
+    public List<Name> findByIndexes(List<Integer> indexes) {
+        return indexes.stream()
+                .map(names::get)
+                .toList();
+    }
+
+    public List<Name> findByIndexes(RandomNumbers randomNumbers) {
+        return randomNumbers.findNames(names);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Names names = (Names) o;
+        return Objects.equals(this.names, names.names);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(names);
+    }
+}

src/main/java/leets/leets_mate/domain/Pair.java

@@ -0,0 +1,32 @@
+package leets.leets_mate.domain;
+
+import java.util.List;
+import java.util.Objects;
+
+public class Pair {
+
+    private final List<Name> names;
+
+    public Pair(List<Name> names) {
+        this.names = names;
+    }
+
+    public List<String> names() {
+        return names.stream()
+                .map(Name::asString)
+                .toList();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Pair pair = (Pair) o;
+        return Objects.equals(names, pair.names);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(names);
+    }
+}

src/main/java/leets/leets_mate/domain/PairCount.java

@@ -0,0 +1,14 @@
+package leets.leets_mate.domain;
+
+public class PairCount {
+
+    private final int value;
+
+    public PairCount(int value) {
+        this.value = value;
+    }
+
+    public int value() {
+        return value;
+    }
+}

src/main/java/leets/leets_mate/domain/PairCountValidator.java

@@ -0,0 +1,13 @@
+package leets.leets_mate.domain;
+
+public class PairCountValidator {
+
+    private static final int MIN_COUNT = 2;
+    private static final String ERROR_FORMAT = "[ERROR] 최대 짝 수는 %d 이상, 이름 수 이하여야 합니다.";
+
+    public void validate(int maxCount, int namesCount) {
+        if (maxCount < MIN_COUNT || maxCount > namesCount) {
+            throw new IllegalArgumentException(String.format(ERROR_FORMAT, MIN_COUNT));
+        }
+    }
+}

src/main/java/leets/leets_mate/domain/PairMatcher.java

@@ -0,0 +1,23 @@
+package leets.leets_mate.domain;
+
+import java.util.List;
+
+public class PairMatcher {
+
+    private final PairCount pairCount;
+    private final RandomNumbersGenerator randomNumbersGenerator;
+
+    public PairMatcher(PairCount pairCount, RandomNumbersGenerator randomNumbersGenerator) {
+        this.pairCount = pairCount;
+        this.randomNumbersGenerator = randomNumbersGenerator;
+    }
+
+    public List<Pair> match(Names names) {
+        RandomNumbers randomNumbers = randomNumbersGenerator.randomNumbers(names.countNames());
+        List<RandomNumbers> splitRandomNumbers = randomNumbers.splitBySize(pairCount.value());
+        return splitRandomNumbers.stream()
+                .map(names::findByIndexes)
+                .map(Pair::new)
+                .toList();
+    }
+}

src/main/java/leets/leets_mate/domain/RandomNumbers.java

@@ -0,0 +1,27 @@
+package leets.leets_mate.domain;
+
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class RandomNumbers {
+
+    private final List<Integer> values;
+
+    public RandomNumbers(List<Integer> values) {
+        this.values = values;
+    }
+
+    public List<RandomNumbers> splitBySize(int size) {
+        int length = values.size();
+        return IntStream.iterate(0, i -> i < length, i -> i + size)
+                .mapToObj(i -> values.subList(i, Math.min(i + size, length)))
+                .map(RandomNumbers::new)
+                .toList();
+    }
+
+    public List<Name> findNames(List<Name> names) {
+        return values.stream()
+                .map(names::get)
+                .toList();
+    }
+}

src/main/java/leets/leets_mate/domain/RandomNumbersGenerator.java

@@ -0,0 +1,17 @@
+package leets.leets_mate.domain;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class RandomNumbersGenerator {
+
+    public RandomNumbers randomNumbers(int bound) {
+        List<Integer> randomNumbers = new ArrayList<>(IntStream.range(0, bound)
+                .boxed()
+                .toList());
+        Collections.shuffle(randomNumbers);
+        return new RandomNumbers(randomNumbers);
+    }
+}