[java-onboarding-week-1] yohan.kim(김요한) 과제 제출합니다.

docs/기능목록.md

@@ -0,0 +1,26 @@
+## 기능 목록
+
+- [x] Problem1
+  - [x] 숫자를 입력받아, 각 자리수의 합, 곱 중 큰 수를 반환하는 함수 구현 - getMaxOfDigitSumAndMultiply()
+  - [x] 길이가 2인 리스트를 입력받아, 두 수에 대해 getMaxOfDigitSumAndMultiply 값이 큰 값 반환 - getScore()
+  - [x] pobi, crong의 getScore() 값 비교 후 result 값 결정 - solution()
+- [x] Problem2
+  - [x] 문자열을 입력받아, 연속하는 중복 문자들을 stack을 사용해 제거하는 함수 구현 - decode()
+- [x] Problem3
+  - [x] 1 ~ num (입력받은 수)까지 각 수마다 박수 값을 구해서 배열 반환 - countClap()
+  - [x] 1 ~ number까지 박수 값 더하기 - sumClap()
+- [x] Problem4
+  - [x] 문자를 대소문자 구분해 반대로 변환하는 함수 - reverseChar()
+  - [x] 문자열을 for문으로 돌면서, reverseChar로 변환한 문자열 반환 - reverseString()
+- [x] Problem5
+  - [x] 금액과 화폐 액수를 받아, 화폐 몇 개로 변환되는지 개수 반환 - getCount()
+  - [x] 오만원부터 일원까지 순서대로 금액을 화폐로 각 몇 개로 변환되는지 리스트로 반환 - getCounts()
+- [x] Problem6
+  - [x] 닉네임을 받아, 연속된 모든 두 글자 Set으로 반환 - getTwoLetters()
+  - [x] forms를 받아, 겹치는 닉네임을 가진 사람 이메일 Set을 반환 - getDuplicated()
+  - [x] Set을 받아, 오름차순으로 정렬된 리스트로 반환 - getSortedList()
+- [x] Problem7
+  - [x] 사용자별 친구 리스트를 저장한 맵 반환 - getFriends()
+  - [x] 유저 이름을 받아, 그의 친구의 친구를 탐색해 점수를 반영한 맵 반환 - getFriendsScore()
+  - [x] 점수 맵과 visitors를 받아, 점수 맵에 반영해 반환 - addVisitorsToScore()
+  - [x] 점수 맵을 받아, 추천 친구 리스트 반환 - getRecommend()

src/main/java/onboarding/Problem1.java

@@ -1,10 +1,64 @@
 package onboarding;
 
+import java.util.ArrayList;
 import java.util.List;
+import java.util.NoSuchElementException;
 
 class Problem1 {
     public static int solution(List<Integer> pobi, List<Integer> crong) {
-        int answer = Integer.MAX_VALUE;
-        return answer;
+
+        if (!isValid(pobi) || !isValid(crong)) {
+            return -1;
+        }
+
+        int pobiScore = getScore(pobi);
+        int crongScore = getScore(crong);
+
+        if (pobiScore > crongScore) {
+            return 1;
+        } else if (pobiScore < crongScore) {
+            return 2;
+        }
+        return 0;
+    }
+
+    private static boolean isValid(List<Integer> pages) {
+        return pages.size() == 2 && pages.get(0) == pages.get(1) - 1;
+    }
+
+    private static int getScore(List<Integer> pages) {
+        return pages.stream()
+                .map(Problem1::getMaxOfDigitSumAndMultiply)
+                .max(Integer::compareTo)
+                .orElseThrow(() -> new NoSuchElementException("동작 오류"));
+    }
+
+    private static int getMaxOfDigitSumAndMultiply(int num) {
+
+        List<Integer> digits = getDigits(num);
+
+        Integer sum = digits.stream()
+                .reduce(0, Integer::sum);
+        Integer multiply = digits.stream()
+                .reduce(1, (x, y) -> x * y);
+
+        return Integer.max(sum, multiply);
+    }
+
+    private static List<Integer> getDigits(int num) {
+
+        List<Integer> digits = new ArrayList<>();
+
+        int cur = num;
+        while (cur > 0) {
+            digits.add(0, cur % 10);
+            cur /= 10;
+        }
+
+        if (digits.isEmpty()) {
+            digits.add(0);
+        }
+
+        return digits;
     }
 }

