[우아한테크코스] 5기 백엔드 1주차 프리코스 회고록

- 2주차가 끝나서야 작성하는 1주차 프리코스 회고록...(?) 

- 1주차에는 정신없이 구현하고 커밋하고 리팩토링하고 그러느라 한 주가 가는지도 모르게 끝났던 것 같다. 

다른 분들이 매주 회고록을 작성하시는 게 꽤 멋있어 보이기도 했고, 개인적으로 여름/겨울마다 회고록을 작성하고 있었어서 우테코 참여 기간 동안에 나도 회고록을 남겨보고자 한다 :D 코드 짜면서 너무 배우는 점이 많아서 기쁘다.

 

- 1주차 과제 코드는 아래에서!

https://github.com/Cl8D/java-onboarding/tree/cl8d

GitHub - Cl8D/java-onboarding: 온보딩 미션을 진행하는 저장소

 

- 사실 1주차 과제는 코테 문제랑 거의 별다를 게 없었다고 본다.

난이도만 보면... 1번은 구현할 게 조금 있고, 2~5번은 평이하고 6~7번이 조금 어려웠던 것 같다.

- 근데 사실상 우테코는 난이도를 따지기보단, 이걸 어떻게 하면 '더 깔끔하게, 클린 코드를 쓸 수 있을까?'의 고민이 가장 큰 것 같다.

기능 구현은 마음 먹으면 1시간 내에도 가능하지만, 수정하는데 며칠씩 걸리기 때문...😵‍💫

 

 

| 과제 시작 전

- 첫 과제인 만큼 긴장 잔뜩 하고 여러 가지 찾아봤던 기억이 난다.

변수 네이밍, 메서드 네이밍, 커밋 컨벤션, 명명규칙, 클린코드 체크리스트까지...

사실 지금까지 개발할 때 자연스럽게 이런 식으로 써야지~는 했지만 막상 각 잡고 하려고 하니까 너무 어지러웠다.

- 하지만... 지금이 아니면 다시는 코딩 습관을 잘 못 잡을 것 같다는 생각 하나로 지키려고 엄청 애썼다.

각각 참고했던 블로그는 다음과 같다.

 

[명명 규칙]

[Java] 명명 규칙

 

[변수 네이밍]

좋은 코드를 위한 자바 변수명 네이밍

 

[메서드 네이밍]

좋은 코드를 위한 자바 메서드 네이밍

 

- 여기서 의도적으로 지키려고 하는 건 숫자 그대로 안 박는 거. 이거는 2주차에서도 신경쓰려고 노력했다.

- 또한, 이름을 길게 가져가는 거에 두려워하지 않는 것. 오히려 메서드가 하는 일을 잘 담을 수 있는 것 같아서 신경쓰는 부분이다.

만약 메서드가 너무 다양한 일을 해서 메서드명이 길어진다? > 이러면 메서드 분리가 필요하다는 부분이기 때문에 체크하면 된다.

- 그리고 getXXX, createXXX... 같이 동사로 시작하게 하는 거. 개인적으로 조회는 get으로 고정하는 게 보기 좋은 것 같다.

 

 

[커밋 컨벤션]

[GitHub] 깃 커밋 메세지 컨벤션 (Git Commit Message Convention)

 

[Git] 커밋 메시지 규약 정리 (the AngularJS commit conventions)

- 개인적으로 2번째 블로그의 내용을 너무 잘 읽었다. 특히 scope에 관한 부분.

사실 feat, chore, fix 말고 지금까지는 개발하면서 거의 안 썼던 것 같은데 1주차 과제하면서 문제 번호를 scope로 두고 커밋하니까 가독성이 확실히 좋아졌다는 걸 느꼈다.

- 나만 그렇게 느끼는 거면 말고....

- 그리고 커밋 메시지에는 소문자만 쓰는 것도 잊지 말기. 처음에 무의식적으로 대문자도 같이 넣어서 고생했다. 

(몇 블로그에서는 첫 문자는 대문자라고도 했지만... 대다수는 소문자로 쓰는 게 맞다고 해서 우선 나는 소문자로 고정해서 사용 중이다)

 

 

[클린 코드 체크리스트]

GitHub - woowacourse/woowacourse-docs: 우아한테크코스 문서를 관리하는 저장소

- 개인적으로 정말 너무 중요하다고 생각하는 부분. 특히 else 안 쓰는 거랑, 인덴트 줄이는 거.

1주차 때는 그 두 개랑 추가적으로 메서드의 인자에 3개 이상으로 안 들어가도록 노력했던 것 같다.

 

---

 

| 1번 문제

- 크게 고민했던 부분은 '제한사항을 코드로 넣는 게 맞는가?' 이 부분이었던 것 같다.

보통 백준이나 프로그래머스에서는 제한사항에 위배되는 입력값은 안 들어오기도 하고, 여기서도 사실 그럴 것 같았기 때문...

하지만! 구현 하나 더 한다고 나쁠 건 전혀 없기 때문에 바로 구현했다 ㅎㅎ 

package onboarding;

        import java.util.Arrays;
        import java.util.List;
        import java.util.stream.Stream;

