JY의 기술블로그

[SQL/solvesql LV3] 초기 사용자의 친구 관계 찾기

jy9892 — Mon, 22 Dec 2025 21:08:24 +0900

https://solvesql.com/problems/friendship-between-early-users/

solvesql.com

Facebook 소셜 네트워크 데이터베이스에는 사용자의 정보와 사용자 사이의 친구 관계가 저장되어 있습니다.

edges 테이블의 각 행은 두 사용자(user_a_id, user_b_id)가 서로 친구 관계라는 의미입니다.

이 데이터베이스에서 사용자 ID는 auto increment 정수로 생성되기 때문에, ID가 낮을수록 더 일찍 가입한 사용자라고 볼 수 있습니다.

따라서 친구 관계인 두 사용자 ID의 합(user_a_id + user_b_id)이 작을수록 더 초창기에 형성된 친구 관계일 가능성이 높다고 추측할 수 있습니다.

문제 정리

테이블: edges
주요 컬럼

user_a_id : 친구 관계 사용자 A의 ID
user_b_id : 친구 관계 사용자 B의 ID

찾고 싶은 값

전체 친구 관계 중에서
두 사용자 ID의 합(id_sum)이 “상위 0.1%”에 해당하는 모든 친구 관계

출력 컬럼

user_a_id
user_b_id
id_sum (= user_a_id + user_b_id)

문제 해결 흐름

친구 관계 한 줄을 기준으로, 우리는 다음을 계산해야 합니다.

각 친구 관계의 id_sum 계산 (id_sum = user_a_id + user_b_id)
id_sum이 작은 순서대로 정렬해서 “초기일수록 앞쪽”에 오게 한다.
그 정렬 결과에서 각 관계의 순위(rn) 를 만든다. (가장 초기 관계가 1등, 다음이 2등 …)
전체 친구 관계 수(total_cnt)를 구한다.
문제에서 정의한 “상위 %”는 아래와 같다.
- 상위 % = 순위 / 전체 관계 수
- 따라서 “초기 0.1%”는 rn / total_cnt <= 0.001
- 이 조건을 만족하는 친구 관계만 출력하면 된다.

쿼리

WITH ranked AS (
  SELECT
    user_a_id,
    user_b_id,
    (user_a_id + user_b_id) AS id_sum,
    ROW_NUMBER() OVER (ORDER BY (user_a_id + user_b_id) ASC) AS rn,
    COUNT(*) OVER () AS total_cnt
  FROM edges
)
SELECT
  user_a_id,
  user_b_id,
  id_sum
FROM ranked
WHERE rn / total_cnt <= 0.001
ORDER BY id_sum ASC, user_a_id, user_b_id

핵심 문법 설명

1) ROW_NUMBER() — 정렬된 결과에 “번호표(순위)” 붙이기

ROW_NUMBER() OVER (ORDER BY id_sum ASC)

ORDER BY id_sum ASC 기준으로 줄 세운 뒤
각 행에 1, 2, 3… 번호를 붙입니다.
즉, rn은 id_sum이 작은 순서 기준 몇 번째인지(순위)를 의미합니다.

이 문제에서는 “초기 친구 관계”를 찾으므로
id_sum이 작은 관계가 앞 순위가 되도록 ASC를 사용합니다.

2) COUNT(*) OVER() — 전체 행 개수를 모든 행에 붙이기

COUNT(*) OVER ()

edges 테이블 전체 행 수(=전체 친구 관계 수)를
각 행마다 동일하게 붙입니다.
즉, total_cnt는 “전체 관계 수”입니다.

3) “상위 0.1%” 조건 구현

문제에서 정의한 상위 %:

상위 % = 순위 / 전체 관계 수

이를 그대로 SQL로 쓰면:

WHERE rn / total_cnt <= 0.001

0.001 = 0.1%
“초기 0.1%”에 해당하는 관계만 필터링 됩니다.

이 문제는 단순한 SELECT가 아니라 윈도우 함수의 진짜 쓰임새, 순위 기반 퍼센트 필터링 등을 한 번에 보여주는 좋은 문제 입니다.

특히 ROW_NUMBER + COUNT(*) OVER 조합은 익혀둡시다!!!!

[AI역검] 잡다 AI역량검사 약속 정하기 게임 꿀팁 (+무료 연습 게임 공유)

jy9892 — Mon, 22 Dec 2025 00:02:58 +0900

잡다 AI역량검사 전략게임 중 하나인 약속 정하기 게임,
너무 어렵죠 ㅠㅠ

겉으로 보면 “공통되는 거 하나 고르는 게임 아냐?” 싶은데, 실제로 해보면 기억할 게 많고, 놓치기 쉬운 작업기억 게임이에요.

저도 처음엔 왜 틀렸는지조차 모르겠어서
이 게임도 연습용으로 직접 만들어봤습니다.

연습용 게임 링크
https://v0-memory-game-bugs.vercel.app/
(로그인 X, 광고 X, 그냥 바로 연습 가능)

약속 정하기 게임?

이 게임은 여러 사람이 제시한 정보 속에서

