자바를 사용한 코딩테스트 준비를 위한 체계적인 스터디 프로젝트입니다.

codingtest-study/
├── src/main/java/
│   ├── algorithm/           # 알고리즘별 분류
│   │   ├── search/         # 탐색 알고리즘
│   │   │   ├── binary/     # 이진탐색
│   │   │   ├── bfs/        # 너비우선탐색
│   │   │   └── dfs/        # 깊이우선탐색
│   │   ├── sort/           # 정렬 알고리즘
│   │   ├── graph/          # 그래프 알고리즘
│   │   ├── dp/             # 동적 프로그래밍
│   │   ├── greedy/         # 그리디 알고리즘
│   │   ├── string/         # 문자열 처리
│   │   └── math/           # 수학 관련
│   ├── platform/           # 플랫폼별 분류
│   │   ├── baekjoon/       # 백준 문제
│   │   ├── programmers/    # 프로그래머스 문제
│   │   └── leetcode/       # 리트코드 문제
│   └── utils/              # 유틸리티 클래스
├── templates/              # 코드 템플릿
├── docs/                   # 문서화
│   ├── algorithm-notes/    # 알고리즘 이론 정리
│   ├── problem-solutions/  # 문제 해설
│   └── study-plans/        # 학습 계획
├── build.gradle           # Gradle 빌드 설정
└── README.md

./gradlew build

./gradlew run

./gradlew test

빠른 입력 처리를 위한 스캐너 클래스

FastScanner sc = new FastScanner();
int n = sc.nextInt();
String s = sc.next();

경쟁 프로그래밍용 고성능 입력 리더

InputReader in = new InputReader(System.in);
int[] arr = in.nextIntArray(n);

테스트 및 디버깅을 위한 유틸리티 함수들

String result = TestUtils.runWithInput("5 3", () -> {
    // 테스트할 코드
});

기본적인 코딩테스트 템플릿

빠른 입출력을 위한 템플릿

경쟁 프로그래밍을 위한 고급 템플릿 (유틸리티 함수 포함)

docs/algorithm-notes/ 디렉토리에서 각 알고리즘의 이론과 구현을 학습하세요.

1. 플랫폼별 디렉토리에서 문제를 풀어보세요
2. 해결 후 docs/problem-solutions/에 해설을 작성하세요

docs/study-plans/에서 학습 계획을 세우고 진도를 체크하세요.

1. 해당 알고리즘 분류의 패키지에 새 Java 파일 생성
2. 템플릿을 복사해서 기본 구조 설정
3. 문제 해결 후 docs에 해설 작성

• 클래스명은 문제번호나 문제명으로 명명
• 주석으로 문제 링크와 간단한 설명 추가
• 시간복잡도와 공간복잡도 명시

• 사용자가 작성한 원본코드 유지하고 하위에 새로운 정답 코드 작성해줘
• 사용자가 작성한 코드에 잘못된 점을 주석으로 남겨줘
• 무조건 한글로 작성할 것
• 상위 주석에 해당 문제의 URL주소도 같이 남겨줄것

/**
 * 문제명 + URL 주소
 * 시간복잡도: 원본 → 개선 복잡도
 */
public class 클래스명 {
    // 사용자 원본 해법 (접근법 명시)
    public static void main(String[] args) {
        // 원본 코드 그대로 유지
        int variable = value; // 개선 포인트 한글 주석
        
        // ✅ 원본 로직 정확성 평가
    }
    
    // 개선된 해법 (최적화 내용)
    public static void solutionOptimized() {
        // 개선된 코드
    }
}

/*
 * 상세 분석 (한글):
 * ✅ 원본 해법: 장단점 분석
 * 🚀 개선 해법: 최적화 내용
 * 학습 포인트: 핵심 패턴들
 */

• docs/study-plans/6weeks-curriculum.md에서 #### Day 2 - 배열, 조건문 [프로그래머스] K번째 수 (Lv1)는 day2_1.java로 명명
• docs/study-plans/6weeks-curriculum.md에서 - 추가 연습: [백준] 11279 최대 힙, [백준] 1927 최소 힙은 day8_add_1,day8_add_2로 명명