class Problem1 {
    static final int FIRST_PAGE = 1;
    static final int LAST_PAGE = 400;

    public static int solution(List<Integer> pobi, List<Integer> crong) {
        // 입력 페이지 검증 후 예외 사항일 경우 -1을 리턴한다.
        if (isNotPageValid(pobi) || isNotPageValid(crong)) {
            return -1;
        }

        // 포비의 왼쪽, 오른쪽 페이지 번호를 구한다.
        int pobiLeftPage = pobi.get(0);
        int pobiRightPage = pobi.get(1);

        // 크롱의 왼쪽, 오른쪽 페이지 번호를 구한다.
        int crongLeftPage = crong.get(0);
        int crongRightPage = crong.get(1);

        // 포비의 결과 리스트를 구한다.
        List<Integer> pobiResultList = List.of(getSumValue(pobiLeftPage), getSumValue(pobiRightPage),
                getMultiplyValue(pobiLeftPage), getMultiplyValue(pobiRightPage));

        int pobiScore = getMaxValue(pobiResultList);

        // 크롱의 결과 리스트를 구한다.
        List<Integer> crongResultList = List.of(getSumValue(crongLeftPage), getSumValue(crongRightPage),
                getMultiplyValue(crongLeftPage), getMultiplyValue(crongRightPage));

        int crongScore = getMaxValue(crongResultList);

        return compareResult(pobiScore, crongScore);
    }

    /**
     * 입력 페이지에 대한 검증을 진행한다.
     *
     * @param pageNums 사용자의 페이지 번호 리스트
     * @return 올바르지 않은 페이지 리스트라면 true, 아니라면 false
     */
    private static boolean isNotPageValid(List<Integer> pageNums) {
        int leftPage = pageNums.get(0);
        int rightPage = pageNums.get(1);

        /* 입력 페이지에 대해서 검증을 진행한다. 다음은 예외 사항으로 간주한다.
            1. 페이지의 범위가 1~400 사이가 아닌 경우
            2. 페이지가 시작이나 마지막 면인 경우
            3. 왼쪽 페이지가 홀수가 아니고, 오른쪽 페이지가 짝수가 아닌 경우
            4. 왼쪽, 오른쪽 페이지의 차가 1이 아닌 경우 (연속된 페이지가 아님)
         */
        return isNotPageRange(leftPage, rightPage) || isPageFirstOrLast(leftPage) ||
                isNotPageOddAndEven(leftPage, rightPage) || isNotPageContinuous(leftPage, rightPage);
    }

    /**
     * 입력 페이지의 범위가 1~400 사이가 아닌지 판단한다.
     *
     * @param leftPage 왼쪽 페이지
     * @param rightPage 오른쪽 페이지
     * @return 1~400 사이가 아니라면 true, 맞다면 false
     */
    private static boolean isNotPageRange(int leftPage, int rightPage) {
        return leftPage < FIRST_PAGE || leftPage >= LAST_PAGE || rightPage <= FIRST_PAGE || rightPage > LAST_PAGE;
    }

    /**
     * 왼쪽 페이지 번호가 시작 면이거나 마지막 면인지 판단한다.
     *
     * @param leftPage 왼쪽 페이지
     * @return 왼쪽 페이지의 값이 1이거나 399라면 true, 아니라면 false
     */
    private static boolean isPageFirstOrLast(int leftPage) {
        return leftPage == FIRST_PAGE || leftPage == LAST_PAGE-1;
    }

    /**
     * 왼쪽 페이지가 홀수, 오른쪽 페이지가 짝수가 아닌지 판단한다.
     *
     * @param leftPage 왼쪽 페이지
     * @param rightPage 오른쪽 페이지
     * @return 왼쪽 페이지가 홀수가 아니고 오른쪽 페이지가 짝수가 아니면 true, 아니라면 false
     */
    private static boolean isNotPageOddAndEven(int leftPage, int rightPage) {
        return leftPage % 2 != 1 && rightPage % 2 != 0;
    }

    /**
     * 왼쪽, 오른쪽 페이지가 연속적이지 않은지 확인한다.
     *
     * @param leftPage 왼쪽 페이지
     * @param rightPage 오른쪽 페이지
     * @return 오른쪽, 왼쪽 페이지의 차가 1이 아니라면 true, 아니라면 false
     */
    private static boolean isNotPageContinuous(int leftPage, int rightPage) {
        return rightPage - leftPage != 1;
    }

    /**
     * 입력 받은 페이지 번호의 각 자리수의 합을 구한다.
     *
     * @param page 페이지 번호
     * @return 각 자리수의 합
     */
    private static int getSumValue(int page) {
        int[] pageArr = getPageValueArray(page);

        return Arrays.stream(pageArr).sum();
    }

    /**
     * 입력 받은 페이지 번호의 각 자리수의 곱을 구한다.
     *
     * @param page 페이지 번호
     * @return 각 자리수의 곱
     */
    private static int getMultiplyValue(int page) {
        int[] pageArr = getPageValueArray(page);

        int multiVal = 1;
        for(int pageVal : pageArr) {
            multiVal *= pageVal;
        }

        return multiVal;
    }

