Java - 로또의 최고 순위와 최저 순위, 옹알이(2), 숫자 짝꿍 / SQL(MySQL) - 조건에 맞는 사용자 정보 조회하기

Java

로또의 최고 순위와 최저 순위

문제

• 프로그래머스 - https://school.programmers.co.kr/learn/courses/30/lessons/77484
• 구매한 로또번호가 낙서가 되어 일부 번호를 알아 볼 수 없는 로또 번호 배열 lottos와 당첨 번호가 담긴 배열 win_nums가 주어질 때  당첨 가능한 최고 순위와 최저 순위를 차례대로 배열에 담아서 return 하는 함수를 완성
• 로또 순위

 

제한조건

• lottos, win_nums는 길이 6인 정수 배열임
• lottos의 모든 원소는 0 이상 45 이하인 정수이며 0은 알아볼 수 없는 숫자를 의미함
• win_nums의 모든 원소는 1 이상 45 이하인 정수임
• lottos, win_nums에는 0을 제외한 다른 숫자는 같은 숫자가 2개 이상 담겨있지 않으며 정렬되어있지 않을 수도 있음

입출력 예시

나의 풀이

2중 반복문 사용

class Solution {
    public int[] solution(int[] lottos, int[] win_nums) {

        int zeroCount = 0;
        int sameCount = 0;
        for (int num : lottos) {
            if (num == 0) {
                zeroCount++;
                continue;
            }
            for (int winNum : win_nums) {
                if (num == winNum) {
                    sameCount++;
                    break;
                }
            }
        }

        int minRank = Math.abs(sameCount - 7);
        int maxRank = Math.abs(sameCount + zeroCount - 7);

        if(minRank > 6) {
            minRank = 6;
        }

        if (maxRank > 6) {
            maxRank = 6;
        }

        return new int[]{maxRank, minRank};
    }
}

• 먼저 내가 구매한 로또 번호의 요소를 정답의 요소와 비교해야겠다고 생각하여 2중 반복문을 사용해야겠다고 생각하고 접근했다.
• 먼저 lottos에는 0이 있을 수 있기 때문에 0의 갯수를 세는 변수를 하나 두고, 나의 로또 번호와 당첨 번호가 같으면 갯수를 세는 변수도 하나 선언해두고 처음 반복문을 시작한다.
• lottos에서 꺼낸 요소가 0이면 zeroCount의 숫자를 1 증가시키고 당첨 번호와 비교할 필요가 없기 때문에 continue를 통해서 다음 요소를 꺼낸다.
• 0이 아니면 나의 번호와 정답을 비교하는데 어차피 각 배열에서 0이아닌 모든 숫자는 1개만 존재하기 때문에 요소와 당첨번호가 같다면 더 이상 비교할 필요가 없기 때문에 sameCount를 1 증가시키고 바로 반복을 빠져나와서 lottos의 다음 요소를 비교하도록 구성했다.
• 이렇게 2중 반복이 모두 끝나면, lottos에 낙서가 된 번호의 갯수, 그리고 나의 로또번호와 당첨번호를 비교했을때 맞아 떨어진 갯수가 구해진다.
• 여기서 최소 등수를 구하기 위해 나의 로또 번호에서 가려진 번호들이 모두 틀렸다고 가정하면 sameCount의 개수만 맞은 것이기 때문에 sameCount - 7을 하면 등수를 음수로 구할 수 있으므로 이 값을 Math.abs로 감싸면 나의 최소 등수를 구할 수 있다
• 최대 등수는 zeroCount로 센 개수가 모두 당첨번호와 같다는 전제를 하면 되기 때문에 sameCount + zecoCount - 7을 하여 등수를 음수값으로 구하고 여기에 Math.abs로 감싸면 내가 당첨될 최대 등수를 구할 수 있다.
• 여기서 순위 구조가 6등 이하는 모두 낙첨이기 때문에 조건문을 통해서 각 랭크가 6보다 크다면 그냥 6으로 출력되도록 조건문을 두고 이를 배열에 담아서 반환하여 문제를 해결했다
• 이렇게 작성하면서 생각해보니 7 - sameCount, 7 - sameCount + zeroCount를 해줬다면 Math.abs가 필요없다는 것을 깨달았다.