• ✅ 원본 코드 보존: 사용자 작성 코드 완전 유지
• ✅ 개선점 인라인 주석: 원본 코드 옆에 한글 설명
• ✅ 개선 해법 분리: solutionOptimized() 메서드로 별도 구현
• ✅ 정확성 평가: 원본 로직의 정확성을 먼저 확인
• ✅ 효율성 분석: 시간/공간복잡도 최적화 포인트 명시
• ✅ 학습 가치 강조: 핵심 패턴과 개념 정리

package algorithm.dp;

/**
 * 백준 1463번 - 1로 만들기
 * https://www.acmicpc.net/problem/1463
 * 시간복잡도: O(N), 공간복잡도: O(N)
 */
public class BOJ1463 {
    public static void main(String[] args) {
        // 구현
    }
}

• 완주하지 못한 선수 (프로그래머스 Lv1) - HashMap + getOrDefault 패턴
• 신규 아이디 추천 (프로그래머스 Lv1) - 정규식 패턴 7단계 처리
• 문자열 반복 (백준 2675) - StringBuilder + 다중 테스트케이스

• ✅ HashMap의 getOrDefault() 활용한 빈도수 카운팅 마스터
• ✅ 정규식 패턴 완벽 가이드 작성 (docs/algorithm-notes/regex-patterns-guide.md)
• ✅ 시간복잡도 최적화 (O(N²) → O(N)) 체험
• ✅ 문자열 처리 7단계 구현 및 디버깅 기법
• ✅ 다중 테스트케이스 처리 패턴

• K번째 수 (프로그래머스 Lv1) - day2_1.java 완료 및 개선
• 실패율 (프로그래머스 Lv1) - day2_2.java 로직 검증 완료
• 최솟값, 최댓값 (백준) - day2_add.java O(N) 최적화 완료

• 다트 게임 (프로그래머스 Lv1) - day3_1.java 문자열 파싱 마스터
• 숫자 문자열과 영단어 (프로그래머스 Lv1) - day3_2.java StringBuilder 최적화 완료
• 알파벳 빈도수 (백준 추정) - day3_add.java HashMap 반복 패턴 학습

• ✅ Arrays.copyOfRange() 활용한 부분 배열 추출 마스터
• ✅ Arrays 클래스 완벽 가이드 작성 (docs/algorithm-notes/arrays-utility-guide.md)
• ✅ 다중 조건 정렬 (실패율 내림차순 → 스테이지 번호 오름차순)
• ✅ 0으로 나누기 방지 및 실수 계산 패턴
• ✅ Math.min/max 활용한 O(N) 최솟값/최댓값 추적 패턴
• ✅ 시간복잡도 최적화 (O(N log N) → O(N)) 체험

• ✅ 문자열 파싱 고급 패턴 (10점 처리, 스타상 영향, 상태 관리)
• ✅ StringBuilder 누적 및 최적화 기법 (length >= 3 조건 활용)
• ✅ replaceAll vs replace 차이점 및 활용법
• ✅ HashMap 반복 방법 4가지 (entrySet, keySet, values, forEach)
• ✅ 문자열 치환 vs 파싱 접근법 비교
• ✅ getOrDefault() 패턴으로 null 안전 프로그래밍

• 입출력 및 기본 문법 (FastScanner, BufferedReader)
• 배열과 문자열 (StringBuilder, 정규식)
• HashMap 활용 (빈도수 카운팅, getOrDefault, 반복 패턴)
• 배열 조작 (Arrays.copyOfRange, 정렬, 이진탐색)
• 문자열 파싱 (상태 관리, 두 자리 수 처리, 치환 vs 파싱)

• DFS/BFS
• 동적 프로그래밍
• 그리디 알고리즘

• 그래프 알고리즘
• 트리 알고리즘
• 고급 자료구조