    /**
     * 입력 받은 페이지의 각 자릿수를 담은 배열을 구한다.
     *
     * @param page 페이지 번호
     * @return 각 자릿수가 담긴 배열
     */
    private static int[] getPageValueArray(int page) {
        String[] digitStrArr = String.valueOf(page).split("");

        return Stream.of(digitStrArr).mapToInt(Integer::parseInt).toArray();
    }

    /**
     * 페이지 번호에 따른 자리수 계산 결과 중 가장 큰 값을 리턴한다.
     *
     * @param resultArr 자리수 계산 결과를 담은 리스트
     * @return 가장 큰 값
     */
    private static int getMaxValue(List<Integer> resultArr) {
        int maxVal = 0;
        for(int resultVal : resultArr) {
            maxVal = Math.max(maxVal, resultVal);
        }

        return maxVal;
    }

    /**
     * 두 사람의 점수를 비교하여 결과를 출력한다.
     *
     * @param pobiScore 포비의 점수
     * @param crongScore 크롱의 점수
     * @return 포비가 이기면 1, 크롱이 이기면 2, 무승부는 0을 리턴한다.
     */
    private static int compareResult(int pobiScore, int crongScore) {
        if (pobiScore > crongScore) {
            return 1;
        }
        if (pobiScore < crongScore) {
            return 2;
        }
        return 0;
    }
}

- 그냥 간단하게 상수화 신경쓰고, 하나의 일만 하도록 메서드를 최대한 작게 분리했다.

Stream.of.mapToInt 사용해서 자릿수 배열 만든 게 가장 기억에 남는 문제이다.

 

---

 

| 2번 문제

- 2번 문제는 생각보다 까다로웠다. 큐(덱)를 사용해서 풀까 고민하다가 그럼 너무 복잡해질 것 같았기 때문...

그래서 while문을 돌까, 아니면 2중 for문을 돌까 고민하다가 둘 다 마음에 안 들어서 엄청 고민하다 정규식으로 풀었다!

개인적으로 풀고 나서 너무 뿌듯했던 문제 ㅎㅎ  

package onboarding;

        import onboarding.common.InputStringUtil;
        import onboarding.common.ValidationUtil;

public class Problem2 {
    public static String solution(String cryptogram) {
        // 입력 암호문 대한 제한사항을 검증한다.
        verifyCryptogram(cryptogram);

        // 입력 문자열을 char형 배열로 분해한다.
        char[] cryptogramArr = InputStringUtil.getCharArr(cryptogram);

        // 배열을 순회하며 해당 원소를 기준으로 중복 문자열을 체크한다.
        for(Character element : cryptogramArr) {
            // 해당 문자가 2번 이상 반복된다면 제거하여 원본 암호문을 변경한다.
            cryptogram = removeDuplicateElement(cryptogram, element);
        }

        return cryptogram;
    }

    /**
     * 입력받은 암호문에 대한 검증 작업을 진행한다.
     *
     * @param cryptogram 입력 암호문
     */
    private static void verifyCryptogram(String cryptogram) {
        // 암호문의 길이는 1~1000 사이로 제한되어 있다.
        ValidationUtil cryptogramValidation = new ValidationUtil();
        cryptogramValidation.addVarName("cryptogram");
        cryptogramValidation.checkStrLowerCase(cryptogram, 1, 1000);
    }

    /**
     * 2번 이상 중복된 문자열을 제거한다.
     *
     * @param cryptogram 제거 진행할 문자열
     * @param element 제거의 기준이 되는 요소
     * @return String - 제거 작업이 완료된 문자열을 리턴한다.
     */
    private static String removeDuplicateElement(String cryptogram, Character element) {
        return cryptogram.replaceAll(element + "{2,}", "");
    }
}

- 다소 1주차 과제는 주석을 엄청 달다 보니까 코드가 길다...

아무튼...! 정규식을 통해서 {2, } -> 2번 이상 반복하는 문자에 대해서 전부 삭제 처리를 진행해주었다.

앞에서 삭제를 처리하면 반복문을 통해 그 다음 요소를 돌아도 또 다시 중복되는 문자를 제거해줄 수 있기 때문에 1중 for문으로도 풀 수 있어서 좋았다.

- 추가적으로 검증에 관한 부분은 따로 아래에 작성할 예정이다.

---

| 3번 문제

- 3번은 진짜 기초 문제여서 크게 어려울 것 없이 풀었다.

package onboarding;

        import onboarding.common.ValidationUtil;

public class Problem3 {
    static final String[] NUM_FOR_CLAPS = {"3", "6", "9"};

    public static int solution(int number) {
        int answer = 0;

        // 입력받은 숫자에 대한 검증 작업을 진행한다.
        verifyNumber(number);

        // 1부터 입력으로 주어진 번호까지 순회를 진행한다.
        for (int num = 1; num <= number; num++) {
            // 각 번호를 문자열로 변경하고, 원본 길이를 구한다.
            String strNum = String.valueOf(num);
            int originLen = strNum.length();

            // 박수 횟수를 계속 더해준다.
            answer += getClapCount(strNum, originLen);
        }
        return answer;
    }

