몸과 마음이 건전한 SW 개발자

[HackerRank-MSSQL] 해커랭크 Basic Join - Top Competitors

스위태니 — Thu, 23 Apr 2026 08:21:31 +0900

문제 링크

https://www.hackerrank.com/challenges/full-score/problem?isFullScreen=true

Top Competitors | HackerRank

Query a list of top-scoring hackers.

www.hackerrank.com

정답 코드

select H.hacker_id, H.name from submissions as S
join challenges as C on S.challenge_id = C.challenge_id 
join difficulty as D on C.difficulty_level = D.difficulty_level
join hackers as H on H.hacker_id = S.hacker_id
where S.score = D.score
group by H.hacker_id, H.name having count(*) >= 2
order by count(*) desc, H.hacker_id asc;

풀이 과정

데이터 결합(Join): 먼저 제출 이력(Submissions), 문제 정보(Challenges), 난이도(Difficulty), 해커 정보(Hackers) 테이블을 모두 연결하여 하나의 거대한 데이터 세트를 만든다.
난이도별 만점 기준 확인: Challenges와 Difficulty 테이블을 조인함으로써, 각 문제의 난이도 레벨에 해당하는 최고 점수(D.score)가 얼마인지 식별한다.
만점 여부 필터링(Where): WHERE S.score = D.score 조건을 통해, 해커가 획득한 점수가 해당 문제의 최고 점수와 일치하는 '만점 제출건'만 남긴다.
해커별 그룹화(Group By): 만점을 받은 기록들을 해커의 ID와 이름별로 묶어, 해커 한 명당 몇 개의 만점을 기록했는지 계산할 준비한다.
2회 이상 달성자 선별(Having): HAVING count(*) >= 2 구문을 사용하여 만점 횟수가 2회 이상인 실력파 해커들만 최종적으로 필터링한다.
결과 정렬(Order By): 만점을 많이 받은 순서(내림차순)로 먼저 정렬하고, 횟수가 같다면 해커 ID(오름차순) 순으로 정렬하여 결과를 출력한다.

느낀점

테이블을 그리고 하나하나 연결하면서 문제를 풀면 좀 괜찮다.
하나씩 조인하고 확인하고 조인하는 과정을 거치면 좋다.

[HackerRank-MSSQL] 해커랭크 Basic Join - The Report

스위태니 — Tue, 21 Apr 2026 14:20:09 +0900

문제 링크

https://www.hackerrank.com/challenges/the-report/problem?isFullScreen=true

The Report | HackerRank

Write a query to generate a report containing three columns: Name, Grade and Mark.

www.hackerrank.com

틀린 코드

select if(gra.grade >= 8, stu.name, null), gra.grade, stu.marks from students as stu
left join grades as gra on stu.marks >= gra.min_mark and stu.marks <= gra.max_mark
order by gra.grade desc, stu.name;

정답 코드

SELECT 
    CASE 
        WHEN G.Grade >= 8 THEN S.Name 
        ELSE NULL 
    END AS Name, 
    G.Grade, 
    S.Marks
FROM Students S
JOIN Grades G ON S.Marks BETWEEN G.Min_Mark AND G.Max_Mark
ORDER BY 
    G.Grade DESC, 
    CASE WHEN G.Grade >= 8 THEN S.Name END ASC,
    CASE WHEN G.Grade < 8 THEN S.Marks END ASC;

풀이 과정

일단 8등급 이하 학생은 null로 보여주려고 했다.
- 근데 IF가 없고 여기서는 CASE END와 그 속에서 WHEN THEN ELSE를 써야했다.
조인은 잘 했는데 정렬을 틀렸다.
등급 순 내림차순으로 정렬하고
- 8등급 이상은 이름 + 오름차순
- 8등급 미만은 점수 + 오름차순
- 으로 정렬해야 한다.

느낀점

이 바닥 겸손해야 한다.
when then else case end 봤지만 쓸줄 모른다.

[HackerRank-MSSQL] 해커랭크 Basic Join - Average Population of Each Continent

스위태니 — Tue, 21 Apr 2026 13:44:30 +0900

문제 링크

https://www.hackerrank.com/challenges/average-population-of-each-continent/problem?isFullScreen=true

Average Population of Each Continent | HackerRank

Query the names of all continents and their respective city populations, rounded down to the nearest integer.

www.hackerrank.com

틀린 코드 1

select co.continent, floor(avg(ci.population)) from city as ci 
left join country as co on ci.countrycode = co.code 
group by co.continent;

틀린 코드 2

select co.continent, floor(avg(ci.population)) from city as ci 
right join country as co on ci.countrycode = co.code 
group by co.continent;

정답 코드

SELECT 
    CO.Continent, 
    FLOOR(AVG(CI.Population))
FROM CITY AS CI
INNER JOIN COUNTRY AS CO 
    ON CI.CountryCode = CO.Code
GROUP BY CO.Continent;

풀이 과정

1. 문제 해결 사고 과정

연결(Join): CITY 테이블에는 인구 정보가 있고, COUNTRY 테이블에는 대륙 정보가 있습니다. 두 테이블을 CountryCode와 Code를 기준으로 합쳐야 합니다.
그룹화(Group By): 대륙별 평균을 구해야 하므로 Continent 컬럼을 기준으로 데이터를 묶습니다.
계산(Average): AVG(Population)를 사용하여 인구 평균을 구합니다.
내림(Floor & Integer): 소수점을 버리고(내림) 결과값을 정수(Integer) 형태로 출력해야 합니다.

2. 주요 오답 포인트 및 정리

왜 INNER JOIN?
- 도시가 있는 국가와 대륙만 계산하면 되기 때문. 만약 RIGHT JOIN을 써서 도시가 없는 대륙까지 나오면 평균값이 NULL이 되어 오답 처리가 될 수 있다.
왜 CAST(... AS FLOAT)?
- MSSQL에서 INT / INT를 하면 결과도 정수형이 되어 소수점이 미리 잘려나갈 수 있다. 정확한 평균 계산 후 내림을 하기 위해 잠시 실수형(FLOAT)으로 변환하는 것이 안전
왜 FLOOR?
- 문제에서 요구한 'Rounded down'에 가장 부합하는 함수. (소수점 첫째 자리에서 무조건 내림)

느낀점

left join을 해버리면 대륙이 명시되지 않은 데이터를 가져와서 null로 보여진다.
right join을 하면 도시에 인구수가 명시되지 않은 데이터까지 avg를 하기 때문에 null이 나온다.
따라서 둘 다 있는 inner join으로 문제를 풀어야 한다.
데이터가 어떻게 생겼는지를 모르니 풀기가 좀 까다로웠다.

[HackerRank-MSSQL] 해커랭크 Aggregation Weather Observation Station 14

스위태니 — Tue, 21 Apr 2026 11:58:45 +0900

문제 링크

https://www.hackerrank.com/challenges/weather-observation-station-14/problem?isFullScreen=true

Weather Observation Station 14 | HackerRank

Query the greatest value of the Northern Latitudes from STATION that are under 137.2345 and truncated to 4 decimal places.

www.hackerrank.com

정답 코드

select top(1) cast(lat_n as decimal(10, 4)) from station
where lat_n < 137.2345
order by lat_n desc;

[HackerRank-MSSQL] 해커랭크 Aggregation Weather Observation Station 13

스위태니 — Tue, 21 Apr 2026 11:54:18 +0900

문제 링크

https://www.hackerrank.com/challenges/weather-observation-station-13/problem?isFullScreen=true

Weather Observation Station 13 | HackerRank

Query the sum of Northern Latitudes having values greater than 38.7880 and less than 137.2345, truncated to 4 decimal places.

www.hackerrank.com

정답 코드

SELECT CAST(SUM(LAT_N) AS DECIMAL(10, 4))
FROM STATION 
WHERE LAT_N > 38.7880 AND LAT_N < 137.2345;

느낀점

MS SQL Server에는 TRUNCATE라는 함수가 따로 없다.
대신 ROUND 함수의 세 번째 인자를 활용하거나 CAST를 사용해야 한다.
하지만 round의 경우 해당 자리에서 자를 뿐이지 00은 원본만큼 보여준다.
- round(1234.1234, 1)
- 1234.1000
따라서 cast나 format을 써야하는데 format이 느리기 때문에 일부러 cast를 사용했다.
숫자가 너무 큰 경우 format을 사용해야 할 수 있다.

[HackerRank-MSSQL] 해커랭크 Aggregation Weather Observation Station 2 (Cast, Decimal, Format, Round, N, F)

스위태니 — Tue, 21 Apr 2026 11:42:19 +0900

문제 링크

https://www.hackerrank.com/challenges/weather-observation-station-2/problem?isFullScreen=true

Weather Observation Station 2 | HackerRank

Write a query to print the sum of LAT_N and the sum of LONG_W separated by space, rounded to 2 decimal places.

www.hackerrank.com

틀린 코드 1

SELECT ROUND(SUM(LAT_N), 2), ROUND(SUM(LONG_W), 2) FROM STATION;

틀린 코드 2

SELECT CAST(SUM(LAT_N) AS DECIMAL(10, 2)), CAST(SUM(LONG_W) AS DECIMAL(10, 2)) FROM STATION;

정답 코드

SELECT 
    CAST(SUM(LAT_N) AS DECIMAL(10, 2)), 
    CAST(SUM(LONG_W) AS DECIMAL(10, 2)) 
FROM STATION;

풀이 과정

생략

공부하기

CAST 함수
- 이 데이터를 저 데이터 형식으로 형변환(Type Conversion)해라
- CAST(대상 AS 바꿀데이터타입)
DECIMAL(p, s)
- decimal(10, 2)
- precision, 정밀도
  - 10
  - 소수점 앞뒤를 모두 포함한 전체 숫자의 개수
- scale, 스케일
  - 2
  - 소수점 아래 몇 번째 자리까지 표현할 것인지
- round와의 차이
  - round는 반올림만 해주고 소수점은 원본만큼 보여줌
    - round (12.1314, 1)
    - 12.1000
  - decimal은 반올림 자동
  - 소수점 자릿수도 딱 n자리로 고정해서 보여준다.
    - cast(123.4567 as decimal(10, 2))
    - 123.46
Format
- 반올림 수행 및 천 단위 콤마
- 천 단위 콤마 = N
  - N2는 1,234.56처럼 콤마를 찍지만, F2는 1234.56으로 출력
- F는 고정 소수점
  - Fixed-point
하지만,,,
- CAST는 매우 빠르고, FORMAT은 상대적으로 꽤 느리다.
- 성능에서 차이가 올 수 있음

[MSSQL] Microsoft SQL Server, SQL Server Management Studio 빠르게 설치하기 (2026년 4월 20일 최신)

스위태니 — Mon, 20 Apr 2026 17:32:05 +0900

< 내용 >

Microsoft SQL Server와 SQL Server Management Studio를 설치하고 실행할 수 있다.

< 목차 >

Microsoft SQL Server 설치
Server Management Studio 설치
데이터베이스 생성

1. Microsoft SQL Server 설치

해당 링크
- https://www.microsoft.com/ko-kr/sql-server/sql-server-downloads
2025 개발자도 무료이고 필자는 Enterprise로 설치해봤다.
다운로드 받고 더블클릭한 뒤 Basic 클릭

SQL Server 다운로드 | Microsoft

지금 Microsoft SQL Server 다운로드를 시작하세요. 내 데이터와 워크로드에 가장 적합한 SQL Server 체험판 또는 버전, 에디션, 도구 또는 커넥터를 선택하세요.

www.microsoft.com

설치 완료

여기서 확인해야 하는 것이 로컬에 새로 설치된 db의 이름
MSSQLSERVER02
- 설치 횟수나 사용자 환경에 따라 다를 수 있음
- 꼭 기억할 것

2. Server Management Studio 설치

Install SSMS 클릭하면 다음 화면이 뜸
- 해당 링크
  - https://learn.microsoft.com/ko-kr/ssms/install/install?redirectedfrom=MSDN

SQL Server Management Studio 설치

Visual Studio 설치 관리자를 사용하여 SSMS(SQL Server Management Studio)를 설치하는 방법을 알아봅니다.

learn.microsoft.com

vs_SSMS 파일 실행

이런 화면이 나오지만 아무것도 선택 안해도 된다.
언어팩이 한국어인지 확인하고 설치

로그인은 나중에 하지뭐

위와 같이 찾아보기 클릭
아까 새로 만든 서버 이름 클릭
- 필자는 MSSQLSERVER02
windows 인증 선택
서버 인증서 신뢰 꼭 선택
연결 클릭
혹시나 이렇게 해도 안되면
- 윈도우 - 시스템 - 설정에서 microsoft 로그인 안되어 있거나
- pin 번호 (윈도우 부팅 후 접속 전에 비밀번호 치게 하는 거) 걸려 있지 않아서 그럴 수 있음

3. 데이터베이스 생성

데이터베이스에서 마우스 오른쪽 클릭
새 데이터베이스 클릭

db 이름 설정
- 필자는 MYDB1으로 설정
새로고침(똥글뱅이) 눌러보면 MYDB1 생성된 것 확인

새 쿼리 클릭해서 실습 진행하면 끝
테이블도 만들어보고 조회도 해보면 좋을듯.

[HackerRank-MSSQL] 해커랭크 basic select Weather Observation Station 11

스위태니 — Fri, 17 Apr 2026 14:04:51 +0900

문제 링크

https://www.hackerrank.com/challenges/weather-observation-station-11/problem?isFullScreen=true

Weather Observation Station 11 | HackerRank

Query a list of CITY names not starting or ending with vowels.

www.hackerrank.com

정답 코드

select distinct city from station where city not like '[aeiou]%[aeiou]';

풀이 과정

city의 앞 문자가 a e i o u로 시작하지 않고 뒷 문자가 a e i o u로 끝나지 않고 라는 명제가 있다.
- '[^aeiou]%' and '%[^aeiou]'
이 명제를 대우로 표현하면 a e i o u로 시작하고 a e i o u로 끝나는 city가 된다.
- '[aeiou]%[aeiou]'
위의 대우 명제를 not like로 부정하면
- not like '[aeiou]%[aeiou]'가 된다.

느낀점

명제, 역, 이, 대우에 대한 것을 배웠지만 언제 써먹을까 생각했다.
마침 좋은 문제 같아서 기록으로 남긴다.

[HackerRank-MSSQL] 해커랭크 basic select Weather Observation Station 8

스위태니 — Fri, 17 Apr 2026 13:38:48 +0900

문제 링크

https://www.hackerrank.com/challenges/weather-observation-station-8/problem?isFullScreen=true

Weather Observation Station 8 | HackerRank

Query CITY names that start AND end with vowels.

www.hackerrank.com

정답 코드

select distinct city from station where city like '[aeiou]%[aeiou]';

풀이 과정

앞 뒤로 a e i o u가 있는 city를 찾는다.

느낀점

이 문제도 마찬가지로 city를 가공해서 풀 수도 있다.
정규표현식을 사용해서 조금이라도 더 빠르게 성능을 향상시킬 수 있다.
하지만 데이터 양이 적거나 aeiou로 시작하고 끝나는 나라의 개수가 50% 전후로 차지한다면 의미 없다.
100% 데이터 중에 25~20% 이하의 데이터를 찾을 때 유용할 것으로 기대한다.

1. 세 가지 방식 정밀 비교

비교 항목	① NOT LIKE '[aeiou]%'	② LIKE '[^aeiou]%'	③ LIKE '[bcdf...]%'
논리 방식	부정의 부정 (모음 찾고 제외)	부정 조건 (모음 제외 필터)	긍정 조건 (자음 목록 지정)
인덱스 활용	매우 낮음	낮음	상대적으로 높음 (이론상)
쿼리 길이	짧음 (깔끔)	짧음 (직관적)	매우 김 (복잡)
유연성	숫자/특수문자도 포함됨	숫자/특수문자도 포함됨	자음만 딱 골라냄

부정이 없는 것이 제일 좋지만 ai agent들은 2번을 제일 추천함
index를 무조건 타야 한다면 3번을 추천

자주 쓰는 정규 표현식 그리고 LIKE, PATINDEX, REGEXP - 성능 향상을 위해서

스위태니 — Fri, 17 Apr 2026 13:27:03 +0900

< 내용 >

정규 표현식을 공부하고 사용할 수 있다.
패턴 매칭을 통해서 성능을 향상할 수 있다.

< 목차 >

기본적으로 알아야 할 패턴
정규 표현식 설명
사이트 추천
LIKE VS PATINDEX
REGEXP_LIKE
정리하기

1. 기본적으로 알아야 할 패턴

1. 필수: 기본 패턴 (LIKE 연산자)

가장 기초적이지만 실무 쿼리의 90%를 차지한다.

기호	의미	예시	설명
%	0개 이상의 모든 문자	LIKE 'A%'	'A'로 시작하는 모든 문자열
_	정확히 1개의 모든 문자	LIKE 'A_'	'A'로 시작하는 딱 두 글자 문자열
[]	대괄호 안의 문자 중 하나	LIKE '[aeiou]%'	모음으로 시작하는 문자열
[^]	대괄호 안의 문자가 아닌 것	LIKE '[^0-9]%'	숫자로 시작하지 않는 문자열

2. 기본: 문자 범위 지정

특정 범위의 문자를 찾을 때 사용하며, 인덱싱 효율도 나쁘지 않은 편이다.

알파벳만 포함: LIKE '[a-zA-Z]%'
숫자만 포함: LIKE '[0-9]%'
특정 범위의 알파벳: LIKE '[a-d]%' (a, b, c, d로 시작하는 경우)

3. 적극 권장: 패턴 조합 (실무 응용)

실제 업무에서 데이터 정제나 유효성 검사를 할 때 가장 많이 쓰는 형태

① 자음으로 시작하고 모음으로 끝나는 데이터

SELECT CITY 
FROM STATION 
WHERE CITY LIKE '[^aeiou]%[aeiou]';

② 특정 자릿수의 숫자 형식 확인 (예: 사번, 코드)

예를 들어 'A'로 시작하고 뒤에 숫자 3자리가 오는 경우:

SELECT CODE 
FROM MY_TABLE 
WHERE CODE LIKE 'A[0-9][0-9][0-9]';

③ 연속된 공백이나 특수문자 포함 확인

SELECT NAME 
FROM USERS 
WHERE NAME LIKE '%[ ]%'; -- 공백이 포함된 경우

4. 응용: PATINDEX (더 정교한 검색)

