[온보딩] - 박준수 Problem1 문제 제출합니다.

docs/PROBLEM1.md

@@ -23,3 +23,16 @@
 | [97, 98] | [197, 198] | 0 |
 | [131, 132] | [211, 212] | 1 |
 | [99, 102] | [211, 212] | -1 |
+
+## 기능 목록
+
+1. 페이지의 각 자리 합을 구하는 메서드
+2. 페이지의 각 자리 곱을 구하는 메서드
+3. 페이지의 연산 중 가장 큰 수를 구하는 메서드
+4. 포비와 크롱 중 점수를 비교해 승자를 구하는 메서드
+
+## 에러 처리
+
+1. 시작 면이나 마지막 면이 나오면 에러 발생
+2. 포비와 크롱의 길이는 무조건 2 / 아니었을 때 에러 발생
+3. 책 왼쪽, 오른쪽 페이지 불일치 에러 발생

docs/PROBLEM2.md

@@ -21,3 +21,14 @@
 | --- | --- |
 | "browoanoommnaon" | "brown" |
 | "zyelleyz" | "" |
+
+## 기능 목록
+
+1. String을 Stack으로 변경하는 메서드
+2. cryptogram에 중복된 문자열을 제거 메소드
+3. 결과 반환 메서드
+
+## 에러 처리
+
+1. cryptogram의 길이가 1이상 1000이하가 아니면 에러
+2. cryptogram이 소문자로만 이루어져 있지 않으면 에러

docs/PROBLEM3.md

@@ -14,3 +14,13 @@
 | --- | --- |
 | 13 | 4 |
 | 33 | 14 |
+
+## 기능 목록
+
+1. 1부터 숫자까지 반복해서 3, 6, 9가 들어있는 횟수를 반환하는 메소드
+2. 3,6,9 횟수 증가 메소드
+3. 문자열에 3, 6, 9가 있는지 판단하는 메소드
+
+## 에러 처리
+
+1. 숫자의 범위는 1부터 10,000 이하

docs/PROBLEM4.md

@@ -19,3 +19,13 @@
 | word | result |
 | --- | --- |
 | "I love you" | "R olev blf" |
+
+## 기능 목록
+
+1. 알파벳표를 반대 알파벳으로 매핑하는 메서드
+2. 알파벳 대소문자 판별 메서드
+3. 문제 결과를 반환하는 메서드
+
+## 에러 처리
+
+1. word의 길이 에러 처리

docs/PROBLEM6.md

@@ -21,3 +21,18 @@
 | forms | result |
 | --- | --- |
 | [ ["[email protected]", "제이엠"], ["[email protected]", "제이슨"], ["[email protected]", "워니"], ["[email protected]", "엠제이"], ["[email protected]", "이제엠"] ] | ["[email protected]", "[email protected]", "[email protected]"] |
+
+
+## 기능 목록
+
+1. 두 글자 이상 연속 판단 메서드
+2. 중복된 닉네임의 이메일을 저장하는 메서드
+3. 결과 오름차순 정렬 후 중복 제거 메서드
+
+## 에러 처리
+
+1. 크루의 개수 에러 처리
+2. 이메일 형식 에러 처리
+3. 이메일 길이 에러 처리
+4. 닉네임 길이 에러 처리
+5. 닉네임 한글 에러 처리

src/main/java/onboarding/Problem1.java

@@ -1,10 +1,29 @@
 package onboarding;
 
+
 import java.util.List;
+import java.util.stream.Stream;
+
+import static onboarding.problem1.util.ErrorHandler.isNotCorrectPage;
+import static onboarding.problem1.util.PageHandler.*;
+import static onboarding.problem1.util.findWinner.getWinner;
+
 
 class Problem1 {
+
+
+    public static final int isNotCorrectPage = -1;
+
+
     public static int solution(List<Integer> pobi, List<Integer> crong) {
-        int answer = Integer.MAX_VALUE;
-        return answer;
+
+        if (isNotCorrectPage(pobi) || isNotCorrectPage(crong)) {
+            return isNotCorrectPage;
+        }
+        int pobiMaxPage = getMaxPage(getPageSumMax(pobi), getPageMultiMax(pobi));
+        int crongMaxPage = getMaxPage(getPageSumMax(crong), getPageMultiMax(crong));
+
+        return getWinner(pobiMaxPage, crongMaxPage);
+
     }
 }