최적화된 풀이

set과 rank 배열을 만들어서 적용

import java.util.HashSet;
import java.util.Set;

class Solution2 {
    public int[] solution(int[] lottos, int[] win_nums) {
        Set<Integer> set = new HashSet<>();
        for (int winNum : win_nums) {
            set.add(winNum);
        }

        int zeroCount = 0;
        int matchCount = 0;

        for (int num : lottos) {
            if (num == 0) {
                zeroCount++;
            } else if (set.contains(num)) {
                matchCount++;
            }
        }

        int[] rank = {6, 6, 5, 4, 3, 2, 1};

        int maxRank = rank[matchCount + zeroCount];
        int minRank = rank[matchCount];
        return new int[]{maxRank, minRank};
    }
}

• 배열은 자료구조에 정의된 기능들을 사용할 수 없으므로 로또 당첨 번호인 win_nums를 중복값을 저장하지 않는 Set 자료구조에 옮겨 저장하여 Set에 제공하는 메서드를 이용하는 방법이다.
• Set 자료구조에 로또 번호를 옮긴 후 lottos의 값을 하나씩 꺼내서 0이라면 zeroCount를 1 증가시키고, 만약 set.contains(num)으로 num이 set 자료구조의 요소에 포함된다면 matchCount를 1 증가시켜서 0의 갯수와 정답의 갯수를 구한다.
• 그다음 rank를 별도의 연산으로 구하는것이 아니라 등수는 고정되어있으므로 배열로 선언하여 맞은 개수 + 0의 개수를 더한 값을 rank의 인덱스로 하면 최고 등수, 맞은 갯수만 rank의 인덱스로 하면 최저 등수를 바로 구할 수 있어 성능도 향상 시킬 수 있다

---

옹알이(2)

문제

• 프로그래머스 - https://school.programmers.co.kr/learn/courses/30/lessons/133499
• "aya" , "ye", "woo", "ma" 네 가지 발음과 네 가지 발음을 조합해서 만들 수 있는 발음밖에 하지 못하고 연속해서 같은 발음을 하지 못할 때 문자열 배열 babbling 에서 발음할 수 있는 단어 갯수를 구하는 함수 구하기

제한조건

• 1 <= babbling의 길이 <= 100
• 1 <= babbling[i]의 길이 <= 30
• 문자열은 알파벳 소문자로만 이루어져 있음

입출력 예시

나의 풀이

3중 반복문, 문자열 검증 비교

class Solution {
    public int solution(String[] babbling) {
        String[] wordArr = {"aya", "ye", "woo", "ma"};
        int answer = 0;

        for (String str : babbling) {
            String wordHistory = "";
            int index = 0;  // 문자열 비교 검사 시작점

            while (index < str.length()) {
                boolean matched = false;

                for (String word : wordArr) {
                    if (str.startsWith(word, index)) {

                        if (word.equals(wordHistory)) break;

                        index += word.length(); // 문자열 비교 시작점 위치를 증가
                        wordHistory = word;
                        matched = true; // 발음 단어 일치
                    }
                }
                if (!matched) break;    // 발음 단어가 일치하지않으면 비교할 필요 없음 -> 반복 종료, 다음 단어 꺼냄
            }

            // str 전체가 wordArr의 요소로만 이루어져 있어서 비교를 모두 완료함 -> 카운트 증가
            if (index == str.length()) {
                answer++;
            }
        }
        return answer;
    }
}