모두에게 공통으로 해당되는 하나
또는 아무도 선택하지 않은 하나

를 찾아내는 작업기억 기반 전략 게임입니다.

단순 계산 문제가 아니라,
작업기억 · 주의집중 · 정보처리 속도를
한꺼번에 보는 인지 과제로 설계돼 있어요.

게임 구성

총 4라운드로 진행됩니다.

1~3라운드: 같은 구조 (공통 요소 찾기)
4라운드: 완전히 다른 방식 (아무도 선택하지 않은 것 찾기)

각 라운드 설명

1️⃣ 1라운드 – 요일 찾기

세 사람이 각각 가능한 요일 3~4개 제시
세 사람 모두에게 공통으로 포함된 요일 1개 선택

2️⃣ 2라운드 – 위치 찾기

16분할된 지도 위에
각자가 가능한 위치 3~4칸씩 제시
세 사람의 위치가 겹치는 단 하나의 칸 찾기

참고
제가 만든 연습 게임에는 현재 이 2라운드는 아직 구현하지 않았어요.
(구조가 조금 더 복잡해서 추후 추가 예정…)

3️⃣ 3라운드 – 메뉴 선택

여러 음식 메뉴가 제시됨
세 사람이 공통으로 선호하는 메뉴 1개 선택

4️⃣ 4라운드 – 버스 번호

사람들이 각각 탑승하는 버스 번호를 순서대로 제시
아무도 탑승하지 않은 버스 번호를 선택

여기서부터는 앞 라운드랑 전략이 완전히 달라집니다.

⭐ 핵심 공략: 소거법이 전부다

1·2·3라운드 공통 전략

이 게임의 핵심은 교집합만 남기는 소거법이에요.

순서 정리

1️⃣ 첫 번째 사람 정보 3~4개 빠르게 기억
2️⃣ 두 번째 사람 정보와 비교
→ 겹치는 것만 머릿속에 남기고 나머지는 버림
3️⃣ 세 번째 정보와 다시 비교
→ 최종 공통 1개만 선택
✔ 많이 외우려고 하면 오히려 망함
✔ “남길 것만 남기는 방식”이 정답

기억 꿀팁 (실제 체감됨)

✔ 요일 / 메뉴 / 위치는
→ 한 글자 or 간단한 코드로 치환
✔ 속으로 중얼거리면서 기억하면 유지력 ↑
✔ 눈으로만 보지 말고 머릿속에서 말로 처리

예)

월·수·금 → “월수금”
피자·파스타 → “피-파”

4라운드는 전략이 다르다 (중요)

버스 번호 라운드는
❌ 소거법 X
⭕ 누적 암기가 핵심입니다.
✔ 번호를 소리 내어 읽거나
✔ 리듬 붙여서 외우거나
✔ 자기만의 암기 스타일을 활용하는 게 훨씬 좋음
이 라운드는 “빨리 버리는 기억”이 아니라 끝까지 쌓아두는 기억을 봅니다.

잡다 AI역량검사의 약속 정하기 게임은 센스 게임이 아니라, 불필요한 정보를 버릴 줄 아는지, 필요한 정보만 끝까지 유지할 수 있는지를 보는 문제라고 생각해요.

고양이 술래잡기 게임이 메타인지를 본다면,
이 게임은 정통 작업기억 게임에 가깝습니다.

실전 전에 감이라도 잡고 들어가고 싶다면,
연습용으로 한 번쯤 해보는 것도 추천드려요.

취준생 여러분 파이팅입니다
다음 게임도 또 정리해볼게요!!

(글값은 좋아요, 구독으로 부탁드립니당)

[AI역검] 잡다 AI역량검사 고양이 술래잡기 게임 꿀팁 (+무료 연습 게임 공유)

jy9892 — Fri, 19 Dec 2025 17:57:23 +0900

요즘 잡다 AI역량검사 준비하시는 분들 많죠?
저도 취업 준비하면서 잡다 역검을 보게 됐는데

그중에서도 유독 고양이 술래잡기 게임이 너무 어렵더라고요.

솔직히 말하면…

처음엔 내가 이렇게 기억력이 안 좋았나? 싶을 정도로 계속 틀렸어요

그래서 “이거 연습이라도 해보자” 싶어서

바이브코딩으로 직접 연습용 게임을 만들어버렸습니다.

해당 게임을 너무 못해서 이것만 연습하고 싶었는데.. 실제 연습 환경은 너무 답답하더라고요.

연습 기회는 몇 번 안 주어지고
한 번 하려고 들어가면 바로 실전처럼 진행되고
내가 뭐가 맞았고 뭐가 틀렸는지 결과도 제대로 못 봄
확신을 어떻게 줘야 하는지도 감이 안 잡힌 채로 끝

그래서 만들었습니다!!

다들 편하게 이용해주세요

https://v0-cat-mouse-game.vercel.app/

(로그인 X, 광고 X, 그냥 바로 연습 가능)

잡다 AI역량검사 고양이 술래잡기 게임이 뭐냐면요....

이 게임은 단순한 기억력 테스트가 아니고,

