[java-onboarding-week-1] roki.kim(김경록) 과제 제출합니다.

src/main/java/onboarding/Problem1.java

@@ -1,10 +1,88 @@
 package onboarding;
 
+import java.util.ArrayList;
 import java.util.List;
 
 class Problem1 {
     public static int solution(List<Integer> pobi, List<Integer> crong) {
-        int answer = Integer.MAX_VALUE;
+        int answer = 0;
+
+        // 예외 처리 함수 호출
+        if (!isValidInput(pobi) || !isValidInput(crong)) {
+            return -1;
+        }
+
+        int pobiMaxScore = calculateMaxPageScore(pobi);
+        int crongMaxScore = calculateMaxPageScore(crong);
+        if (pobiMaxScore > crongMaxScore) return 1;
+        else if (pobiMaxScore < crongMaxScore) return 2;
+
         return answer;
     }
-}
+
+    // 예외 처리 함수
+    public static boolean isValidInput(List<Integer> pages) {
+        if (pages.size() != 2) {
+            return false;
+        }
+        int leftPage = pages.get(0);
+        int rightPage = pages.get(1);
+
+        // 페이지 번호가 범위를 벗어나는 경우
+        if (leftPage <= 1 || rightPage >= 400) {
+            return false;
+        }
+
+        // 페이지 순서가 잘못되었거나 차이가 1이 아닌 경우
+        if (rightPage <= leftPage || rightPage - leftPage != 1) {
+            return false;
+        }
+
+        // 왼쪽 페이지는 홀수, 오른쪽 페이지는 짝수이어야 함
+        if (leftPage % 2 != 1 || rightPage % 2 != 0) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public static List<Integer> splitDigits(int number) {
+        List<Integer> result = new ArrayList<>();
+
+        while (number > 0) {
+            result.add(0, number % 10);
+            number = number / 10;
+        }
+        return result;
+    }
+
+    public static Integer sumDigits(List<Integer> digits) {
+        int sum = 0;
+        for (int digit : digits) {
+            sum += digit;
+        }
+        return sum;
+    }
+
+    public static Integer multiplyDigits(List<Integer> digits) {
+        int product = 1;
+        for (int digit : digits) {
+            product *= digit;
+        }
+        return product;
+    }
+
+    public static Integer calculateMaxSumOrProduct(Integer page) {
+        List<Integer> pageDigits = splitDigits(page);
+        int sumOfDigits = sumDigits(pageDigits);
+        int productOfDigits = multiplyDigits(pageDigits);
+        return Math.max(sumOfDigits, productOfDigits);
+    }
+
+    public static Integer calculateMaxPageScore(List<Integer> user) {
+        int maxLeftPageScore = calculateMaxSumOrProduct(user.get(0));
+        int maxRightPageScore = calculateMaxSumOrProduct(user.get(1));
+
+        return Math.max(maxLeftPageScore, maxRightPageScore);
+    }
+}

src/main/java/onboarding/Problem2.java

@@ -2,7 +2,40 @@
 
 public class Problem2 {
     public static String solution(String cryptogram) {
-        String answer = "answer";
-        return answer;
+
+        // 길이 검증
+        if (cryptogram == null || cryptogram.length() < 1 || cryptogram.length() > 1000) {
+            return "error";
+        }
+        // 알파벳 소문자 검증
+        if (!cryptogram.matches("^[a-z]+$")) {
+            return "error";
+        }
+
+        StringBuilder sb = new StringBuilder(cryptogram);
+
+        while (true) {
+            boolean changed = false;
+            int count = 1;
+            for (int i = 0; i < sb.length() - 1; i++) {
+                if (sb.charAt(i) == sb.charAt(i + 1)) {
+                    count++;
+                    if(i + 1 == sb.length() - 1) {
+                        sb.delete(i - count + 2, sb.length());
+                        return sb.toString();
+                    }
+                } else {
+                    if (count > 1) {
+                        sb.delete(i - count + 1, i + 1);
+                        changed = true;
+                        i = Math.max(-1, i - count - 1); // 변경 후 이전 위치부터 다시 검사
+                    }
+                    count = 1;
+                }
+            }
+            if (!changed) break;
+        }
+
+        return sb.toString();
     }
 }

src/main/java/onboarding/Problem3.java

@@ -1,8 +1,26 @@
 package onboarding;
 