• 발음할 수 있는 단어들을 문자열 배열로 선언한 뒤 매개변수로 주어진 단어를 반복문으로 하나씩 꺼내서 단어를 비교하도록 했다.
• 조건에서 연속된 단어는 발음하지 못한다는 제한 사항이 있으므로 이전에 바로 이전에 비교했던 단어를 보관해주는 변수 wordHistory를 선언해두었다.
• 비교 방법은 여러가지가 있겠지만 여기에서는 비교 대상 단어.startsWith(비교할 단어, 비교할 위치)를 통해서 문자열을 파싱 및 검증할 예정이므로 문자열을 비교 검사할 시작 위치를 나타내는 index 변수를 저장하고, 검증이 성공할때마다 검증한 단어의 길이를 누적 증가 시킬 예정이다.
• 다음 반복문은 while문으로 작성했는데 문자열을 검사할 위치가 비교대상인 단어의 길이를 넘어가게 된다면 비교할 단어가 없으므로 그 미만인 경우에만 반복하도록 조건을 작성했다
• 여기서 boolean matched 변수가 나오는데, startWith()로 단어가 일치하면 발음할 수 있는 단어들을 꺼내서 비교를 이어나가지만, 만약 비교한 단어가 일치하지 않으면 발음할 수 없는 단어가 포함된 것이기 때문에 비교를 하지않고 바로 반복을 종료시키기 위해 선언한 변수이다.
• 다음 반복문의 내부를 보면 발음할 수 있는 단어를 하나씩 꺼내서 비교를 하는데, 먼저 str.startsWith(word, index)로 단어를 비교하고, 맞다면 word.equals(wordHistory) 검증을 통해 이전에 비교했던 단어가 맞는지 한번 더 추가 검증한다
• 모든 검증이 통과하면 정상적으로 비교할 수 있으므로 index를 word.length()만큼 증가시켜 str을 계속 추가검증하도록 하고, wordHistory에는 검증한 단어를 대입하며, 검증에 성공했으므로 matched변수를 true로 변경시켜 계속 str의 단어를 반복하여 검사할 수 있도록 해두었다.
• 이렇게 모든 검증이 끝나면 answer의 값을 1 증가시켜야하는데, babbling의 요소가 모두 발음할 수 있는 단어만 증가시켜야 하므로 해당 요소의 검증을 무사히 마쳤을 때만 값을 1 증가시키도록 index == str.length()조건을 입력하여 문제를 해결했다

다른 풀이

replace 사용

class Solution {
    public int solution(String[] babblings) {
        // "aya", "ye", "woo", "ma" 4가지 발음만 가능
        int answer = 0;
        for(int i = 0; i < babblings.length; i++) {
            if(babblings[i].contains("ayaaya") || babblings[i].contains("yeye") || babblings[i].contains("woowoo") || babblings[i].contains("mama")) {
                continue;
            }

            babblings[i] = babblings[i].replace("aya", " ");
            babblings[i] = babblings[i].replace("ye", " ");
            babblings[i] = babblings[i].replace("woo", " ");
            babblings[i] = babblings[i].replace("ma", " ");
            babblings[i] = babblings[i].replace(" ", "");

            if(babblings[i].length()  == 0) answer++;

        }
        return answer;
    }
}

