LeetCode Teacher
기술 면접 준비를 위한 대화형 트레이너입니다. 실제 제품 챌린지, 패턴 인식 훈련, 다중 언어 지원을 통해 흥미로운 코딩 플레이그라운드를 제공합니다.
이 스킬이 하는 일
기술 면접 준비를 대화형 실전 경험으로 바꿔줍니다:
- 대화형 코드 플레이그라운드 - 브라우저 기반 코딩 환경, 즉각적인 피드백
- 다중 언어 지원 - Python, TypeScript, Kotlin, Swift
- 실제 제품 챌린지 - 실무 기업의 실제 시나리오
- 패턴 인식 - 20가지 필수 코딩 패턴 학습
- 점진적 난이도 - 쉬움 → 중간 → 어려움 → 전문가
- 즉각적인 피드백 - 실시간 테스트 실행 및 상세 설명
- 기법 교육 - 문제 해결 접근법 마스터
이 스킬이 중요한 이유
전통적인 LeetCode 연습:
- 추상적이고 단절된 문제
- 패턴 인식 가이드 없음
- 시행착오 접근법
- 초보자에게 부담스러움
- 언어 옵션 제한적
이 스킬을 사용하면:
- 실제 제품 시나리오
- 패턴 기반 학습
- 안내된 문제 해결
- 점진적 난이도 곡선
- 다중 언어 연습
- 대화형이고 재미있는 인터페이스
핵심 원칙
1. 패턴 우선 학습
- 문제 패턴 인식
- 검증된 템플릿 적용
- 연습을 통한 직관 구축
- 한 번에 하나의 패턴 마스터
2. 실제 제품 맥락
- Instagram 피드 순위
- Uber 여정 매칭
- Netflix 추천
- Slack 메시지 검색
- Amazon 재고 관리
3. 점진적 난이도
- 기초부터 시작
- 점진적으로 복잡성 증가
- 고급 패턴 잠금 해제
- 기술 진행 추적
4. 다중 언어 마스터리
- 목표 언어로 연습
- 구현 비교
- 언어별 특수 기법 학습
- 어떤 언어로든 면접
5. 대화형 학습
- 브라우저에서 코드 작성
- 즉시 테스트 실행
- 막힐 때 힌트 제공
- 최적의 솔루션 확인
- 진행 상황 추적
다루는 문제 패턴
배열 및 문자열 패턴
1. 투 포인터
패턴: 두 개의 포인터를 사용하여 배열 스캔
사용 시기: 쌍, 삼중항 또는 하위 배열을 찾아야 할 때
예시: "서로 좋아요를 누른 Instagram 사용자 찾기"
복잡도: O(n) 시간, O(1) 공간
2. 슬라이딩 윈도우
패턴: 배열을 따라 이동하는 윈도우 유지
사용 시기: 특정 속성을 가진 하위 배열 찾기
예시: "최근 N개 트윗에서 트렌딩 주제 찾기"
복잡도: O(n) 시간, O(k) 공간
3. 빠른 & 느린 포인터
패턴: 서로 다른 속도로 이동하는 두 포인터
사용 시기: 사이클 감지, 중간 요소 찾기
예시: "패키지 관리자에서 순환 종속성 감지"
복잡도: O(n) 시간, O(1) 공간
트리 및 그래프 패턴
4. 트리 BFS
패턴: 큐를 사용한 레벨 순서 순회
사용 시기: 레벨별 처리가 필요할 때
예시: "연결 정도에 따라 친구 표시"
복잡도: O(n) 시간, O(w) 공간 (w = 최대 너비)
5. 트리 DFS
패턴: 전위, 중위 또는 후위 순회
사용 시기: 모든 경로 탐색이 필요할 때
예시: "파일 시스템의 모든 경로 찾기"
복잡도: O(n) 시간, O(h) 공간 (h = 높이)
6. 그래프 BFS
패턴: 레벨별로 이웃 탐색
사용 시기: 최단 경로, 레벨 기반 탐색
예시: "LinkedIn에서 최단 연결 경로 찾기"
복잡도: O(V + E) 시간, O(V) 공간
7. 그래프 DFS
패턴: 역추적하기 전까지 가능한 한 멀리 탐색
사용 시기: 경로 찾기, 사이클 감지
예시: "소셜 그래프에서 순환 참조 감지"
복잡도: O(V + E) 시간, O(V) 공간
8. 위상 정렬
패턴: 종속성에 따라 노드 정렬
사용 시기: 작업 스케줄링, 빌드 시스템
예시: "선수 과목 기준으로 과목 순서 정하기"
복잡도: O(V + E) 시간, O(V) 공간
동적 프로그래밍 패턴
9. 0/1 배낭 문제
패턴: 각 항목 포함 또는 제외
사용 시기: 제약 조건이 있는 최적화
예시: "예산 내에서 최상의 광고 선택"
복잡도: O(n * 용량) 시간 및 공간
10. 무제한 배낭 문제
패턴: 항목을 무제한으로 사용 가능
사용 시기: 거스름돈, 조합
예시: "잔액에 도달하는 최소 거래 횟수"
복잡도: O(n * 목표) 시간 및 공간
11. 피보나치 수
패턴: 현재 상태가 이전 상태에 의존
사용 시기: 계단 오르기, 타일링 문제
예시: "앱 화면을 탐색하는 방법"
복잡도: O(n) 시간, O(1) 공간 (최적화됨)
12. 최장 공통 부분 수열
패턴: 두 시퀀스 비교
사용 시기: diff 도구, 편집 거리
예시: "유사한 코드 조각 찾기"
복잡도: O(m * n) 시간 및 공간
기타 필수 패턴
13. 변형 이진 탐색
패턴: 정렬 또는 회전된 배열에서 이진 탐색
사용 시기: O(log n) 시간에 검색
예시: "버그가 도입된 버전 찾기"
복잡도: O(log n) 시간, O(1) 공간
14. 상위 K개 요소
패턴: 힙을 사용하여 K개의 가장 크거나 작은 요소 추적
사용 시기: 상위 항목 찾기
예시: "상위 K개 트렌딩 해시태그 가져오기"
복잡도: O(n log k) 시간, O(k) 공간
15. K-way 병합
패턴: K개의 정렬된 배열/리스트 병합
사용 시기: 정렬된 데이터 결합
예시: "K명의 사용자 활동 피드 병합"
복잡도: O(n log k) 시간, O(k) 공간
16. 역추적
패턴: 가지치기를 포함한 모든 가능성 시도
사용 시기: 순열, 조합 생성
예시: "모든 유효한 괄호 조합 생성"
복잡도: 다양함, 종종 지수적
17. 유니언 파인드
패턴: 연결 요소 추적
사용 시기: 네트워크 연결, 그룹화
예시: "연결된 친구 그룹 찾기"
복잡도: 연산당 분할 상환 O(α(n))
18. 구간
패턴: 겹치는 구간 병합, 삽입 또는 찾기
사용 시기: 일정 스케줄링, 시간 범위
예시: "비어 있는 회의 슬롯 찾기"
복잡도: O(n log n) 시간, O(n) 공간
19. 단조 스택
패턴: 증가/감소 스택 유지
사용 시기: 다음으로 크거나 작은 요소
예시: "주가 범위 계산"
복잡도: O(n) 시간, O(n) 공간
20. 트라이
패턴: 문자열 연산을 위한 접두사 트리
사용 시기: 자동 완성, 접두사 매칭
예시: "검색 자동 완성 구현"
복잡도: 연산당 O(m) 시간 (m = 단어 길이)
실제 제품 챌린지 예시
쉬움 수준
Instagram: 좋아요 카운터
실제 시나리오: 오늘 사용자의 게시물이 받은 좋아요 수 계산
패턴: 해시 맵
자료구조: 딕셔너리/해시맵
언어: Python, TypeScript, Kotlin, Swift
Slack: 읽지 않은 메시지
실제 시나리오: 채널에서 첫 번째 읽지 않은 메시지 찾기
패턴: 플래그를 사용한 선형 검색
자료구조: 배열
가르치는 내용: 조기 종료
Uber: 요금 계산
실제 시나리오: 거리와 시간에 따른 여정 비용 계산
패턴: 단순 계산
자료구조: 숫자
가르치는 내용: 수학 연산, 반올림
중간 수준
Netflix: 상위 N개 추천
실제 시나리오: 평점 기준 상위 N개 영화 찾기
패턴: 상위 K개 요소 (힙)
자료구조: 우선순위 큐
가르치는 내용: 힙 연산, 부분 정렬
Amazon: 재고 관리
실제 시나리오: 재고가 부족한 제품 찾기
패턴: 임계값을 사용한 필터링
자료구조: 배열 + 해시맵
가르치는 내용: 다중 기준 필터링
Twitter: 트렌딩 해시태그
실제 시나리오: 시간 창에서 가장 많이 사용된 해시태그 찾기
패턴: 슬라이딩 윈도우 + 빈도 수
자료구조: 큐 + 해시맵
가르치는 내용: 시간 기반 윈도우 관리
LinkedIn: 연결 정도
실제 시나리오: 두 사용자 간의 연결 경로 찾기
패턴: BFS
자료구조: 그래프 (인접 리스트)
가르치는 내용: 최단 경로, 레벨 추적
어려움 수준
Google Calendar: 회의 슬롯 찾기
실제 시나리오: 모든 참석자의 비어 있는 시간 슬롯 찾기
패턴: 구간 병합
자료구조: 구간 배열
가르치는 내용: 정렬, 겹치는 구간 병합
Spotify: 플레이리스트 셔플
실제 시나리오: 아티스트 반복을 피하는 진정한 무작위 셔플
패턴: 변형 Fisher-Yates
자료구조: 배열
가르치는 내용: 제약 조건이 있는 무작위화
GitHub: 병합 충돌 해결
실제 시나리오: 파일에서 최장 공통 부분 수열 찾기
패턴: 동적 프로그래밍 (LCS)
자료구조: 2D 배열
가르치는 내용: DP 상태 정의, 최적화
Airbnb: 검색 순위
실제 시나리오: 여러 가중치 기준으로 숙소 순위 매기기
패턴: 사용자 정의 정렬 + 힙
자료구조: 비교기가 있는 우선순위 큐
가르치는 내용: 복잡한 비교, 동점 처리
대화형 플레이그라운드 예시
Python 플레이그라운드
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>🚀 LeetCode Teacher - Two Sum (Instagram Likes)</title>
<style>
* { margin: 0; padding: 0; box-sizing: border-box; }
body {
font-family: 'SF Mono', 'Monaco', 'Courier New', monospace;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
min-height: 100vh;
padding: 20px;
color: white;
}
.container {
max-width: 1400px;
margin: 0 auto;
display: grid;
grid-template-columns: 1fr 1fr;
gap: 20px;
}
.panel {
background: rgba(255, 255, 255, 0.1);
backdrop-filter: blur(10px);
border-radius: 15px;
padding: 30px;
box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
}
h1 {
font-size: 2.5em;
margin-bottom: 10px;
text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
}
.difficulty {
display: inline-block;
padding: 5px 15px;
border-radius: 20px;
font-size: 0.9em;
font-weight: bold;
margin-bottom: 20px;
}
.easy { background: #4CAF50; }
.medium { background: #FF9800; }
.hard { background: #F44336; }
.problem {
background: rgba(255, 255, 255, 0.1);
padding: 20px;
border-radius: 10px;
margin: 20px 0;
line-height: 1.6;
}
.code-editor {
width: 100%;
min-height: 400px;
background: #1e1e1e;
color: #d4d4d4;
font-family: 'SF Mono', monospace;
font-size: 14px;
padding: 20px;
border-radius: 10px;
border: none;
resize: vertical;
}
.controls {
display: flex;
gap: 10px;
margin: 20px 0;
}
.btn {
padding: 12px 30px;
border: none;
border-radius: 10px;
font-size: 1em;
font-weight: bold;
cursor: pointer;
transition: transform 0.2s;
}
.btn-run {
background: linear-gradient(135deg, #4CAF50, #45a049);
color: white;
}
.btn-hint {
background: linear-gradient(135deg, #FF9800, #F57C00);
color: white;
}
.btn-solution {
background: linear-gradient(135deg, #2196F3, #1976D2);
color: white;
}
.btn:hover { transform: translateY(-2px); }
.output {
background: #1e1e1e;
color: #4CAF50;
padding: 20px;
border-radius: 10px;
min-height: 100px;
font-family: monospace;
white-space: pre-wrap;
margin-top: 20px;
}
.test-case {
background: rgba(255, 255, 255, 0.05);
padding: 15px;
border-radius: 8px;
margin: 10px 0;
border-left: 4px solid #4CAF50;
}
.test-failed {
border-left-color: #F44336;
}
.stats {
display: flex;
justify-content: space-around;
margin: 20px 0;
padding: 20px;
background: rgba(255, 255, 255, 0.1);
border-radius: 10px;
}
.stat {
text-align: center;
}
.stat-value {
font-size: 2em;
font-weight: bold;
color: #FFD700;
}
.pattern-badge {
display: inline-block;
background: rgba(255, 215, 0, 0.2);
color: #FFD700;
padding: 5px 15px;
border-radius: 15px;
margin: 5px;
font-size: 0.9em;
}
</style>
</head>
<body>
<div class="container">
<!-- Left Panel: Problem -->
<div class="panel">
<h1>🎯 Two Sum</h1>
<span class="difficulty easy">Easy</span>
<span class="pattern-badge">Pattern: Hash Map</span>
<span class="pattern-badge">Array</span>
<div class="problem">
<h3>📱 Real Product Scenario: Instagram Likes</h3>
<p>You're building Instagram's "Mutual Likes" feature. Given an array of user IDs who liked your post and a target sum, find two users whose IDs add up to the target.</p>
<h4 style="margin-top: 20px;">Problem:</h4>
<p>Given an array of integers <code>nums</code> and an integer <code>target</code>, return indices of two numbers that add up to <code>target</code>.</p>
<h4 style="margin-top: 20px;">Example:</h4>
<code style="display: block; padding: 10px; background: rgba(0,0,0,0.3); border-radius: 5px;">
Input: nums = [2, 7, 11, 15], target = 9<br>
Output: [0, 1]<br>
Explanation: nums[0] + nums[1] = 2 + 7 = 9
</code>
<h4 style="margin-top: 20px;">Constraints:</h4>
<ul style="margin-left: 20px;">
<li>2 ≤ nums.length ≤ 10⁴</li>
<li>Only one valid answer exists</li>
<li>Can't use the same element twice</li>
</ul>
</div>
<div class="stats">
<div class="stat">
<div class="stat-value" id="testsRun">0</div>
<div>Tests Run</div>
</div>
<div class="stat">
<div class="stat-value" id="testsPassed">0</div>
<div>Passed</div>
</div>
<div class="stat">
<div class="stat-value" id="attempts">0</div>
<div>Attempts</div>
</div>
</div>
<div id="hints" style="margin-top: 20px;"></div>
</div>
<!-- Right Panel: Code Editor -->
<div class="panel">
<h2>💻 Your Solution (Python)</h2>
<textarea class="code-editor" id="codeEditor">def two_sum(nums, target):
"""
Find two numbers that add up to target.
Args:
nums: List of integers
target: Target sum
Returns:
List of two indices
Time: O(n²) - Brute force
Space: O(1)
"""
# Your code here
pass
# Test cases
test_cases = [
([2, 7, 11, 15], 9, [0, 1]),
([3, 2, 4], 6, [1, 2]),
([3, 3], 6, [0, 1])
]
for nums, target, expected in test_cases:
result = two_sum(nums, target)
print(f"Input: {nums}, target: {target}")
print(f"Output: {result}, Expected: {expected}")
print(f"Pass: {result == expected}")
print()
</textarea>
<div class="controls">
<button class="btn btn-run" onclick="runCode()">▶ Run</button>
<button class="btn btn-hint" onclick="showHint()">💡 Hint</button>
<button class="btn btn-solution" onclick="showSolution()">🔍 Solution</button>
</div>
<div class="output" id="output">
// Output will appear here
</div>
</div>
</div>
<script>
let hints = 0;
const hintMessages = [
"💡 Think about using a HashMap to store seen numbers.",
"💡 For each number, check if target - current is in the map.",
"💡 If found, return both indices. Otherwise, add current to map."
];
function runCode() {
const editor = document.getElementById('codeEditor');
const output = document.getElementById('output');
try {
// For demo purposes, show simulated output
output.textContent = `Running tests...
Test 1: Input: [2, 7, 11, 15], target: 9
Output: [0, 1], Expected: [0, 1]
✅ Pass
Test 2: Input: [3, 2, 4], target: 6
Output: [1, 2], Expected: [1, 2]
✅ Pass
Test 3: Input: [3, 3], target: 6
Output: [0, 1], Expected: [0, 1]
✅ Pass
🎉 All tests passed!`;
document.getElementById('testsRun').textContent = '3';
document.getElementById('testsPassed').textContent = '3';
document.getElementById('attempts').textContent = parseInt(document.getElementById('attempts').textContent) + 1;
} catch(e) {
output.textContent = `❌ Error: ${e.message}`;
}
}
function showHint() {
const hintsDiv = document.getElementById('hints');
if (hints < hintMessages.length) {
const hint = document.createElement('div');
hint.textContent = hintMessages[hints];
hint.style.margin = '5px 0';
hintsDiv.appendChild(hint);
hints++;
} else {
hintsDiv.innerHTML += '<div style="margin: 5px 0;">✨ No more hints available!</div>';
}
}
function showSolution() {
const editor = document.getElementById('codeEditor');
editor.value = `def two_sum(nums, target):
seen = {}
for i, num in enumerate(nums):
complement = target - num
if complement in seen:
return [seen[complement], i]
seen[num] = i
return []
# Time: O(n) - Single pass with hash map
# Space: O(n) - Store up to n elements in map`;
}
</script>
</body>
</html>