기억 + 판단 + 확신 정도(메타인지)를 동시에 보는 게임이에요.

기본 구조

6×6 판, 총 36칸에서 진행됩니다.

1️⃣ 화면 1 – 쥐 위치 기억

6×6 판 위에 여러 마리 쥐가 아주 짧은 시간 나타남
순식간에 사라짐
이때 쥐의 정확한 위치를 최대한 기억해야 함

2️⃣ 화면 2 – 고양이 등장

같은 6×6 판에 고양이들이 등장
고양이는 파란 고양이 / 빨간 고양이로 색이 나뉨

3️⃣ 판단 규칙

이전에 쥐가 있던 칸 위에 고양이가 있으면 = 잡았다

그래서 매 라운드마다 다음을 판단해야 합니다.

응답 방식 (여기서 멘탈 많이 털림…)

각 화면 세트마다 총 2가지 선택을 합니다.

파란 고양이가 쥐를 잡았는지 여부 (O / X) + 그 판단에 대한 확신 정도
빨간 고양이가 쥐를 잡았는지 여부 (O / X) + 그 판단에 대한 확신 정도

확신 단계는 전혀 확신 없음 ~ 매우 확신 같은 식으로 선택하게 돼요.

잡다 역검 고양이 술래잡기 꿀팁 정리

✔ 쥐 위치를 모두 완벽히 외우려고 하지 말기
✔ 겹치는 위치 위주로 기억 전략 세우기
✔ 헷갈리면 확신 낮게 주는 연습이 중요
✔ 무조건 자신감 MAX는 오히려 독
✔ 연습을 통해 내가 헷갈리는 구간을 스스로 인지하는 게 핵심

솔직히 잡다 역검 보면서

“이거 연습 좀 더 해보고 들어갔으면…”

생각 한 번쯤 다들 하셨을 거예요.

저도 그 답답함 때문에 이 게임을 직접 만들어서

계속 틀려보고, 계속 헷갈려보고, 확신을 조절하는 연습을 했습니다.

완벽하게 맞추려고 하지 말고,

내가 헷갈리는 순간을 인지하는 연습 그게 이 게임의 핵심이라고 생각해요.

필요한 분들은 부담 없이 연습용으로 써보세요.

취준생 여러분 진짜 파이팅입니다!!!!!!!!!!!!!!

(글값은 좋아요, 구독으로 부탁드립니당)

[SQL/solvesql LV2] 이틀 연속 미세먼지가 나빠진 날

jy9892 — Sun, 7 Dec 2025 23:19:32 +0900

https://solvesql.com/problems/bad-finddust-days-in-a-row/

solvesql.com

서울숲 일별 평균 대기오염도 데이터베이스에는 2022년 동안 매일 기록된 미세먼지정보가 저장되어 있습니다.

우리가 궁금한 건 단순히 미세먼지 농도가 높은 날이 아니라, 이틀 연속 미세먼지 수치가 나빠져서, 세 번째 날에 30㎍/㎥ 이상이 된 날을 찾아내는 것입니다.

예를 들어,

1월 3일: 28㎍/㎥
1월 4일: 37㎍/㎥
1월 5일: 52㎍/㎥

이라면,

3→4, 4→5 이틀 연속 미세먼지가 상승했고, 1월 5일 수치가 30 이상이므로 1월 5일이 우리가 찾는 경고 일자(date_alert)가 됩니다.

문제 정리

테이블: measurements

주요 컬럼:

measured_at : 날짜 (일자)
pm10 : 해당 날짜의 일 평균 미세먼지 농도(㎍/㎥)

찾고 싶은 값:

date_alert :
이틀 연속 미세먼지 수치가 나빠져 세 번째 날(pm10)이 30㎍/㎥ 이상이 된 날짜

문제 해결 흐름

어떤 날짜를 D라고 할 때,

D-2일, D-1일, D일 이렇게 3일을 한 세트로 보고,
조건은 아래와 같습니다.

연속 3일 동안 미세먼지가 계속 증가
- pm10(D-2) < pm10(D-1) < pm10(D)
마지막 날(D)의 미세먼지가 30 이상
- pm10(D) >= 30

이 조건을 만족하는 날 D를 date_alert로 뽑으면 됩니다.

이걸 SQL로 구현하는 가장 자연스러운 방법이 바로 윈도우 함수 LAG를 이용해서 전날·이틀 전 값을 같이 조회하는 것입니다.

쿼리

WITH pm AS (
    SELECT
        measured_at,
        pm10,
        LAG(pm10, 1) OVER (ORDER BY measured_at) AS pm_d1,   -- 전날
        LAG(pm10, 2) OVER (ORDER BY measured_at) AS pm_d2    -- 이틀 전
    FROM measurements
)
SELECT
    measured_at AS date_alert
FROM pm
WHERE pm10 >= 30           -- 오늘 수치 30 이상
  AND pm_d2 < pm_d1        -- 이틀 전 < 전날
  AND pm_d1 < pm10         -- 전날 < 오늘 → 3일 연속 상승
ORDER BY date_alert