    /**
     * 입력받은 숫자에 대한 검증 작업을 진행한다.
     *
     * @param number 입력받은 숫자
     */
    private static void verifyNumber(int number) {
        ValidationUtil numValidation = new ValidationUtil();
        numValidation.addVarName("number");
        // 숫자의 범위는 1~10000 사이로 제한되어 있다.
        numValidation.checkNumRange(number, 1, 10000);
    }

    /**
     * 박수 횟수를 구한다.
     *
     * @param strNum 기준 문자열
     * @param originLen 기준 문자열의 원본 길이
     * @return int - 3/6/9가 포함되었을 때 친 박수 횟수를 리턴한다.
     */
    private static int getClapCount(String strNum, int originLen) {
        int clapCount = 0;
        for(String clapNum : NUM_FOR_CLAPS) {
            int newLen = checkClapNumAndGetLength(strNum, clapNum);

            // 제거된 길이만큼이 박수를 친 횟수가 된다.
            if (newLen != -1) {
                clapCount += (originLen - newLen);
            }
        }

        return clapCount;
    }

    /**
     * 기준 문자열에 3/6/9가 포함이 되어 있다면 제거 후 길이를 구한다.
     *
     * @param strNum 기준 문자열
     * @param clapNum 369 게임의 기준이 되는 번호 (3/6/9)
     * @return int - 제거 완료된 문자열의 길이를 리턴한다. 변경사항이 없을 경우 -1을 리턴한다.
     */
    private static int checkClapNumAndGetLength(String strNum, String clapNum) {
        if (strNum.contains(clapNum)) {
            String removedStr = removeClapNum(strNum, clapNum);
            return removedStr.length();
        }

        return -1;
    }

    /**
     * 문자열에 존재하는 clapNum (3/6/9)를 제거한다.
     *
     * @param strNum 기준 문자열
     * @param clapNum 369 게임의 기준이 되는 번호 (3/6/9)
     * @return String - 제거가 완료된 문자열을 리턴한다.
     */
    private static String removeClapNum(String strNum, String clapNum) {
        return strNum.replaceAll(clapNum, "");
    }
}

- 다른 분들 코드를 보니까 수학적으로 접근하신 분들도 계셨는데, 나는 그정도로 머리가 굴러가지 않기 때문에...

어차피 3, 6, 9라는 길이가 1인 문자에 대해서만 제거 처리를 하면, 그게 곧 박수 횟수가 되기 때문에 길이가 어느 정도 달라졌는지로 판단했다.

이것도 꽤... 독특하게 풀었다고 생각하는데 나만 그럴지도...?

---

| 4번 문제

- 4번은 아스키를 활용하는 문제! 아스키코드표 보면서 풀었다 ㅋㅋㅋ ㅠㅠ 

package onboarding;

public class Problem4 {
    static final char START_ASCII_BY_UPPER_CASE = 'A';
    static final char END_ASCII_BY_UPPER_CASE = 'Z';
    static final char START_ASCII_BY_LOWER_CASE = 'a';
    static final char END_ASCII_BY_LOWER_CASE = 'z';

    public static String solution(String word) {
        StringBuilder answer = new StringBuilder("");

        // 입력 문자열을 배열로 변환한다.
        char[] wordArr = getCharArr(word);

        for(Character wordVal : wordArr) {
            // 만약 알파벳이 아니라면 공백으로 간주한다.
            if(isNotAlphabetic(wordVal)) {
                answer.append(' ');
                continue;
            }

            // 알파벳이라면 변환 작업을 진행한다.
            char reversedVal = changeReversed(wordVal);
            answer.append(reversedVal);
        }

        return answer.toString();
    }

    /**
     * 청개구리 사전에 따라 단어를 변환한다.
     *
     * @param value 원본 단어 요소
     * @return char - 사전에 따라 변환된 요소를 리턴한다. 대문자는 대문자로, 소문자는 소문자로 리턴된다.
     */

    private static char changeReversed(char value) {
        if (Character.isUpperCase(value))
            return (char) (END_ASCII_BY_UPPER_CASE - (value - START_ASCII_BY_UPPER_CASE));
        return (char) (END_ASCII_BY_LOWER_CASE - (value - START_ASCII_BY_LOWER_CASE));
    }

    /**
     * 요소가 알파벳이 아닌지 판단한다.
     *
     * @param value 판단할 요소
     * @return 알파벳이 아니라면 true, 맞다면 false
     */
    private static boolean isNotAlphabetic(Character value) {
        return !Character.isAlphabetic(value);
    }

    /**
     * 파라미터로 받은 문자열을 char형 배열로 분해하여 리턴한다.
     *
     * @param str 문자열
     * @return char[] - 입력으로 받은 문자열에 대해 char형 배열로 쪼갠 결과를 리턴한다.
     */
    private static char[] getCharArr(String str) {
        return str.toCharArray();
    }
}

 - 사실 사전에 그냥 청개구리 사전의 값을 지정해두고 풀었다면 더 간단하겠지만... 코드가 간지가 없다. 그런 건 용납 불가.