LIKE만으로는 부족할 때, 특정 패턴이 시작되는 위치를 찾아주는 함수

숫자가 처음 나타나는 위치 찾기:

SELECT PATINDEX('%[0-9]%', 'ABC123DEF'); -- 결과: 4

한글만 포함된 데이터 찾기 (ASCII 범위 활용):

-- 한글 범위는 데이터베이스 정렬 설정(Collation)에 따라 다를 수 있음
SELECT * FROM PRODUCT WHERE PATINDEX('%[가-힣]%', NAME) > 0;

5. 심화: REGEXP_LIKE (MSSQL 2022 이상)

최신 버전의 MSSQL을 사용하신다면, 드디어 다른 DB처럼 표준 정규 표현식을 쓸 수 있다.

-- 이메일 형식이 대략 맞는지 확인
SELECT EMAIL
FROM USERS
WHERE REGEXP_LIKE(EMAIL, '^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$');

실무 팁: 성능 최적화 (SARGability)

패턴 매칭을 쓸 때 가장 중요한 규칙 하나만 기억하자.

"와일드카드(%)를 앞에 두지 마라."

LIKE 'Apple%': 인덱스 사용 가능 (A로 시작하는 페이지를 바로 찾아감)
LIKE '%Apple': 인덱스 사용 불가 (모든 데이터를 다 읽어서 끝이 Apple인지 확인해야 함)

지금 관리하시는 제조 시스템 DB에서 특정 모델 번호나 시리얼 번호를 조회할 때, 가급적 접두사(Prefix)를 명시하여 검색하는 습관을 들이시면 성능 차이를 확연히 느낄 수 있다.

2. 정규 표현식 설명

정규 표현식(Regular Expression): 특정 패턴을 가진 문자열을 찾기 위한 '약속된 기호'들의 집합

1. 와일드카드(Wildcard)란?

카드 게임의 '조커'처럼, 어떤 문자든 대신할 수 있는 만능 기호를 말한다. SQL의 LIKE 연산자에서 가장 먼저 접하게 된다.

기호	이름	의미	비유
%	퍼센트	0개 이상의 아무 문자	"이 뒤에 뭐가 오든, 아예 없든 상관없어"
_	언더바	딱 1개의 아무 문자	"여기에 글자 하나는 반드시 있어야 해"

예시:

WHERE NAME LIKE '이%': 이승엽, 이문세, 이선희 (이로 시작하는 모든 것)
WHERE NAME LIKE '이_': 이산, 이황, 이이 (이로 시작하는 딱 두 글자)

2. 정규 표현식 핵심 기호 (표준 & MSSQL 패턴)

기호	기능	설명	예시
.	점 (Any)	임의의 한 글자 (와일드카드의 _와 같음)	a.b → aab, acb, a1b 등
^	삿갓 (Start)	문자열의 시작을 의미	^A → 'A'로 시작하는 문장
$	달러 (End)	문자열의 끝을 의미	Z$ → 'Z'로 끝나는 문장
[]	대괄호 (Or)	괄호 안의 문자 중 하나라도 일치	[abc] → a 또는 b 또는 c
[^]	부정 (Not)	대괄호 안의 문자를 제외하고 일치	[^0-9] → 숫자가 아닌 문자
-	하이픈 (Range)	문자의 범위를 지정	[a-z] → 영어 소문자 전체

3. 수량자 (얼마나 반복되는가?)

기호 뒤에 붙어서 "앞의 패턴이 몇 번이나 나올까?"를 결정한다.

기호	의미	설명
*	0번 이상	앞의 글자가 없어도 되고, 아주 많아도 됨
+	1번 이상	앞의 글자가 최소 1번은 꼭 나와야 함
?	0번 또는 1번	앞의 글자가 있거나 없거나 (선택 사항)
{n}	정확히 n번	앞의 패턴이 정확히 n번 반복됨
{n, m}	n번 ~ m번	최소 n번에서 최대 m번까지 반복됨

4. 실제 예시로 이해하기 (SQL 연습용)

"숫자로 시작하는 것만 찾고 싶어"
- 패턴: ^[0-9] (시작(^)이 숫자 범위(0-9)인 것)
"전화번호 형식(010-숫자4자리-숫자4자리)을 찾고 싶어"
- 패턴: 010-[0-9]{4}-[0-9]{4}
"마지막 글자가 모음(a,e,i,o,u)이 아닌 것만 찾고 싶어"
- 패턴: [^aeiou]$ (끝($) 부분이 모음이 아닌 것([^]) )

주의할 점

MSSQL의 LIKE 문법에서는 표준 정규식의 모든 기호(예: +, {})를 다 지원하지는 않는다.
대신 LIKE '[^aeiou]%' 처럼 대괄호를 활용한 패턴을 주로 쓴다.

3. 사이트 추천

연습하기 가장 좋고 유명한 사이트 3곳을 추천

1. RegexOne (완전 초보자용 강추 / 영어)

정규표현식을 아예 모르는 사람을 위해 레벨 1부터 단계별로 미션을 주는 학습 사이트

특징: "숫자만 골라내 보세요", "글자 세 개만 골라내 보세요" 같은 문제를 주고, 하단 입력창에 정답을 치면 다음 단계로 넘어간다.
장점: 설명이 매우 친절하고, 문법을 하나씩 쌓아 올리는 방식이라 정석으로 배우기 좋다.
링크: RegexOne 바로가기

2. Regex101 (실전 연습 및 검증용 / 영어)

정규표현식의 '끝판왕' 사이트. 실제 개발자들이 가장 많이 사용한다.

특징: 내가 쓴 정규표현식이 어떤 원리로 작동하는지 오른쪽 'Explanation' 창에서 한 줄 한 줄 해석해 준다.
장점: 내가 가진 데이터(문장들)를 복사해서 붙여넣고, 내가 짠 정규식이 실시간으로 어디를 강조(Highlight)하는지 바로 볼 수 있다.
링크: Regex101 바로가기

3. RegExr (직관적인 인터페이스 / 영어)

Regex101과 비슷하지만 좀 더 깔끔하고 시각적이다.

특징: 상단 메뉴에 'Cheatsheet'가 있어서, 기호가 기억 안 날 때 옆에서 바로 찾아서 써볼 수 있다.
장점: 커뮤니티에서 사람들이 미리 만들어둔 정규식(예: 이메일 체크, 전화번호 체크)을 검색해서 구경할 수 있다.
링크: RegExr 바로가기

공부하는 팁 (이미지로 흐름 잡기)

정규표현식은 아래 그림처럼 '특정 문자를 가리키는 기호'와 '그게 몇 번 반복되는지 말하는 기호'의 조합이라고 생각하시면 편하다.

4. 한글로 배우고 싶다면?

영어가 부담스럽다면, 웹사이트는 아니지만 '점프 투 파이썬 - 정규 표현식' 파트를 추천한다.
파이썬 기반 설명이지만, 정규식 문법 자체는 공통이라 기초 개념을 잡기에 이보다 좋은 한국어 설명이 없다.
링크: 위키독스 - 정규 표현식

4. LIKE VS PATINDEX

1. LIKE vs PATINDEX 차이점

가장 큰 차이는 "찾느냐, 위치를 알려주느냐".

기능	LIKE	PATINDEX
결과값	참/거짓 (맞다/틀리다)	숫자 (패턴이 시작되는 위치)
주요 용도	데이터 필터링 (WHERE 절)	문자열 자르기, 복잡한 위치 찾기
인덱스 활용	시작 패턴(A%) 시 활용 가능	활용 불가 (느림)

LIKE: "이 데이터에 '서울'이 포함되어 있어?" (Yes/No)
PATINDEX: "이 데이터에서 '숫자'가 처음 나타나는 게 몇 번째 글자야?" (12번째!)

2. PATINDEX에서 쓸 수 있는 정규표현식 (패턴)

PATINDEX는 LIKE보다 패턴을 조금 더 유연하게 쓸 수 있지만, 여전히 MSSQL 표준 패턴만 지원

✅ 쓸 수 있는 것 (LIKE와 비슷함)

%: 아무 문자열
_: 아무 한 글자
[]: 대괄호 안의 문자 중 하나 ([0-9], [a-z], [aeiou])
[^]: 대괄호 안의 문자가 아닌 것

❌ 못 쓰는 것 (표준 정규식 기호)

*, +, ?: 수량자 (몇 번 반복되는지 지정 불가)
{n, m}: 반복 횟수 지정 불가
|: OR 연산 (A 또는 B를 |로 구분 불가)
(): 그룹화 불가

3. 왜 PATINDEX를 씀? (실무 예시)

LIKE로는 도저히 안 될 때 PATINDEX가 구원투수로 등판한다.

상황: "상품명에서 숫자가 처음 시작되는 부분부터 문자열을 자르고 싶어"

LIKE는 단순히 "숫자가 있다"만 알려주지만, PATINDEX는 위치를 알려주기 때문에 SUBSTRING 함수와 조합해서 데이터를 가공할 수 있다.

-- 'Product_123' 이라는 데이터가 있다면?
-- PATINDEX('%[0-9]%', 'Product_123') -> 결과는 9 (9번째부터 숫자 시작)

SELECT SUBSTRING(ProductName, PATINDEX('%[0-9]%', ProductName), 100)
FROM Products;
-- 이렇게 하면 '123'만 쏙 뽑아낼 수 있다.

4. 요약: 언제 무엇을 쓸까?