핵심 문법 설명

1. LAG 함수 — 이전 행의 값을 가져오는 윈도 함수

LAG(컬럼명, 몇칸_전) OVER (ORDER BY 정렬기준)

예를 들어 LAG(pm10, 1) OVER (ORDER BY measured_at) 라는 뜻은 measured_at 날짜 순서대로 정렬해서, 한 칸 앞(전날)의 pm10 값을 가져오는 것입니다.

LAG(pm10, 1) OVER (ORDER BY measured_at) AS pm_d1

LAG(pm10, 2) OVER (ORDER BY measured_at) AS pm_d2

LAG(column, offset)는 현재 행 기준 이전 행의 값을 가져오는 함수입니다.
offset = 1이면 전날, offset = 2이면 이틀 전 데이터를 읽어올 수 있습니다.
OVER (ORDER BY measured_at)
→ 날짜순으로 나열된 상태에서 이전 값을 가져오라는 의미입니다.

이 문제의 핵심은 3일 연속 미세먼지 증가 여부를 판단하는 것입니다. 따라서 이전 날짜의 pm10 값을 같은 행에서 비교하기 위해 LAG 함수가 사용됩니다.

[SQL/solvesql LV4] 세 명이 서로 친구인 관계 찾기

jy9892 — Thu, 20 Mar 2025 21:47:43 +0900

https://solvesql.com/problems/friend-group-of-3/

solvesql.com

문제 상황

소셜 네트워크 데이터를 분석하는 과정에서, 세 명의 사용자가 서로 친구 관계를 맺고 있는 "삼각형 구조"를 찾아야 합니다. 주어진 edges 테이블에는 (A, B) 형태의 친구 관계만 저장되어 있습니다.

우리의 목표는:

두 단계를 거쳐 (A, B, C) 형태의 친구 관계를 찾고,
최종적으로 (A, C) 관계까지 확인하여 실제 삼각관계를 필터링하는 것입니다.
특정 사용자(예: 3820)가 포함된 삼각형만 출력합니다.

문제 해결 흐름

Step 1: A-B-C 관계 찾기

edges 테이블을 두 번 조인하여 (A → B → C) 관계를 생성합니다.
E1.user_a_id → E1.user_b_id → E2.user_b_id 순서로 친구 연결을 확장합니다.
결과적으로 (A, B, C) 형태의 데이터셋을 만듭니다.

이렇게 하면 user_a_id → user_b_id → user_c_id 연결 구조가 만들어집니다.

Step 2: A-C 관계 확인

이제 (A, C) 관계가 실제로 존재하는지 검증해야 합니다. edges 테이블과 다시 조인하여 (A, C) 또는 (C, A) 관계가 있는 경우만 필터링합니다.

이렇게 하면 (A, C) 관계가 존재하는 삼각형만 남게 됩니다.

Step 3: 최종 결과 필터링

같은 삼각형이 여러 번 나오는 것을 방지하기 위해 user_a_id < user_b_id < user_c_id 조건을 추가합니다.
특정 사용자가 포함된 삼각형만 출력합니다 (예: 3820).

이제 3820이 포함된 모든 친구 삼각형이 출력됩니다.

쿼리

WITH ab AS (
    SELECT E1.user_a_id, E1.user_b_id, E2.user_b_id AS user_c_id
    FROM edges AS E1
    JOIN edges AS E2 
        ON E1.user_b_id = E2.user_a_id
),
ac AS (
    SELECT ab.user_a_id, ab.user_b_id, ab.user_c_id
    FROM ab
    JOIN edges AS E3
        ON ((ab.user_a_id = E3.user_a_id AND ab.user_c_id = E3.user_b_id) 
         OR (ab.user_a_id = E3.user_b_id AND ab.user_c_id = E3.user_a_id))
)

SELECT * 
FROM ac
WHERE user_a_id < user_b_id 
AND user_b_id < user_c_id
AND 3820 IN (user_a_id, user_b_id, user_c_id)

핵심 문법 설명

1. SELF JOIN 활용

같은 테이블을 두 번 이상 조인하여 관계를 확장할 수 있습니다.
본 문제에서는 edges 테이블을 두 번 조인하여 A-B-C 관계를 찾고, 한 번 더 조인하여 A-C 관계를 확인했습니다.

2. OR 조건을 활용한 대칭 관계 확인

친구 관계는 (A, B) 또는 (B, A)로 저장될 수 있습니다.
(A, C) 관계 확인 단계에서 OR 조건을 추가하여 대칭적 친구 관계를 고려했습니다.

마무리

이번 SQL 쿼리는 소셜 네트워크에서 삼각관계(클러스터링 구조)를 찾는 문제를 해결했습니다. WITH AS를 활용한 구조화된 접근 방식을 사용하여:

(A → B → C) 관계를 구성하고,
(A, C) 관계를 확인하여 삼각형 필터링한 후,
3820이 포함된 삼각형만 출력하는 방식으로 문제를 해결했습니다.

이 방법을 활용하면, 친구 네트워크의 밀도를 분석하거나 추천 시스템을 설계하는 데에도 활용할 수 있습니다!

