🎯 1. Counter 실전 패턴 ⭐⭐⭐

패턴 1: 가장 많이/적게 등장하는 원소

from collections import Counter

arr = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
counter = Counter(arr)

# 가장 많은 원소 1개
most_common = counter.most_common(1)
print(most_common)  # [(4, 4)]
element, count = most_common[0]
print(f"{element}이(가) {count}번")  # 4이(가) 4번

# 가장 많은 원소 3개
top_3 = counter.most_common(3)
print(top_3)  # [(4, 4), (3, 3), (2, 2)]

# 가장 적은 원소
least_common = counter.most_common()[-1]
print(least_common)  # (1, 1)

# 또는
least_common = min(counter.items(), key=lambda x: x[1])
print(least_common)  # (1, 1)

패턴 2: 등장 횟수 조건 필터링

from collections import Counter

arr = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]
counter = Counter(arr)

# 2번 이상 등장한 원소
duplicates = [num for num, count in counter.items() if count >= 2]
print(duplicates)  # [2, 3, 4, 5]

# 정확히 1번만 등장한 원소
unique = [num for num, count in counter.items() if count == 1]
print(unique)  # [1]

# 3번 이상 등장한 원소의 개수
count_3_plus = sum(1 for count in counter.values() if count >= 3)
print(count_3_plus)  # 3 (3, 4, 5)

# 가장 많이 등장한 횟수와 같은 원소들
max_count = max(counter.values())
most_frequent = [num for num, count in counter.items() if count == max_count]
print(most_frequent)  # [5]

패턴 3: 문자열 아나그램 체크

from collections import Counter

def is_anagram(s1, s2):
    """두 문자열이 아나그램인지 확인"""
    return Counter(s1) == Counter(s2)

print(is_anagram("listen", "silent"))  # True
print(is_anagram("hello", "world"))    # False

# 공백/대소문자 무시 아나그램
def is_anagram_ignore(s1, s2):
    s1 = s1.lower().replace(' ', '')
    s2 = s2.lower().replace(' ', '')
    return Counter(s1) == Counter(s2)

print(is_anagram_ignore("A gentleman", "Elegant man"))  # True
print(is_anagram_ignore("Conversation", "Voices rant on"))  # True

패턴 4: 아나그램 그룹화 ⭐⭐⭐

from collections import defaultdict, Counter

def group_anagrams(words):
    """
    같은 아나그램끼리 그룹화
    LeetCode 49: Group Anagrams
    """
    groups = defaultdict(list)

    for word in words:
        # 정렬된 문자열을 키로 사용
        key = ''.join(sorted(word))
        groups[key].append(word)

    return list(groups.values())

words = ["eat", "tea", "tan", "ate", "nat", "bat"]
print(group_anagrams(words))
# [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

# Counter를 사용한 방법 (더 정확)
def group_anagrams_v2(words):
    groups = defaultdict(list)

    for word in words:
        # Counter를 튜플로 변환하여 키로 사용
        key = tuple(sorted(Counter(word).items()))
        groups[key].append(word)

    return list(groups.values())

패턴 5: 가장 많이 등장한 k개 원소 ⭐⭐⭐

from collections import Counter
import heapq

def top_k_frequent(nums, k):
    """
    LeetCode 347: Top K Frequent Elements
    """
    counter = Counter(nums)

    # 방법 1: most_common 사용 (가장 간단)
    return [num for num, count in counter.most_common(k)]

print(top_k_frequent([1, 1, 1, 2, 2, 3], 2))  # [1, 2]
print(top_k_frequent([1], 1))  # [1]

# 방법 2: 힙 사용 (O(n log k))
def top_k_frequent_heap(nums, k):
    counter = Counter(nums)
    return heapq.nlargest(k, counter.keys(), key=counter.get)

패턴 6: Counter 산술 연산 ⭐⭐⭐

from collections import Counter

c1 = Counter(['a', 'b', 'c', 'a', 'b'])
c2 = Counter(['a', 'b', 'd', 'd'])

# 덧셈: 합치기
print(c1 + c2)
# Counter({'a': 3, 'b': 3, 'd': 2, 'c': 1})

# 뺄셈: 차집합 (음수/0 제외)
print(c1 - c2)
# Counter({'a': 1, 'c': 1, 'b': 1})

# 교집합: 최솟값
print(c1 & c2)
# Counter({'a': 1, 'b': 1})

# 합집합: 최댓값
print(c1 | c2)
# Counter({'a': 2, 'b': 2, 'd': 2, 'c': 1})

# 활용: 완주하지 못한 선수
def solution(participant, completion):
    return list((Counter(participant) - Counter(completion)).keys())[0]

🎯 2. defaultdict 실전 패턴 ⭐⭐⭐

패턴 1: 그래프 표현 (가장 많이 씀!) ⭐⭐⭐

from collections import defaultdict

# 인접 리스트로 그래프 표현
graph = defaultdict(list)

edges = [(1, 2), (1, 3), (2, 4), (3, 4), (4, 5)]

# 무방향 그래프
for a, b in edges:
    graph[a].append(b)
    graph[b].append(a)

print(dict(graph))
# {1: [2, 3], 2: [1, 4], 3: [1, 4], 4: [2, 3, 5], 5: [4]}

# 유방향 그래프
directed_graph = defaultdict(list)
for a, b in edges:
    directed_graph[a].append(b)

print(dict(directed_graph))
# {1: [2, 3], 2: [4], 3: [4], 4: [5]}

# 가중치 그래프
weighted_graph = defaultdict(list)
edges_with_weight = [(1, 2, 5), (1, 3, 3), (2, 4, 2)]

for a, b, weight in edges_with_weight:
    weighted_graph[a].append((b, weight))
    weighted_graph[b].append((a, weight))

print(dict(weighted_graph))
# {1: [(2, 5), (3, 3)], 2: [(1, 5), (4, 2)], 3: [(1, 3)], 4: [(2, 2)]}

패턴 2: 그룹화 (카테고리별 분류) ⭐⭐⭐

from collections import defaultdict

# 학생 데이터를 학년별로 그룹화
students = [
    ('Alice', 1, 85),
    ('Bob', 2, 90),
    ('Charlie', 1, 78),
    ('David', 2, 88),
    ('Eve', 3, 92)
]

# 학년별 그룹화
by_grade = defaultdict(list)
for name, grade, score in students:
    by_grade[grade].append((name, score))

print(dict(by_grade))
# {1: [('Alice', 85), ('Charlie', 78)],
#  2: [('Bob', 90), ('David', 88)],
#  3: [('Eve', 92)]}

# 점수대별 그룹화
by_score_range = defaultdict(list)
for name, grade, score in students:
    score_range = (score // 10) * 10  # 80점대, 90점대 등
    by_score_range[score_range].append(name)

print(dict(by_score_range))
# {80: ['Alice', 'David'], 90: ['Bob', 'Eve'], 70: ['Charlie']}