1. 완주하지 못한 선수 - HashMap 빈도수 패턴
2. 신규 아이디 추천 - 정규식 7단계 처리
3. 문자열 반복 - StringBuilder + 다중 케이스
4. K번째 수 - Arrays.copyOfRange + 정렬
5. 실패율 - 다중 조건 정렬, 실수 계산
6. 최솟값, 최댓값 - Math.min/max + O(N) 최적화
7. 다트 게임 - 문자열 파싱, 상태 관리, 10점 처리
8. 숫자 문자열과 영단어 - StringBuilder 누적, replaceAll 활용
9. 알파벳 빈도수 - HashMap 반복 패턴, getOrDefault
10. 나는야 포켓몬 마스터 이다솜 - 양방향 매핑, 1-based 인덱싱
11. 문자열 내 마음대로 정렬하기 - 커스텀 Comparator, 다중 조건 정렬
12. 가장 큰 수 - 문자열 조합 비교 (a+b vs b+a), 엣지케이스 처리
13. 기능개발 (Lv2) - Queue 시뮬레이션, Stream API 변환 패턴
14. 프린터 (Lv2) - Queue+PriorityQueue 조합, 위치 정보 보존
15. 제로 (백준 10773) - Stack LIFO 특성, ArrayDeque 활용
16. 큐 2 (백준 18258) - 원형 배열, 투 포인터 기법
17. 더 맵게 (Lv2) - PriorityQueue 힙, 그리디 알고리즘
18. 최대 힙 (백준 11279) - Collections.reverseOrder(), 힙 기본 연산
19. 최소 힙 (백준 1927) - 기본 PriorityQueue, 타입 안전성
20. 위장 (Lv2) - 곱의 법칙, HashMap 카운팅 패턴
21. 패션왕 신해빈 (백준 9375) - getOrDefault 패턴, 다중 테스트케이스
22. H-Index (Lv2) - 정렬 기반 해법, 문제 정의 정확한 이해

• 나는야 포켓몬 마스터 이다솜 (백준 1620) - day4_add.java 양방향 매핑 패턴

• ✅ 양방향 매핑: Array(번호→이름) + HashMap(이름→번호) 조합 패턴 마스터
• ✅ 1-based 인덱싱: 문제 조건에 맞는 자연스러운 배열 처리
• ✅ 숫자/문자 판별: Character.isDigit() vs try-catch 방법 비교
• ✅ 메모리 최적화: 즉시 처리 vs 저장 후 처리 기법
• ✅ 시간/공간 복잡도: 완벽 가이드 문서 생성

• 문자열 내 마음대로 정렬하기 (프로그래머스 Lv1) - day5_1.java 커스텀 정렬 완성
• 가장 큰 수 (프로그래머스 Lv1) - day5_2.java 조합 비교 알고리즘 마스터

• ✅ Arrays.sort 커스텀 정렬: 3가지 방법 완전 숙지 (람다식, Comparator.comparing, 전통적 방식)
• ✅ Comparator 반환값 규칙: 1/-1/0의 정확한 의미와 정렬 동작 원리 이해
• ✅ 다중 조건 정렬: 우선 조건 → 보조 조건 패턴 완성
• ✅ 문자열 조합 비교: a+b vs b+a 비교로 최적 조합 찾기 (가장 큰 수 핵심 알고리즘)
• ✅ 배열 타입 주의사항: int[] vs Integer[] Comparator 호환성
• ✅ 엣지케이스 처리: "000" → "0" 변환 등 실전 팁

• 기능개발 (프로그래머스 Lv2) - day8_1.java Stream API 마스터
• 프린터 (프로그래머스 Lv2) - day8_2.java Queue+PriorityQueue 조합
• 제로 (백준 10773) - day8_add_1.java Stack LIFO 패턴
• 큐 2 (백준 18258) - day8_add_2.java 원형 배열 구현

• 더 맵게 (프로그래머스 Lv2) - day10_1.java 힙(PriorityQueue) 활용
• 최대 힙 (백준 11279) - day10_add_1.java Collections.reverseOrder()
• 최소 힙 (백준 1927) - day10_add_2.java 기본 PriorityQueue

• 위장 (프로그래머스 Lv2) - day11_1.java 곱의 법칙 활용
• 패션왕 신해빈 (백준 9375) - day11_add_1.java HashMap 카운팅

• H-Index (프로그래머스 Lv2) - day12_1.java 정렬 기반 해법