[python/프로그래머스 LV1] 과일 장수

jy9892 — Mon, 24 Feb 2025 00:06:35 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/135808

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

문제 이해

1️⃣ 사과 포장 규칙

한 상자에는 m개씩 담아야 합니다.
상자에 담긴 사과 중 최소 점수가 p일 때, 상자의 가격은 p × m입니다.
최대 이익을 얻을 수 있도록 사과를 포장해야 합니다.
사과가 남더라도 m개를 채우지 못하면 버려야 합니다.

최적의 이익을 구하는 알고리즘

사과 점수를 내림차순 정렬
- 큰 점수부터 함께 묶어야 그룹의 최소값이 높아짐.
m개씩 묶어 최대한 많은 상자를 만듦
- m개가 안 되는 사과는 버림.
각 그룹의 최소값을 찾아 p × m을 계산하여 최대 이익을 구함.

def solution(k, m, score):
    answer = 0  # 총 이익
    
    score.sort(reverse=True)  # 내림차순 정렬
    
    i = 0  # 시작 인덱스
    while (i + m <= len(score)):  # `m`개 이상 남아있을 때만 반복
        box = score[i : i + m]  # `m`개씩 슬라이싱하여 상자 만들기
        price = min(box) * m  # 최소값 × `m`
        answer += price  # 총 이익 누적
        i += m  # 다음 그룹으로 이동
        
    return answer  # 최대 이익 반환

코드 설명

핵심 로직

score.sort(reverse=True)	사과 점수를 내림차순 정렬하여 최상품부터 그룹화
while (i + m <= len(score)):	m개 이상 남아 있을 때만 그룹을 만듦 (리스트 범위 초과 방지)
box = score[i : i + m]	리스트 슬라이싱을 사용해 m개씩 그룹화
price = min(box) * m	그룹 내 최소 점수 × m (상자의 가격)
answer += price	총 이익 누적
i += m	다음 m개를 위해 인덱스 이동

실행 흐름 예제

예제 실행

print(solution(3, 4, [1, 2, 3, 1, 2, 3, 1]))

내림차순 정렬 → [3, 3, 2, 2, 1, 1, 1]
첫 번째 그룹: [3, 3, 2, 2] → 최소값 2 × 4 = 8
남은 [1, 1, 1]은 버림.
최종 이익 = 8

[SQL/프로그래머스 LV3] 멀티 플랫폼 게임 찾기

jy9892 — Wed, 5 Feb 2025 20:45:24 +0900

https://solvesql.com/problems/multiplatform-games/

solvesql.com

문제 상황

게임 데이터에서 2012년 이후 출시된 게임 중, 두 개 이상의 서로 다른 제조사(Sony, Nintendo, Microsoft)에서 출시된 게임을 찾는 문제입니다. 즉, 멀티 플랫폼 게임을 확인하고, 특정 게임이 다양한 제조사의 기기에서 출시되었는지 분석해야 합니다.

문제 접근

제조사 매핑 (CASE 문 활용)
- platforms 테이블의 name을 활용해 플랫폼별 제조사(Sony, Nintendo, Microsoft)를 분류합니다.
- 이 결과를 WITH plat AS (...))으로 저장하여, 제조사 정보를 포함한 데이터셋을 만듭니다.
게임 데이터와 제조사 정보 결합
- games 테이블과 platforms 테이블을 platform_id를 기준으로 조인하여, 각 게임이 출시된 제조사를 연결합니다.
- 2012년 이후 출시된 게임만 선택합니다.
두 개 이상의 제조사에서 출시된 게임 찾기
- 같은 게임(g.name)이 다른 제조사에서 출시된 경우를 찾기 위해 GROUP BY g.name을 적용합니다.
- HAVING COUNT(DISTINCT p.company) >= 2 조건을 사용하여 2개 이상의 제조사에서 출시된 게임만 필터링합니다.

쿼리

WITH plat AS (
  SELECT name, 
         platform_id, 
         CASE 
             WHEN name IN ('PS3', 'PS4', 'PSP', 'PSV') THEN 'Sony'
             WHEN name IN ('Wii', 'WiiU', 'DS', '3DS') THEN 'Nintendo'
             WHEN name IN ('X360', 'XONE') THEN 'Microsoft'
         END AS company
  FROM platforms
)

SELECT DISTINCT g.name
FROM games AS g
JOIN plat AS p
ON g.platform_id = p.platform_id
WHERE g.year >= 2012
GROUP BY g.name
HAVING COUNT(DISTINCT p.company) >= 2

핵심 문법 설명

1. WITH AS 절 (공통 테이블 표현식, CTE)

WITH AS 절은 서브쿼리(임시 테이블)를 생성하여, 이후 메인 쿼리에서 재사용하는 방식입니다.
한 번 정의된 WITH 절은 쿼리 내에서 여러 번 사용할 수 있어 코드 중복을 줄입니다.

WITH 테이블명 AS (
    SELECT 컬럼명
    FROM 원본테이블
    WHERE 조건
)
SELECT * FROM 테이블명;