+import java.util.Arrays;
+import java.util.List;
+
 public class Problem3 {
     public static int solution(int number) {
         int answer = 0;
+        if(number < 1 || number > 10000) {
+            return -1;
+        }
+
+        List<Integer> clapNumbers = Arrays.asList(3, 6, 9);
+
+        for(int i = 1; i <= number; i++) {
+            List<Integer> digits = Problem1.splitDigits(i);
+            for (Integer digit : digits) {
+                if (clapNumbers.contains(digit)) {
+                    answer++;
+                }
+            }
+        }
+
         return answer;
     }
 }

src/main/java/onboarding/Problem4.java

@@ -1,8 +1,36 @@
 package onboarding;
 
 public class Problem4 {
+
+    private static final int LOWERCASE_TRANSFORM_BASE = 219;
+    private static final int UPPERCASE_TRANSFORM_BASE = 155;
+
     public static String solution(String word) {
         String answer = "";
+
+        if(word.length() < 1 || word.length() > 1000) {
+            return "error";
+        }
+
+        for(int i = 0; i < word.length(); i++) {
+            char c = word.charAt(i);
+
+            if(c == ' ') {
+                answer += ' ';
+                continue;
+            }
+
+            char newChar;
+            if(c >= 'a' && c <= 'z') { //소문자
+                newChar = (char) (LOWERCASE_TRANSFORM_BASE - c);
+            } else if (c >= 'A' && c <= 'Z') {  // 대문자 변환
+                newChar = (char) (UPPERCASE_TRANSFORM_BASE - c);
+            } else {
+                newChar = c;  // 알파벳이 아닌 경우 그대로 유지
+            }
+            answer += newChar;
+        }
+
         return answer;
     }
 }

src/main/java/onboarding/Problem5.java

@@ -1,11 +1,33 @@
 package onboarding;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
 public class Problem5 {
     public static List<Integer> solution(int money) {
-        List<Integer> answer = Collections.emptyList();
+
+        if (money < 1 || money > 1000000) {
+            return null;
+        }
+
+        List<Integer> answer = new ArrayList<>();
+        final List<Integer> moneyUnit = List.of(
+                50000,
+                10000,
+                5000,
+                1000,
+                500,
+                100,
+                50,
+                10,
+                1
+        );
+
+        for (int i = 0; i < moneyUnit.size(); i++) {
+            answer.add(money / moneyUnit.get(i));
+            money = money % moneyUnit.get(i);
+        }
         return answer;
     }
 }

src/main/java/onboarding/Problem6.java

@@ -1,10 +1,72 @@
 package onboarding;
 
+import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.List;
 
 public class Problem6 {
     public static List<String> solution(List<List<String>> forms) {
-        List<String> answer = List.of("answer");
+        List<String> answer = new ArrayList<>();
+        if (forms.size() < 1 || forms.size() > 10000) {
+            return null;
+        }
+
+        for (int i = 0; i < forms.size(); i++) {
+            String email = forms.get(i).get(0);
+            String name = forms.get(i).get(1);
+
+            if (!isValidEmail(email) || !isValidNickname(name) || answer.contains(email)) {
+                continue;
+            }
+
+            checkDuplicateSubstrings(forms, i, name, email, answer);
+        }
+
+        answer.sort(Comparator.naturalOrder());
         return answer;
     }
-}
+
+    private static void checkDuplicateSubstrings(List<List<String>> forms, int currentIndex, String currentName, String currentEmail, List<String> answer) {
+        for (int j = currentIndex + 1; j < forms.size(); j++) {
+            String compName = forms.get(j).get(1);
+            String compEmail = forms.get(j).get(0);
+
+            if (answer.contains(compEmail)) {
+                continue;
+            }
+
+            if (hasDuplicateSubstring(currentName, compName)) {
+                answer.add(compEmail);
+                if (!answer.contains(currentEmail)) {
+                    answer.add(currentEmail);
+                }
+            }
+        }
+    }
+
+    private static boolean hasDuplicateSubstring(String name1, String name2) {
+        for (int k = 0; k < name2.length() - 1; k++) {
+            String subString = name2.substring(k, k + 2);
+            if (name1.contains(subString)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean isValidEmail(String email) {
+        if (email.length() < 11 || email.length() >= 20) {
+            return false;
+        }
+        String emailPattern = "^[a-zA-Z0-9._%+-]+@email\\.com$";
+        return email.matches(emailPattern);
+    }
+
+    private static boolean isValidNickname(String name) {
+        if (name.length() < 1 || name.length() >= 20) {
+            return false;
+        }
+        String nicknamePattern = "^[가-힣]+$";
+        return name.matches(nicknamePattern);
+    }
+}