src/main/java/onboarding/Problem2.java

@@ -1,8 +1,51 @@
 package onboarding;
 
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.Objects;
+
+import static onboarding.problem2.CrypErrorHandler.checkCryptogram;
+
 public class Problem2 {
     public static String solution(String cryptogram) {
-        String answer = "answer";
-        return answer;
+
+        checkCryptogram(cryptogram);
+        Deque<Character> cryptogramStack = convertStringToStack(cryptogram);
+        Deque<Character> resultStack = removeDuplicateChar(cryptogramStack);
+
+        return resultPassword(resultStack);
+    }
+
+    private static Deque<Character> convertStringToStack(String cryptogram){
+        Deque<Character> stack = new ArrayDeque<Character>();
+        for (char word : cryptogram.toCharArray()){
+            stack.add(word);
+        }
+        return stack;
+    }
+
+    private static Deque<Character> removeDuplicateChar(Deque<Character> cryptogram) {
+        Deque<Character> resultStack = new ArrayDeque<Character>();
+        while (!cryptogram.isEmpty()){
+               Character word = cryptogram.removeFirst();
+               if (isDuplicate(resultStack, word)){
+                   resultStack.removeLast();
+                   continue;
+               }
+               resultStack.addLast(word);
+        }
+        return resultStack;
+    }
+
+    private static String resultPassword(Deque<Character> resultStack) {
+        StringBuilder password = new StringBuilder();
+        while (!resultStack.isEmpty()){
+            password.append(resultStack.removeFirst());
+        }
+        return password.toString();
+    }
+
+    private static boolean isDuplicate(Deque<Character> resultStack, Character word) {
+        return !resultStack.isEmpty() && Objects.equals(word, resultStack.peekLast());
     }
 }

src/main/java/onboarding/Problem3.java

@@ -1,8 +1,55 @@
 package onboarding;
 
+import java.util.stream.IntStream;
+
 public class Problem3 {
+
+    public static final String NUMBER_RANGE_ONE_TO_THOUSAND = "숫자의 범위는 1부터 10000 이하입니다.";
+    public static final char TREE = '3';
+    public static final char SIX = '6';
+    public static final char NINE = '9';
     public static int solution(int number) {
-        int answer = 0;
-        return answer;
+        validateNumberRange(number);
+        return getCount(number);
+    }
+
+    private static void validateNumberRange(int number) {
+        if (number < 1 || number > 10000){
+            throw new IllegalArgumentException(NUMBER_RANGE_ONE_TO_THOUSAND);
+        }
+    }
+
+    public static int getCount(int number){
+        int count = 0;
+        for (int i = 1; i <= number; i++){
+            String num = String.valueOf(i);
+            count = upCount(count, num);
+        }
+        return count;
+    }
+
+    private static int upCount(int count, String num) {
+        for (int j = 0; j < num.length(); j++){
+            if (isInclude369(num, j)){
+                count++;
+            }
+        }
+        return count;
+    }
+
+    private static boolean isInclude369(String num, int j) {
+        return num.charAt(j) == TREE || num.charAt(j) == SIX || num.charAt(j) == NINE;
     }
+
+
+    // 람다식으로 바꾸었을 때
+    public static int getResult(int number){
+        return IntStream.rangeClosed(1, number)
+                .mapToObj(String::valueOf)
+                .mapToInt(num -> Math.toIntExact(num.chars()
+                        .filter(ch -> ch == TREE || ch == SIX || ch == NINE)
+                        .count()))
+                .sum();
+    }
+
 }

src/main/java/onboarding/Problem4.java

@@ -1,8 +1,10 @@
 package onboarding;
 
+import onboarding.problem4.Sentence;
+
 public class Problem4 {
     public static String solution(String word) {
-        String answer = "";
-        return answer;
+        return new Sentence(word).getResult();
     }
+
 }

src/main/java/onboarding/Problem6.java

@@ -1,10 +1,12 @@
 package onboarding;
 
-import java.util.List;
+import onboarding.problem6.Crews;
+
+import java.util.*;
 
 public class Problem6 {
     public static List<String> solution(List<List<String>> forms) {
-        List<String> answer = List.of("answer");
-        return answer;
+        return new Crews(forms).getResultEmail();
     }
+
 }