• ✅ Stack & Queue 자료구조: LIFO/FIFO 특성과 실전 활용법 완전 마스터
• ✅ Stream API: mapToInt(Integer::intValue).toArray() 변환 패턴 및 메서드 참조(::) 이해
• ✅ Lambda 표현식: -> 연산자와 함수형 프로그래밍 패턴 완전 숙지
• ✅ 원형 배열: 투 포인터와 모듈로 연산으로 O(1) Queue 구현
• ✅ PriorityQueue: 힙 자료구조로 최솟값 추출 최적화 (O(N²) → O(N log N))
• ✅ 복합 자료구조: Queue+PriorityQueue 조합으로 우선순위 처리
• ✅ 정보 보존 패턴: int[]{value, index} 방식으로 위치 정보 유지
• ✅ ArrayDeque 활용: 레거시 Stack 대신 현대적 구현체 사용

문제 해설 (15개):

• docs/problem-solutions/prog-level1-완주하지못한선수.md - HashMap 빈도수 패턴
• docs/problem-solutions/prog-level1-신규아이디추천.md - 정규식 7단계 처리
• docs/problem-solutions/baekjoon-2675-문자열반복.md - 다중 테스트케이스
• docs/problem-solutions/prog-level1-K번째수.md - Arrays.copyOfRange 활용
• docs/problem-solutions/prog-level1-실패율.md - 다중 조건 정렬
• docs/problem-solutions/baekjoon-10818-최솟값최댓값.md - 시간복잡도 최적화
• docs/problem-solutions/prog-level1-다트게임.md - 문자열 파싱 마스터
• docs/problem-solutions/baekjoon-1620-포켓몬마스터.md - 양방향 매핑 패턴
• docs/problem-solutions/prog-level2-기능개발.md - Queue 시뮬레이션, Stream API
• docs/problem-solutions/prog-level2-프린터.md - Queue+PriorityQueue 조합 패턴
• docs/problem-solutions/baekjoon-10773-제로.md - Stack LIFO 특성과 실전 활용
• docs/problem-solutions/baekjoon-18258-큐2.md - 원형 배열과 효율적 Queue 구현
• docs/problem-solutions/prog-level2-더맵게.md - PriorityQueue 힙 활용, 그리디 알고리즘
• docs/problem-solutions/prog-level2-위장.md - 곱의 법칙, HashMap 카운팅 완벽 가이드
• docs/problem-solutions/baekjoon-9375-패션왕신해빈.md - 백준 입출력, getOrDefault 패턴
• docs/problem-solutions/prog-level2-H-Index.md - 정렬 기반 해법, 복잡도 최적화

알고리즘 가이드 (7개):

• docs/algorithm-notes/regex-patterns-guide.md - 정규식 완벽 가이드
• docs/algorithm-notes/arrays-utility-guide.md - Java Arrays 클래스 가이드 (Comparator 규칙 추가)
• docs/algorithm-notes/complexity-analysis.md - 시간/공간복잡도 완벽 가이드
• docs/algorithm-notes/coding-test-patterns.md - 기존 자료
• docs/algorithm-notes/queue-stack-fundamentals.md - Stack/Queue 자료구조 완벽 가이드
• docs/algorithm-notes/java-stream-api-guide.md - Stream API와 람다 표현식 완벽 가이드
• docs/algorithm-notes/heap-priorityqueue-guide.md - 힙과 PriorityQueue 완벽 마스터 가이드
• docs/algorithm-notes/combinatorics-guide.md - 경우의 수 계산: 곱의 법칙 vs 조합/순열 구분법

• ✅ PriorityQueue 마스터: 최소/최대 힙 완벽 구현
• ✅ 곱의 법칙 이해: 조합론과 구분하여 정확한 적용
• ✅ HashMap 카운팅: getOrDefault 패턴 완전 숙지
• ✅ 백준 입출력: 다중 테스트케이스 처리 마스터
• ✅ 정렬 기반 해법: 복잡한 자료구조 대신 단순한 접근
• ✅ 그리디 알고리즘: 힙과 조합한 최적화 패턴

