feat(python): add 25 dictionary and data manipulation problems

Add problems covering Counter, defaultdict, ChainMap, OrderedDict,
dictionary comprehensions, nested operations, and Python 3.9+ merge
operators.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: davidagustin

lib/problems/python.ts

@@ -3898,6 +3898,360 @@ export const pythonProblems: Problem[] = [
     validPatterns: [/SequenceMatcher\s*\(\s*None\s*,\s*s1\s*,\s*s2\s*\)\.ratio\s*\(\s*\)/],
     tags: ['difflib', 'sequence-matcher', 'similarity', 'advanced'],
   },
+
+  // ============================================================
+  // DICTIONARY AND DATA MANIPULATION - ADVANCED (25 problems)
+  // ============================================================
+  {
+    id: 'py-dict-020',
+    category: 'dict',
+    difficulty: 'easy',
+    title: 'Counter Basic Usage',
+    text: 'Count occurrences of each character in the string using Counter',
+    setup: 'from collections import Counter\ntext = "abracadabra"',
+    setupCode: 'from collections import Counter\ntext = "abracadabra"',
+    expected: { a: 5, b: 2, r: 2, c: 1, d: 1 },
+    sample: 'dict(Counter(text))',
+    hints: ['Counter counts hashable objects', 'It returns a Counter object (subclass of dict)'],
+    validPatterns: [/Counter\s*\(\s*text\s*\)/, /dict\s*\(\s*Counter\s*\(\s*text\s*\)\s*\)/],
+    tags: ['counter', 'collections'],
+  },
+  {
+    id: 'py-dict-021',
+    category: 'dict',
+    difficulty: 'easy',
+    title: 'Counter Most Common',
+    text: 'Find the 2 most common elements in the list using Counter',
+    setup: 'from collections import Counter\nnums = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]',
+    setupCode: 'from collections import Counter\nnums = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]',
+    expected: [[4, 4], [3, 3]],
+    sample: 'Counter(nums).most_common(2)',
+    hints: ['most_common(n) returns the n most frequent elements'],
+    validPatterns: [/Counter\s*\(\s*nums\s*\)\.most_common\s*\(\s*2\s*\)/],
+    tags: ['counter', 'collections'],
+  },
+  {
+    id: 'py-dict-022',
+    category: 'dict',
+    difficulty: 'easy',
+    title: 'Merge with Pipe Operator',
+    text: 'Merge base config with override config using | operator',
+    setup: 'base = {"debug": False, "timeout": 30}\noverride = {"debug": True, "retries": 3}',
+    setupCode: 'base = {"debug": False, "timeout": 30}\noverride = {"debug": True, "retries": 3}',
+    expected: { debug: true, timeout: 30, retries: 3 },
+    sample: 'base | override',
+    hints: ['Use | to merge dictionaries (Python 3.9+)'],
+    validPatterns: [/base\s*\|\s*override/],
+    tags: ['merge', 'dict-operator'],
+  },
+  {
+    id: 'py-dict-023',
+    category: 'dict',
+    difficulty: 'easy',
+    title: 'Dictionary from Two Lists',
+    text: 'Create a dictionary pairing names with ages',
+    setup: 'names = ["Alice", "Bob", "Charlie"]\nages = [25, 30, 35]',
+    setupCode: 'names = ["Alice", "Bob", "Charlie"]\nages = [25, 30, 35]',
+    expected: { Alice: 25, Bob: 30, Charlie: 35 },
+    sample: 'dict(zip(names, ages))',
+    hints: ['Use zip() to pair corresponding elements'],
+    validPatterns: [/dict\s*\(\s*zip\s*\(\s*names\s*,\s*ages\s*\)\s*\)/],
+    tags: ['dict-comprehension', 'zip'],
+  },
+  {
+    id: 'py-dict-024',
+    category: 'dict',
+    difficulty: 'easy',
+    title: 'Check Key Existence',
+    text: 'Check if "email" key exists in the dictionary',
+    setup: 'user = {"name": "Alice", "age": 30}',
+    setupCode: 'user = {"name": "Alice", "age": 30}',
+    expected: false,
+    sample: '"email" in user',
+    hints: ['Use the "in" operator to check key existence'],
+    validPatterns: [/["']email["']\s+in\s+user/],
+    tags: ['membership', 'dict-method'],
+  },
+  {
+    id: 'py-dict-025',
+    category: 'dict',
+    difficulty: 'easy',
+    title: 'Clear Dictionary',
+    text: 'Remove all items from the dictionary and return its length',
+    setup: 'data = {"a": 1, "b": 2, "c": 3}\ndata.clear()',
+    setupCode: 'data = {"a": 1, "b": 2, "c": 3}\ndata.clear()',
+    expected: 0,
+    sample: 'len(data)',
+    hints: ['clear() removes all items in-place'],
+    validPatterns: [/len\s*\(\s*data\s*\)/],
+    tags: ['clear', 'dict-method'],
+  },
+  {
+    id: 'py-dict-026',
+    category: 'dict',
+    difficulty: 'easy',
+    title: 'Enumerate to Index Map',
+    text: 'Create a dictionary mapping index to fruit using enumerate',
+    setup: 'fruits = ["apple", "banana", "cherry"]',
+    setupCode: 'fruits = ["apple", "banana", "cherry"]',
+    expected: { 0: 'apple', 1: 'banana', 2: 'cherry' },
+    sample: 'dict(enumerate(fruits))',
+    hints: ['enumerate() returns index-value pairs'],
+    validPatterns: [/dict\s*\(\s*enumerate\s*\(\s*fruits\s*\)\s*\)/],
+    tags: ['dict-comprehension', 'enumerate'],
+  },
+  {
+    id: 'py-dict-027',
+    category: 'dict',
+    difficulty: 'easy',
+    title: 'Pop with Default',
+    text: 'Remove and return "status" key with default "unknown" if not found',
+    setup: 'data = {"name": "test", "value": 42}',
+    setupCode: 'data = {"name": "test", "value": 42}',
+    expected: 'unknown',
+    sample: 'data.pop("status", "unknown")',
+    hints: ['pop() can take a default value as second argument'],
+    validPatterns: [/data\.pop\s*\(\s*["']status["']\s*,\s*["']unknown["']\s*\)/],
+    tags: ['pop', 'dict-method'],
+  },
+  {
+    id: 'py-dict-028',
+    category: 'dict',
+    difficulty: 'medium',
+    title: 'defaultdict with List',
+    text: 'Group names by their first letter using defaultdict(list)',
+    setup: 'from collections import defaultdict\nnames = ["Alice", "Bob", "Anna", "Charlie", "Amy"]\nresult = defaultdict(list)\nfor name in names:\n    result[name[0]].append(name)',
+    setupCode: 'from collections import defaultdict\nnames = ["Alice", "Bob", "Anna", "Charlie", "Amy"]\nresult = defaultdict(list)\nfor name in names:\n    result[name[0]].append(name)',
+    expected: { A: ['Alice', 'Anna', 'Amy'], B: ['Bob'], C: ['Charlie'] },
+    sample: 'dict(result)',
+    hints: ['defaultdict(list) auto-creates empty lists'],
+    validPatterns: [/dict\s*\(\s*result\s*\)/],
+    tags: ['defaultdict', 'collections', 'grouping'],
+  },
+  {
+    id: 'py-dict-029',
+    category: 'dict',
+    difficulty: 'medium',
+    title: 'defaultdict with Int',
+    text: 'Count word occurrences using defaultdict(int)',
+    setup: 'from collections import defaultdict\nwords = ["a", "b", "a", "c", "b", "a"]\ncounts = defaultdict(int)\nfor w in words:\n    counts[w] += 1',
+    setupCode: 'from collections import defaultdict\nwords = ["a", "b", "a", "c", "b", "a"]\ncounts = defaultdict(int)\nfor w in words:\n    counts[w] += 1',
+    expected: { a: 3, b: 2, c: 1 },
+    sample: 'dict(counts)',
+    hints: ['defaultdict(int) initializes missing keys to 0'],
+    validPatterns: [/dict\s*\(\s*counts\s*\)/],
+    tags: ['defaultdict', 'collections', 'counting'],
+  },
+  {
+    id: 'py-dict-030',
+    category: 'dict',
+    difficulty: 'medium',
+    title: 'Nested Dictionary Access',
+    text: 'Safely get a nested value with get() chaining',
+    setup: 'data = {"user": {"profile": {"name": "Alice"}}}',
+    setupCode: 'data = {"user": {"profile": {"name": "Alice"}}}',
+    expected: 'Alice',
+    sample: 'data.get("user", {}).get("profile", {}).get("name", "Unknown")',
+    hints: ['Chain get() calls with empty dict defaults'],
+    validPatterns: [/data\.get\s*\(.*\)\.get\s*\(.*\)\.get\s*\(/],
+    tags: ['nested', 'safe-access'],
+  },
+  {
+    id: 'py-dict-031',
+    category: 'dict',
+    difficulty: 'medium',
+    title: 'Update Nested Dictionary',
+    text: 'Update the nested name field to "Bob"',
+    setup: 'data = {"user": {"profile": {"name": "Alice", "age": 30}}}',
+    setupCode: 'data = {"user": {"profile": {"name": "Alice", "age": 30}}}',
+    expected: { user: { profile: { name: 'Bob', age: 30 } } },
+    sample: 'data["user"]["profile"]["name"] = "Bob"; data',
+    hints: ['Access nested keys with chained brackets'],
+    validPatterns: [/data\s*\[.*\]\s*\[.*\]\s*\[.*\]\s*=\s*["']Bob["']/],
+    tags: ['nested', 'update'],
+  },
+  {
+    id: 'py-dict-032',
+    category: 'dict',
+    difficulty: 'medium',
+    title: 'Counter Arithmetic',
+    text: 'Subtract inventory sold from inventory using Counter subtraction',
+    setup: 'from collections import Counter\ninventory = Counter({"apple": 10, "banana": 5, "cherry": 3})\nsold = Counter({"apple": 3, "banana": 2})',
+    setupCode: 'from collections import Counter\ninventory = Counter({"apple": 10, "banana": 5, "cherry": 3})\nsold = Counter({"apple": 3, "banana": 2})',
+    expected: { apple: 7, banana: 3, cherry: 3 },
+    sample: 'dict(inventory - sold)',
+    hints: ['Counter supports arithmetic operations'],
+    validPatterns: [/inventory\s*-\s*sold/],
+    tags: ['counter', 'collections', 'arithmetic'],
+  },
+  {
+    id: 'py-dict-033',
+    category: 'dict',
+    difficulty: 'medium',
+    title: 'ChainMap for Config Layers',
+    text: 'Create a layered config using ChainMap (user overrides defaults)',
+    setup: 'from collections import ChainMap\ndefaults = {"color": "blue", "size": "medium"}\nuser_prefs = {"color": "red"}',
+    setupCode: 'from collections import ChainMap\ndefaults = {"color": "blue", "size": "medium"}\nuser_prefs = {"color": "red"}',
+    expected: { color: 'red', size: 'medium' },
+    sample: 'dict(ChainMap(user_prefs, defaults))',
+    hints: ['ChainMap searches maps in order'],
+    validPatterns: [/ChainMap\s*\(\s*user_prefs\s*,\s*defaults\s*\)/],
+    tags: ['chainmap', 'collections', 'config'],
+  },
+  {
+    id: 'py-dict-034',
+    category: 'dict',
+    difficulty: 'medium',
+    title: 'Dict Comprehension with Conditional Value',
+    text: 'Create a dict with "pass" or "fail" based on score >= 60',
+    setup: 'scores = {"Alice": 85, "Bob": 55, "Charlie": 72, "Diana": 45}',
+    setupCode: 'scores = {"Alice": 85, "Bob": 55, "Charlie": 72, "Diana": 45}',
+    expected: { Alice: 'pass', Bob: 'fail', Charlie: 'pass', Diana: 'fail' },
+    sample: '{k: ("pass" if v >= 60 else "fail") for k, v in scores.items()}',
+    hints: ['Use ternary expression in dict comprehension'],
+    validPatterns: [/\{.*["']pass["'].*if.*else.*["']fail["'].*for.*in\s+scores\.items\s*\(\s*\)\s*\}/],
+    tags: ['dict-comprehension', 'conditional'],
+  },
+  {
+    id: 'py-dict-035',
+    category: 'dict',
+    difficulty: 'medium',
+    title: 'In-Place Update with |=',
+    text: 'Update the config dict in-place with new settings using |=',
+    setup: 'config = {"debug": False, "timeout": 30}\nnew_settings = {"timeout": 60, "retries": 3}',
+    setupCode: 'config = {"debug": False, "timeout": 30}\nnew_settings = {"timeout": 60, "retries": 3}',
+    expected: { debug: false, timeout: 60, retries: 3 },
+    sample: 'config |= new_settings; config',
+    hints: ['Use |= for in-place dictionary merge (Python 3.9+)'],
+    validPatterns: [/config\s*\|=\s*new_settings/],
+    tags: ['merge', 'dict-operator', 'in-place'],
+  },
+  {
+    id: 'py-dict-036',
+    category: 'dict',
+    difficulty: 'medium',
+    title: 'Flatten Nested Dict Values',
+    text: 'Extract all leaf values from nested dict into a flat list',
+    setup: 'nested = {"a": {"b": 1, "c": 2}, "d": {"e": 3}}',
+    setupCode: 'nested = {"a": {"b": 1, "c": 2}, "d": {"e": 3}}',
+    expected: [1, 2, 3],
+    sample: '[v for inner in nested.values() for v in inner.values()]',
+    hints: ['Use nested comprehension to flatten'],
+    validPatterns: [/\[.*for.*in\s+nested\.values\s*\(\s*\)\s+for.*in.*\.values\s*\(\s*\)\s*\]/],
+    tags: ['nested', 'flatten', 'comprehension'],
+  },
+  {
+    id: 'py-dict-037',
+    category: 'dict',
+    difficulty: 'medium',
+    title: 'Counter Total Count',
+    text: 'Get the total count of all items in the Counter',
+    setup: 'from collections import Counter\ncounts = Counter({"apple": 5, "banana": 3, "cherry": 2})',
+    setupCode: 'from collections import Counter\ncounts = Counter({"apple": 5, "banana": 3, "cherry": 2})',
+    expected: 10,
+    sample: 'counts.total()',
+    hints: ['Counter has a total() method (Python 3.10+)'],
+    validPatterns: [/counts\.total\s*\(\s*\)/, /sum\s*\(\s*counts\.values\s*\(\s*\)\s*\)/],
+    tags: ['counter', 'collections'],
+  },
+  {
+    id: 'py-dict-038',
+    category: 'dict',
+    difficulty: 'medium',
+    title: 'Sort Dictionary by Value',
+    text: 'Sort the dictionary by values in descending order',
+    setup: 'scores = {"Alice": 85, "Bob": 92, "Charlie": 78, "Diana": 95}',
+    setupCode: 'scores = {"Alice": 85, "Bob": 92, "Charlie": 78, "Diana": 95}',
+    expected: { Diana: 95, Bob: 92, Alice: 85, Charlie: 78 },
+    sample: 'dict(sorted(scores.items(), key=lambda x: x[1], reverse=True))',
+    hints: ['Use sorted() with a key function'],
+    validPatterns: [/dict\s*\(\s*sorted\s*\(\s*scores\.items\s*\(\s*\).*reverse\s*=\s*True/],
+    tags: ['sorting', 'dict-method'],
+  },
+  {
+    id: 'py-dict-039',
+    category: 'dict',
+    difficulty: 'medium',
+    title: 'OrderedDict Move to End',
+    text: 'Move the "b" key to the end of the OrderedDict',
+    setup: 'from collections import OrderedDict\nod = OrderedDict([("a", 1), ("b", 2), ("c", 3)])\nod.move_to_end("b")',
+    setupCode: 'from collections import OrderedDict\nod = OrderedDict([("a", 1), ("b", 2), ("c", 3)])\nod.move_to_end("b")',
+    expected: { a: 1, c: 3, b: 2 },
+    sample: 'dict(od)',
+    hints: ['OrderedDict has move_to_end() method'],
+    validPatterns: [/dict\s*\(\s*od\s*\)/],
+    tags: ['ordereddict', 'collections'],
+  },
+  {
+    id: 'py-dict-040',
+    category: 'dict',
+    difficulty: 'hard',
+    title: 'Deep Merge Dictionaries',
+    text: 'Merge nested dictionaries recursively (nested values should merge, not replace)',
+    setup: 'def deep_merge(d1, d2):\n    result = d1.copy()\n    for k, v in d2.items():\n        if k in result and isinstance(result[k], dict) and isinstance(v, dict):\n            result[k] = deep_merge(result[k], v)\n        else:\n            result[k] = v\n    return result\nbase = {"a": {"x": 1, "y": 2}, "b": 3}\nupdate = {"a": {"y": 20, "z": 30}, "c": 4}',
+    setupCode: 'def deep_merge(d1, d2):\n    result = d1.copy()\n    for k, v in d2.items():\n        if k in result and isinstance(result[k], dict) and isinstance(v, dict):\n            result[k] = deep_merge(result[k], v)\n        else:\n            result[k] = v\n    return result\nbase = {"a": {"x": 1, "y": 2}, "b": 3}\nupdate = {"a": {"y": 20, "z": 30}, "c": 4}',
+    expected: { a: { x: 1, y: 20, z: 30 }, b: 3, c: 4 },
+    sample: 'deep_merge(base, update)',
+    hints: ['Recursively merge when both values are dicts'],
+    validPatterns: [/deep_merge\s*\(\s*base\s*,\s*update\s*\)/],
+    tags: ['nested', 'merge', 'recursive'],
+  },
+  {
+    id: 'py-dict-041',
+    category: 'dict',
+    difficulty: 'hard',
+    title: 'Group and Aggregate Sales',
+    text: 'Group sales by product and sum the amounts',
+    setup: 'from collections import defaultdict\nsales = [{"product": "A", "amount": 100}, {"product": "B", "amount": 200}, {"product": "A", "amount": 150}, {"product": "B", "amount": 50}]\nresult = defaultdict(int)\nfor s in sales:\n    result[s["product"]] += s["amount"]',
+    setupCode: 'from collections import defaultdict\nsales = [{"product": "A", "amount": 100}, {"product": "B", "amount": 200}, {"product": "A", "amount": 150}, {"product": "B", "amount": 50}]\nresult = defaultdict(int)\nfor s in sales:\n    result[s["product"]] += s["amount"]',
+    expected: { A: 250, B: 250 },
+    sample: 'dict(result)',
+    hints: ['Use defaultdict(int) for summing'],
+    validPatterns: [/dict\s*\(\s*result\s*\)/],
+    tags: ['defaultdict', 'grouping', 'aggregation'],
+  },
+  {
+    id: 'py-dict-042',
+    category: 'dict',
+    difficulty: 'hard',
+    title: 'Transform JSON-like Data',
+    text: 'Extract usernames from nested user data into a list',
+    setup: 'data = {"users": [{"id": 1, "profile": {"username": "alice"}}, {"id": 2, "profile": {"username": "bob"}}, {"id": 3, "profile": {"username": "charlie"}}]}',
+    setupCode: 'data = {"users": [{"id": 1, "profile": {"username": "alice"}}, {"id": 2, "profile": {"username": "bob"}}, {"id": 3, "profile": {"username": "charlie"}}]}',
+    expected: ['alice', 'bob', 'charlie'],
+    sample: '[u["profile"]["username"] for u in data["users"]]',
+    hints: ['Access nested structure with bracket notation'],
+    validPatterns: [/\[.*\[.*profile.*\].*\[.*username.*\].*for.*in\s+data\s*\[.*users.*\]\s*\]/],
+    tags: ['json', 'nested', 'transform'],
+  },
+  {
+    id: 'py-dict-043',
+    category: 'dict',
+    difficulty: 'hard',
+    title: 'Counter Elements Expansion',
+    text: 'Expand Counter back to list of individual elements',
+    setup: 'from collections import Counter\ncounts = Counter({"a": 3, "b": 2, "c": 1})',
+    setupCode: 'from collections import Counter\ncounts = Counter({"a": 3, "b": 2, "c": 1})',
+    expected: ['a', 'a', 'a', 'b', 'b', 'c'],
+    sample: 'list(counts.elements())',
+    hints: ['Counter has an elements() method'],
+    validPatterns: [/list\s*\(\s*counts\.elements\s*\(\s*\)\s*\)/],
+    tags: ['counter', 'collections', 'expansion'],
+  },
+  {
+    id: 'py-dict-044',
+    category: 'dict',
+    difficulty: 'hard',
+    title: 'Pivot Data Structure',
+    text: 'Pivot list of dicts to dict of lists by key',
+    setup: 'records = [{"name": "Alice", "score": 85}, {"name": "Bob", "score": 90}, {"name": "Charlie", "score": 78}]',
+    setupCode: 'records = [{"name": "Alice", "score": 85}, {"name": "Bob", "score": 90}, {"name": "Charlie", "score": 78}]',
+    expected: { name: ['Alice', 'Bob', 'Charlie'], score: [85, 90, 78] },
+    sample: '{k: [r[k] for r in records] for k in records[0].keys()}',
+    hints: ['Get keys from first record'],
+    validPatterns: [/\{.*:\s*\[.*for.*in\s+records\s*\].*for.*in\s+records\s*\[\s*0\s*\]/],
+    tags: ['pivot', 'transform', 'comprehension'],
+  },
 ];
 
 export default pythonProblems;