---

| 5번 문제

- 5번도 진짜 기초 문제였기 때문에 어렵지 않게 풀 수 있었다.

package onboarding;

        import onboarding.common.ValidationUtil;

        import java.util.ArrayList;
        import java.util.List;

public class Problem5 {

    static final int[] MONETARY_UNIT = {50000, 10000, 5000, 1000, 500, 100, 50, 10, 1};

    public static List<Integer> solution(int money) {
        List<Integer> answer = new ArrayList<>();

        // 입력된 금액에 대한 검증을 진행한다.
        moneyValidation(money);

        // 내림차순으로 정렬된 화폐 단위를 순회한다.
        for(int unit : MONETARY_UNIT) {
            // 기존 금액이 단위보다 작으면 해당 화폐의 개수는 0으로 간주한다.
            if (money < unit) {
                answer.add(0);
                continue;
            }
            // 그게 아니라면 기존 금액에서 화폐 단위로 나눈 몫이 개수가 된다.
            answer.add(money/unit);
            // 기존 금액은 화폐 단위로 나눈 나머지로 갱신한다.
            money %= unit;
        }

        return answer;
    }

    /**
     * 입력으로 들어온 금액에 대해 검증한다.
     *
     * @param money 입력받은 금액
     */
    private static void moneyValidation(int money) {
        ValidationUtil moneyValidation = new ValidationUtil();
        moneyValidation.addVarName("money");
        // 금액은 1~1000000 사이의 값이어야 한다. 
        moneyValidation.checkNumRange(money, 1, 1000000);
    }
}

- 약간... 백준에서 볼 것 같은 문제였다.

---

| 6번 문제

- 6번부터 점점 난이도가 어려워졌던 느낌... 

하지만 개인적으로 Map, Set 같은 자료구조를 이용한 문제 푸는 걸 너무 좋아하기 때문에 풀면서 재밌었다 ㅎㅎ

package onboarding;

        import onboarding.common.ValidationUtil;
        import onboarding.exception.InputRangeException;
        import onboarding.exception.InputTypeException;

        import java.util.*;
        import java.util.regex.Pattern;

public class Problem6 {
    // 부분 닉네임 문자열과 이메일 정보를 담은 맵이다.
    static Map<String, String> partNameWithEmail;

    // 결과 이메일을 담는 TreeSet이다.
    static Set<String> answer;

    public static List<String> solution(List<List<String>> forms) {
        partNameWithEmail = new HashMap<>();
        answer = new TreeSet<>();

        // 크루의 인원 수에 대해서 검증한다.
        verifyCrewNum(forms);

        for(List<String> form : forms) {
            // 크루들의 이메일과 닉네임 정보를 각각 추출한다.
            String email = form.get(0);
            // 이메일에 대한 도메인 검증을 진행한다.
            checkEmailCond(email);

            String nickname = form.get(1);
            // 닉네임에 대한 조건을 검증한다.
            checkNicknameCond(nickname);

            // 이메일을 한 글자씩 끊어서 배열로 만든다.
            String[] nameArr = nickname.split("");

            // 2글자씩 끊어서 부분 닉네임을 생성한 뒤 중복을 체크한다.
            createPartNicknameAndCheck(email, nameArr);
        }

        // 결과를 오름차순으로 정렬한다.
        List<String> answerList = new ArrayList<>(answer);
        answerList.sort(String::compareTo);

        return answerList;
    }

    /**
     * 입력받은 크루의 인원수에 대해서 검증한다.
     *
     * @param forms 크루 리스트
     */
    private static void verifyCrewNum(List<List<String>> forms) {
        ValidationUtil crewSizeValidation = new ValidationUtil();
        crewSizeValidation.addVarName("crew member size");
        // 크루의 사이즈는 1~10000 사이이다.
        crewSizeValidation.checkNumRange(forms.size(), 1, 10000);
    }

    /**
     * 닉네임에 대한 형식을 검증한다.
     *
     * @param nickname 입력받은 닉네임
     */
    private static void checkNicknameCond(String nickname) {
        // 닉네임은 한글로만 이루어져 있으며, 길이는 1~19 사이여야 한다.
        String regex = "^[ㄱ-ㅎㅏ-ㅣ가-힣]{1,19}$";
        if (!Pattern.matches(regex, nickname)) {
            throw new InputRangeException("닉네임은 한글로만 이루어져야 하며, 길이는 1~19자까지 가능합니다.");
        }
    }

    /**
     * 이메일에 대한 형식을 검증한다.
     *
     * @param email 입력받은 이메일
     */
    private static void checkEmailCond(String email) {
        // 이메일은 @email.com 도메인으로 구성되어 있으며, 전체 길이는 11~20자 미만이다.
        // @email.com이 10자이기 때문에, 앞단의 아이디는 1~9자까지 될 수 있다.
        String regex = "^[a-zA-Z0-9]{1,9}@email[.]com$";

        if (!Pattern.matches(regex, email)) {
            throw new InputTypeException("이메일은 11~20자 사이이며, 도메인은 @email.com로 제한되어 있습니다.");
        }
    }