• ✅ 힙 자료구조: offer()/poll()/peek() 연산과 시간복잡도 완전 이해
• ✅ Collections.reverseOrder(): 최대 힙 구현법 마스터
• ✅ 곱의 법칙 vs 조합론: 문제 패턴별 수학적 모델링 능력 습득
• ✅ 경우의 수 계산: 독립적 선택 → 곱의 법칙 적용 기준 정립
• ✅ 문제 정의 이해: H-Index처럼 복잡한 정의도 정확히 파악하는 능력
• ✅ 알고리즘 선택: 복잡한 접근 vs 단순한 해법 판단 기준

• Week 3 진입: DFS/BFS, 완전탐색, 백트래킹
• 단기 목표: 그래프 탐색 알고리즘 기초
• 중기 목표: 동적 프로그래밍 입문
• 장기 목표: 고급 그래프 알고리즘

기초 문법 & 자료구조:

• HashMap getOrDefault() 안전 패턴
• StringBuilder 효율적 활용 (String 연결 최적화)
• Arrays.copyOfRange() 부분 배열 추출
• Math.min/max 활용한 O(N) 최적화

문자열 처리:

• 정규식 7단계 처리 (신규 아이디 추천)
• 문자열 파싱 상태 관리 (다트 게임)
• replaceAll vs replace 차이점 활용
• 두 자리 수 처리 (10점 특수 케이스)

고급 패턴:

• 다중 조건 정렬 (실패율 내림차순 → 스테이지 번호 오름차순)
• 0으로 나누기 방지: (total == 0) ? 0.0 : (double)fail/total
• HashMap 반복 4가지 방법 (entrySet, keySet, values, forEach)
• 시간복잡도 최적화 체험 (O(N²) → O(N), O(N log N) → O(N))

새로 완료된 패턴 (Day 4-5):

• 양방향 매핑: Array(인덱스→값) + HashMap(값→인덱스) 조합
• 1-based 인덱싱 처리법과 0-based 차이점 이해
• 숫자/문자 판별: Character.isDigit() vs try-catch 방법
• Arrays.sort 커스텀 정렬 3가지 방법 (람다, Comparator.comparing, 전통적)
• Comparator 반환값 규칙 (-1/0/1)과 정렬 동작 원리
• 문자열 조합 비교: a+b vs b+a로 최적 조합 찾기
• 배열 타입 호환성: int[] vs Integer[] Comparator 사용법
• 시간/공간복잡도 완전 이해 (Big-O 표기법부터 실전 활용까지)

새로 완료된 패턴 (Day 8):

• Stack LIFO 특성: "가장 최근" 패턴 인식 및 ArrayDeque 활용
• Queue FIFO 특성: 원형 배열과 투 포인터로 O(1) 연산 구현
• PriorityQueue 힙: 최솟값 추출 최적화 (O(N²) → O(N log N))
• 복합 자료구조: Queue+PriorityQueue 조합으로 우선순위 처리
• 정보 보존 패턴: int[]{value, index} 방식으로 위치 정보 유지
• Stream API: mapToInt(Integer::intValue).toArray() 변환 체인
• 메서드 참조(::): 람다식의 간결한 표현과 타입 추론
• 원형 배열 구현: 모듈로 연산으로 배열 순환 처리

새로 완료된 패턴 (Day 10-12):

• 힙 연산 마스터: offer()/poll()/peek() 시간복잡도와 활용법 완전 이해
• Collections.reverseOrder(): 최대 힙 구현 및 커스텀 Comparator 활용
• 곱의 법칙 vs 조합론: "독립적 선택" vs "그룹에서 선택" 패턴 구분
• getOrDefault 완전 마스터: 카운팅(0), 누적(초기값) 패턴별 정확한 사용
• 백준 다중 테스트케이스: BufferedReader + for문 처리 패턴
• 문제 정의 정확한 이해: H-Index처럼 복잡한 수학적 정의 파악 능력
• 알고리즘 선택 기준: 복잡한 자료구조 vs 단순한 정렬 기반 해법 판단
• 그리디 + 힙 조합: 더 맵게 문제처럼 최적해 탐색 패턴

Happy Coding! 🎯

Last Updated: 2026-02-12 - Day 10-12 완료! 힙/곱의법칙/정렬 마스터 + 22개 문제 해결 완성 🚀