src/main/java/onboarding/Problem2.java

@@ -1,8 +1,28 @@
 package onboarding;
 
+import java.util.Stack;
+import java.util.stream.Collectors;
+
 public class Problem2 {
     public static String solution(String cryptogram) {
-        String answer = "answer";
-        return answer;
+        return decode(cryptogram);
+    }
+
+    private static String decode(String cryptogram) {
+
+        Stack<Character> stack = new Stack<>();
+
+        for (char c: cryptogram.toCharArray()) {
+            if (stack.isEmpty() || c != stack.peek()) {
+                stack.push(c);
+                continue;
+            }
+
+            stack.pop();
+        }
+
+        return stack.stream()
+                .map(String::valueOf)
+                .collect(Collectors.joining());
     }
 }

src/main/java/onboarding/Problem3.java

@@ -1,8 +1,29 @@
 package onboarding;
 
+import java.util.Arrays;
+import java.util.List;
+
 public class Problem3 {
+
+    private final static List<Integer> special = List.of(3, 6, 9);
+
     public static int solution(int number) {
-        int answer = 0;
-        return answer;
+        return sumClap(countClap(number));
+    }
+
+    private static int sumClap(int[] counts) {
+        return Arrays.stream(counts).sum();
+    }
+
+    private static int[] countClap(int last) {
+
+        int[] counts = new int[last + 1];
+        for (int num = 1; num <= last; num++) {
+
+            int lastDigitCount = special.contains(num % 10) ? 1 : 0;
+            counts[num] = counts[num/10] + lastDigitCount;
+        }
+
+        return counts;
     }
 }

src/main/java/onboarding/Problem4.java

@@ -2,7 +2,27 @@
 
 public class Problem4 {
     public static String solution(String word) {
-        String answer = "";
-        return answer;
+        return reverseString(word);
+    }
+
+    private static String reverseString(String word) {
+
+        StringBuilder result = new StringBuilder();
+
+        for (char c: word.toCharArray()) {
+            result.append(reverseChar(c));
+        }
+        return result.toString();
+    }
+
+    private static char reverseChar(char c) {
+        if (Character.isLowerCase(c)) {
+            return (char) ('a' + 'z' - c);
+        }
+        if (Character.isUpperCase(c)) {
+            return (char) ('A' + 'Z' - c);
+        }
+
+        return c;
     }
 }

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 {
+
+    private final static List<Integer> currencies = List.of(50000, 10000, 5000, 1000, 500, 100, 50, 10, 1);
+
     public static List<Integer> solution(int money) {
-        List<Integer> answer = Collections.emptyList();
-        return answer;
+        return getCounts(money);
+    }
+
+    private static List<Integer> getCounts(int money) {
+
+        int currentMoney = money;
+
+        List<Integer> counts = new ArrayList<>();
+        for (int currency: currencies) {
+
+            int count = getCount(currentMoney, currency);
+
+            counts.add(count);
+            currentMoney -= count * currency;
+        }
+        return counts;
+    }
+
+    private static int getCount(int money, int currency) {
+        return money / currency;
     }
 }

src/main/java/onboarding/Problem6.java

@@ -1,10 +1,48 @@
 package onboarding;
 
-import java.util.List;
+import java.util.*;
+import java.util.stream.Collectors;
 
 public class Problem6 {
     public static List<String> solution(List<List<String>> forms) {
-        List<String> answer = List.of("answer");
-        return answer;
+        return getSortedList(getDuplicated(forms));
+    }
+
+    private static List<String> getSortedList(Set<String> set) {
+
+        List<String> collect = new ArrayList<>(set);
+
+        Collections.sort(collect);
+
+        return collect;
+    }
+
+    private static Set<String> getDuplicated(List<List<String>> forms) {
+
+        Set<String> duplicated = new HashSet<>();
+
+        Map<String, Set<String>> emailsPerTwoLetter = new HashMap<>();
+        for (List<String> form : forms) {
+            String email = form.get(0);
+            String nickName = form.get(1);
+
+            for (String letter : getTwoLetters(nickName)) {
+                if (!emailsPerTwoLetter.containsKey(letter)) {
+                    emailsPerTwoLetter.put(letter, new HashSet<>(){{add(email);}});
+                    continue;
+                }
+                emailsPerTwoLetter.get(letter).add(email);
+                duplicated.addAll(emailsPerTwoLetter.get(letter));
+            }
+        }
+        return duplicated;
+    }
+
+    private static Set<String> getTwoLetters(String nickName) {
+        Set<String> set = new HashSet<>();
+        for (int i = 0; i < nickName.length() - 1; i++) {
+            set.add(nickName.substring(i, i + 2));
+        }
+        return set;
     }
 }