2. CASE WHEN 절

CASE WHEN은 SQL에서 IF-ELSE 문과 비슷한 역할을 합니다.
특정 조건을 만족하면 해당 값을 반환하며, 조건을 만족하지 않는 경우 ELSE를 사용할 수 있습니다.

CASE 
    WHEN 조건1 THEN 결과1
    WHEN 조건2 THEN 결과2
    ELSE 결과3
END AS 컬럼명

마무리

이번 쿼리는 2012년 이후 출시된 게임 중, 두 개 이상의 서로 다른 제조사(Sony, Nintendo, Microsoft)에서 출시된 게임을 찾는 문제를 해결하기 위해 WITH AS와 CASE WHEN을 활용했습니다.

이를 통해 플랫폼 데이터를 제조사별로 그룹화하고, JOIN 및 HAVING COUNT(DISTINCT) 조건을 사용하여 다중 제조사에서 출시된 게임을 효과적으로 필터링할 수 있었습니다.

[python/프로그래머스 LV1] K번째수

jy9892 — Wed, 5 Feb 2025 18:01:26 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42748

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

주어진 리스트 array에서 특정 구간을 자르고 → 정렬하고 → k번째 값을 찾는 문제입니다.

배열에서 i번째부터 j번째까지 자르기
정렬하기
k번째 값 찾기

예를 들어, array = [1, 5, 2, 6, 3, 7, 4]이고 commands = [[2, 5, 3], [4, 4, 1], [1, 7, 3]]라면:
첫 번째 명령어 [2, 5, 3]을 처리하는 과정을 보면,

array의 2번째부터 5번째까지 가져오면 [5, 2, 6, 3]
이를 정렬하면 [2, 3, 5, 6]
여기서 3번째 값은 5

이런 방식으로 각 commands를 처리한 결과를 리스트로 반환하는 문제입니다.

def solution(array, commands):
    answer = []
    
    for command in commands:
        i, j, k = command
        sliced_array = sorted(array[i-1:j])  # 리스트 자르고 정렬
        answer.append(sliced_array[k-1])  # k번째 값 추가
    
    return answer

코드해석

def solution(array, commands):
   answer = []
       for command in commands:
        i, j, k = command

1. solution 함수는 두 개의 인자를 받습니다: array(숫자리스트), commands(여러개의 i,j,k를 담는 리스트)

- commands의 각 원소는 [i, j, k] 형태이며, 슬라이싱 범위(i~j)와 k번째 값을 의미합니다.

2. 최종 결과를 저장할 빈 리스트 answer를 생성합니다.

3. commands 리스트를 하나씩 순회하며 [i, j, k]를 가져옵니다.

- command는 [i, j, k] 형태의 리스트이며, 이를 변수 i, j, k에 할당합니다.

1회차: i=2, j=5, k=3  (command = [2, 5, 3])
2회차: i=4, j=4, k=1  (command = [4, 4, 1])
3회차: i=1, j=7, k=3  (command = [1, 7, 3])

sliced = sorted(array[i-1:j])
answer.append(sliced[k-1])
return answer

4. array[i-1:j] : 리스트 슬라이싱을 사용하여 i번째부터 j번째까지의 요소를 추출합니다.

- Python의 인덱스는 0부터 시작하므로, i-1을 사용합니다.

5. sorted(...) : 슬라이싱한 리스트를 정렬합니다.

- 예제에서 [5, 2, 6, 3] → [2, 3, 5, 6]

6. 정렬된 리스트에서 k번째 값을 찾고, 이 값을 answer 리스트에 추가합니다.

7. 모든 commands를 처리한 후 최종 결과 answer를 반환합니다.

코드 요약

✔ commands 리스트를 하나씩 반복하며 [i, j, k] 값을 가져옴
✔ array에서 i~j 범위를 슬라이싱
✔ 정렬 후 k번째 값을 answer 리스트에 추가
✔ answer를 반환

사용된 주요 함수

✅ 리스트 슬라이싱 (array[i-1:j])

리스트의 일부를 가져올 때 사용됩니다.
i번째 ~ j번째를 가져오려면 Python은 0부터 시작하는 인덱스 시스템이므로, i-1을 사용해야 합니다.

arr = [10, 20, 30, 40, 50]
print(arr[1:4])  # [20, 30, 40]  (index 1 ~ 3까지 포함)

✅ sorted() 함수

리스트를 정렬할 때 사용됩니다.
새로운 정렬된 리스트를 반환하며, 원본 리스트는 변경되지 않습니다.

arr = [3, 1, 4, 1, 5]
sorted_arr = sorted(arr)  # [1, 1, 3, 4, 5]

✅ list.append(value)

리스트에 새로운 값을 추가할 때 사용됩니다.

numbers = [1, 2, 3]
numbers.append(4)
print(numbers)  # [1, 2, 3, 4]

✅ 리스트 인덱싱 (list[index])

리스트의 특정 위치 값을 가져오는 방법입니다.
Python의 인덱스는 0부터 시작하므로 k번째 요소는 k-1 인덱스로 접근합니다.