    /**
     * 닉네임 배열로부터 2글자씩 자르고 중복을 체크한다.
     *
     * @param email 사용자의 이메일
     * @param nameArr 사용자의 닉네임 배열
     */
    private static void createPartNicknameAndCheck(String email, String[] nameArr) {
        for (int i = 0; i < nameArr.length-1; i++) {
            String partNickname = nameArr[i] + nameArr[i+1];
            // 부분 닉네임 문자열에 대한 중복 체크를 진행한다.
            checkDuplicatedAndAddResult(email, partNickname);
            partNameWithEmail.put(partNickname, email);
        }
    }

    /**
     * 부분 닉네임 문자열에 대한 중복 체크를 진행한 뒤 결과 Set에 담는다.
     *
     * @param email 사용자의 이메일
     * @param partNickname 사용자의 부분 닉네임 문자열
     */
    private static void checkDuplicatedAndAddResult(String email, String partNickname) {
        if(partNameWithEmail.containsKey(partNickname)) {
            // 해당 사용자의 이메일을 결과 Set에 추가한다.
            answer.add(email);
            // 중복된 부분 문자열을 가진 사용자의 이메일을 결과 Set에 추가한다.
            answer.add(partNameWithEmail.get(partNickname));
        }
    }
}

- 역시 기억에 남는 건 정규식...

제한사항 검증을 코드에 넣지 않았다면 사실 필요없는 부분이었지만, 넣게 되면서 정규식도 엄청 찾아가면서 공부했다. ㅋㅋㅋㅋ

^[]{} : 이런 식으로 앞에 패턴을 넣고, 뒤에 길이를 넣으면 해당 길이 + 형식까지 검증할 수 있는 게 너무 신기했다...

아직 정규식 쓰는 건 안 익숙해서, 앞으로 더 익숙해지도록 노력해야 될 것 같다.

---

| 7번 문제

- 7번!! 사실 가장 시간을 많이 썼던 문제이다. 왜냐면 처음에 문제 자체를 이해 못 해서 시간 낭비를 했기 때문... 😅

'사용자와 함께 아는 친구의 수' << 사실 이 말을 잘 보면 이해할 수 있는데 이때는 사용자의 친구의 친구라는 건가...? 이러면서 엄청 헷갈려했다.

그냥 사용자와 친구가 아닌 전체 유저 중에서 사용자와 친구가 어느 정도 겹치는지 체크하면 되는 거였는데... ㅎㅎ

그래도 이것도 Map 쓰는 거여서 구현하면서 재밌었다. ㅎㅎ

package onboarding;

        import onboarding.common.ValidationUtil;

        import java.util.*;

public class Problem7 {

    // 전체 사용자의 친구 관계를 정의할 Map을 선언한다.
    // key 값으로 사용자의 아이디, value 값으로 리스트로 해당 사용자의 친구 리스트가 들어간다.
    static Map<String, List<String>> friendMap;

    // 점수 정보를 관리할 Map을 선언한다.
    // key 값으로 사용자의 아이디, value 값으로 점수가 들어간다.
    static Map<String, Integer> scoreMap;

    // 사용자의 친구 목록 리스트를 관리한다.
    static List<String> userFriendList;

    public static List<String> solution(String user, List<List<String>> friends, List<String> visitors) {
        friendMap = new HashMap<>();
        scoreMap = new HashMap<>();

        // 입력받은 리스트들에 대한 검증 작업을 진행한다.
        verifyInputList(user, friends, visitors);

        // 전체 사용자에 대한 친구 관계를 정의한다.
        for(List<String> relationship : friends) {
            // 각 원소의 사이즈가 2인지 검증한다.
            verifyRelationship(relationship);
            defineFriendship(relationship);
        }

        // 사용자의 친구 목록을 조회한다.
        userFriendList = friendMap.get(user);

        // 친구 관계 Map에서 사용자의 정보를 제거한다. (기준이 사용자이기 때문)
        friendMap.remove(user);

        // 다른 사용자의 친구 리스트를 조회하여 사용자의 친구 리스트와 비교한다.
        for(String diffUser : friendMap.keySet()) {
            getFriendsOfDiffUserAndCompare(diffUser);
        }

        // 사용자의 타임라인을 방문한 사용자에 대해 1점씩 부여한다.
        addOneScoreToVisitors(visitors);

        // 사용자와 이미 친구인 사용자는 추천에서 제외한다.
        removeAlreadyUserFriend();

        // 점수가 0점인 사용자는 제거한다.
        for(String recommendUser : scoreMap.keySet()) {
            removeUserWithZeroScore(recommendUser);
        }

        // 점수와 이름 순서대로 정렬을 진행한다.
        List<String> recommendUserList = new ArrayList<>(scoreMap.keySet());
        recommendUserList.sort(Problem7::sortByScoreAndName);

        // 최종적으로 추천할 인원을 선별한다.
        return selectRecommendUsers(recommendUserList);
    }