src/main/java/onboarding/Problem7.java

@@ -1,11 +1,80 @@
 package onboarding;
 
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static java.util.Map.Entry.comparingByValue;
 
 public class Problem7 {
+
+    private final static int FRIEND_OF_FRIEND_SCORE = 10;
+
     public static List<String> solution(String user, List<List<String>> friends, List<String> visitors) {
-        List<String> answer = Collections.emptyList();
-        return answer;
+
+        Map<String, List<String>> friendsPerUser = getFriends(friends);
+
+        Map<String, Integer> friendsScore = getFriendsScore(user, friendsPerUser);
+        Map<String, Integer> friendsScoreWithVisitors = addVisitorsToScore(visitors, friendsScore);
+
+        return getRecommend(friendsScoreWithVisitors, friendsPerUser.getOrDefault(user, new ArrayList<>()));
+    }
+
+    private static List<String> getRecommend(Map<String, Integer> friendsScoreWithVisitors, List<String> userFriends) {
+        return friendsScoreWithVisitors.entrySet().stream()
+                .filter(e -> !userFriends.contains(e.getKey()))
+                .filter(e -> e.getValue() != 0)
+                .sorted(Problem7::compareToScore)
+                .map(Map.Entry::getKey)
+                .limit(5)
+                .collect(Collectors.toList());
+    }
+
+    private static int compareToScore(Map.Entry<String, Integer> e1, Map.Entry<String, Integer> e2) {
+        if (e1.getValue().equals(e2.getValue())) {
+            return e1.getKey().compareTo(e2.getKey());
+        }
+        return e2.getValue() - e1.getValue();
+    }
+
+    private static Map<String, Integer> addVisitorsToScore(List<String> visitors, Map<String, Integer> friendsScore) {
+        HashMap<String, Integer> friendsScoreWithVisitors = new HashMap<>(friendsScore);
+
+        for (String visitor : visitors) {
+            friendsScoreWithVisitors.put(visitor, friendsScoreWithVisitors.getOrDefault(visitor, 0) + 1);
+        }
+        return friendsScoreWithVisitors;
+    }
+
+    private static Map<String, Integer> getFriendsScore(String user, Map<String, List<String>> friendsPerUser) {
+        Map<String, Integer> score = new HashMap<>();
+
+        for (String friend: friendsPerUser.getOrDefault(user, new ArrayList<>())) {
+            for (String friendOfFriend : friendsPerUser.getOrDefault(friend, new ArrayList<>())) {
+                if (!friendOfFriend.equals(user)) {
+                    score.put(friendOfFriend, score.getOrDefault(friendOfFriend, 0) + FRIEND_OF_FRIEND_SCORE);
+                }
+            }
+        }
+        return score;
+    }
+
+    private static Map<String, List<String>> getFriends(List<List<String>> friends) {
+        Map<String, List<String>> friendsPerUser = new HashMap<>();
+
+        for (List<String> friend : friends) {
+            String user1 = friend.get(0);
+            String user2 = friend.get(1);
+
+            if (!friendsPerUser.containsKey(user1)) {
+                friendsPerUser.put(user1, new ArrayList<>());
+            }
+            if (!friendsPerUser.containsKey(user2)) {
+                friendsPerUser.put(user2, new ArrayList<>());
+            }
+            friendsPerUser.get(user1).add(user2);
+            friendsPerUser.get(user2).add(user1);
+        }
+
+        return friendsPerUser;
     }
 }