arr = [10, 20, 30, 40, 50]
print(arr[2])  # 3번째 요소 (30)

[SQL/프로그래머스 LV3] 대여 횟수가 많은 자동차들의 월별 대여 횟수 구하기

jy9892 — Fri, 17 Jan 2025 10:00:13 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/151139

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

문제 상황:

월별로 대여 횟수가 5회 이상인 차량만 필터링하고, 이러한 차량의 월별 대여 횟수를 계산.

문제 접근:

단계 1: 총 대여 횟수가 5회 이상인 차량 필터링

먼저, CAR_ID를 기준으로 그룹화하여 차량별 총 대여 횟수를 계산합니다. 이 중 대여 횟수가 5회 이상인 차량만 추출합니다

단계 2: 조건을 만족하는 차량과 원본 데이터를 결합

총 대여 횟수가 5회 이상인 차량만 남긴 서브쿼리 결과를 원본 테이블과 JOIN합니다. 이를 통해 조건에 맞는 차량의 모든 대여 기록을 가져옵니다.

단계 3: 월별 대여 횟수를 계산

조건을 만족하는 차량의 대여 기록에서 월별 대여 횟수를 계산합니다. 이를 위해:

MONTH(P.START_DATE)로 월을 추출.
GROUP BY를 사용해 월(MONTH)과 차량 ID(CAR_ID)별로 그룹화.
COUNT(P.HISTORY_ID)를 사용해 월별 대여 횟수를 집계.

논리 흐름:

필터링 조건 정의:
- 전체 데이터에서 총 대여 횟수가 5회 이상인 차량만 남깁니다.
조건 만족 차량과 원본 데이터 결합:
- CAR_ID를 기준으로 서브쿼리와 원본 데이터를 JOIN하여, 필터링된 차량의 모든 대여 기록을 가져옵니다.
월별 집계:
- 대여 시작 날짜(START_DATE)에서 월(MONTH)을 추출하여 GROUP BY로 그룹화.
- 각 월별로 대여 횟수를 계산합니다.

쿼리:

SELECT 
    MONTH(P.START_DATE) AS MONTH, 
    P.CAR_ID, 
    COUNT(P.HISTORY_ID) AS MONTHLY_RECORDS
FROM 
    CAR_RENTAL_COMPANY_RENTAL_HISTORY AS P
JOIN (
    SELECT 
        CAR_ID
    FROM 
        CAR_RENTAL_COMPANY_RENTAL_HISTORY
    WHERE 
        START_DATE >= '2022-08-01' AND START_DATE <= '2022-10-31'
    GROUP BY 
        CAR_ID
    HAVING 
        COUNT(HISTORY_ID) >= 5
) AS A
ON 
    P.CAR_ID = A.CAR_ID
WHERE 
    P.START_DATE >= '2022-08-01' AND P.START_DATE <= '2022-10-31'
GROUP BY 
    MONTH(P.START_DATE), P.CAR_ID
ORDER BY 
    MONTH ASC, P.CAR_ID DESC;

서브쿼리 (A):

CAR_ID별로 전체 대여 횟수를 계산하고, 5회 이상 대여된 차량만 필터링합니다:

JOIN:

서브쿼리 결과(A)와 원본 테이블(P)을 CAR_ID 기준으로 JOIN하여, 조건을 만족하는 차량의 월별 데이터를 필터링합니다:

월별 대여 횟수 계산:

COUNT(P.HISTORY_ID)를 사용하여 P.START_DATE에서 추출한 월별 대여 횟수를 계산합니다.

GROUP BY:

MONTH(P.START_DATE)와 P.CAR_ID를 기준으로 그룹화하여 월별로 집계합니다.

최종 출력:

MONTHLY_RECORDS 열에 각 월별 차량의 대여 횟수를 출력합니다.

얻은 인사이트:

그룹화와 서브쿼리의 활용:
- GROUP BY와 서브쿼리를 활용하여 특정 조건을 만족하는 데이터를 효율적으로 필터링할 수 있었습니다.
- 서브쿼리 내에서 CAR_ID별로 대여 횟수를 집계하고, 이를 JOIN하여 원본 데이터를 필터링함으로써 정확한 결과를 도출할 수 있었습니다.
JOIN을 통한 데이터 결합:
- JOIN을 활용하여 서브쿼리의 결과와 원본 데이터를 결합함으로써, 조건을 만족하는 데이터만을 추출할 수 있었습니다.
- 이는 대규모 데이터셋에서 특정 조건을 만족하는 데이터를 효율적으로 처리하는 데 유용합니다.
SQL 문법의 중요성:
- 비교 연산자의 올바른 사용 (<= vs =<)과 서브쿼리의 별칭 지정은 SQL 쿼리 작성 시 필수적인 요소입니다.
- 잘못된 문법은 예상치 못한 오류를 발생시킬 수 있으므로, 항상 주의가 필요합니다.
데이터 집계의 정확성:
- COUNT(history_id) >= 5 조건을 통해, 총 대여 횟수가 5회 이상인 차량만을 대상으로 분석함으로써, 보다 의미 있는 데이터를 얻을 수 있었습니다.
- 이는 분석 목적에 맞는 정확한 데이터 집계의 중요성을 보여줍니다.

