Hash Maps and Sets

d = {}
d["a"] = 1
d.setdefault("b", []).append(2)   # init-on-first-use
d.get("z", 0)                     # default instead of KeyError
d.pop("a", None)                  # delete with default
"a" in d                          # key membership, O(1)
d.keys(), d.values(), d.items()
for k, v in d.items(): ...
{k: v for k, v in d.items() if v > 1}
max(d, key=d.get)                 # key with the largest value

from collections import defaultdict, Counter
groups = defaultdict(list)
groups[key].append(x)             # no setdefault needed
cnt = defaultdict(int)
cnt[x] += 1

c = Counter("mississippi")
c.most_common(2)                  # [('i', 4), ('s', 4)]
c["z"]                            # 0, does not insert
c1 - c2                           # subtract, drops non-positive
c1 & c2                           # per-key minimum (intersection)
sum(c.values())                   # total count

s = set()
s.add(1); s.discard(9)            # discard never raises
s.remove(1)                       # KeyError if absent
a | b, a & b, a - b, a ^ b        # union, intersection, difference, symmetric
a <= b                            # subset
frozenset([1, 2])                 # hashable, usable as a dict key

# group anagrams in O(n * k log k)
from collections import defaultdict
groups = defaultdict(list)
for w in words:
    groups[tuple(sorted(w))].append(w)
result = list(groups.values())

# O(n * k) variant with a count signature
def sig(w):
    c = [0] * 26
    for ch in w:
        c[ord(ch) - 97] += 1
    return tuple(c)

def two_sum(nums, target):
    """Complement lookup. O(n) time, O(n) space."""
    seen = {}                      # value -> index
    for i, x in enumerate(nums):
        if target - x in seen:
            return [seen[target - x], i]
        seen[x] = i
    return []

def subarray_sum_equals_k(nums, k):
    """Prefix sum counts. Handles negatives, unlike sliding window."""
    from collections import defaultdict
    count = defaultdict(int)
    count[0] = 1                   # empty prefix
    total = ans = 0
    for x in nums:
        total += x
        ans += count[total - k]
        count[total] += 1
    return ans

def longest_consecutive(nums):
    """O(n): only start counting from a sequence start."""
    s = set(nums)
    best = 0
    for x in s:
        if x - 1 in s:
            continue
        y = x
        while y + 1 in s:
            y += 1
        best = max(best, y - x + 1)
    return best

def first_duplicate(a):
    seen = set()
    for x in a:
        if x in seen:
            return x
        seen.add(x)
    return None

Map<String, Integer> m = new HashMap<>();
m.put("a", 1);
m.getOrDefault("z", 0);
m.merge("a", 1, Integer::sum);            // counting idiom
m.computeIfAbsent("k", k -> new ArrayList<>()).add(2);
m.containsKey("a");
for (Map.Entry<String, Integer> e : m.entrySet()) e.getKey();

Set<Integer> s = new HashSet<>();
s.add(1); s.contains(1); s.remove(1);

// ordered variants: O(log n) but give you ranges and min/max
TreeMap<Integer, Integer> t = new TreeMap<>();
t.floorKey(5); t.ceilingKey(5); t.firstKey(); t.lastKey();
t.headMap(5); t.tailMap(5); t.subMap(1, 9);
LinkedHashMap<String, Integer> lru = new LinkedHashMap<>();  // insertion order

unordered_map<string, int> m;
m["a"]++;                      // default-constructs to 0 first
if (m.count("a")) ...
if (auto it = m.find("a"); it != m.end()) it->second;
unordered_set<int> s{1, 2, 3};

map<int, int> t;               // red-black tree, O(log n), sorted
t.lower_bound(5);              // first key >= 5
t.upper_bound(5);              // first key > 5