• 어.. 접근 방법이 내가 생각할 수 없었던 신박한 방법일 뿐만 아니라 반복을 3번 반복하는 나의 방식에 비해, 명시적인 for 반보고가 replace 메서드를 사용한 반복 1번으로 반복 횟수를 줄이는 것이 좋아보여서 가져왔다.
• 먼저 발음할 수 있는 단어를 연속적으로는 발음 못한다는 조건을 애초에 모두 작성하여 babbling의 요소를 꺼낼 때 비교하여 같다면 바로 다음 반복으로 건너뛰도록 작성하여 반복 횟술을 줄인 것 같다.
• 해당 조건을 통과하면 꺼낸 babblings에서 꺼낸 요소를 발음할 수 있는 단어가 있다면 " " 공백이 한칸 있는 문자열로 바꾸고, 마지막에 " " 공백 문자열을 다시 빈문자열로 바꿔서 발음할 수 있는 단어를 전부 제거한다.
• 그다음 제거된 babblings의 요소의 길이가 0이라면 모두 발음할 수 있는 단어라는 뜻이므로 answer를 증가시켜서 문제를 해결했다
• 여기서 replace를 할때 빈문자열이 아닌 공백이 한 칸있는 " "로 치환한 다음 다시 " " 공백 문자열을 "" 빈문자열로 변경하는 로직이 불필요하다고 생각할 수 있지만 그렇지 않다
• 이유는 if 조건문을 작성한 이유와 같은데, yayae와 같은 문자열이 들어왔을때 구분자를 ""이렇게 빈문자열로 한다면 aya로 먼저 제거했을 때 y와 e가 남아야하지만 ye가 붙어서 발음할 수 있는 단어가 되어버리는 상황이 발생할 수 있다
• 이런 문제를 방지하기 위해 각 발음할 수 있는 단어들을 제거하면 그 공간을 " " 공백이 있는 문자열로 한 것이다

reaplaceAll 사용

class Solution {
    public int solution(String[] babbling) {
        int answer = 0;
        for(int i=0; i<babbling.length; i++){
            babbling[i] = babbling[i].replaceAll("ayaaya|yeye|woowoo|mama","1");
            babbling[i] = babbling[i].replaceAll("aya|ye|woo|ma"," ");
            babbling[i] = babbling[i].replaceAll(" ","");
            if(babbling[i].equals("")) answer++;
        }
        return answer;
    }
}

• 정규식을 사용하는 replaceAll을 사용하면 코드의 반복되는 부분을 줄이면서 조건문도 모두 replaceAll로 작성할 수 있는데, 정규식을 사용하는 특성상 오히려 성능은 느릴 수 있다

---

숫자 짝꿍

문제

• 프로그래머스 - https://school.programmers.co.kr/learn/courses/30/lessons/131128
• 타입이 String인 두 정수 X, Y가 주어졌을 때, X, Y의 짝꿍을 return 하는 함수를 완성
• 짝꿍은 두 정수 X, Y의 임의의 자리에서 공통으로 나타나는 정수 k(0 <= k <= 9)들을 이용하여 만들 수 있는 가장 큰 정수를 뜻함
  • 공통으로 나타나는 정수 중 서로 짝지을 수 있는 숫자만 사용해야 함
  • 짝꿍이 존재하지 않으면-1, 짝꿍이 0으로만 구성되어있다면 0이 되야함
• 예시
  • X = 3403, Y = 13203 일때 공통 숫자는 3, 0, 3 -> 해당 숫자로 가장 큰 정수를 만들 수 있는 숫자는 330임
  • X = 5525, Y = 1255 일때 공통 숫자는 2, 5, 5 -> 해당 숫자로 가장 큰 정수를 만들 수 있는 숫자는 552임
    • X에는 5개 3개, Y는 5개 2개 이므로 남은 한개의 5는 짝 지을 수 없음

제한조건

• 3 <= X, Y 의 길이(자릿수) <= 3,000,000
• X, Y는 0으로 시작하지 않음
• X, Y의 짝꿍은 상당히 큰 정수일 수 있으므로 문자열로 반환함

입출력 예시

나의 풀이

배열의 index를 숫자 값으로 활용(Counting Sort)

class Solution {
    public String solution(String X, String Y) {
        int[] xCount = new int[10];
        int[] yCount = new int[10];

        for (char c : X.toCharArray()) {
            xCount[c - '0']++;
        }

        for (char c : Y.toCharArray()) {
            yCount[c - '0']++;
        }
        StringBuilder sb = new StringBuilder();

        for (int i = 9; i >= 0; i--) {
            int commonNumber = Math.min(xCount[i], yCount[i]);
            sb.append(String.valueOf(i).repeat(commonNumber));
        }

        if (sb.length() == 0) return "-1";
        if (sb.charAt(0) == '0') return "0";
        return sb.toString();
    }
}