    /**
     * 친구 관계 리스트에 대한 검증 작업을 진행한다.
     *
     * @param relationship 친구 관계 리스트
     */
    private static void verifyRelationship(List<String> relationship) {
        ValidationUtil relationshipValidation = new ValidationUtil();
        relationshipValidation.addVarName("relationship size");
        // 각 원소의 사이즈는 2여야 한다.
        relationshipValidation.checkNumRange(relationship.size(), 2, 2);
    }

    /**
     * 입력받은 리스트들에 대한 검증 작업을 진행한다.
     *
     * @param user 사용자 아이디
     * @param friends 친구 관계 정보
     * @param visitors 사용자 타임라인 방문 기록
     */
    private static void verifyInputList(String user, List<List<String>> friends, List<String> visitors) {
        // 입력으로 받은 user 문자열에 대해 검증한다.
        ValidationUtil userValidation = new ValidationUtil();
        userValidation.addVarName("user length");
        userValidation.checkNumRange(user.length(), 1, 30);

        // friends의 사이즈에 대해서 검증한다.
        ValidationUtil friendsValidation = new ValidationUtil();
        friendsValidation.addVarName("friends size");
        friendsValidation.checkNumRange(friends.size(), 1, 10000);

        // visitors 사이즈에 대해서 검증한다.
        ValidationUtil visitorsValidation = new ValidationUtil();
        visitorsValidation.addVarName("visitors size");
        visitorsValidation.checkNumRange(visitors.size(), 0, 10000);
    }

    /**
     * 최종적으로 추천할 사용자를 뽑는다.
     *
     * @param recommendUserList 정렬된 사용자 리스트
     * @return 추천할 사용자 리스트를 리턴한다.
     */
    private static List<String> selectRecommendUsers(List<String> recommendUserList) {
        List<String> answer = new ArrayList<>();

        // 기존 추천 리스트에 담긴 인원이 5명보다 작으면 그대로, 아니라면 최대 5명까지 선별한다.
        int numberOfUser = Math.min(recommendUserList.size(), 5);

        for(int i=0; i<numberOfUser; i++) {
            answer.add(recommendUserList.get(i));
        }

        return answer;
    }

    /**
     * 추천 리스트를 점수(내림차순)와 이름(사전순)에 따라 정렬한다.
     *
     * @param userA 비교할 사용자 A
     * @param userB 비교할 사용자 B
     * @return 정렬 결과에 따른 -1, 0(변경하지 않음), 1(자리 변경)이 리턴된다.
     */
    private static int sortByScoreAndName(String userA, String userB) {
        // 점수가 같다면 이름순으로 정렬한다.
        if (Objects.equals(scoreMap.get(userA), scoreMap.get(userB))) {
            return userA.compareTo(userB);
        }
        // 그게 아니라면 점수를 기준으로 내림차순 정렬한다.
        return scoreMap.get(userB) - scoreMap.get(userA);
    }

    /**
     * 점수가 0점인 사용자는 점수 Map에서 제거한다.
     *
     * @param recommendUser 추천 후보 사용자 아이디
     */
    private static void removeUserWithZeroScore(String recommendUser) {
        if (scoreMap.get(recommendUser) == 0) {
            scoreMap.remove(recommendUser);
        }
    }

    /**
     * 사용자와 이미 친구인 경우 제거한다.
     */
    private static void removeAlreadyUserFriend() {
        for(String userFriend : userFriendList) {
            scoreMap.remove(userFriend);
        }
    }

    /**
     * 사용자의 타임라인을 방문한 사용자에게 1점씩 부여한다.
     *
     * @param visitors 사용자의 타임라인 방문자
     */
    private static void addOneScoreToVisitors(List<String> visitors) {
        for(String visitor : visitors) {
            scoreMap.put(visitor, scoreMap.getOrDefault(visitor,0) + 1);
        }
    }

    /**
     * 다른 사용자의 친구 리스트를 조회하여 사용자의 친구 리스트와 비교한다.
     *
     * @param diffUser 다른 사용자의 아이디
     */
    private static void getFriendsOfDiffUserAndCompare(String diffUser) {
        List<String> diffFriendList = friendMap.get(diffUser);
        for(String friendOfDiffUser : diffFriendList) {
            addTenScore(diffUser, friendOfDiffUser);
        }
    }

    /**
     * 사용자의 친구 리스트와 동일한 친구를 가지고 있다면, 해당 사용자에게 10점을 부여한다.
     *
     * @param diffUser 다른 사용자 아이디
     * @param friendOfDiffUser 다른 사용자의 친구
     */
    private static void addTenScore(String diffUser, String friendOfDiffUser) {
        if (userFriendList.contains(friendOfDiffUser)) {
            scoreMap.put(diffUser, scoreMap.getOrDefault(diffUser, 0) + 10);
        }
    }