src/main/java/onboarding/problem1/util/ErrorHandler.java

@@ -0,0 +1,35 @@
+package onboarding.problem1.util;
+
+import java.util.List;
+
+public final class ErrorHandler {
+
+    public static boolean validateLeftRightPage(List<Integer> user) {
+        if (user.get(0) == (user.get(1) - 1)) {
+            return true;
+        }
+        return false;
+    }
+
+    public static boolean validateStartOrEndPage(List<Integer> user) {
+        if (user.get(0) >= 1 && user.get(1) <= 400) {
+            return true;
+        }
+        return true;
+    }
+
+    public static boolean validatePageLength(List<Integer> user) {
+        if (user.size() == 2) {
+            return true;
+        }
+        return false;
+    }
+
+    public static boolean isNotCorrectPage(List<Integer> user) {
+        if (validateLeftRightPage(user) && validateStartOrEndPage(user) && validatePageLength(user)) {
+            return false;
+        }
+        return true;
+    }
+
+}

src/main/java/onboarding/problem1/util/PageHandler.java

@@ -0,0 +1,30 @@
+package onboarding.problem1.util;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+public final class PageHandler {
+    public static Stream<String> getPage(List<Integer> user) {
+        return user.stream().map(Object::toString);
+    }
+
+    public static int getPageSumMax(List<Integer> user) {
+        Stream<String> page = getPage(user);
+        return page.mapToInt(str -> str.chars()
+                        .map(Character::getNumericValue)
+                        .sum())
+                .max().orElseThrow(NullPointerException::new);
+    }
+
+    public static int getPageMultiMax(List<Integer> user) {
+        Stream<String> page = getPage(user);
+        return page.mapToInt(str -> str.chars()
+                        .map(Character::getNumericValue)
+                        .reduce(1, (a, b) -> a * b))
+                .max().orElseThrow(NullPointerException::new);
+    }
+
+    public static int getMaxPage(int pageSumMax, int pageMultiMax) {
+        return Math.max(pageSumMax, pageMultiMax);
+    }
+}

src/main/java/onboarding/problem1/util/findWinner.java

@@ -0,0 +1,32 @@
+package onboarding.problem1.util;
+
+public final class findWinner {
+    public static final int CRONG_WIN = 2;
+    public static final int POBI_WIN = 1;
+    public static final int NO_WINNER = 0;
+
+    public static int getWinner(int pobiMaxPage, int crongMaxPage) {
+        if (isPobiWin(pobiMaxPage, crongMaxPage))
+            return POBI_WIN;
+
+        if (isCrongWin(pobiMaxPage, crongMaxPage))
+            return CRONG_WIN;
+
+        return NO_WINNER;
+    }
+
+    public static boolean isPobiWin(int pobiMaxPage, int crongMaxPage) {
+        if (pobiMaxPage > crongMaxPage) {
+            return true;
+        }
+        return false;
+    }
+
+    public static boolean isCrongWin(int pobiMaxPage, int crongMaxPage) {
+        if (crongMaxPage > pobiMaxPage) {
+            return true;
+        }
+        return false;
+    }
+
+}

src/main/java/onboarding/problem2/CrypErrorHandler.java

@@ -0,0 +1,26 @@
+package onboarding.problem2;
+
+public final class CrypErrorHandler {
+
+    public final static String CRYP_LENGTH_IS_ONE_TO_HUND= "1이상 1000이하인 문자열이어야합니다.";
+    public final static String CRYP_COMPOSE_BY_SMALL_LETTER = "cryptogram은 소문자로만 이루어져 있습니다.";
+    private static void validateCrypLength(String cryptogram) {
+        if (cryptogram.length() < 1 || cryptogram.length() > 1000){
+            throw new IllegalArgumentException(CRYP_LENGTH_IS_ONE_TO_HUND);
+        }
+    }
+
+    private static void validateCrypSmallLetter(String cryptogram) {
+        for (char word : cryptogram.toCharArray()){
+            if (!Character.isLowerCase(word)){
+                throw new IllegalArgumentException(CRYP_COMPOSE_BY_SMALL_LETTER);
+            }
+        }
+    }
+
+    public static void checkCryptogram(String cryptogram){
+        validateCrypLength(cryptogram);
+        validateCrypSmallLetter(cryptogram);
+    }
+
+}