단순히 데이터를 찾거나 필터링할 때: 무조건 LIKE가 유리하다. (인덱스를 탈 수 있어서 훨씬 빠르다.)
특정 패턴의 "위치"가 필요할 때: PATINDEX를 쓴다.
진짜 강력한 정규표현식(전화번호, 이메일 검증 등)을 쓰고 싶을 때:
- MSSQL 2022 이상: REGEXP_LIKE를 사용한다.
- 이전 버전: 사용자 정의 함수(UDF)를 만들거나, 프로그래밍 언어(C#, Java, Python) 단에서 처리한다.

5. REGEXP_LIKE

LIKE나 PATINDEX가 "비슷한 패턴 찾기" 수준이었다면, REGEXP_LIKE는 "정교한 설계도로 정밀 타격"하는 수준이라고 본다.

1. REGEXP_LIKE에서 쓸 수 있는 강력한 무기들

기호	의미	예시	설명
+	1개 이상	[0-9]+	숫자가 최소 하나 이상 연속됨 (1, 12, 123...)
*	0개 이상	AB*C	AC, ABC, ABBC 모두 포함
?	0개 또는 1개	https?	http와 https 둘 다 찾음
{n}	횟수 지정	[0-9]{3}	숫자가 정확히 3자리인 것만
**`	`**	선택 (OR)	`(Apple
^, $	시작과 끝	^A.*Z$	A로 시작해서 Z로 끝나는 전체 문장

2. 실전 비교: LIKE vs REGEXP_LIKE

"연속된 숫자 3자리로 시작하는 도시 이름"을 찾는다고 가정해 보자.

LIKE (노가다 방식):(숫자가 10자리라면 [0-9]를 10번 써야 한다...)
```
WHERE CITY LIKE '[0-9][0-9][0-9]%';
```
REGEXP_LIKE (스마트한 방식):({3} 하나로 깔끔하게 정리된다.)
```
WHERE REGEXP_LIKE(CITY, '^[0-9]{3}');
```

3. 왜 이게 "진짜" 정규표현식인가?

REGEXP_LIKE는 문자열의 논리적 구조를 파악할 수 있기 때문이다.
예를 들어, 이메일 형식을 체크할 때 LIKE로는 거의 불가능에 가깝지만, REGEXP_LIKE는 한 줄로 끝낼 수 있다.

-- 이메일 검사 (대략적인 예시)
WHERE REGEXP_LIKE(EMAIL, '^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$');

⚠️ 주의할 점 (현실적인 문제)

버전 확인: 사용 중인 MSSQL이 2022 버전 이전이라면 REGEXP_LIKE를 썼을 때 "그런 함수 없는데?"라는 에러가 날 수 있다. 이럴 땐 어쩔 수 없이 LIKE나 PATINDEX를 조합해서 써야 한다.
성능(속도): 정규표현식은 매우 강력하지만, 엔진이 복잡한 계산을 해야 하므로 단순 LIKE보다 CPU를 더 많이 쓴다. 데이터가 수천만 건이라면 꼭 필요한 곳에만 써야 한다.

6. 정리하기

1. 쌩기초: 와일드카드 (LIKE 연산자 전용)

가장 기본적이고 인덱스를 탈 수 있어 성능이 가장 좋다.

기호	의미	예시	설명
%	무한대	LIKE 'A%'	'A'로 시작하는 모든 단어 (Apple, Ant...)
_	한 글자	LIKE 'A_'	'A'로 시작하는 딱 두 글자 (At, As...)

2. 중급: MSSQL 기본 패턴 (LIKE & PATINDEX)

단순 와일드카드보다 조금 더 범위를 좁힐 수 있다.

기호	의미	예시	설명
[]	택일 (OR)	[aeiou]%	모음(a,e,i,o,u) 중 하나로 시작하는 것
[^]	부정 (NOT)	[^0-9]%	숫자로 시작하지 않는 것
-	범위	[a-z]%	소문자 a부터 z 사이로 시작하는 것

3. 고급: 진짜 정규표현식 (REGEXP_LIKE)

MSSQL 2022 이상에서 사용 가능하며, 기호들을 조합해 '문법'을 만든다.

① 위치 및 그룹 기호

기호	의미	설명
^	시작	^A : 문장의 맨 앞글자가 'A'여야 함
$	끝	Z$ : 문장의 맨 마지막 글자가 'Z'여야 함
**`	`**	선택 (OR)
.	만능	아무 문자나 딱 한 글자를 의미

② 수량자 (반복 횟수 지정) - 이게 핵심!

기호	의미	설명
*	0번 이상	앞의 글자가 없어도 되고, 무한정 많아도 됨
+	1번 이상	앞의 글자가 최소한 한 번은 꼭 나와야 함
?	0 또는 1	앞의 글자가 있거나 없거나 (선택 사항)
{n}	정확히 n번	[0-9]{3} : 숫자가 딱 3자리 연속됨
{n,m}	n~m번 사이	[0-9]{2,4} : 숫자가 2자리에서 4자리 사이

4. 한눈에 보는 요약 (SARGability & Power)

구분	LIKE / PATINDEX	REGEXP_LIKE
수준	초급 ~ 중급	고급 (강력함)
정밀도	대략적인 패턴 검색	매우 정교한 설계 가능
성능	상대적으로 빠름 (인덱스 활용)	상대적으로 느림 (연산 복잡)
반복 지정	일일이 써야 함 ([0-9][0-9])	숫자로 지정 가능 ([0-9]{2})

실무 적용 가이드

성능이 중요하다면? 가급적 LIKE 'A%' 처럼 앞부분을 고정한 와일드카드
복잡한 검증(이메일, 전화번호)이 필요하다면? REGEXP_LIKE
특정 글자의 위치를 찾아야 한다면? PATINDEX

[HackerRank-MSSQL] 해커랭크 basic select Weather Observation Station 7 [성능 최적화-인덱스를 위해서]

스위태니 — Fri, 17 Apr 2026 11:33:19 +0900

문제 링크

https://www.hackerrank.com/challenges/weather-observation-station-7/problem?isFullScreen=true

Weather Observation Station 7 | HackerRank

Query the list of CITY names ending with vowels (a, e, i, o, u) from STATION.

www.hackerrank.com

최적화 코드

SELECT DISTINCT CITY
FROM STATION
WHERE CITY LIKE '%[aeiou]';

아쉬운 코드 (내코드)

select distinct city from station where right(city, 1) in ('a', 'e', 'i', 'o', 'u');

풀이 과정

풀이는 간단하다 중복 제거, 뒤에 a e i o u인 도시를 찾게 조건문을 쓰면 된다.

느낀점

회사에서 수석님께 sql교육을 받았다.
- 인덱스를 타기 위해서는 가공을 하면 안된다고 하셨다.
- left right substring 등 컬럼 전체를 가공해서 where 에서 비교하는 형태는 인덱스를 타지 않는다.
- 왜냐하면 모든 컬럼을 가공한다 = 모든 컬럼을 조회한다 라는 말이 되고 full scan이 된다.
우리가 원하는 것은 index scan이지 full scan이 아니다 그래서 어떻게 최적화가 가능할지 gemini에 물어보니 정규표현식을 가르쳐줬다.
- 수석님 교육에서도 분명 말씀해주셨는데 돌아서면 까먹는다.
결론은 정규표현식과 like를 사용해서 인덱스를 타자
- left right 등을 최대한 사용하지 말자.
- 당연히 조건문에서지 select에서 쓰는 것은 상관 없다.
  - 예를 들어 000 조건의 도시를 찾고 앞에 3글자만 보여라. 라고 했을 때
  - 이미 조건을 통해 찾은 데이터를 가공해서 보여주는 것이기 때문에 이때는 가공해도 무방하다.
추가로 정규표현식이나 like를 사용하더라도 앞에 %나 _가 있으면 인덱스를 타지 않는다 ㅋㅋㅋㅋ

[HackerRank-MSSQL] 해커랭크 basic select Weather Observation Station 5 [다시 풀어 보기]

스위태니 — Fri, 17 Apr 2026 11:17:10 +0900

문제 링크

https://www.hackerrank.com/challenges/weather-observation-station-5/problem?isFullScreen=true

Weather Observation Station 5 | HackerRank

Write a query to print the shortest and longest length city name along with the length of the city names.

www.hackerrank.com

정답 코드

SET NOCOUNT ON;

SELECT TOP 1 CITY, LEN(CITY)
FROM STATION
ORDER BY LEN(CITY) ASC, CITY ASC;

SELECT TOP 1 CITY, LEN(CITY)
FROM STATION
ORDER BY LEN(CITY) DESC, CITY ASC;

go

틀린 코드

SET NOCOUNT ON;

select city, len(city) from station where len(city) = max(len(city)) or len(city) = min(len(city));
/*
Enter your query here.
Please append a semicolon ";" at the end of the query and enter your query in a single line to avoid error.
*/

go

풀이 과정

각각 하나씩 출력한다.
도시 이름 길이가 긴 순, 짧은 순으로 정렬한다.
1. 긴 순일 경우 내림차순
2. 짧은 순일 경우 오름차순
정렬한 select의 가장 위에 행을 출력하면 끝

느낀점

두 번 나눠서 출력하면 된다.
my sql에서 limit만 생각했는데 여기는 top으로 하면 해결된다.
bottom은 없어서 정렬 후 맨 위만 뽑아야 한다.
top 1도 있으니 top 2 ... n이 가능하다.

[HackerRank-MSSQL] 해커랭크 basic select Weather Observation Station 4

스위태니 — Fri, 17 Apr 2026 10:55:10 +0900

문제 링크

https://www.hackerrank.com/challenges/weather-observation-station-4/problem?isFullScreen=true

Weather Observation Station 4 | HackerRank

Find the number of duplicate CITY names in STATION.

www.hackerrank.com

정답 코드

SET NOCOUNT ON;

SELECT COUNT(CITY) - COUNT(DISTINCT CITY)
FROM STATION;
/*
Enter your query here.
Please append a semicolon ";" at the end of the query and enter your query in a single line to avoid error.
*/

go

풀이 과정

도시의 숫자를 세고 중복된 도시의 수를 센 다음 빼면 끝.

느낀점

아직 모르는 것이 많다.
select로 찾아서 distinct하고 그럴 줄 알았는데 그냥 select에서 count로 세서 뺄 줄은 몰랐다.

[React] useEffect cleanup function (내가 한 실수 포함)

스위태니 — Fri, 22 Aug 2025 12:17:42 +0900

▶▷ 서론◁◀

dayjs를 수정하다가 현재 페이지(컴포넌트) 외에 전역으로 영향을 미친다는 사실을 알게 되었다. 그러다보니 weekStart를 메인 페이지에서 1로 설정했고 다른 페이지에서 2로 설정했다면 충돌이 날 수밖에 없게 된다. (에러가 나지는 않지만 둘 중 하나의 방식만 선택됨) 이런 경우에 useEffect를 써서 각 컴포넌트에서만 실행되게 하고 싶었고 그 방법을 cleanup function에서 찾았다.

▶▷ 목차 ◁◀

정의
언제 실행되는가
자 사용하는 패턴
내가 사용한 패턴
주의사항
정리하기

▶▷ 1. 정의 ◁◀

React의 useEffect에서 return하는 함수는 cleanup function(정리 함수)라고 부른다.
이 함수는 컴포넌트가 언마운트되거나 의존성 배열이 변경되어 effect가 다시 실행되기 전에 호출된다.

▶▷ 2. 언제 실행되는가 ◁◀

컴포넌트 언마운트 시: 컴포넌트가 DOM에서 제거될 때
의존성 배열 변경 시: 다음 effect 실행 전에 이전 effect를 정리
컴포넌트 리렌더링 시 (의존성이 변경된 경우)

▶▷ 3. 자주 사용하는 패턴 ◁◀

1. 이벤트 리스너 제거

useEffect(() => {
  const handleResize = () => {
    setWindowWidth(window.innerWidth);
  };
  
  window.addEventListener('resize', handleResize);
  
  // cleanup: 이벤트 리스너 제거
  return () => {
    window.removeEventListener('resize', handleResize);
  };
}, []);

2. 타이머 정리

useEffect(() => {
  const timer = setInterval(() => {
    setCount(prev => prev + 1);
  }, 1000);
  
  // cleanup: 타이머 정리
  return () => {
    clearInterval(timer);
  };
}, []);

3. API 요청 취소

useEffect(() => {
  const controller = new AbortController();
  
  fetch('/api/data', { signal: controller.signal })
    .then(response => response.json())
    .then(data => setData(data))
    .catch(err => {
      if (err.name !== 'AbortError') {
        console.error(err);
      }
    });
  
  // cleanup: 진행 중인 요청 취소
  return () => {
    controller.abort();
  };
}, []);

4. 구독(subscription) 해제

useEffect(() => {
  const subscription = someObservable.subscribe(data => {
    setData(data);
  });
  
  // cleanup: 구독 해제
  return () => {
    subscription.unsubscribe();
  };
}, []);

▶▷ 4. 내가 사용한 패턴 ◁◀

useEffect(() => {
  // 현재 설정 백업
  const originalWeekStart = dayjs.Ls.ko?.weekStart || 1

  // 임시로 일요일 시작 설정
  dayjs.locale('ko')
  dayjs.updateLocale('ko', {
    weekStart: 0
  })

  // cleanup: 원래 설정으로 복원
  return () => {
    dayjs.updateLocale('ko', {
      weekStart: originalWeekStart
    })
  }
}, [])

이 패턴은 전역 설정 임시 변경 패턴이다.
컴포넌트가 마운트될 때 dayjs의 주간 시작일을 일요일로 변경하고, 언마운트될 때 원래 설정으로 되돌린다.
이렇게 하면 해당 컴포넌트가 다른 컴포넌트나 전역 상태에 영향을 주지 않도록 할 수 있다.

▶▷ 5. 주의사항 ◁◀

cleanup function은 동기적으로 실행되어야 한다 (async 함수 사용 불가)
의존성 배열이 있는 경우, 배열이 변경될 때마다 cleanup이 먼저 실행되고 새로운 effect가 실행된다
cleanup을 잊으면 메모리 누수나 예상치 못한 동작이 발생할 수 있다

▶▷ 6. 정리하기 ◁◀

전역으로 설정하는 경우 스크롤이 될 수도 있고, 내가 설정한 dayjs를 사용할 수도 있다.
이런 경우에 useEffect의 cleanup 함수를 사용해보자.
하지만 cleanup 함수를 사용하기 전에 내가 사용하는 라이브러리의 함수가 전역으로 관리되는지 생각하고 개발할 필요가 있다.

FastAPI 백엔드 개발 가이드: API 구현 순서와 모던 개발 방법론 [3탄]

스위태니 — Tue, 12 Aug 2025 17:09:14 +0900

6. Testing 전략

테스트 피라미드 구현

1. 단위 테스트 (70%)

# Repository 단위 테스트
def test_user_repository_create():
    # Given
    user_data = UserCreate(email="test@example.com", username="testuser",
password="password123")

    # When
    user = repository.create(user_data)

    # Then
    assert user.email == "test@example.com"
    assert user.id is not None

# Service 단위 테스트
def test_user_service_business_logic():
    # Mock 의존성을 사용한 비즈니스 로직 테스트
    pass

2. 통합 테스트 (20%)

# API 엔드포인트 테스트
def test_user_creation_flow():
    # 전체 요청-응답 플로우 테스트
    pass

# 데이터베이스 연동 테스트
def test_database_operations():
    # 실제 데이터베이스와의 상호작용 테스트
    pass

3. E2E 테스트 (10%)

# 전체 사용자 시나리오 테스트
def test_complete_user_journey():
    # 사용자 등록 -> 로그인 -> 프로필 수정 -> 탈퇴
    pass

테스트 데이터 관리

# tests/fixtures.py
import pytest
from app.domain.users.models.user import User

@pytest.fixture
def sample_user_data():
    return {
        "email": "test@example.com",
        "username": "testuser",
        "password": "password123"
    }

@pytest.fixture
def created_user(db_session, sample_user_data):
    user = User(**sample_user_data)
    db_session.add(user)
    db_session.commit()
    return user

# 테스트에서 사용
def test_get_user(created_user):
    assert created_user.email == "test@example.com"

7. 배포 및 운영

Docker 컨테이너화

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

# Poetry 설치
RUN pip install poetry

# 의존성 복사 및 설치
COPY pyproject.toml poetry.lock ./
RUN poetry config virtualenvs.create false \\
    && poetry install --no-dev

# 소스 코드 복사
COPY ./app ./app

# 포트 노출
EXPOSE 8000

# 실행 명령
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:password@db:5432/myapp
    depends_on:
      - db
      - redis

  db:
    image: postgres:13
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: myapp
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:alpine

volumes:
  postgres_data:

운영 환경 설정

# 프로덕션용 설정
class ProductionSettings(Settings):
    debug: bool = False
    log_level: str = "WARNING"

    # 보안 강화
    allowed_hosts: list[str] = ["yourdomain.com"]

    # 성능 최적화
    database_pool_size: int = 20
    database_max_overflow: int = 30

    # 모니터링
    sentry_dsn: Optional[str] = None

    class Config:
        env_file = ".env.production"

헬스체크 및 모니터링

# app/core/health.py
  from fastapi import APIRouter, Depends
  from sqlalchemy.orm import Session
  from app.core.database import get_db

  router = APIRouter()

  @router.get("/health")
  async def health_check():
      return {"status": "healthy", "timestamp": datetime.utcnow()}

  @router.get("/health/db")
  async def database_health_check(db: Session = Depends(get_db)):
      try:
          # 데이터베이스 연결 확인
          db.execute("SELECT 1")
          return {"status": "healthy", "database": "connected"}
      except Exception as e:
          raise HTTPException(status_code=503, detail="Database unavailable")

  @router.get("/metrics")
  async def metrics():
      # Prometheus 메트릭 반환
      return {
          "active_connections": get_active_connections(),
          "response_times": get_response_times(),
          "error_rates": get_error_rates()
      }

모던 백엔드 개발의 핵심 원칙

1. 관심사의 분리 (Separation of Concerns)

각 레이어는 고유한 책임만 가짐
의존성 역전 원칙으로 유연한 구조 구축

2. 테스트 가능한 코드 (Testable Code)

의존성 주입으로 Mock 테스트 가능
비즈니스 로직과 인프라 코드 분리

3. API 우선 설계 (API-First Design)

OpenAPI 스펙으로 계약 우선 개발
프론트엔드와 백엔드 병렬 개발 가능

4. 자동화 (Automation)

CI/CD 파이프라인으로 배포 자동화
코드 품질 검사 자동화

5. 관찰 가능성 (Observability)

로깅, 메트릭, 트레이싱으로 시스템 상태 파악
장애 대응 및 성능 최적화

FastAPI 백엔드 개발 가이드: API 구현 순서와 모던 개발 방법론 [2탄]

스위태니 — Tue, 12 Aug 2025 17:07:45 +0900

4. API 개발 순서

Step 1: Pydantic Schemas 정의

# app/domain/users/schemas/user_schemas.py
  from pydantic import BaseModel, EmailStr, Field
  from datetime import datetime
  from typing import Optional

  class UserBase(BaseModel):
      email: EmailStr
      username: str = Field(..., min_length=3, max_length=50)

  class UserCreate(UserBase):
      password: str = Field(..., min_length=8)

  class UserUpdate(BaseModel):
      email: Optional[EmailStr] = None
      username: Optional[str] = None

  class UserResponse(UserBase):
      id: int
      is_active: bool
      created_at: datetime

      class Config:
          from_attributes = True  # SQLAlchemy 모델 지원

  class UserListResponse(BaseModel):
      items: list[UserResponse]
      total: int
      page: int
      size: int

왜 먼저 Schema를 정의하는가?

계약 우선 개발: API 인터페이스를 먼저 정의
타입 안전성: Pydantic이 자동으로 검증 및 직렬화
문서 자동화: FastAPI가 자동으로 OpenAPI 스펙 생성

Step 2: Repository Layer 구현

# app/domain/users/repositories/user_repository.py
  from sqlalchemy.orm import Session
  from sqlalchemy import and_, or_
  from typing import List, Optional
  from app.domain.users.models.user import User
  from app.domain.users.schemas.user_schemas import UserCreate, UserUpdate

  class UserRepository:
      def __init__(self, db: Session):
          self.db = db

      def create(self, user_data: UserCreate) -> User:
          """사용자 생성"""
          db_user = User(**user_data.dict(exclude={'password'}))
          db_user.hashed_password = hash_password(user_data.password)

          self.db.add(db_user)
          self.db.commit()
          self.db.refresh(db_user)
          return db_user

      def get_by_id(self, user_id: int) -> Optional[User]:
          """ID로 사용자 조회"""
          return self.db.query(User).filter(User.id == user_id).first()

      def get_by_email(self, email: str) -> Optional[User]:
          """이메일로 사용자 조회"""
          return self.db.query(User).filter(User.email == email).first()

      def get_list(self, skip: int = 0, limit: int = 100) -> List[User]:
          """사용자 목록 조회 (페이징)"""
          return self.db.query(User).offset(skip).limit(limit).all()

      def update(self, user_id: int, user_data: UserUpdate) -> Optional[User]:
          """사용자 정보 업데이트"""
          db_user = self.get_by_id(user_id)
          if not db_user:
              return None

          update_data = user_data.dict(exclude_unset=True)
          for field, value in update_data.items():
              setattr(db_user, field, value)

          self.db.commit()
          self.db.refresh(db_user)
          return db_user

      def delete(self, user_id: int) -> bool:
          """사용자 삭제 (소프트 삭제)"""
          db_user = self.get_by_id(user_id)
          if not db_user:
              return False

          db_user.is_active = False
          self.db.commit()
          return True

Repository 패턴을 사용하는 이유

데이터 액세스 추상화: 데이터베이스 구현체와 비즈니스 로직 분리
테스트 용이성: Mock Repository로 단위 테스트 가능
변경 용이성: 데이터베이스 변경 시 Repository만 수정

Step 3: Service Layer 구현

# app/domain/users/services/user_service.py
  from sqlalchemy.orm import Session
  from typing import List, Optional
  from app.domain.users.repositories.user_repository import UserRepository
  from app.domain.users.schemas.user_schemas import (
      UserCreate, UserUpdate, UserResponse, UserListResponse
  )
  from app.core.exceptions import NotFoundException, ConflictException

  class UserService:
      def __init__(self, db: Session):
          self.repository = UserRepository(db)

      def create_user(self, user_data: UserCreate) -> UserResponse:
          """사용자 생성 비즈니스 로직"""
          # 비즈니스 규칙 검증
          existing_user = self.repository.get_by_email(user_data.email)
          if existing_user:
              raise ConflictException("이미 존재하는 이메일입니다.")

          # 사용자 생성
          user = self.repository.create(user_data)

          # 추가 비즈니스 로직 (이메일 발송, 로깅 등)
          self._send_welcome_email(user.email)

          return UserResponse.from_orm(user)

      def get_user(self, user_id: int) -> UserResponse:
          """사용자 조회"""
          user = self.repository.get_by_id(user_id)
          if not user or not user.is_active:
              raise NotFoundException("사용자를 찾을 수 없습니다.")

          return UserResponse.from_orm(user)

      def get_users(self, page: int = 1, size: int = 20) -> UserListResponse:
          """사용자 목록 조회"""
          skip = (page - 1) * size
          users = self.repository.get_list(skip=skip, limit=size)
          total = self.repository.count()

          return UserListResponse(
              items=[UserResponse.from_orm(user) for user in users],
              total=total,
              page=page,
              size=size
          )

      def update_user(self, user_id: int, user_data: UserUpdate) -> UserResponse:        
          """사용자 정보 업데이트"""
          # 권한 검증 로직
          if user_data.email:
              existing_user = self.repository.get_by_email(user_data.email)
              if existing_user and existing_user.id != user_id:
                  raise ConflictException("이미 사용 중인 이메일입니다.")

          user = self.repository.update(user_id, user_data)
          if not user:
              raise NotFoundException("사용자를 찾을 수 없습니다.")

          return UserResponse.from_orm(user)

      def delete_user(self, user_id: int) -> bool:
          """사용자 삭제"""
          success = self.repository.delete(user_id)
          if not success:
              raise NotFoundException("사용자를 찾을 수 없습니다.")

          return True

      def _send_welcome_email(self, email: str):
          """환영 이메일 발송 (내부 메서드)"""
          # 이메일 발송 로직
          pass

Service Layer의 역할:

비즈니스 로직 집중: 도메인 규칙 구현
트랜잭션 관리: 복잡한 비즈니스 연산의 원자성 보장
외부 서비스 호출: 이메일, 알림 등 부가 기능
검증 및 변환: 데이터 검증과 응답 형식 변환

Step 4: Controller Layer 구현

# app/domain/users/controllers/user_controller.py
  from fastapi import APIRouter, Depends, HTTPException, Query, Path
  from sqlalchemy.orm import Session
  from typing import List

  from app.core.database import get_db
  from app.core.dependencies import get_current_user
  from app.domain.users.services.user_service import UserService
  from app.domain.users.schemas.user_schemas import (
      UserCreate, UserUpdate, UserResponse, UserListResponse
  )

  router = APIRouter(prefix="/users", tags=["users"])

  @router.post("/", response_model=UserResponse, status_code=201)
  async def create_user(
      user_data: UserCreate,
      db: Session = Depends(get_db)
  ):
      """
      사용자 생성

      - **email**: 유효한 이메일 주소
      - **username**: 3-50자 사용자명
      - **password**: 8자 이상 비밀번호
      """
      service = UserService(db)
      return service.create_user(user_data)

  @router.get("/{user_id}", response_model=UserResponse)
  async def get_user(
      user_id: int = Path(..., gt=0, description="사용자 ID"),
      db: Session = Depends(get_db),
      current_user = Depends(get_current_user)  # 인증 필요
  ):
      """사용자 상세 조회"""
      service = UserService(db)
      return service.get_user(user_id)

  @router.get("/", response_model=UserListResponse)
  async def get_users(
      page: int = Query(1, ge=1, description="페이지 번호"),
      size: int = Query(20, ge=1, le=100, description="페이지 크기"),
      db: Session = Depends(get_db)
  ):
      """사용자 목록 조회 (페이징)"""
      service = UserService(db)
      return service.get_users(page=page, size=size)

  @router.put("/{user_id}", response_model=UserResponse)
  async def update_user(
      user_id: int = Path(..., gt=0),
      user_data: UserUpdate,
      db: Session = Depends(get_db),
      current_user = Depends(get_current_user)
  ):
      """사용자 정보 업데이트"""
      # 권한 검증: 본인 또는 관리자만 수정 가능
      if current_user.id != user_id and not current_user.is_admin:
          raise HTTPException(status_code=403, detail="권한이 없습니다.")

      service = UserService(db)
      return service.update_user(user_id, user_data)

  @router.delete("/{user_id}", status_code=204)
  async def delete_user(
      user_id: int = Path(..., gt=0),
      db: Session = Depends(get_db),
      current_user = Depends(get_current_user)
  ):
      """사용자 삭제"""
      if current_user.id != user_id and not current_user.is_admin:
          raise HTTPException(status_code=403, detail="권한이 없습니다.")

      service = UserService(db)
      service.delete_user(user_id)

Controller Layer의 역할

HTTP 요청/응답 처리: 요청 파라미터 검증, 응답 직렬화
라우팅: URL 경로와 HTTP 메서드 매핑
인증/인가: 사용자 권한 검증
예외 처리: HTTP 상태 코드와 에러 메시지 변환

Step 5: Exception Handling

# app/core/exceptions.py
  class BaseCustomException(Exception):
      def __init__(self, message: str):
          self.message = message
          super().__init__(self.message)

  class NotFoundException(BaseCustomException):
      pass

  class ConflictException(BaseCustomException):
      pass

  class ValidationException(BaseCustomException):
      pass

  # app/core/exception_handlers.py
  from fastapi import Request, HTTPException
  from fastapi.responses import JSONResponse

  async def not_found_exception_handler(request: Request, exc: NotFoundException):       
      return JSONResponse(
          status_code=404,
          content={"error": "Not Found", "message": exc.message}
      )

  async def conflict_exception_handler(request: Request, exc: ConflictException):        
      return JSONResponse(
          status_code=409,
          content={"error": "Conflict", "message": exc.message}
      )

  # main.py에서 등록
  app.add_exception_handler(NotFoundException, not_found_exception_handler)
  app.add_exception_handler(ConflictException, conflict_exception_handler)

FastAPI 백엔드 개발 가이드: API 구현 순서와 모던 개발 방법론 [1탄]

스위태니 — Tue, 12 Aug 2025 17:00:41 +0900

1. 개발 환경 설정

가상환경 및 의존성 관리

# Poetry 사용 (권장)
poetry init
poetry add fastapi uvicorn sqlalchemy alembic pydantic

# 또는 pip with requirements.txt
pip install fastapi uvicorn sqlalchemy alembic pydantic

왜 Poetry를 사용하는가?

의존성 해결: pip은 의존성 충돌을 해결하지 못하지만, Poetry는 자동으로 해결
락 파일: poetry.lock으로 정확한 버전 관리
가상환경 통합: 자동으로 가상환경 생성 및 관리

프로젝트 초기 설정

 # main.py
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI(
  title="API Documentation",
  description="RESTful API with FastAPI",
  version="1.0.0",
  docs_url="/docs",
  redoc_url="/redoc"
)

# CORS 설정
app.add_middleware(
  CORSMiddleware,
  allow_origins=["*"],  # 운영환경에서는 특정 도메인만 허용
  allow_credentials=True,
  allow_methods=["*"],
  allow_headers=["*"],
)

2. 프로젝트 구조 설계

Layered Architecture (권장)

project/
  ├── app/
  │   ├── core/                 # 핵심 설정 및 공통 기능
  │   │   ├── config.py         # 환경 변수, 설정
  │   │   ├── database.py       # DB 연결 설정
  │   │   ├── security.py       # 인증/인가
  │   │   └── exceptions.py     # 커스텀 예외
  │   ├── domain/               # 도메인별 모듈
  │   │   └── users/
  │   │       ├── controllers/  # API 엔드포인트
  │   │       ├── services/     # 비즈니스 로직
  │   │       ├── repositories/ # 데이터 액세스
  │   │       ├── schemas/      # Pydantic 모델
  │   │       └── models/       # SQLAlchemy 모델
  │   ├── shared/               # 공통 유틸리티
  │   │   ├── utils.py
  │   │   └── constants.py
  │   └── main.py
  ├── tests/
  ├── migrations/               # Alembic 마이그레이션
  ├── docker-compose.yml
  ├── Dockerfile
  └── pyproject.toml           # Poetry 설정

왜 이런 구조를 사용하는가?

Domain-Driven Design (DDD) 접근
- 도메인 분리: 각 비즈니스 도메인이 독립적으로 관리됨
- 의존성 역전: Repository 패턴으로 데이터베이스 의존성 분리
- 테스트 용이성: 각 레이어를 독립적으로 테스트 가능

Layered Architecture 이유

Controller Layer: HTTP 요청/응답 처리만 담당
Service Layer: 비즈니스 로직 집중, 트랜잭션 관리
Repository Layer: 데이터 액세스 추상화
Model Layer: 데이터 구조 정의

3. Database Layer 구현

1. Database 설정

# app/core/database.py
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from sqlalchemy.pool import StaticPool

DATABASE_URL = "sqlite:///./app.db"

engine = create_engine(
  DATABASE_URL,
  poolclass=StaticPool,  # SQLite용
  connect_args={"check_same_thread": False}
)

SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

def get_db():
  """의존성 주입용 DB 세션"""
  db = SessionLocal()
  try:
      yield db
  finally:
      db.close()

2. SQLAlchemy Models

# app/domain/users/models/user.py
from sqlalchemy import Column, Integer, String, DateTime, Boolean
from sqlalchemy.sql import func
from app.core.database import Base

class User(Base):
  __tablename__ = "users"

  id = Column(Integer, primary_key=True, index=True)
  email = Column(String, unique=True, index=True, nullable=False)
  username = Column(String, unique=True, index=True, nullable=False)
  hashed_password = Column(String, nullable=False)
  is_active = Column(Boolean, default=True)
  created_at = Column(DateTime(timezone=True), server_default=func.now())
  updated_at = Column(DateTime(timezone=True), onupdate=func.now())

3. Alembic 마이그레이션 설정

# 초기 설정
alembic init migrations

# 마이그레이션 파일 생성
alembic revision --autogenerate -m "Create users table"

# 마이그레이션 실행
alembic upgrade head

왜 Alembic을 사용하는가?

스키마 버전 관리: 데이터베이스 스키마 변경사항 추적
팀 협업: 모든 개발자가 동일한 스키마 상태 유지
배포 안전성: 운영 환경에서 안전한 스키마 업데이트

[인공지능] Claude Code VS Cursor AI

스위태니 — Mon, 11 Aug 2025 12:40:28 +0900

커서(Cursor)

커서는 AI를 활용한 코드 작성 및 편집 도구로, 개발자가 코드를 빠르게 작성하고 수정할 수 있도록 지원한다. 특히 반복 작업의 자동화와 다양한 AI 모델의 통합이 강점이다.

장점

1. Tab 기능

기계적 작업 자동화: 탭(Tab) 키를 활용해 반복적인 코딩 작업을 빠르게 수행 가능. 예를 들어, 비슷한 패턴의 코드를 여러 번 작성해야 할 때, 탭 키로 자동 완성 및 생성을 지원.
코드 분석 기반 즉시 작성: 기존 코드베이스를 분석한 상태로 동작하므로, 사용자가 원하는 코드를 맥락에 맞게 즉시 생성. 이는 프로젝트의 일관성을 유지하는 데 유용.
- 예: 특정 함수나 컴포넌트의 구조를 파악한 후, 비슷한 구조의 코드를 자동으로 제안.

2. 여러 모델 사용 가능

커서는 다양한 AI 모델을 통합적으로 사용 가능:
- Claude: Anthropic의 모델로, 코드 생성 및 자연어 처리에 강점.
- GPT: OpenAI의 모델로, 범용적인 코드 작성 및 문제 해결에 유용.
- Gemini: Google의 모델로, 특정 작업에 최적화된 성능 제공.
장점: 사용자는 작업의 성격에 따라 적합한 모델을 선택하거나, 여러 모델을 조합해 문제를 해결 가능. 예를 들어, Claude로 코드 구조를 잡고, GPT로 세부 로직을 작성.
단점: 모델 간 전환 시 일관성 문제가 발생할 가능성 있음(예: 코드 스타일 차이).

3. 개별 수정 기능

수정 단위별 Accept 버튼: 코드 수정 시 변경된 부분마다 Accept 버튼이 제공되어, 사용자가 원하는 수정만 선택적으로 적용 가능.
직관적 변경 구분: 수정된 부분과 기존 코드가 명확히 구분되어 표시. 이는 디버깅이나 코드 검토 시 가독성을 높임.
- 예: 특정 함수만 수정하고 나머지는 유지 가능.
장점: 세밀한 코드 제어가 가능하며, 대규모 수정 시 실수를 줄이는 데 효과적.

단점

모델 의존성: 여러 모델을 사용 가능하지만, 특정 모델의 성능에 의존할 경우 결과물의 품질이 달라질 수 있음.
제공된 정보 부족: 사용량 제한이나 구독 플랜에 대한 정보가 없어, 비용 효율성을 판단하기 어려움.

클로드(Claude) 코드

클로드는 Anthropic에서 개발한 AI 모델로, 코드 생성 및 수정에 특화된 기능을 제공한다. 특히 Sonnet 4.0과 Opus 모델을 활용해 꼼꼼하고 정밀한 코드 작업을 지원한다. 제공된 정보에 따르면, 클로드는 특정 구독 플랜(Pro, Max)에 따라 사용량과 기능이 달라진다.

장점

1. claude sonnet 4.0

기본 모델: Sonnet 4.0이 디폴트로 설정되어 있어, 별도 설정 없이 고성능 코드 생성 및 수정 가능.
성능: 코드 이해와 생성에서 높은 정확도를 제공하며, 일반적인 개발 작업에 적합.
- 예: 중소 규모 프로젝트의 컴포넌트 작성, 디버깅, 리팩토링.
장점: 별도 설정 없이 바로 사용 가능하며, 안정적인 성능을 보장.

2. claude opus

고급 모델: Max 구독 플랜에서 사용 가능. 대규모 코드 수정이나 복잡한 프로젝트에 최적화.
빠른 이해 및 수정: 대량의 코드베이스를 빠르게 파악하고, 일관성 있는 수정 제안.
- 예: 레거시 코드 리팩토링, 복잡한 DOM 구조 수정.
장점: 대규모 작업에서 시간 절약 가능. 특히 복잡한 구조의 코드를 한 번에 처리할 때 유리.

3. ToDo

꼼꼼한 문제 해결: ToDo 리스트를 기반으로 문제를 체계적으로 분석하고 해결.
- 예시: 제공된 코드 블록에서 DOM nesting 에러를 단계적으로 해결.
  - 문제 식별: Typography 컴포넌트의 <p> 태그 내 <div> 중첩 문제 발견.
  - 해결 과정:
    1. ToDo 리스트 작성(문제 찾기, 수정, 테스트).
    2. 코드 분석(165번째 줄의 문제 확인).
    3. 수정 제안(Typography를 Box로 변경, 색상 및 스타일 조정).
    4. ToDo 업데이트 및 완료 보고.
  - 결과: 올바른 DOM 구조로 수정 완료, 에러 해결.
- 코드 예시

● 이 에러는 HTML DOM 구조 규칙 위반 때문입니다. <p> 태그 안에 <div> 태그가 들어가면       
  안 되는데, Typography 컴포넌트가 기본적으로 <p> 태그를 렌더링하고 그 안에 Grid나        
  div가 포함되어 있어서 발생합니다.

● Update Todos
  ⎿  ☐ Find the DOM nesting issue in onedb page components
     ☐ Fix Typography component with nested div elements
     ☐ Test the fix

● 에러 스택을 보면 TopListBox 컴포넌트에서 문제가 발생하고 있습니다. 이 컴포넌트를        
  확인해보겠습니다:

● Read(src\views\components\box\top-list-box.tsx)
  ⎿  Read 216 lines (ctrl+r to expand)

● 문제를 찾았습니다! 165번째 줄에서 Typography 컴포넌트 안에 Link가 있고, 그 Link
  안에 다시 Stack과 Typography가 중첩되어 있습니다. Typography는 기본적으로 <p>
  태그로 렌더링되는데, 그 안에 <div> (Stack)가 들어가면 DOM 규칙 위반입니다.

● Update Todos
  ⎿  ☒ Find the DOM nesting issue in onedb page components
     ☐ Fix Typography component with nested div elements
     ☐ Test the fix

● 이제 이 문제를 수정하겠습니다. Typography를 Box나 div로 바꾸거나, component prop을      
   사용해서 올바른 HTML 태그로 렌더링하도록 수정하겠습니다:

● Update(src\views\components\box\top-list-box.tsx)
  ⎿  Updated src\views\components\box\top-list-box.tsx with 4 additions and 3
     removals
       162                          textAlign={'start'}
       163                        >{`${data.category.categoryName} >
             ${data.category.child.categoryName}`}</Typography>
       164                        {sessionTypeChip(data)}
       165 -                      <Typography variant='body2' color={'primary'} 
     textAlign={'start'} sx={{ cursor: 'pointer' }}>
           - textAlign={'start'} sx={{ cursor: 'pointer' }}>
       165 +                      <Box sx={{ cursor: 'pointer' }}>
       166                          <Link
       167                            onClick={event => {
       168                              event.preventDefault()
       169
     router.push(`/onedb/content/${data.onedbId}`)
       170                            }}
       171 +                          color={'primary'}
       172                          >
       173                            <Stack direction={'row'} spacing={2}
             alignItems={'center'}>
       174 -                            <Typography variant={'Body2'} 
     fontWeight={600} textAlign={'start'}>
           - fontWeight={600} textAlign={'start'}>
       174 +                            <Typography variant={'Body2'} 
     fontWeight={600} textAlign={'start'} color={'primary'}>
           + fontWeight={600} textAlign={'start'} color={'primary'}>
       175                                {data.subject}
       176                              </Typography>
       177                              {data.hasAttachments && <Icon
             icon={'fa:paperclip'} style={{ flexShrink: 0 }}></Icon>}
     ...
       184                              )}
       185                            </Stack>
       186                          </Link>
       187 -                      </Typography>
       187 +                      </Box>
       188                      </Stack>
       189
       190                      <Typography variant={'body2'} minWidth={'80px'}>

● Update Todos
  ⎿  ☒ Find the DOM nesting issue in onedb page components
     ☒ Fix Typography component with nested div elements
     ☒ Test the fix

● 완료! DOM nesting 에러를 수정했습니다.

  문제:
  - Typography 컴포넌트(기본적으로 <p> 태그로 렌더링)
  - 그 안에 Link 컴포넌트가 있고
  - Link 안에 다시 Stack(div) 컴포넌트가 중첩되어 있음
  - HTML 규칙상 <p> 안에 <div>가 올 수 없음

  해결:
  - Typography를 Box로 변경 (<div>로 렌더링됨)
  - 텍스트 색상을 Link에 직접 적용
  - Typography 내부의 텍스트 색상을 명시적으로 설정

  변경 사항:
  // 이전 (잘못된 DOM 구조)
  <Typography variant='body2' color={'primary'}>
    <Link>
      <Stack>...</Stack> // ❌ p > a > div 구조
    </Link>
  </Typography>

  // 수정 후 (올바른 DOM 구조)
  <Box sx={{ cursor: 'pointer' }}>
    <Link color={'primary'}>
      <Stack>...</Stack> // ✅ div > a > div 구조
    </Link>
  </Box>

  이제 onedb 페이지에서 DOM nesting 경고가 더 이상 나타나지 않을 것입니다!

중간 저장 및 수정: 작업 중 Esc 키를 눌러 ToDo를 일시 중지하고, 필요한 부분만 수정 후 재개 가능.
장점: 체계적이고 투명한 워크플로우 제공. 복잡한 디버깅 시 작업 추적이 용이.

사용량 (월 기준)

Pro 플랜: Sonnet 4: 40 ~ 80시간
Max X5 플랜: Sonnet 4: 140 ~ 280시간, Opus: 15 ~ 35시간
Max X20 플랜: Sonnet 4: 800 ~ 1,600 시간

소넷 모델 기준 월 사용량 비교

커서 (Cursor) - Sonnet 4 기준

Pro ($20/월): 월 225회 요청
Pro+ ($60/월): 월 675회 요청
Ultra ($200/월): 월 4,500회 요청

클로드 (Claude) - 5시간마다 리셋 기준

월 사용량 계산 (30일 기준: 144번의 5시간 주기)

Pro ($20/월): 월 6,480회 메시지
- 5시간마다 45개 × 144주기 = 6,480개
Max 확장 ($100/월): 월 32,400회 메시지
- 5시간마다 225개 × 144주기 = 32,400개
Max 최대 ($200/월): 월 129,600회 메시지
- 5시간마다 900개 × 144주기 = 129,600개

결론

같은 $20 가격대에서:

커서 Pro: 월 225회
클로드 Pro: 월 6,480회

느낀점

코드 품질 측면에서의 우위

현재 시점(2025년 8월)에서 코드 개발에 있어 Claude Sonnet과 Opus를 능가하는 AI 모델은 없다고 단언할 수 있다. 특히 복잡한 로직 구현과 코드 구조 설계에서 보여주는 Claude의 성능은 압도적이다.

비용 효율성의 명확한 차이

이런 상황에서 자연스럽게 "어떤 플랫폼이 우수한 모델을 더 경제적으로 사용할 수 있게 해주는가?"라는 질문이 생긴다.

같은 $20 투자 기준:

Cursor Pro: 월 225회 사용
Claude Pro: 월 6,480회 사용 (약 29배 차이)

이는 단순히 숫자상의 차이가 아니다. 실제 개발 과정에서 반복적인 질문과 수정이 필요한 상황을 고려하면, Claude의 압도적인 사용량은 개발 속도와 직결된다.

일관성과 품질에 대한 기대

Claude의 또 다른 강점은 모델의 일관성이다. Cursor의 경우 여러 모델(Claude, GPT, Gemini)을 자동으로 전환하는 시스템이지만, 이로 인해 코드 스타일이나 접근 방식에서 일관성이 떨어질 수 있다.

반면 Claude는 Sonnet과 Opus라는 검증된 모델만을 사용하기 때문에, 프로젝트 전반에 걸쳐 일관된 코드 품질과 스타일을 유지할 수 있다.

실제 사용 경험을 통한 결론

3개월간의 Cursor 사용과 1개월간의 Claude 사용 경험을 비교해본 결과, 터미널 기반의 Claude 환경이 다소 불편함에도 불구하고 다음과 같은 이유로 Cursor 구독을 취소하게 되었다:

Claude의 장점

압도적인 비용 효율성 (29배 많은 사용량)
일관된 고품질 모델 사용
체계적인 문제 해결 접근법 (ToDo 시스템)
정확한 코드 분석과 수정 제안

개발자로서의 최종 판단

결국 개발 도구는 생산성과 비용 효율성의 균형이 가장 중요하다. 터미널 환경의 불편함은 적응으로 극복할 수 있지만, 비용 대비 성능의 차이는 장기적으로 더 큰 영향을 미친다.

특히 개인 개발자나 스타트업처럼 예산에 민감한 환경에서는 Claude의 선택이 거의 필수적이라고 생각한다. 같은 예산으로 29배 많은 AI 어시스턴스를 받을 수 있다는 것은, 곧 더 많은 실험과 더 빠른 개발 사이클을 의미한다.

프로그래머스 [Lv. 2] 완전범죄 {언어 : JavaScript}

스위태니 — Sun, 27 Apr 2025 17:24:18 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

정답 코드

function solution(info, n, m) {
    let answer = 0;
    const lenI = info.length;
    info.sort(([a, b], [c, d]) => c/d - a/b);
    let [cntA, cntB] = [0, 0];
    for (let i = 0; i < lenI; i++) {
        const [showA, showB] = info.at(i);
        if (cntB + showB < m) {
            cntB += showB;
        } else {
            cntA += showA;
        }
    }
    if (cntA >= n) {
        answer = -1;
    } else {
        answer = cntA;
    }
    
    return answer;
}

풀이 방법

A에게 부담이 되는 흔적부터 정렬한다.
1. 여기서 A에게 부담이 되는 흔적이란 무작정 흔적의 개수가 많은 것을 의미하지 않는다.
2. 예를 들어 [2, 3]과 [1, 1]이 있다면 A에게 부담이 되는 것은 [1, 1]이 된다.
3. 왜냐하면 B가 3의 흔적을 남기면 A의 흔적 2개를 지우는 것이지만
4. B가 [1, 1]씩 3번 흔적을 남기면 A의 흔적 3개를 지울 수 있다.
5. 따라서 [a흔적, b흔적] 을 a흔적을 b흔적으로 나눈 값이 큰 순으로 정렬한다.
정렬된 값을 B의 최대 수용량만큼 채운다.
나머지는 A에 채운다.
A가 n 이상이면 answer = -1
아니라면 A의 흔적만큼 반환하면 끝!

느낀점

처음엔 마냥 A에게 많은 흔적이 되는 것 부터 지웠다.
오랜만에 프로그래머스 lv2문제들이 올라와서 남김없이 풀어보려고 한다.
시간복잡도를 계산하지 않았다면 이걸 dfs로 풀었을 것 같다.
- dfs로 접근하게 된다면 흔적을 남길지 지울지 하는 선택지 2개
- 총 info의 길이 40개
- 2^40 = 1,099,511,627,776
- 이렇게 되면 시간초과를 해결할 수 없다.

프로그래머스 [Lv. 2] 지게차와 크레인 {언어 : JavaScript}

스위태니 — Sun, 23 Mar 2025 14:32:40 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

정답 코드

function solution(storage, requests) {
    let cnt = 0;
    
    const n = storage.length;
    const m = storage.at(0).length;
    const di = [-1, 1, 0, 0];
    const dj = [0, 0, -1, 1];
    const isValid = (ni, nj) => {
        return 0 <= ni && ni < n+2 && 0 <= nj && nj < m+2;
    }
    
    const board = Array.from({length: n+2}, () => Array(m+2).fill(0));
    for (let i = 1; i < n+1; i++) {
        for (let j = 1; j < m+1; j++) {
            const ascii = storage.at(i-1).at(j-1).charCodeAt();
            board[i][j] = ascii - 64;
        }
    }
    
    requests.forEach((e) => {
        const lenE = e.length;
        const selected = e.at(0).charCodeAt() - 64;
        if (lenE === 2) {
            for (let i = 1; i < n+2; i++) {
                for (let j = 1; j < m+2; j++) {
                    if (board.at(i).at(j) === selected) {
                        board[i][j] = -1;
                        cnt++;
                    }
                }
            }
        } else {
            const stack = [];
            // -1이 있는 부분 중에 0이랑 닿는 부분 0으로 만들기
            const visited = Array.from({length: n+2}, () => Array(m+2).fill(0));
            const queue = [[0, 0]];
            while (queue.length > 0) {
                const [i, j] = queue.shift();
                for (let d = 0; d < 4; d++) {
                    const ni = i + di[d];
                    const nj = j + dj[d];
                    if (isValid(ni, nj) && visited.at(ni).at(nj) === 0) {
                        const banianj = board.at(ni).at(nj);
                        if (banianj === 0) {
                            queue.push([ni, nj]);
                            visited[ni][nj] = 1;
                        } else if (banianj === -1) {
                            queue.push([ni, nj]);
                            visited[ni][nj] = 1;
                            board[ni][nj] = 0;
                        }
                    }
                }
            }
            // 0이랑 닿는 부분 stack에 넣기
            for (let i = 1; i < n+2; i++) {
                for (let j = 1; j < m+2; j++) {
                    const baiaj = board.at(i).at(j);
                    if (baiaj === selected) {
                        for (let d = 0; d < 4; d++) {
                            const ni = i + di[d];
                            const nj = j + dj[d];
                            if (isValid(ni, nj) && board.at(ni).at(nj) === 0) {
                                stack.push([i, j])
                                break;
                            }
                        }
                    }
                }
            }
            cnt += stack.length;
            stack.forEach(([i, j]) => {
                board[i][j] = 0;
            })
        }
    })
    const answer = n * m - cnt;
    return answer;
}

풀이 방법

스토리지를 0으로 감싸서 더 큰 배열을 만든다.
- 이렇게 해서 바깥 부분을 특정지을 수 있다.
0과 닿는 부분을 지우고 0으로 만든다.
모두 지울 수 있는 경우 -1로 만들고 0과 닿았는지 확인하여 -1이 0과 닿았으면 0으로 바꿔준다.
- -1이 바깥이 된 경우 언제까지나 -1로 있을 수는 없다.
이런식으로 계산해서 남는 부분의 개수를 출력하면 끝!

느낀점

오랜만에 풀면 array 설정 방법도 헷갈린다.
bfs로 푸는 방법을 떠올렸으나 크레인으로 뺀 부분을 어떻게 처리 해야할지 고민했었다.

프로그래머스 [Lv. 2] 비밀 코드 해독 {언어 : JavaScript}

스위태니 — Sun, 23 Mar 2025 14:23:13 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

정답 코드

function solution(n, q, ans) {
    const lenQ = q.length;
    let answer = 0;
    for (let i = 1; i <= n; i++) {
        for (let j = i+1; j <= n; j++) {
            for (let k = j+1; k <= n; k++) {
                for (let l = k+1; l <= n; l++) {
                    for (let m = l+1; m <= n; m++) {
                        // 현재 배열이 q와 비교했을 때 ans 값과 일치하는지 확인
                        let selectedArr = [i, j, k, l, m];
                        let check = true;
                        for (let o = 0; o < lenQ; o++) {
                            let cnt = 0;
                            for (let p = 0; p < 5; p++) {
                                if (q.at(o).includes(selectedArr.at(p))) {
                                    cnt++;
                                }
                            }
                            if (cnt !== ans.at(o)) {
                                check = false;
                                break;
                            }
                        }
                        if (check) {
                            answer++;
                        }
                    }
                }
            }
        }
    }
    return answer;
}

풀이 방법

dfs로 만들다가 실패해서 5중 for문으로 만들었다.
조합을 만들어서 q의 요소들과 비교한다.
ans와 같은 값이 나오면 answer++
이후 answer를 출력하면 끝!

느낀점

사실 dfs를 사용해야 더 깔끔한 풀이가 될 수 있지만 결국 가장 직관적이고 바로 해결할 수 있는 방법을 고안했다.
어차피 조합은 반복문의 연속이다.

줄 바꿈 CRLF, LF 문제 해결

스위태니 — Thu, 20 Mar 2025 11:49:00 +0900

정의

CRLF
- 캐리지 리턴 + 줄 바꿈
- \r\n
LF
- 줄 바꿈
- \n

문제 상황

.editorconfig와 개발 툴을 사용해서 CRLF를 LF로 바꿔야 한다.
WebStorm과 달리 VS Code에서는 .editorconfig를 기본적으로 사용하지 않는다.
CRLF를 LF로 바꾸고 싶으나 코드를 최소한으로 수정해서(개발 툴을 사용해서) 원하는 결과를 얻고 싶다.

목표

파일 하나만 CRLF 에서 LF로 바꾸기
VS Code 설정으로 줄 끝 문자 변경하
확장 프로그램 사용하기
Git 설정으로 CRLF 방지하기

1. 파일 하나만 CRLF에서 LF로 바꾸기

단계:
1. 변환하고 싶은 파일을 VS Code에서 연다.
2. 오른쪽 하단에 현재 줄 끝 문자가 표시된다 (예: CRLF 또는 LF).
3. CRLF을 클릭하면 LF로 변경할 수 있는 옵션이 나타난다. LF를 선택.
4. 파일을 저장(Ctrl + S)하면 LF로 변환된다.

2. VS Code 설정으로 줄 끝 문자 변경하

단계:
1. VS Code를 열고 왼쪽 하단의 톱니바퀴 아이콘(설정)을 클릭하거나 Ctrl + , (Windows) / Cmd + , (Mac)를 누른다.
2. 검색창에 Files: Eol을 입력한다.
3. Files: Eol 설정에서 기본값(\r\n, CRLF)을 \n (LF)으로 변경한다.
효과: 이후 저장하는 모든 파일이 LF로 저장된다.
- 따라서 yarn format 등을 사용해서 저장하면 모든 파일이 자동으로 LF로 저장된다.

3. 확장 프로그램 사용하기

EditorConfig for VS Code 확장 프로그램을 설치한다.
.editorconfig 파일을 만든다. (현재는 이미 만들어져 있음)

root = true
[*]
end_of_line = lf

4. Git 설정으로 CRLF 방지하기

.gitattributes 파일을 생성한다.

* text=auto eol=lf

Git 설정 변경

git config --global core.autocrlf false

GIT 사용법 정리 (2025-03-18)

스위태니 — Tue, 18 Mar 2025 11:32:41 +0900

1. 브랜치 관리

브랜치 생성 및 전환

git branch <브랜치명> : 새로운 브랜치 생성
git checkout <브랜치명> : 해당 브랜치로 이동 (구버전)
git switch <브랜치명> : 해당 브랜치로 이동 (권장)
git switch -c <브랜치명> : 브랜치 생성과 동시에 전환

브랜치 삭제

git switch <다른 브랜치> : 삭제 전 다른 브랜치로 이동
git branch -D <브랜치명> : 병합되지 않은 브랜치 강제 삭제
git branch -d <브랜치명> : 병합된 브랜치 삭제
원격 브랜치 삭제 순서:
1. git branch -d <브랜치명>
2. git push origin --delete <브랜치명>
3. git fetch
4. git pull
5. (필요 시) git push

2. 브랜치 병합

git switch <병합할 브랜치> : 병합할 브랜치로 이동
git merge <브랜치명> : 해당 브랜치를 현재 브랜치에 병합
git push origin <현재 브랜치> : 병합 후 원격 저장소에 반영

Fast-forward 병합 전략

git switch dev → git pull origin dev (최신화)
git switch <기능 브랜치> → git merge dev (병합)
git push origin <기능 브랜치>
git switch dev → git pull (최신화)
git merge <기능 브랜치> → git push origin dev
dev에서 문제 없으면 main으로 PR 후 병합 진행
- 테스트 완료 후 PR 생성
- 본부장님께 해당 업무 보고
- main으로 병합 후 먼데이 링크 추가
- 해당 내용 요약 작성

3. 새 브랜치 원격 저장소에 올리기

git push -u origin <브랜치명> : 브랜치를 원격에 등록
이후부터는 git push 만으로 푸시 가능

4. 브랜치 목록 조회

git branch -a : 로컬 및 원격 브랜치 모두 표시
git branch : 로컬 브랜치만 표시
git branch -r : 원격 브랜치만 표시
git branch -v : 각 브랜치의 마지막 커밋 정보 표시

5. 롤백 (이미 push한 경우)

특정 커밋으로 되돌리기

git log : 해시값 찾기 (예: commit abc123...)
git revert -m 1 <해시값>
- -m 1 : 병합된 브랜치에서 되돌릴 경우 사용
- :wq 입력 후 저장
git push origin <브랜치명> : 원격 반영

6. 기타 유용한 명령어

git stash : 현재 작업을 임시 저장 (커밋 없이 변경사항 숨김)
git stash pop : 임시 저장된 변경 사항 적용
git rebase -i HEAD~3 : 최근 3개의 커밋을 인터랙티브 리베이스
git cherry-pick <해시값> : 특정 커밋을 현재 브랜치로 가져오기
git log --oneline --graph : 한 줄씩 그래프 형태로 로그 확인

프로그래머스 [Lv. 2] 서버 증설 횟수 {언어 : JavaScript}

스위태니 — Wed, 12 Mar 2025 22:41:28 +0900

문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/389479?language=javascript

프로그래머스

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

programmers.co.kr

정답 코드

function solution(players, m, k) {
    const lenP = players.length;
    let answer = 0;

    const servers = Array.from({length: lenP}, () => 0);
    players.forEach((e, idx) => {
        if (e >= m) {
            const sai = servers.at(idx);
            const mcedm = Math.floor(e/m);
            if (sai < mcedm) {
                const diff = mcedm - sai;
                answer += diff;
                for (let jdx = idx; jdx < Math.min(idx+k, lenP); jdx++) {
                    servers[jdx] += diff;
                }
            }
        }
    })    
    return answer;
}

풀이 방법

해당 시간대의 서버 개수(servers.at(idx))와 현재 이용자 수(e)를 비교하고 m명 보다 많은 경우를 걸러준다.
만약 서버 개수가 적다면 새로 증설하고 k 시간 만큼 servers에 차이(diff)만큼 추가한다.
answer에는 diff를 한 번만 더해준다.
마지막으로 answer만 출력하면 끝!

느낀점

오랜만에 문제 푸니까 Array 설정하는 방법도 까먹었다.
다시 많이 풀어 보는 것이 좋겠다.

백준 BRONZE 2 [2745번] 진법 변환 {언어 : Python} [실수 주의]

스위태니 — Tue, 25 Feb 2025 08:27:15 +0900

문제 링크

https://www.acmicpc.net/problem/2745

메모리 초과 코드

n, b = input().split()
b = int(b)
length = len(n)
c = length - 1
answer = 0
dp = [1] * length
for i in range(1, length):
    dp[i] = dp[i-1] * b
for i in range(length):
    ni = n[i]
    if ni.isdigit():
        answer += ni * dp[c-i]
    else:
        answer += (ord(ni) - 55) * dp[c-i]
print(answer)

정답 코드

n, b = input().split()
b = int(b)
answer = 0

for char in n:
    if char.isdigit():
        answer = answer * b + int(char)
    else:
        answer = answer * b + (ord(char) - 55)

print(answer)

풀이 방법

메모리가 초과된 이유는 숫자를 int로 바꾸는 작업을 하지 않아서였다.
ni가 isdigit일 때 int로 바꾸면 40ms가 걸린다.

느낀점

실수를 주의하자.
기존 변수에 형변환을 여러 번 시도하면 메모리 초과가 난다.

백준 GOLD 5 [11729번] 하노이 탑 이동 순서 {언어 : Python} [다시 풀어 보기]

스위태니 — Fri, 14 Feb 2025 16:32:05 +0900

문제 링크

https://www.acmicpc.net/problem/11729

정답 코드

n = int(input())
dp = [0] * 21
dp[1] = 1
for i in range(2, 21):
    dp[i] = dp[i-1] * 2 + 1
print(dp[n])
def hanoi(number, start, end, assist):
    if number == 1:
        print(start, end)
        return
    else:
        hanoi(number-1, start, assist, end)
        print(start, end)
        hanoi(number-1, assist, end, start)
hanoi(n, 1, 3, 2)

풀이 방법

파라미터에 숫자, 시작 지점, 옮길 위치, 경유할 위치로 구분한다.
숫자가 1인 경우 한 번만 이동하면 된다.
나머지는 이 풀이를 보면 좋을 것 같다.

https://mgyo.tistory.com/185

'하노이의 탑' 이해하기 (feat. 재귀 함수)

들어가며 하노이의 탑 문제 소개 문제 정의 아이디어 얻기 아이디어 재귀 출발점, 도착점, 경유점 문제 분해 실제 코드 번외 : 원반의 개수에 따른 총 이동횟수 구하기 마무리 자료 출처 https://www

mgyo.tistory.com

느낀점

하노이탑은 재귀라기보단 수학 문제에 가까운 것 같다.

백준 GOLD 5 [9251번] LCS {언어 : Python} [다시 풀어 보기]

스위태니 — Thu, 13 Feb 2025 13:38:41 +0900

문제 링크

https://www.acmicpc.net/problem/9251

정답 코드 1

a = input()
b = input()
lenA = len(a)
lenB = len(b)
dp = [[0] * (lenA+1) for _ in range(lenB+1)]
maxLength = 0
for i in range(lenB):
    alphaB = b[i]
    for j in range(lenA):
        alphaA = a[j]
        if alphaA == alphaB:
            dp[i][j] += dp[i-1][j-1] + 1
        else:
            dp[i][j] = max(dp[i-1][j], dp[i][j-1])
        maxLength = max(maxLength, dp[i][j])
print(maxLength)

정답 코드 2

a = input()
b = input()
lenA = len(a)
lenB = len(b)
prevDp = [0] * (lenB+1)
for i in range(1, lenA+1):
    nextDp = [0] * (lenB+1)
    alphaA = a[i-1]
    for j in range(1, lenB+1):
        alphaB = b[j-1]
        if alphaA == alphaB:
            nextDp[j-1] = prevDp[j-2] + 1
        else:
            nextDp[j-1] = max(prevDp[j-1], nextDp[j-2])
    prevDp = nextDp
print(max(prevDp))

풀이 방법

lcs라고 최장 공통 부분수열(Longest Common Subsequence) 또는, 최장 공통 문자열(Longest Common Substring)을 사용했다.
dp[i][j]에 값을 더해가면서 가장 긴 부분의 길이를 찾는다.
- 역추적하면 가장 긴 수열도 출력할 수 있다.
알파벳이 같을 경우 대각선의 dp[i-1][j-1]에 1을 더해준다.
다를 경우 상, 좌에 있는 dp[i-1][j]와 dp[i][j-1] 중 큰 값을 넣는다.
dp에 가장 큰 값이 공통되는 가장 긴 길이이다.

느낀점

전에 비슷한 문제를 풀어봤다.
하지만 한 번밖에 안 풀어봐서 그런지 기억이 잘 나지 않았다.

https://sound-programming.tistory.com/352

Softeer [Level 3] 효도 여행 {언어 : JavaScript} [시간초과 해결]

문제 링크https://softeer.ai/practice/7649 Softeer - 현대자동차그룹 SW인재확보플랫폼 softeer.ai정답 코드const readline = require('readline');const rl = readline.createInterface({ input: process.stdin, output: process.stdout,});// 트

sound-programming.tistory.com

결국 다시 푸는 방법을 찾았고 이 분이 쓴 내용이 제일 이해가 잘 되었다.

https://velog.io/@emplam27/%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-%EA%B7%B8%EB%A6%BC%EC%9C%BC%EB%A1%9C-%EC%95%8C%EC%95%84%EB%B3%B4%EB%8A%94-LCS-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-Longest-Common-Substring%EC%99%80-Longest-Common-Subsequence

[알고리즘] 그림으로 알아보는 LCS 알고리즘 - Longest Common Substring와 Longest Common Subsequence

LCS는 주로 최장 공통 부분수열(Longest Common Subsequence)을 말합니다만, 최장 공통 문자열(Longest Common Substring)을 말하기도 합니다.

velog.io

1번 풀이는 2차원 배열로 풀어봤고
2번 풀이는 1차원 배열로 풀어봤다.

2번 풀이가 메모리도 작고 시간복잡도도 낮아서 더 효율적인 것을 알 수 있다.

백준 SILVER 3 [3273번] 두 수의 합 {언어 : Python}

스위태니 — Tue, 11 Feb 2025 15:22:24 +0900

문제 링크

https://www.acmicpc.net/problem/3273

정답 코드

n = int(input())
arr = sorted(list(map(int, input().split())))
val = int(input())
left = 0
right = n - 1
answer = 0
while left < right:
    tmp = arr[left] + arr[right]
    if tmp == val:
        left += 1
        right -= 1
        answer += 1
    elif tmp > val:
        right -= 1
    else:
        left += 1
print(answer)

풀이 방법

투 포인터를 사용했다.
정렬한 배열의 좌 우측에서 값을 가져온다.
값이 원하는 값과 같다면 좌를 키우고 우를 낮춰서 범위를 줄여준다.
값이 작다면 좌측에서 값을 키워야 하므로 좌를 키운다.
값이 크다면 우측에서 값을 낮춰야 하므로 우를 낮춘다.
좌우 값이 같지 않을 때 까지 한다.
1. 인덱스가 겹치지 않는 서로 다른 양의 정수의 쌍을 찾는 문제
값이 같을 때만 answer에 1을 더해주고 이를 출력하면 끝!

느낀점

다른 사람 풀이가 60ms도 내 풀이 84ms 보다 빠르기에 확인해봤다.

def solution(arr, val):
    arrSet = set(arr)
    cnt = 0
    for num in arr:
        if val - num in arrSet:
            cnt += 1
    return cnt // 2

n = int(input())
arr = list(map(int, input().split()))
val = int(input())
print(solution(arr, val))

속도는 빠르지만 메모리가 올라간 것을 확인할 수 있다.
시간 복잡도는 낮출 수 있지만 set를 사용하면서 공간 복잡도를 키웠다고 생각한다.
둘 중에 어떤 알고리즘을 선택하는 것은 자유이나 상황에 맞는 알고리즘을 선택하는 개발자가 되겠다.

백준 GOLD 5 [2565번] 전깃줄 {언어 : Python} [다시 풀어 보기]

스위태니 — Mon, 10 Feb 2025 16:23:36 +0900

문제 링크

https://www.acmicpc.net/problem/2565

정답 코드

import sys
input = sys.stdin.readline
n = int(input())
lines = sorted([list(map(int, input().split())) for _ in range(n)], key=lambda x:x[1])
dp = [1] * n
for i in range(1, n):
    si, ti = lines[i]
    for j in range(i):
        sj, tj = lines[j]
        if sj < si:
            dp[i] = max(dp[j]+1, dp[i])

print(n - max(dp))

풀이 방법

입력 처리 및 정렬
- (시작점, 끝점)을 입력받고 끝나는 지점 기준으로 정렬한다.
- 정렬은 그리디 + DP 조합을 활용하기 위한 사전 작업이다.
DP 배열 정의 및 초기화
- dp[i]는 i번째 선분을 포함했을 때 겹치지 않는 최대 선분 개수를 저장한다.
- 모든 값은 최소 1이므로 [1] * n으로 초기화한다.
DP 점화식 적용
- 이중 반복문을 돌며 sj < si 조건을 만족하는 경우 dp[i] = max(dp[j] + 1, dp[i])로 갱신한다.
- 즉, 선분이 겹치지 않는 경우 최대 선택 개수를 업데이트한다.
결과 출력
- max(dp)는 최대 겹치지 않는 선분 개수를 의미한다.
- 전체 개수 n에서 max(dp)를 빼면, 제거해야 할 최소 선분 개수가 된다.

lis 알고리즘

from bisect import bisect_left

import sys
input = sys.stdin.readline
n = int(input())
lines = sorted([list(map(int, input().split())) for _ in range(n)], key=lambda x:x[1])

lis = []
for si, _ in lines:
    pos = bisect_left(lis, si)  # lis에서 si가 들어갈 위치 찾기
    if pos == len(lis):
        lis.append(si)  # 새로운 원소 추가
    else:
        lis[pos] = si  # 기존 원소 교체 (LIS 유지)

print(n - len(lis))  # 제거해야 하는 최소 선분 개수

느낀점

기존 코드 (O(n^2)): DP를 이용해 최대 겹치지 않는 선분 개수를 구한다.
개선 코드 (O(n log n)): 이분 탐색 기반 LIS 알고리즘을 활용하여 최적화 가능하다.
print(n - max(dp))를 통해 제거해야 할 최소 선분 개수를 출력하는 것이 핵심이다.
겹치는 부분을 구하려고 했으나 안 겹치는 부분의 개수를 구하면 쉬워지는 문제였다.

백준 GOLD 5 [12919번] A와 B 2 {언어 : Python} [반례 포함]

스위태니 — Fri, 7 Feb 2025 16:36:04 +0900

문제 링크

https://www.acmicpc.net/problem/12919

정답 코드

s = input()
t = input()
lenS = len(s)
lenT = len(t)
answer = 0

def isIncluded(arr):
    normarlString = "".join(arr)
    reversString = "".join(arr[::-1])
    return normarlString in t or reversString in t

def dfs(length, arr):
    global answer
    if answer:
        return

    if length == lenT:
        string = "".join(arr)
        if string == t:
            answer = 1
        return

    if isIncluded(arr+["A"]):
        dfs(length+1, arr+["A"])
    if isIncluded(["B"] + arr[::-1]):
        dfs(length+1, ["B"] + arr[::-1])

dfs(lenS, list(s))
print(answer)

풀이 방법

길이가 lenT와 같아지면 종료되는 재귀함수를 만든다.
만약 이미 바꿀 수 있음을 확인했다면 종료시킨다.
재귀가 최대 2^50 = 1,125,899,906,842,624번 연산이 될 수 있다.
- 따라서 바꾸려고 하는 문자열이 t에 있는지 확인하고 재귀를 돌린다.
  - 여기서 문자열을 뒤집어서도 확인 해봐야 한다.
  - 그렇지 않으면 다음과 같은 반례가 나온다.
  - s = AB
  - t = BABB
  - 답 = 1
  - 오답 = 0
연산이 끝나면 answer를 출력한다

느낀점

항상 반례가 있다는 점을 명심하자.

백준 GOLD 4 [10830번] 행렬 제곱 {언어 : Python}

스위태니 — Tue, 4 Feb 2025 17:23:54 +0900

문제 링크

https://www.acmicpc.net/problem/10830

정답 코드

import sys
input = sys.stdin.readline
n, b = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]
optimization = dict()
# matrix의 원소가 1000이하이기 때문에 처음부터 걸러준다.
for i in range(n):
    for j in range(n):
        matrix[i][j] %= 1000
optimization[1] = matrix

# cal = calculation
def cal(leftM, rightM):
    newM = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            for k in range(n):
                newM[i][j] += (leftM[i][k] * rightM[k][j]) % 1000
            newM[i][j] %= 1000
    return newM
# dac = divide and conquer
def dac(depth):
    if depth == 1:
        return matrix
    elif depth == 2:
        return cal(matrix, matrix)
    else:
        if optimization.get(depth, 0) == 0:
            if depth % 2:
                optimization[depth] = cal(dac(depth//2+1), dac(depth//2))
            else:
                optimization[depth] = cal(dac(depth//2), dac(depth//2))
        return optimization[depth]
answer = dac(b)
for a in answer:
    print(*a)

풀이 방법

분할정복으로 풀었다.
만약 10제곱이라면
1. 2등분해서 5 5로 나누고
2. 5를 2 3으로 나누고
3. 2는 1 1
4. 3은 다시 2 1
5. 2는 1 1
6. 이렇게 나눠서 가장 깊숙한 지점부터 계산해서 올라 온다.
만약 n제곱이 존재하면 계산할 필요가 없이 dictionary에서 찾을 수 있도록 최적화 했다.
1. 이렇게 하지 않았다면 시간초과가 걸렸을 것이다.
맨 처음에 1000으로 나누어 떨어뜨리는 이유
1. 주어진 행렬의 원소가 1 <= elem <= 1000 이고 결과값은 원소 모두가 1000으로 나누어 떨어진 값이어야 하기 때문이다.
2. 이렇게 안 하면 거듭제곱이 1이고 원소가 다 1000일 경우 틀린 값이 나오게 된다.
계산이 완료되면 answer에 넣고 출력하면 끝!

느낀점

문제를 잘 읽어도 이런 문제는 실수를 유도하는 것 같다.
b의 값이 100,000,000,000이었기 때문에 분할 정복을 유추할 수 있었다.
이미 계산한 과정은 생략하고 바로 값을 찾을 수 있도록 딕셔너리에 넣는 방법을 배웠다.

[NextJS] favicon 바꾸기

스위태니 — Sat, 25 Jan 2025 21:18:20 +0900

< 내용 >

favicon을 바꿀 수 있다.
png, jpg 파일을 ico 확장자로 변환할 수 있다.

< 목차 >

favicon 바꾸기

1. favicon 바꾸기

파비콘은 위와 같이 탭에 있는 아이콘이나 이미지를 말한다.
이 파비콘을 바꾸는 방법은 간단하다.

위와 같이 favicon.ico를 원하는 이미지로 바꾸면 된다.

원하는 이미지 (png, jpg 등)을 선택한다.
이미지를 ico확장자로 변경한다.
1. png ico 변환으로 구글 검색하면 쉽게 찾을 수 있다.
ico로 변경한 이미지의 이름을 favicon으로 바꾼다.
원래 있던 favicon과 바꿔치기 하면 끝!

https://www.freeconvert.com/ko/png-to-ico

ICO PNG 으로 변환기 - FreeConvert.com

PNG를 ICO로 변환하는 변환기. 온라인에서 최고 품질로 PNG를 ICO로 변환하는 가장 좋은 방법입니다. 이 도구는 무료이며 안전하며 모든 웹 브라우저에서 작동합니다.

www.freeconvert.com

백준 GOLD 5 [12865번] 평범한 배낭 {언어 : Python} [다시 풀어 보기]

스위태니 — Fri, 24 Jan 2025 15:13:37 +0900

문제 링크

https://www.acmicpc.net/problem/12865

정답 코드

import sys
input = sys.stdin.readline
n, k = map(int, input().split())
dp = [[0] * (k+1) for _ in range(n+1)]
for i in range(1, n+1):
    w, v = map(int, input().split())
    for j in range(1, k+1):
        if j >= w:
            dp[i][j] = max(v+dp[i-1][j-w], dp[i-1][j])
        else:
            dp[i][j] = dp[i-1][j]
print(dp[n][k])

풀이 방법

DP 배열의 의미:
dp[i][j]dp[i][j]는 앞에서 ii번째 물건까지 고려했을 때, 배낭의 최대 무게가 jj일 때의 최대 가치를 저장.

느낀점

오랜만에 dp를 푸는데 어려웠다.
dp일 거라고 추측은 했지만 방법을 잘 몰랐다.
dp가 2차원 배열로도 만들 수 있다는 부분을 간과했다.

백준 GOLD 3 [15684번] 사다리 조작 {언어 : Python}

스위태니 — Thu, 23 Jan 2025 21:01:57 +0900

문제 링크

https://www.acmicpc.net/problem/15684

내 코드

import sys
input = sys.stdin.readline
n, m, h = map(int, input().split())
board = [[0] * (n+1) for _ in range(h+1)]

for _ in range(m):
    row, column = map(int, input().split())
    board[row][column] = column + 1
    board[row][column+1] = column

def check(board, destination):
    c = destination
    for r in range(1, h+1):
        if board[r][c]:
            c = board[r][c]
    if c == destination:
        return True
    return False

def marking(board, destination):
    c = destination
    for r in range(1, h+1):
        if board[r][c]:
            c = board[r][c]
        else:
            board[r][c] = -1

def backtracking(board, column, cnt):
    global answer
    # 가지치기
    if answer <= cnt:
        return
    if column > n:
        answer = cnt
        return
    if check(board, column):
        marking(board, column)
        return backtracking(board, column+1, cnt)

    # 설치
    c = column
    for r in range(1, h+1):
        if board[r][c] > 0:
            c = board[r][c]
        else:
            right = c + 1
            left = c - 1
            # 왼쪽 설치
            # 왼쪽에 없어야 하고
            # 오른쪽이 n 이거나 오른쪽에서 현재 지점으로 선이 없어야 한다.
            if c > 1 and board[r][left] == 0 and ((right <= n and board[r][right] != c) or right > n):
                leftBoard = [line[:] for line in board]
                leftBoard[r][left] = c
                leftBoard[r][c] = left
                backtracking(leftBoard, column, cnt+1)
            if c < n and board[r][right] == 0 and ((left >= 1 and board[r][left] != c) or left < 1):
                rightBoard = [line[:] for line in board]
                rightBoard[r][right] = c
                rightBoard[r][c] = right
                backtracking(rightBoard, column, cnt+1)
answer = 4
backtracking(board, 1, 0)
print(answer if answer < 4 else -1)

효율적인 코드

from sys import stdin

def back_tracking(n: int, max_cnt: int):
    global ladder, answer, H, N

    if answer!=-1:
        return
    
    cur_cnt = check()
    if cur_cnt+(max_cnt-n)*2 < N:
        return
    
    if n==max_cnt:
        if cur_cnt==N:
            answer = max_cnt
        return
    
    for h in range(1, H+1):
        for i in range(1, N):
            if ladder[h][i]==0 and ladder[h][i+1]==0:
                ladder[h][i], ladder[h][i+1] = i+1, i
                back_tracking(n+1, max_cnt)
                ladder[h][i], ladder[h][i+1] = 0, 0

def check() -> int:
    global ladder, N, H
    matched = 0
    for i in range(1, N+1):
        cur_i = i
        for h in range(1, H+1):
            if ladder[h][cur_i]!=0:
                cur_i = ladder[h][cur_i]
        if cur_i==i:
            matched += 1
    return matched

N, M, H = map(int, stdin.readline().split())
ladder = [[0]*(N+1) for _ in range(H+1)]
for i in stdin:
    a, b = map(int, i.split())
    ladder[a][b] = b+1
    ladder[a][b+1] = b
answer = -1
for cnt in range(4):
    back_tracking(0, cnt)
    if answer != -1:
        break
print(answer)

풀이 방법

사다리를 그린다.
- 예를들어 3 2 라면
- 3번 세로줄의 2번 행에서 우로 선이 이어진다.
- board[3][2] = 2 + 1
  - 즉 오른쪽으로 이동할 수 있도록 방향을 적는다.
- board[3][3] = 2
  - 오른쪽에서도 이동할 수 있도록 이쪽 지점을 적는다.
세로 줄 하나가 출발점과 끝점이 같은지 확인하는 함수를 만든다.
지나온 길을 마크할 수 있게 마킹 함수를 만든다.
- 가로줄이 없는 세로 길에 이미 지나간 번호가 있다면 이 길을 건들면 안된다.
- 가로선은 중복되서 지나갈 수 있지만 세로 선은 중복되지 않기 때문이다.
백트래킹을 실시한다.
실시후 answer의 값이 4이면 불가능하다는 말로 -1 아닌 경우는 answer값을 출력하면 끝!

느낀점

백트래킹을 할 때 깊은 복사를 자주 사용하는 것 같다.
이로인해 오히려 시간복잡도가 오르고 코드가 더 복잡해질 수 있다고 생각한다.
일단 풀었으면 된다라는 마인드가 아닌 왜 이렇게 풀었고 더 효율적인 방법은 없을지 찾는 과정이 필요하다.

코드트리 | HashMap / 순서를 바꾸었을 때 같은 단어 그룹화하기 {언어 : Python} [가장 작은 시공간복잡도]

스위태니 — Fri, 17 Jan 2025 17:09:07 +0900

문제 링크

https://www.codetree.ai/trails/complete/curated-cards/challenge-group-same-word/description

Code Tree | Learning to Code with Confidence

A super-comprehensive, meticulously arranged Coding Learning Curriculum engineered by Algorithm Experts composed of former International Olympiad in Informatics (IOI) medalists.

www.codetree.ai

정답 코드

import sys
input = sys.stdin.readline

n = int(input())
words = [input().strip() for _ in range(n)]

# Write your code here!
asciiDict = dict()
def makeKeys(word):
    tmpArr = [0] * 52 # 앞 26개는 대문자 뒤 26개는 소문자
    for w in word:
        ascii = ord(w)
        if ascii < 97:
            tmpArr[ascii-65] += 1
        else:
            tmpArr[ascii-71] += 1
    return "".join(map(str, tmpArr))
for word in words:
    asciiKey = makeKeys(word)
    if asciiKey in asciiDict:
        asciiDict[asciiKey] += 1
    else:
        asciiDict[asciiKey] = 1
maxCnt = max(list(asciiDict.values()))
print(maxCnt)

풀이 방법

ascii 코드를 활용해서 길이가 52인 문자열로 된 키를 만든다.
- 대문자는 65 ~ 90
- 소문자는 97 ~ 122
- 대문자는 앞에 0 ~ 25인덱스에 저장
- 소문자는 뒤에 26 ~ 51인덱스에 저장
- "AZABacaz"라면
- [2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
- 이를 하나로 합치기 전에 map을 사용해서 문자로 바꾼다.
- join으로 합쳐서 ascii 키를 만든다.
키를 asciiDict에 저장한다.
1. 있으면 +1
2. 없으면 1
values 중에 가장 큰 값을 max로 찾는다.
maxCnt를 출력하면 끝!

느낀점

문자열을 리스트로 바꾸고 정렬한 다음에 다시 뭉치고 새로 만들어진 문자열을 딕셔너리에 저장하는 방식이 떠오르지 않았다.
하지만 아스키 코드를 활용해서 푸는 방법을 고안했고 결국 제일 빠른 방법이 되었다.
이유로는 문자열의 길이가 1000이라고 가정할 때 정렬해서 join하는 것 보다 길이가 52인 배열에 저장해서 join하는 것이 더 빠르기 때문이다.
이처럼 하나의 방법에 매몰되지 말고 여러 방법을 떠올리는 것이 중요하다.

코드트리 | HashMAP / 원소의 합이 0 {언어 : Python}

스위태니 — Thu, 16 Jan 2025 14:20:24 +0900

문제 링크

https://www.codetree.ai/trails/complete/curated-cards/challenge-the-sum-of-the-elements-is-0/description

Code Tree | Learning to Code with Confidence

A super-comprehensive, meticulously arranged Coding Learning Curriculum engineered by Algorithm Experts composed of former International Olympiad in Informatics (IOI) medalists.

www.codetree.ai

내 코드

n = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
D = list(map(int, input().split()))

# Write your code here!
answer = 0
dictAB = dict()
dictCD = dict()

def addKey(dictTmp, left, right):
    for i in range(n):
        elemL = left[i]
        for j in range(n):
            elemR = right[j]
            tmp = elemL + elemR
            if dictTmp.get(tmp, 0):
                dictTmp[tmp] += 1
            else:
                dictTmp[tmp] = 1

addKey(dictAB, A, B)
addKey(dictCD, C, D)
keysAB = list(dictAB.keys())
for kab in keysAB:
    kcd = 0 - kab
    if dictCD.get(kcd, 0):
        answer += dictAB[kab] * dictCD[kcd]

print(answer)

더 효율적인 코드

n = int(input())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
C = list(map(int,input().split()))
D = list(map(int,input().split()))

count = dict()
for i in range(n):
    for j in range(n):
        sum = A[i] + B[j]
        if sum in count:
            count[sum] += 1
        else:
            count[sum] = 1

result = 0
for i in range(n):
    for j in range(n):
        target = -(C[i] + D[j])
        if target in count:
            result += count[target]

print(result)

풀이 방법

A와 B에서 합을 키로 하고 빈도를 값으로 하는 딕셔너리를 만든다.
C와 D에서 합을 키로 하고 빈도를 값으로 하는 딕셔너리를 만든다.
둘의 키를 합쳤을 때 0이 되는 경우 answer에 각 값을 곱해서 더해준다.
- 예를 들어 AB의 키가 45고 CD의 키가 -45인 경우
- answer += dictAB[45] * dictCD[-45]
- 주의할 점
  - dictAB의 키의 개수는 1 <= 키의 개수 <= 5000 * 5000이 된다.
  - 따라서 이중 반복문으로 dictCD에 있는 키 값을 찾으면 안된다.
  - 즉 dictCD에 0 - kab가 존재하는지만 확인하면 되므로 이중 반복문을 사용하지 않아도 된다.
answer를 출력한다.

느낀점

keys값의 개수가 5000개라고 생각해서 2중 for문을 사용한 결과 시간초과가 발생했다.
더 효율적인 코드의 경우 두 번째 CD의 합을 구할 때 바로 0이 되는 경우의 수를 구해준다.
따라서 반복을 한 번 더 할 필요가 없기 때문에 효율적인 코드가 된다.

코드트리 | HashMap / 자주 등장한 top k 숫자 {언어 : Python}

스위태니 — Wed, 15 Jan 2025 17:49:14 +0900

문제 링크

https://www.codetree.ai/trails/complete/curated-cards/challenge-top-k-frequent-elements/description

Code Tree | Learning to Code with Confidence

A super-comprehensive, meticulously arranged Coding Learning Curriculum engineered by Algorithm Experts composed of former International Olympiad in Informatics (IOI) medalists.

www.codetree.ai

정답 코드

n, k = map(int, input().split())
arr = list(map(int, input().split()))

# Write your code here!
stack = []
dictArr = dict()
for num in arr:
    if dictArr.get(num, 0):
        dictArr[num] += 1
    else:
        dictArr[num] = 1
itemsArr = sorted(list(dictArr.items()), key=lambda x:(x[1], x[0]), reverse=True)
for i in range(k):
    iak, iav = itemsArr[i]
    print(iak, end=" ")

다른 사람 풀이

n, k =map(int, input().split())
arr = list(map(int, input().split()))
freq = dict()

for num in arr:
    if num in freq:
        freq[num]+=1
        
    else:
        freq[num]=1

topk=dict()

keys = []
for key, value in freq.items():
    if value in topk:
        topk[value].append(key)
    else:
        topk[value] = [key]
        keys.append(value)

keys = sorted(keys, reverse=True)

for key, value in topk.items():
    topk[key] = sorted(topk[key],reverse=True)

for num in keys:
    if k<=0:
        break
    for answer in topk[num]:
        if k<=0:
            break

        print(answer, end=" ")
        k-=1

풀이 방법

입력 받기:
- n, k는 숫자의 개수와 출력할 숫자의 개수.
- arr는 숫자가 담긴 배열.
빈도 계산:
- freq 딕셔너리를 만들어 배열 arr의 각 숫자가 몇 번 등장했는지 저장한다.
- 딕셔너리의 key는 숫자, value는 등장 횟수.
빈도를 기준으로 그룹화:
- topk 딕셔너리를 만들어, 등장 횟수를 기준으로 숫자를 그룹화한다.
- 딕셔너리의 key는 등장 횟수, value는 해당 등장 횟수를 가진 숫자의 리스트.
정렬:
- 등장 횟수를 나타내는 key 값들을 keys 리스트에 모아, 내림차순으로 정렬한다.
- 각 등장 횟수에 속하는 숫자 리스트들도 내림차순으로 정렬한다.
출력:
- 등장 횟수가 높은 숫자부터 k개를 차례대로 출력한다.
- k가 0이 되면 반복을 멈춘다.

느낀점

속도가 283ms 와 96ms로 차이가 날 정도로 아래 코드가 더 효율적이다.
lambda 오랜만에 써서 어떻게 쓰나 했다.
sorted에 정렬을 하기 위해 key=을 사용해야 한다.
다 까먹었다...

코드트리 | HashMap / 세 수의 합 {언어 : Python}

스위태니 — Tue, 14 Jan 2025 23:17:44 +0900

문제 링크

https://www.codetree.ai/trails/complete/curated-cards/challenge-sum-of-three-num/description

Code Tree | Learning to Code with Confidence

A super-comprehensive, meticulously arranged Coding Learning Curriculum engineered by Algorithm Experts composed of former International Olympiad in Informatics (IOI) medalists.

www.codetree.ai

내 코드

n, k = map(int, input().split())
arr = list(map(int, input().split()))

# Write your code here!
dictNum = dict()
for num in arr:
    if dictNum.get(num, 0):
        dictNum[num] += 1
    else:
        dictNum[num] = 1

answer = 0
keysNum = list(dictNum.keys())
visited = dict()
def makeKeys(a, b, c):
    return [str(a)+str(b)+str(c), 
            str(a)+str(c)+str(b), 
            str(b)+str(a)+str(c),
            str(b)+str(c)+str(a),
            str(c)+str(a)+str(b),
            str(c)+str(b)+str(a)]
lenN = len(keysNum)
for i in range(lenN):
    for j in range(lenN):
        a, b = keysNum[i], keysNum[j]
        c = k - (a + b)
        cntA = dictNum[a]
        cntB = dictNum[b]
        tmp = 0
        if dictNum.get(c, 0):
            cntC = dictNum[c]
            if a == b == c:
                tmp += (cntA * (cntA - 1) * (cntA - 2)) // 6
            elif a == b:
                tmp += ((cntA * (cntA - 1)) // 2) * cntC
            elif a == c:
                tmp += ((cntA * (cntA - 1)) // 2) * cntB
            elif b == c:
                tmp += ((cntB * (cntB - 1)) // 2) * cntA
            else:
                tmp += cntA * cntB * cntC
            vk = makeKeys(a, b, c)
            if not visited.get(vk[0], 0):
                for nk in vk:
                    visited[nk] = 1
                answer += tmp
print(answer)

수정 코드

n, k = tuple(map(int, input().split()))
arr = list(map(int, input().split()))

count = dict()

for elem in arr:
    if elem in count:
        count[elem] += 1
    else:
        count[elem] = 1

ans = 0
for i in range(n):
    count[arr[i]] -= 1

    for j in range(i):
        diff = k - arr[i] - arr[j]

        if diff in count:
            ans += count[diff]

print(ans)

풀이 방법

빈도 저장: 배열 내 각 숫자의 빈도를 count 딕셔너리에 저장.
조합 탐색:
- 첫 번째 숫자(arr[i])를 선택 후, 중복 방지를 위해 빈도 감소.
- 두 번째 숫자(arr[j])를 선택 후, k - arr[i] - arr[j]로 세 번째 숫자(diff) 계산.
- count에서 diff 존재 여부를 확인하고, 존재하면 빈도만큼 결과 증가.
결과 출력: 가능한 모든 조합의 경우의 수를 ans에 저장하고 출력.

느낀점

일단 풀 수는 있었지만 빈도를 계산하는 방식이 비효율적이다.
따라서 다른 사람의 코드를 확인했고 더 간결하고 시간복잡도가 낮은 코드를 발견했다.

코드트리 | Two Pointer / 가장 짧은 부분합 {언어 : Python} [다시 풀어 보기]

스위태니 — Tue, 31 Dec 2024 16:40:08 +0900

문제 링크

https://www.codetree.ai/missions/8/problems/shortest-subtotal/submissions

코드트리 | 코딩테스트 준비를 위한 알고리즘 정석

국가대표가 만든 코딩 공부의 가이드북 코딩 왕초보부터 꿈의 직장 코테 합격까지, 국가대표가 엄선한 커리큘럼으로 준비해보세요.

www.codetree.ai

내 코드

n, k = map(int, input().split())
nums = list(map(int, input().split()))
tot = nums[0]
answer = 100000
r = 0
for l in range(n):
    while r + 1 < n and tot < k:
        tot += nums[r+1]
        r += 1
    if tot >= k:
        answer = min(answer, r - l + 1)
    tot -= nums[l]
if answer == 100000:
    print(-1)
else:
    print(answer)

풀이 방법

두 포인터 초기화
- 배열의 시작 지점을 가리키는 왼쪽 포인터 l과 끝 지점을 가리키는 오른쪽 포인터 r을 설정한다.
- 처음에는 두 포인터가 배열의 첫 번째 원소를 가리킨다.
- 현재 부분 배열의 합을 저장하는 변수 tot를 초기화한다.
오른쪽 포인터 이동 (확장)
- 현재 부분 배열의 합 tot이 목표값 k보다 작으면, 오른쪽 포인터를 이동시켜 배열의 다음 원소를 포함한다.
- 새로운 원소를 tot에 추가하여 현재 합을 갱신한다.
조건 만족 시 최소 길이 계산
- 부분 배열의 합 tot이 k 이상이 되면, 현재 부분 배열의 길이를 계산한다.
  - 길이는 (오른쪽 포인터 - 왼쪽 포인터 + 1)로 구한다.
- 계산한 길이를 기존의 최소 길이와 비교하여 더 짧은 값을 갱신한다.
왼쪽 포인터 이동 (축소)
- 왼쪽 포인터를 이동하여 현재 부분 배열의 시작점을 변경한다.
- 이때, 시작점이 빠지므로 tot에서 해당 값을 빼서 갱신한다.
- 이렇게 하면 부분 배열의 길이를 줄이면서도 조건을 만족하는지 확인할 수 있다.
반복
- 왼쪽 포인터를 배열의 끝까지 이동시키면서 위의 과정을 반복한다.
- 오른쪽 포인터는 조건에 따라 계속 확장하거나 유지되므로, 배열 전체를 완전히 탐색할 필요 없이 효율적으로 작업이 이루어진다.
결과 출력
- 만약 k 이상의 합을 가지는 부분 배열이 한 번도 없다면, 결과로 -1을 출력한다.
- 그렇지 않다면, 최소 길이를 출력한다.

작동 예제

예제 배열

배열: [5, 1, 3, 5, 10, 7, 4, 9, 2, 8]
목표값: k = 15

과정

초기 상태: tot = 5, l = 0, r = 0.
오른쪽 포인터 이동: tot = 5 + 1 + 3 + 5 = 14, 조건 미충족.
계속 이동: tot = 14 + 10 = 24, 조건 충족 → 길이 계산 → 최소 길이 = 5.
왼쪽 포인터 이동: tot = 24 - 5 = 19, 조건 충족 → 길이 갱신 → 최소 길이 = 4.
반복: 최단 길이 = 2까지 갱신.

출력

조건을 만족하는 부분 배열의 최소 길이: 2.

느낀점

이렇게 계산한다는 것을 이제 알았다...
아직 갈 길이 멀다.

[SQL-DATE] 프로그래머스 Lv. 3 오랜 기간 보호한 동물(2)

스위태니 — Fri, 27 Dec 2024 14:40:33 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

정답 코드

SELECT
    ANMO.ANIMAL_ID,
    ANMO.NAME
FROM ANIMAL_INS ANMI
RIGHT JOIN ANIMAL_OUTS ANMO
ON ANMI.ANIMAL_ID = ANMO.ANIMAL_ID 
    AND ANMI.DATETIME IS NOT NULL
ORDER BY DATEDIFF(ANMO.DATETIME, ANMI.DATETIME) DESC
LIMIT 2;

풀이 과정

조인 조건:
- ANIMAL_INS 테이블과 ANIMAL_OUTS 테이블을 ANIMAL_ID를 기준으로 RIGHT JOIN한다.
- 조인 조건에 추가로 ANMI.DATETIME IS NOT NULL이 적용되어, ANIMAL_INS의 DATETIME이 NULL이 아닌 경우만 포함된다.
- RIGHT JOIN을 사용했기 때문에 ANIMAL_OUTS에 있는 모든 동물이 결과에 포함되며, ANIMAL_INS에 없는 동물도 조회될 수 있다.
SELECT:
- 조인된 결과에서 ANIMAL_OUTS의 ANIMAL_ID와 NAME 컬럼을 선택한다.
DATEDIFF 계산 및 정렬:
- DATEDIFF(ANMO.DATETIME, ANMI.DATETIME)를 계산하여 동물이 입소된 날짜(ANMI.DATETIME)와 출소된 날짜(ANMO.DATETIME) 간의 차이를 기준으로 정렬한다.
- DESC 정렬을 사용하여 날짜 차이가 가장 큰 동물이 우선으로 출력된다.
LIMIT:
- 정렬된 결과에서 상위 2개만 선택한다.

느낀점

문법에 대해서 많이 떠오르지는 않지만 LIMIT, JOIN, ORDER BY를 적절하게 사용해서 문제를 풀어 봤다.
다음 게시글에는 내장함수를 정리하고 다시 풀어 봐야 하는 문제들을 복습할 것 같다.

[SQL-STRING] 프로그래머스 Lv. 3 조건에 맞는 사용자 정보 조회하기 [다시 풀어 보기]

스위태니 — Fri, 27 Dec 2024 14:30:40 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

정답 코드

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

풀이 과정

이 SQL 쿼리는 게시글을 3개 이상 작성한 사용자의 정보를 조회하고 정렬한다.
- 첫 번째 CTE THREE_MORE는 USED_GOODS_BOARD 테이블에서 작성자 ID(WRITER_ID)를 기준으로 그룹화하고, HAVING COUNT(*) >= 3 조건을 사용하여 게시글 개수가 3개 이상인 작성자만 선택한다.
두 번째 CTE TM_USERS는 첫 번째 CTE의 결과와 USED_GOODS_USER 테이블을 조인하여 사용자 정보를 조회한다.
- 조인 조건은 THREE_MORE.WRITER_ID = USED_GOODS_USER.USER_ID다.
- 전체 주소(전체주소)는 CITY, STREET_ADDRESS1, STREET_ADDRESS2를 CONCAT 함수로 연결해 생성된다.
- 전화번호(전화번호)는 SUBSTRING과 CONCAT을 사용해 XXX-XXXX-XXXX 형식으로 변환된다.
최종적으로, TM_USERS에서 사용자 ID, 닉네임, 전체 주소, 전화번호를 선택하고 USER_ID를 기준으로 내림차순 정렬하여 출력한다.
- 결과는 조건을 만족하는 사용자들의 정보를 정리된 형태로 제공한다.

느낀점

HAVING을 사용해서 3개 이상의 유저를 찾는 방법을 배웠다.
SUBSTRING으로 자르는데 SUBSTRING('1234567', 2, 3)이면 INDEX 2번째 => '2'부터 3개 => '234'가 출력된다.
여기서 주의할 점은 SUBSTRING의 맨 처음 INDEX는 1이다.

[SQL-STRING, DATE] 프로그래머스 Lv. 3 대여 기록이 존재하는 자동차 리스트 구하기

스위태니 — Fri, 27 Dec 2024 13:58:23 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

정답 코드

SELECT CRCRH.CAR_ID
FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY CRCRH
JOIN CAR_RENTAL_COMPANY_CAR CRCC
ON CRCRH.CAR_ID = CRCC.CAR_ID 
    AND CRCRH.START_DATE BETWEEN '2022-10-01' AND '2022-10-31' 
    AND CRCC.CAR_TYPE = '세단'
GROUP BY CRCRH.CAR_ID
ORDER BY CRCRH.CAR_ID DESC;

풀이 과정

CAR_RENTAL_COMPANY_RENTAL_HISTORY (CRCRH)와 CAR_RENTAL_COMPANY_CAR (CRCC)를 CAR_ID를 기준으로 조인한다.
- ON 조건을 만족하는 데이터만 결합되며, CRCRH.CAR_ID = CRCC.CAR_ID 조건이 적용된다.
조인된 데이터에서 WHERE 조건에 따라 필터링한다.
- 조건은 CRCRH.START_DATE가 2022-10-01에서 2022-10-31 사이에 포함되고, CRCC.CAR_TYPE이 '세단'인 경우다.
필터링된 데이터를 GROUP BY CRCRH.CAR_ID로 그룹화하여 중복된 차량 ID를 제거한다.
그룹화된 데이터에서 SELECT 문을 통해 CAR_ID를 선택한다.
마지막으로 ORDER BY CRCRH.CAR_ID DESC를 적용하여 차량 ID를 내림차순으로 정렬하고 결과를 출력한다.

느낀점

JOIN을 할 때 INNER JOIN으로 조건을 모두 만족하는 경우만 출력하게 했으며 CAR_ID를 그룹화 시켜서 중복을 제거했다.
한번에 풀려서 다행이라고 느끼면서도 항상 실수하지 않도록 꼼꼼히 풀어 보자.

[SQL-DATE] 프로그래머스 Lv. 3 조건별로 분류하여 주문상태 출력하기 [다시 풀어 보기]

스위태니 — Fri, 27 Dec 2024 13:48:51 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

정답 코드

SELECT
    ORDER_ID,
    PRODUCT_ID,
    DATE_FORMAT(OUT_DATE, '%Y-%m-%d') AS OUT_DATE,
    CASE
        WHEN OUT_DATE > '2022-05-01' THEN '출고대기'
        WHEN OUT_DATE <= '2022-05-01' THEN '출고완료'
        ELSE '출고미정'
    END AS 출고여부
FROM FOOD_ORDER
ORDER BY ORDER_ID;

풀이 과정

컬럼 선택 및 변환
- 목적: ORDER_ID, PRODUCT_ID, OUT_DATE 정보를 가져오고, OUT_DATE는 지정된 형식(YYYY-MM-DD)으로 변환.
- 수행:
  - SELECT ORDER_ID, PRODUCT_ID, DATE_FORMAT(OUT_DATE, '%Y-%m-%d') AS OUT_DATE
  - DATE_FORMAT 함수는 OUT_DATE를 원하는 날짜 형식으로 출력.
출고 여부 계산 (CASE 문 사용)
- 목적: OUT_DATE에 따라 출고 여부를 계산하여 새로운 컬럼(출고여부)을 생성.
- 수행:
  - CASE 문으로 조건을 설정:
    1. OUT_DATE > '2022-05-01': 출고대기 (미래 날짜)
    2. OUT_DATE <= '2022-05-01': 출고완료 (과거 또는 같은 날짜)
    3. ELSE: 기본값으로 출고미정.
  - 결과는 출고여부 컬럼으로 출력.
테이블 지정
- 목적: 데이터를 가져올 테이블을 지정.
- 수행:
  - FROM FOOD_ORDER를 통해 FOOD_ORDER 테이블에서 데이터를 가져온다.
정렬
- 목적: 결과를 ORDER_ID 기준으로 정렬.
- 수행:
  - ORDER BY ORDER_ID를 사용해 ORDER_ID의 오름차순으로 정렬한다.
최종 결과
- 목적: 변환된 데이터와 계산된 값을 출력.
- 결과 컬럼:
  - ORDER_ID: 주문 ID.
  - PRODUCT_ID: 제품 ID.
  - OUT_DATE: YYYY-MM-DD 형식의 출고 날짜.
  - 출고여부: 출고 상태를 나타냄.

느낀점

DATE 부분도 실수하기 쉬운 부분 같다.
%Y-%M-%D인지 %Y-%M인지 시간을 필요로 하는지를 유의해서 문제를 풀자.

[SQL-STRING] 프로그래머스 Lv. 3 조회수가 가장 많은 중고거래 게시판의 첨부파일 조회하기 [다시 풀어 보기]

스위태니 — Fri, 27 Dec 2024 13:23:05 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

틀린 코드

WITH MAX_GOODS AS (
    SELECT BOARD_ID
    FROM USED_GOODS_BOARD
    ORDER BY VIEWS DESC
    LIMIT 1
), MAX_GOODS_FILE_PATH AS (
    SELECT '/home/grep/src/' + BOARD_ID + '/' + FILE_ID + FILE_EXT
    FROM USED_GOODS_FILE UGF
    JOIN MAX_GOODS MG
    ON MG.BOARD_ID = UGF.BOARD_ID
    ORDER BY UGF.FILE_ID DESC
)
SELECT * FROM MAX_GOODS_FILE_PATH;

정답 코드

-- 가장 조회수가 높은 게시물의 BOARD_ID를 가져오는 CTE
WITH MAX_GOODS AS (
    SELECT BOARD_ID
    FROM USED_GOODS_BOARD
    ORDER BY VIEWS DESC
    LIMIT 1
),
-- 해당 게시물의 파일 경로를 생성하는 CTE
MAX_GOODS_FILE_PATH AS (
    SELECT 
        CONCAT('/home/grep/src/', UGF.BOARD_ID, '/', UGF.FILE_ID, UGF.FILE_NAME, UGF.FILE_EXT) AS FILE_PATH
    FROM USED_GOODS_FILE UGF
    JOIN MAX_GOODS MG
    ON MG.BOARD_ID = UGF.BOARD_ID
    ORDER BY UGF.FILE_ID DESC
)
-- 최종 결과 출력
SELECT FILE_PATH
FROM MAX_GOODS_FILE_PATH;

풀이 과정

MAX_GOODS CTE 생성
- 목적: 조회수가 가장 높은 게시물의 BOARD_ID를 가진다.
- 수행 방식:
  - USED_GOODS_BOARD 테이블에서 VIEWS 기준으로 내림차순 정렬.
  - LIMIT 1을 사용하여 가장 조회수가 높은 게시물 하나만 선택
MAX_GOODS_FILE_PATH CTE 생성
- 목적: 조회수가 가장 높은 게시물과 연결된 파일들의 경로를 생성한다.
- 수행 방식:
  - USED_GOODS_FILE 테이블과 MAX_GOODS를 조인하여 해당 게시물의 파일 정보 가져오기.
  - CONCAT 함수로 파일 경로를 /home/grep/src/{BOARD_ID}/{FILE_ID}{FILE_NAME}{FILE_EXT} 형식으로 생성.
  - FILE_ID를 기준으로 내림차순 정렬.
최종 SELECT
- 목적: 생성된 파일 경로 출력.
- 수행 방식:
  - MAX_GOODS_FILE_PATH CTE에서 FILE_PATH 컬럼만 선택하여 결과로 반환.

느낀점

CONCAT부분만 틀린줄 알았더니 FILE_PATH 부분이 잘 못된 것으로 보아 문제를 제대로 읽지 않았다는 것을 깨달았다.
문제를 꼼꼼하게 보는 습관은 언제나 중요하다.

[SQL-JOIN] 프로그래머스 Lv. 3 오랜 기간 보호한 동물(1)

스위태니 — Thu, 26 Dec 2024 17:19:19 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

정답 코드

WITH STILL_STAY AS (
    SELECT
        ANI.NAME,
        ANI.DATETIME
    FROM ANIMAL_INS ANI
    LEFT JOIN ANIMAL_OUTS ANO
    ON ANI.ANIMAL_ID = ANO.ANIMAL_ID
    WHERE ANO.ANIMAL_ID IS NULL
)
SELECT * FROM STILL_STAY ORDER BY DATETIME LIMIT 3;

풀이 과정

ANIMAL_INS와 ANIMAL_OUTS를 LEFT JOIN하여 입양되지 않은 동물을 필터링.
입양되지 않은 동물들의 이름과 입소 날짜를 가져옴.
입소 날짜 기준으로 정렬하고 상위 3개만 출력.

느낀점

내장 함수?만 잘 기억하면 문제를 풀 수 있을 것 같다.

[SQL-JOIN] 프로그래머스 Lv. 3 있었는데요 없었습니다

스위태니 — Thu, 26 Dec 2024 17:08:57 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

정답 코드

SELECT
    ANI.ANIMAL_ID,
    ANI.NAME
FROM ANIMAL_INS ANI
JOIN ANIMAL_OUTS ANO
ON ANI.ANIMAL_ID = ANO.ANIMAL_ID AND ANI.DATETIME > ANO.DATETIME
ORDER BY ANI.DATETIME;

풀이 과정

ANIMAL_INS와 ANIMAL_OUTS를 ANIMAL_ID로 JOIN.
ANI.DATETIME > ANO.DATETIME 조건으로 입양 날짜가 입소 날짜보다 앞선 데이터를 필터링.
결과를 ANI.DATETIME 기준으로 정렬하여 출력.

느낀점

조건을 실수하지 않도록 주의해야 겠다.

[SQL-JOIN] 프로그래머스 Lv. 3 없어진 기록 찾기 [다시 풀어 보기]

스위태니 — Thu, 26 Dec 2024 17:00:56 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

정답 코드

SELECT 
    ANO.ANIMAL_ID,
    ANO.NAME
FROM ANIMAL_OUTS ANO
LEFT JOIN ANIMAL_INS ANI
ON ANO.ANIMAL_ID = ANI.ANIMAL_ID
WHERE ANI.ANIMAL_ID IS NULL
ORDER BY ANO.ANIMAL_ID;

풀이 과정

LEFT JOIN:
- ANIMAL_OUTS를 기준으로 ANIMAL_INS와 LEFT JOIN하여, ANIMAL_OUTS의 모든 데이터를 가져오고 ANIMAL_INS에 해당하는 데이터를 매칭.
WHERE 조건:
- ANI.ANIMAL_ID IS NULL 조건을 통해, ANIMAL_OUTS에는 있지만 ANIMAL_INS에는 없는 데이터(유실된 데이터)를 필터링.
ORDER BY:
- ANIMAL_ID 기준으로 오름차순 정렬.

느낀점

INNER JOIN, OUTER JOIN, FULL JOIN에 대해서 더 알고 싶으면 아래 링크를 타고 들어가서 공부하면 좋다.

https://hongong.hanbit.co.kr/sql-%EA%B8%B0%EB%B3%B8-%EB%AC%B8%EB%B2%95-joininner-outer-cross-self-join/

SQL 기본 문법: JOIN(INNER, OUTER, CROSS, SELF JOIN)

조인은 두 개의 테이블을 서로 묶어서 하나의 결과를 만들어 내는 것을 말한다. INNER JOIN(내부 조인)은 두 테이블을 조인할 때, 두 테이블에 모두 지정한 열의 데이터가 있어야 한다.OUTER JOIN(외부

hongong.hanbit.co.kr

[SQL-IS NULL] 프로그래머스 Lv. 3 업그레이드 할 수 없는 아이템 구하기 [다시 풀어 보기]

스위태니 — Thu, 26 Dec 2024 16:47:19 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

틀린 코드

WITH HAVE_PAR AS (
    SELECT PARENT_ITEM_ID
    FROM ITEM_TREE
    WHERE PARENT_ITEM_ID IS NOT NULL
    GROUP BY PARENT_ITEM_ID
), NO_UPGRADE AS (
    SELECT
        II.ITEM_ID,
        II.ITEM_NAME,
        II.RARITY
    FROM ITEM_INFO II
    JOIN HAVE_PAR HP
    ON HP.PARENT_ITEM_ID != II.ITEM_ID
)
SELECT
    ITEM_ID,
    ITEM_NAME,
    RARITY
FROM NO_UPGRADE
ORDER BY ITEM_ID DESC;

정답 코드

WITH NO_UPGRADE AS (
    SELECT 
        II.ITEM_ID,
        II.ITEM_NAME,
        II.RARITY
    FROM ITEM_INFO II
    LEFT JOIN ITEM_TREE IT
    ON II.ITEM_ID = IT.PARENT_ITEM_ID
    WHERE IT.PARENT_ITEM_ID IS NULL
)
SELECT
    ITEM_ID,
    ITEM_NAME,
    RARITY
FROM NO_UPGRADE
ORDER BY ITEM_ID DESC;

풀이 과정

NO_UPGRADE CTE:
- ITEM_INFO 테이블을 기준으로 ITEM_TREE 테이블과 LEFT JOIN.
- ITEM_TREE.PARENT_ITEM_ID IS NULL 조건을 사용하여 더 이상 업그레이드 대상이 아닌 아이템을 필터링.
최종 SELECT:
- NO_UPGRADE CTE에서 필요한 컬럼 (ITEM_ID, ITEM_NAME, RARITY)을 선택.
- ORDER BY ITEM_ID DESC로 아이템 ID 기준 내림차순 정렬.

느낀점

LEFT JOIN을 하면 빈 값은 NULL로 채워지며 NULL인 값을 찾으면 업그레이드가 불가능한 아이템이 된다.

백준 GOLD 4 [1504번] 특정한 최단 경로 {언어 : Python}

스위태니 — Tue, 24 Dec 2024 15:36:11 +0900

문제 링크

https://www.acmicpc.net/problem/1504

정답 코드

import sys
import heapq

input = sys.stdin.readline
n, e = map(int, input().split())
adjL = [[] for _ in range(n+1)]
for _ in range(e):
    start, to, dist = map(int, input().split())
    adjL[start].append([to, dist])
    adjL[to].append([start, dist])
v1, v2 = map(int, input().split())
# 1에서 v1 까지 최소 + N에서 v2 까지 최소 + v1 v2 까지 최소
# 1에서 v2 까지 최소 + N에서 v1 까지 최소 + v1 v2 까지 최소
def Dijkstra(s1, t1):
    dp = [-1] * (n+1) # 최단 경로로 해야하므로
    hq = [[0, s1]]
    while hq:
        dist, start = heapq.heappop(hq)
        for to, nd in adjL[start]:
            newD = dist + nd
            if dp[to] == -1 or dp[to] > newD:
                dp[to] = newD
                heapq.heappush(hq, [newD, to])
    return dp[t1]

oneToV1 = Dijkstra(1, v1)
oneToV2 = Dijkstra(1, v2)
v1ToV2 = Dijkstra(v1, v2)
nToV1 = Dijkstra(n, v1)
nToV2 = Dijkstra(n, v2)

ov1v2n = -1
ov2v1n = -1
if v1ToV2 >= 0:
    if v1 == 1:
        if v2 == n:
            ov1v2n = ov2v1n = v1ToV2
        else:
            if nToV2 >= 0:
                ov1v2n = v1ToV2 + nToV2
    else:
        if oneToV1 >= 0 and nToV2 >= 0:
            ov1v2n = oneToV1 + v1ToV2 + nToV2
        if oneToV2 >= 0 and nToV1 >= 0:
            ov2v1n = oneToV2 + v1ToV2 + nToV1

if ov1v2n == -1 and ov2v1n == -1:
    print(-1)
else:
    if ov1v2n == -1:
        ov1v2n = 800_001
    if ov2v1n == -1:
        ov2v1n = 800_001
    print(min(ov1v2n, ov2v1n))

풀이 방법

1에서 v1까지 v1에서 v2까지 v2에서 n까지 거리를 구한다.
1에서 v2까지 v2에서 v1까지 v1에서 n까지 거리를 구한다.
각각의 거리에서 -1이 나오면 안되므로 검증한다.
v1이 1일 때와 v2가 n일때를 구분한다.
마지막으로 ov1v2n과 ov2v1n이 모두 -1일 때는 길이 없으므로 -1
아닌 경우에는 -1인 쪽을 800_001로 치환하고 최소 값을 출력하면 끝!

주의 사항

v1이 1이 아니라는 보장이 없고
v2가 n이 아니라는 보장이 없다.
대신 v1은 n이 아니라는 조건과 v2는 1이 아니라는 조건은 있었다.

느낀점

입력 조건을 꼼꼼하게 읽지 않으면 틀릴 문제.

[SQL-GROUP BY] 프로그래머스 Lv. 3 특정 조건을 만족하는 물고기별 수와 최대 길이 구하기 [다시 풀어 보기]

스위태니 — Mon, 23 Dec 2024 21:02:55 +0900

문제 링크

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

프로그래머스

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

programmers.co.kr

틀린 코드

WITH FISH_TOTAL_AVG AS (
    SELECT
        AVG(LENGTH) AS TOTAL_AVG
    FROM FISH_INFO
), FISH_TYPE_AVG AS (
    SELECT
        ID,
        FISH_TYPE,
        AVG(LENGTH) AS TYPE_AVG,
        MAX(LENGTH) AS MAX_LENGTH,
        COUNT(*) AS FISH_COUNT
    FROM FISH_INFO
    GROUP BY FISH_TYPE
), FISH_AVG_OVER AS (
    SELECT
        FTYA.ID,
        FTYA.MAX_LENGTH,
        FTYA.FISH_TYPE
    FROM FISH_TYPE_AVG FTYA
    JOIN FISH_TOTAL_AVG FTOA
    ON FTYA.TYPE_AVG >= FTOA.TOTAL_AVG
)
SELECT
    ID,
    MAX_LENGTH,
    FISH_TYPE
FROM FISH_AVG_OVER
ORDER BY FISH_TYPE;

정답 코드

WITH FISH_TYPE_STATS AS (
    SELECT
        FISH_TYPE,
        COUNT(*) AS FISH_COUNT,
        MAX(IF(LENGTH IS NULL, 10, LENGTH)) AS MAX_LENGTH,
        AVG(IF(LENGTH IS NULL, 10, LENGTH)) AS AVG_LENGTH
    FROM FISH_INFO
    GROUP BY FISH_TYPE
), FILTERED_FISH AS (
    SELECT
        FISH_TYPE,
        FISH_COUNT,
        MAX_LENGTH
    FROM FISH_TYPE_STATS
    WHERE AVG_LENGTH >= 33
)
SELECT
    FISH_COUNT,
    MAX_LENGTH,
    FISH_TYPE
FROM FILTERED_FISH
ORDER BY FISH_TYPE ASC;

풀이 과정

FISH_TYPE_STATS CTE:
- 물고기 종류별로 아래 데이터를 계산한다:
  - 잡은 물고기의 수 (FISH_COUNT)
  - 최대 길이 (MAX_LENGTH): NULL인 경우 길이를 10으로 간주.
  - 평균 길이 (AVG_LENGTH): NULL인 경우 길이를 10으로 간주.
FILTERED_FISH CTE:
- 평균 길이(AVG_LENGTH)가 33cm 이상인 물고기 종류만 선택한다.
최종 SELECT:
- 필터링된 결과에서 FISH_COUNT, MAX_LENGTH, FISH_TYPE를 출력하고, FISH_TYPE 기준으로 오름차순 정렬한다.

느낀점

문제에 평균 33이라고 나와 있는데 테스트 케이스 마다 평균이 다를줄 알고 다르게 계산했다.
심지어 10cm이하는 NULL이고 10으로 잡고 계산해야 하는데 이것 또한 지키지 못했다.