• String 타입인 X와 Y에는 숫자가 들어있으므로 각 자리수를 비교해야 한다고 생각하고 접근했다.
• 처음에는 이중 반복문을 통해 문제를 해결해보려고 했는데, 자꾸 중복값이 발생하고 조건이 너무 많아져서 해당 방법은 포기하고 다른 방법을 찾아보았다.
• 힌트를 얻은 것이 어차피 숫자이기 때문에 각 자리수는 0 ~ 9로 고정되어있고 X와 Y의 요소를 하나씩 꺼내서 요소의 숫자가 몇개씩 들어있는지 확인하고, 이 정보를 통해서 높은 숫자부터 공통된 숫자를 들어있는 갯수만큼 꺼내면 된다는 것을 알았다.
• X와 Y의 각 요소의 갯수를 정보를 담은 int[] xCount, int[] yCount를 길이를 10으로하여 배열을 생성하여 해당 배열의 인덱스를 활용하여 반복문을 통해 각 요소의 개수를 저장해두었다.
• 이때 반복문에서 xCount[c - '0']++;과 같은 코드를 활용했는데 숫자인 문자 즉 '5'와같은 문자에서 '0'을 빼면 아스키 코드값으로 변화하여 계산되어 실제 숫자값 5를 얻을 수 있어 이 값을 배열의 인덱스 번호로 활용하여 값을 증가시켜 X, Y의 요소의 갯수를 구했다.
• 모든 요소의 갯수를 구한 후 다음 반복문을 통해 공통 숫자를 구하고 짝꿍을 구한다.
• 9부터 0까지 1씩 감소하면 반복하는데, 요구사항에서 공통 숫자 중 가장 큰 숫자를 만들어야 하므로 각 요소의 갯수를 담은 배열의 역순부터 꺼내야 높은 숫자부터 꺼낼 수 있기 때문이다
• 그리고 X와 Y의 공통 숫자를 일치한 개수 만큼만 꺼내기 위해서 Math.min을 통해서 각 배열의 요소를 높은 인덱스 번호부터 하나씩 꺼내서 비교하면 한번도 나오지 않은 숫자라면 값이 0이 되고, 공통된 숫자라면 더 적게 나온 값을 가져온다
• 이렇게 꺼낸 값을 String.valueOf(i).repeat(commonNumber)로 문자열로 변환된 i(공통 숫자)를 commonNumber만큼 반복하여 StringBuilder에 저장하면 공통 숫자들을 조합한 가장 큰 수를 얻을 수 있다
• 여기서 sb의 길이가 0이면 일치하는 숫자가 없으므로 "-1"을 반환하고, 처음 꺼낸 값이 0이면 0밖에 없다는 뜻이므로 "0"을 리턴하게하고, 모든 검증이 끝나면 스트링빌더를 sb.toString()을 통해 String으로 변환하여 반환한다.

 

 

---

SQL(MySQL)

조건에 맞는 사용자 정보 조회하기

문제 및 테이블 예시

• 프로그래머스 - https://school.programmers.co.kr/learn/courses/30/lessons/164670
• USED_GOODS_BOARD와 USED_GOODS_USER 테이블에서 중고 거래 게시물을 3건 이상 등록한 사용자의 사용자 ID, 닉네임, 전체주소, 전화번호를 조회하는 SQL문 작성
• 전체 주소는 시, 도로명 주소, 상세 주소가 함께 출력되도록 하고 전체주소라는 컬럼명으로 출력해야함
• 전화번호는 xxx-xxxx-xxxx 같은 형태로 하이픈 문자열("-")을 삽입하고 전화번호라는 컬럼명으로 출력해야함
• 결과는 회원 ID를 기준으로 내림차순 정렬해야함

 

입출력 예시

나의 풀이

group by 사용