    /**
     * 전체 사용자의 친구 목록을 친구 관계 Map에 저장한다.
     *
     * @param relationship 친구 관계 정보
     */
    private static void defineFriendship(List<String> relationship) {
        String userA = relationship.get(0);
        String userB = relationship.get(1);

        // 아이디에 대한 검증을 진행한다.
        idValidation(userA, userB);

        // 만약 처음 삽입된다면 초기화 작업을 진행해준다.
        List<String> friendListOfUserA = friendMap.getOrDefault(userA, new ArrayList<>());
        // 친구 정보를 추가한다.
        friendListOfUserA.add(userB);

        List<String> friendListOfUserB = friendMap.getOrDefault(userB, new ArrayList<>());
        friendListOfUserB.add(userA);

        // 친구 관계 Map에 추가한다.
        friendMap.put(userA, friendListOfUserA);
        friendMap.put(userB, friendListOfUserB);
    }

    /**
     * 사용자의 아이디에 대한 검증 작업을 진행한다.
     *
     * @param userA 사용자 A
     * @param userB 사용자 B
     */
    private static void idValidation(String userA, String userB) {
        // 사용자의 아이디의 길이는 1~30 사이여야 하며, 소문자로 이루어져 있다.
        ValidationUtil userAValidation = new ValidationUtil();
        userAValidation.addVarName("userId");
        userAValidation.checkStrLowerCase(userA, 1, 30);

        ValidationUtil userBValidation = new ValidationUtil();
        userBValidation.addVarName("userId");
        userBValidation.checkStrLowerCase(userB, 1, 30);
    }
}

- 개인적으로 이렇게 요구사항 잔뜩 주고 자료형에 넣다 뺐다 하는 문제가 재밌는 것 같다.

이 문제를 처음 접한 사람이었다면 이 문제 하나 해결함으로서 Map은 완벽 마스터 할 수 있지 않을까... 라고 생각했다!

 

---

| 공통 클래스

- 리팩토링 하면서 만들었던 공통 클래스!

package onboarding.common;

/**
 * 입력으로 들어온 문자열에 대한 통합 관리 기능을 제공하는 클래스.
 */
public class InputStringUtil {

    /**
     * 문자열을 char형 배열로 분해하여 리턴한다.
     *
     * @param str 문자열
     * @return char[] - 입력으로 받은 문자열에 대해 char형 배열로 쪼갠 결과를 리턴한다.
     */
    public static char[] getCharArr(String str) {
        return str.toCharArray();

    }
}

- 문자열을 배열로 받는 부분이 상당히 많아서 그냥 분리했는데... 사실 이 정도까지는 분리 안 해도 됐지 않았을까 싶다. ㅎㅎㅎ

package onboarding.common;

        import onboarding.exception.InputRangeException;
        import onboarding.exception.InputTypeException;

        import java.util.regex.Pattern;

/**
 * 입력으로 들어온 값에 대해 공통 검증 기능을 제공하는 클래스.
 */
public class ValidationUtil {

    private String varName;

    /**
     * 오류 메시지 전달 시 사용할 입력 변수 이름 설정 메서드
     *
     * @param varName 입력한 변수 이름
     */
    public void addVarName(String varName) {
        this.varName = varName;
    }

    /**
     * 입력받은 number의 범위에 대한 검증을 진행한다.
     *
     * @param number 입력으로 들어온 number
     * @param start 시작 범위
     * @param end 끝 범위
     */
    public void checkNumRange(int number, int start, int end) {
        if (number < start || number > end) {
            if (start == end)
                throw new InputRangeException(this.varName + "은(는) " + start + "로 제한되어 있습니다.");

            throw new InputRangeException(this.varName + "은(는) " + start + "~" + end + " 사이로 제한되어 있습니다.");
        }
    }

    /**
     * 입력받은 문자열이 소문자로 구성되어 있는지 검증한다.
     *
     * @param str 입력받은 문자열
     * @param startLen 시작 길이
     * @param endLen 끝 길이
     */
    public void checkStrLowerCase(String str, int startLen, int endLen) {
        String regex = "^[a-z]{" + startLen + "," + endLen + "}$";

        if (!Pattern.matches(regex, str)) {
            throw new InputTypeException(this.varName + "의 길이는 " + startLen + "~" + endLen +
                    " 사이로 제한되어 있으며, 소문자로만 구성되어야 합니다.");
        }
    }
}

- 개인적으로 이번 주차에서 또 고민했던 검증 클래스!

검증 메시지를 처리할 때 변수 이름을 함께 출력해주고 싶어서 클래스 내부 변수로 varName을 선언해 관리했다.

개인적으로 소문자 검증도 파라미터로 길이를 받아서 처리해둔 게 마음에 든다!

 

---

| 소감

- 깃헙에도 올려둔 거지만 따로 저장해두고 싶어서 적어두는 소감 :D

마크다운이 티스토리에서 다소 깨지는 경향이 있는 게 싫어서 캡쳐로 올려둔다.

 

1주차는 이런 식으로 코드 구현을 했었는데... 일주일 동안 코드 바라보면서 수정한 결과인 만큼 꽤 뿌듯했다.

사실 얼른 2주차 회고 써야겠다는 생각뿐이지만 ㅎㅎㅎ 앞으로는 밀리지 않고 써야겠다...

앞으로 남은 시간도 파이팅! 꼭 합격했으면 😌