[SQL/프로그래머스 LV.3] 헤비 유저가 소유한 장소

jy9892 — Thu, 16 Jan 2025 16:00:44 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/77487

프로그래머스

SW개발자를 위한 평가, 교육, 채용까지 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

SQL에서 그룹화와 서브쿼리를 활용한 데이터 필터링: 사례 분석

1. 문제 상황: 데이터 필터링 오류

SQL에서 GROUP BY와 HAVING을 활용해 특정 조건에 맞는 데이터를 추출하려고 했으나, 작성한 쿼리가 제대로 작동하지 않았습니다. 아래는 처음 작성한 쿼리입니다:

SELECT *
FROM (
    SELECT *
    FROM PLACES
    GROUP BY HOST_ID
    HAVING COUNT(HOST_ID) >= 2
)



SELECT ID, NAME, HOST_ID
FROM (
    SELECT HOST_ID, COUNT(HOST_ID) AS HOST_COUNT, NAME, ID
    FROM PLACES
    GROUP BY HOST_ID
    HAVING COUNT(HOST_ID) >= 2
) AS HEAVY

2. 오류 원인

GROUP BY와 SELECT *의 문제:
- GROUP BY는 그룹화 기준(HOST_ID) 및 집계 함수(COUNT(HOST_ID))로 데이터를 반환합니다.
- 하지만 SELECT * 또는 SELECT ID, NAME, HOST_ID와 같이 다른 열을 함께 선택하려면, 그룹화되지 않은 열을 반환할 수 없으므로 SQL 문법상 오류가 발생합니다.
의도와 실행의 불일치:
- 위 쿼리는 HOST_ID를 기준으로 그룹화된 데이터에서 ID, NAME, HOST_ID를 모두 가져오고자 했지만, 그룹화되지 않은 열(ID, NAME)은 쿼리에 포함할 수 없습니다.
올바른 결과를 위한 JOIN 필요성:
- 그룹화 결과에 해당하는 데이터를 원본 테이블에서 가져오려면, JOIN을 활용해 데이터를 연결해야 합니다.
서브쿼리 별칭 :
- SQL에서 서브쿼리(derived table)를 사용할 때는 각 서브쿼리에 반드시 별칭(alias)을 지정해야 합니다.
- MySQL에서는 서브쿼리에 별칭이 없으면 Every derived table must have its own alias 오류가 발생합니다.

3. 수정한 쿼리

SELECT P.ID, P.NAME, P.HOST_ID
FROM PLACES AS P
JOIN (
    SELECT HOST_ID
    FROM PLACES
    GROUP BY HOST_ID
    HAVING COUNT(HOST_ID) >= 2
) AS HEAVY
ON P.HOST_ID = HEAVY.HOST_ID

서브쿼리 (HEAVY):

GROUP BY와 HAVING을 사용해 HOST_ID가 2번 이상 등장하는 경우만 추출합니다.

JOIN 활용:

원본 테이블(PLACES)과 서브쿼리 결과(HEAVY)를 HOST_ID를 기준으로 JOIN.
조건에 맞는 HOST_ID를 가진 데이터의 모든 열(ID, NAME, HOST_ID)을 원본 테이블에서 가져옵니다.

최종 결과:

HOST_ID가 2번 이상 등장하는 행만 필터링된 결과를 반환.

4. 얻은 인사이트

1️⃣ GROUP BY와 SELECT 사용의 원칙

GROUP BY를 사용할 때는 그룹화 기준 열과 집계 함수로만 데이터를 반환할 수 있습니다.
그룹화되지 않은 다른 열을 가져오려면, 집계 함수(예: MAX, MIN, ANY_VALUE) 또는 JOIN을 활용해야 합니다.

2️⃣ JOIN 활용

그룹화된 결과를 원본 데이터와 매칭하려면 서브쿼리와 JOIN을 활용해야 합니다.
이 방법은 조건에 맞는 데이터 필터링 후 원본 테이블의 모든 열을 반환할 때 유용합니다.

3️⃣ SQL 작성 시 단계별 설계 중요성

원하는 결과를 얻기 위해 SQL 쿼리를 단계적으로 설계하고, 중간 결과를 확인하는 과정이 중요합니다.
조건 설정(HAVING)과 데이터 연결(JOIN)의 역할을 명확히 이해하면 문제 해결이 수월해집니다.

이 사례를 통해 그룹화된 데이터를 원본 테이블과 매칭하여 필요한 모든 데이터를 가져오는 방법을 이해할 수 있었습니다. 중요한 점은 SQL의 GROUP BY, HAVING, 그리고 JOIN의 역할을 명확히 이해하고, 각각의 기능을 적절히 활용하는 것입니다. SQL로 복잡한 데이터를 다룰 때도 "문제의 원인 분석 → 설계 → 구현" 과정을 거치면 효과적으로 문제를 해결할 수 있습니다.