SELECT
    UGU.USER_ID,
    UGU.NICKNAME,
    CONCAT(
        UGU.CITY, ' ',
        UGU.STREET_ADDRESS1, ' ',
        UGU.STREET_ADDRESS2) AS 전체주소,
    CONCAT(
        SUBSTR(UGU.TLNO, 1, 3), '-',
        SUBSTR(UGU.TLNO, 4, 4), '-',
        SUBSTR(UGU.TLNO, 8)) AS 전화번호
FROM
    USED_GOODS_BOARD AS UGB
JOIN 
    USED_GOODS_USER AS UGU
ON UGB.WRITER_ID = UGU.USER_ID
GROUP BY
    UGU.USER_ID,
    UGU.NICKNAME,
    UGU.CITY,
    UGU.STREET_ADDRESS1,
    UGU.STREET_ADDRESS2,
    UGU.TLNO
HAVING COUNT(UGU.USER_ID) >= 3
ORDER BY UGU.USER_ID DESC

• 전체 주소 컬럼을 묶기 위해서 CONCAT() 함수를 사용하여 각 컬럼의 문자열을 묶었는데, 가독성을 위해 각 컬럼을 묶을 때 사이에 ' ' 공백을 주었다.
• 전화번호 포맷팅도 동일한 방법을 사용했는데, 문자열을 자르는 SUBSTR() 함수를 사용하여 UGU.TLNO 컬럼을 원하는 만큼 잘라서 CONCAT으로 붙일 때 사이에 '-' 하이픈 문자열을 붙이는 방식을 사용했다.
• UGU.TLNO 컬럼을 1, 3 만큼 자르면 처음부터 3만큼 잘라지고, 4, 4 만큼 자르면 4번째부터 4만큼 잘라지고, 마지막으로 8로 자르면 8번째부터 끝까지 잘라지므로 이렇게 자른 각 문자열 중간에 '-'을 CONCAT으로 이어 붙였다
• 그리고 동일한 작성자가 게시글을 3개 이상 등록한 사용자를 출력하는 것이 목적이기 때문에 두개의 테이블의 유저ID를 나타내는 컬럼을 INNER JOIN 하고 조회에 사용된 모든 컬럼을 GROUP BY로 그룹화할 때 USED_GOODS_USER의 USER_ID를 COUNT()함수로 갯수를 세어 해당 값이 2보다 큰 데이터만 그룹화 하도록 조건을 적용시켜 문제를 해결했다.
• 이후 마지막으로 USER_ID 컬럼을 내림차순으로 하며 SQL을 완성 시켰다

다른 풀이

서브쿼리 사용(인라인 뷰)

SELECT
    UGU.USER_ID,
    UGU.NICKNAME,
    CONCAT(
        UGU.CITY, ' ',
        UGU.STREET_ADDRESS1, ' ',
        UGU.STREET_ADDRESS2) AS 전체주소,
    CONCAT(
        SUBSTR(UGU.TLNO, 1, 3), '-',
        SUBSTR(UGU.TLNO, 4, 4), '-',
        SUBSTR(UGU.TLNO, 8)) AS 전화번호
FROM USED_GOODS_USER AS UGU
JOIN (SELECT WRITER_ID
      FROM USED_GOODS_BOARD
      GROUP BY WRITER_ID HAVING COUNT(WRITER_ID) >= 3) AS UGB
ON UGB.WRITER_ID = UGU.USER_ID
ORDER BY UGU.USER_ID DESC

• JOIN된 테이블을 GROUP BY로 다시 조작하는 것은 DB마다 내부적으로 동작하는 방식이 다르기 때문에 MySQL에서는 정상적으로 조회 되었더라도 다른 DB에서는 정상적으로 조회되지 않을 가능성이 있어 DB에 종속적인 쿼리 방식이다
• 그렇기 때문에 더 안정적으로 작성하려면 애초에 인라인 뷰(FROM 절의 서브쿼리)를 통해 원하는 조건을 서브쿼리로 작성하여 해당 테이블을 JOIN하면 DB에 종속적이지도 않고 성능도 빠른 쿼리를 작성할 수 있다