feat: add script to sort sets by difficulty

Author: vikahaze

data/book-sets.json

@@ -17,32 +17,32 @@
       "Dynamic Programming"
     ],
     "problems": [
-      724, 392, 205, 142, 21, 206, 876, 230, 98, 435, 452, 704, 701, 235, 208, 746, 198, 64, 494, 733, 994, 547, 334, 238, 1431, 345, 1732, 605, 338,
-      918, 1071, 1768, 151, 643, 1004, 11, 394, 841, 104, 116, 19, 1372, 136, 283, 167, 121, 66, 1480, 1704, 1657, 120, 278, 74, 153, 933, 1046, 215,
-      383, 200, 997, 53, 509, 409, 1926, 1493, 139, 1137, 2462, 102, 199, 450, 15, 1557, 1143
+      104, 136, 206, 283, 338, 345, 374, 392, 605, 643, 700, 724, 746, 872, 933, 1071, 1137, 1207, 1431, 1732, 1768, 2215, 11, 17, 62, 72, 151, 162,
+      198, 199, 208, 215, 216, 236, 238, 328, 334, 394, 399, 435, 437, 443, 450, 452, 547, 649, 714, 735, 739, 790, 841, 875, 901, 994, 1004, 1143,
+      1161, 1268, 1318, 1372, 1448, 1456, 1466, 1493, 1657, 1679, 1926, 2095, 2130, 2300, 2336, 2352, 2390, 2462, 2542
     ]
   },
   {
     "title": "LeetCode Top 150",
     "description": "Problem list from official https://leetcode.com/studyplan/top-interview-150",
     "tags": [],
     "problems": [
-      88, 27, 26, 80, 169, 189, 121, 122, 55, 45, 274, 380, 238, 134, 135, 42, 13, 12, 58, 14, 151, 6, 28, 68, 125, 392, 167, 11, 15, 209, 3, 30, 76,
-      36, 54, 48, 73, 289, 383, 205, 290, 242, 49, 1, 202, 219, 128, 228, 56, 57, 452, 20, 71, 155, 150, 224, 141, 2, 21, 138, 92, 25, 19, 82, 61, 86,
-      146, 104, 100, 226, 101, 105, 106, 117, 114, 112, 129, 124, 173, 222, 236, 199, 637, 102, 103, 530, 230, 98, 200, 130, 133, 399, 207, 210, 909,
-      433, 127, 208, 211, 212, 17, 77, 46, 39, 52, 22, 79, 108, 148, 427, 23, 53, 918, 35, 74, 162, 33, 34, 153, 4, 215, 502, 373, 295, 67, 190, 191,
-      136, 137, 201, 9, 66, 172, 69, 50, 149, 70, 198, 139, 322, 300, 120, 64, 63, 5, 97, 72, 123, 188, 221
+      1, 9, 13, 14, 20, 21, 26, 27, 28, 35, 58, 66, 67, 69, 70, 88, 100, 101, 104, 108, 112, 121, 125, 136, 141, 169, 190, 191, 202, 205, 219, 222,
+      226, 228, 242, 290, 383, 392, 530, 637, 2, 3, 5, 6, 11, 12, 15, 17, 19, 22, 33, 34, 36, 39, 45, 46, 48, 49, 50, 53, 54, 55, 56, 57, 61, 63, 64,
+      71, 72, 73, 74, 77, 79, 80, 82, 86, 92, 97, 98, 102, 103, 105, 106, 114, 117, 120, 122, 128, 129, 130, 133, 134, 137, 138, 139, 146, 148, 150,
+      151, 153, 155, 162, 167, 172, 173, 189, 198, 199, 200, 201, 207, 208, 209, 210, 211, 215, 221, 230, 236, 238, 274, 289, 300, 322, 373, 380, 399,
+      427, 433, 452, 909, 918, 4, 23, 25, 30, 42, 52, 68, 76, 123, 124, 127, 135, 149, 188, 212, 224, 295, 502
     ]
   },
   {
     "title": "Top 100 Liked Questions",
     "description": "Problem list from official https://leetcode.com/studyplan/top-100-liked/",
     "tags": ["Essential", "High-Value Interview Prep"],
     "problems": [
-      1, 2, 3, 4, 5, 7, 11, 15, 17, 19, 20, 21, 23, 31, 33, 34, 39, 42, 46, 48, 49, 53, 56, 62, 64, 70, 72, 75, 76, 78, 79, 84, 94, 98, 101, 102, 104,
-      105, 114, 121, 124, 128, 136, 139, 141, 146, 148, 155, 160, 169, 190, 198, 199, 200, 206, 207, 208, 215, 221, 230, 234, 236, 238, 240, 242, 287,
-      297, 300, 322, 337, 344, 347, 378, 412, 438, 448, 460, 494, 543, 560, 581, 617, 647, 695, 739, 876, 973, 981, 994, 1029, 1046, 1167, 1249, 1288,
-      1304, 1337, 1423, 1480, 1528, 1584, 1672
+      1, 20, 21, 70, 94, 101, 104, 121, 136, 141, 160, 169, 190, 206, 234, 242, 344, 412, 448, 543, 617, 876, 1046, 1304, 1337, 1480, 1528, 1672, 2,
+      3, 5, 7, 11, 15, 17, 19, 31, 33, 34, 39, 46, 48, 49, 53, 56, 62, 64, 72, 75, 78, 79, 98, 102, 105, 114, 128, 139, 146, 148, 155, 198, 199, 200,
+      207, 208, 215, 221, 230, 236, 238, 240, 287, 300, 322, 337, 347, 378, 438, 494, 560, 581, 647, 695, 739, 973, 981, 994, 1029, 1167, 1249, 1288,
+      1423, 1584, 4, 23, 42, 76, 84, 124, 297, 460
     ]
   },
   {

scripts/normalize_book_sets.py

@@ -147,7 +147,9 @@ def normalize_book_sets(
 
         if removed:
             changes_made = True
-            print(f"\n[All-TODO] Removing {len(removed)} problems with both solution and explanation:")
+            print(
+                f"\n[All-TODO] Removing {len(removed)} problems with both solution and explanation:"
+            )
             print(f"  Removed: {removed[:10]}{'...' if len(removed) > 10 else ''}")
             all_todo_obj["problems"] = sorted(new_problems)
             print(f"  Updated count: {original_count} -> {len(new_problems)}")
@@ -190,9 +192,13 @@ def normalize_book_sets(
 
             print(f"\n[All] Updating problem list:")
             if added:
-                print(f"  Added {len(added)} problems: {added[:10]}{'...' if len(added) > 10 else ''}")
+                print(
+                    f"  Added {len(added)} problems: {added[:10]}{'...' if len(added) > 10 else ''}"
+                )
             if removed:
-                print(f"  Removed {len(removed)} problems: {removed[:10]}{'...' if len(removed) > 10 else ''}")
+                print(
+                    f"  Removed {len(removed)} problems: {removed[:10]}{'...' if len(removed) > 10 else ''}"
+                )
             print(f"  Updated count: {original_count} -> {len(problems_with_both)}")
 
             all_obj["problems"] = problems_with_both
@@ -238,7 +244,9 @@ def normalize_book_sets(
             print(f"  Status: COMPLETE ({completed}/{total} problems)")
         else:
             print(f"\n✗ {title}")
-            print(f"  Status: INCOMPLETE ({completed}/{total} problems, {completion_pct:.1f}%)")
+            print(
+                f"  Status: INCOMPLETE ({completed}/{total} problems, {completion_pct:.1f}%)"
+            )
             if missing:
                 # Show first 20 missing problems, then count if more
                 if len(missing) <= 20:
@@ -257,9 +265,17 @@ def normalize_book_sets(
     print("SUMMARY")
     print("=" * 70)
     print(f"Total sets: {total_sets}")
-    print(f"Completed sets: {completed_sets} ({completed_sets/total_sets*100:.1f}%)" if total_sets > 0 else "Completed sets: 0")
+    print(
+        f"Completed sets: {completed_sets} ({completed_sets/total_sets*100:.1f}%)"
+        if total_sets > 0
+        else "Completed sets: 0"
+    )
     print(f"Total problems across all sets: {total_problems}")
-    print(f"Completed problems: {total_completed_problems} ({total_completed_problems/total_problems*100:.1f}%)" if total_problems > 0 else "Completed problems: 0")
+    print(
+        f"Completed problems: {total_completed_problems} ({total_completed_problems/total_problems*100:.1f}%)"
+        if total_problems > 0
+        else "Completed problems: 0"
+    )
 
     # Write the updated JSON file
     if changes_made:
@@ -322,4 +338,3 @@ def normalize_book_sets(
         args.explanations_dir,
         dry_run=dry_run,
     )
-

scripts/sort_book_sets_by_difficulty.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""
+Script to sort problems in book-sets.json by difficulty (Easy -> Medium -> Hard).
+
+By default, sorts:
+- "LeetCode 75"
+- "LeetCode Top 150"
+- "Top 100 Liked Questions"
+
+Usage:
+    python scripts/sort_book_sets_by_difficulty.py
+    python scripts/sort_book_sets_by_difficulty.py --all  # Sort all sets
+    python scripts/sort_book_sets_by_difficulty.py --set "LeetCode 75"  # Sort specific set
+"""
+
+import json
+import os
+import sys
+import argparse
+from pathlib import Path
+
+# Paths
+SCRIPT_DIR = Path(__file__).parent
+ROOT_DIR = SCRIPT_DIR.parent
+BOOK_SETS_PATH = ROOT_DIR / "data" / "book-sets.json"
+LEETCODE_PROBLEMS_PATH = ROOT_DIR / "data" / "leetcode-problems.json"
+
+# Default sets to sort
+DEFAULT_SETS = ["LeetCode 75", "LeetCode Top 150", "Top 100 Liked Questions"]
+
+# Difficulty order for sorting
+DIFFICULTY_ORDER = {"Easy": 0, "Medium": 1, "Hard": 2, "Unknown": 3}
+
+
+def load_json_file(file_path):
+    """Load JSON file."""
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        print(f"Error: File not found: {file_path}")
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON in {file_path}: {e}")
+        sys.exit(1)
+
+
+def get_problem_difficulty(problem_id, problems_data):
+    """Get difficulty for a problem ID."""
+    problem_str = str(problem_id)
+    if problem_str in problems_data:
+        return problems_data[problem_str].get("difficulty", "Unknown")
+    return "Unknown"
+
+
+def sort_problems_by_difficulty(problem_ids, problems_data):
+    """Sort problem IDs by difficulty (Easy -> Medium -> Hard)."""
+    # Create list of (problem_id, difficulty_order)
+    problems_with_order = []
+    for pid in problem_ids:
+        difficulty = get_problem_difficulty(pid, problems_data)
+        order = DIFFICULTY_ORDER.get(difficulty, 3)
+        problems_with_order.append((pid, order, difficulty))
+
+    # Sort by difficulty order, then by problem ID (for stable sorting within same difficulty)
+    problems_with_order.sort(key=lambda x: (x[1], x[0]))
+
+    # Return sorted problem IDs
+    return [pid for pid, _, _ in problems_with_order]
+
+
+def sort_book_set(book_set, problems_data, verbose=False):
+    """Sort problems in a book set by difficulty."""
+    title = book_set.get("title", "Unknown")
+    problems = book_set.get("problems", [])
+
+    if not problems:
+        if verbose:
+            print(f"  {title}: No problems to sort")
+        return False
+
+    # Sort problems
+    sorted_problems = sort_problems_by_difficulty(problems, problems_data)
+
+    # Check if order changed
+    if sorted_problems == problems:
+        if verbose:
+            print(f"  {title}: Already sorted ({len(problems)} problems)")
+        return False
+
+    # Update the set
+    book_set["problems"] = sorted_problems
+
+    if verbose:
+        # Show difficulty breakdown
+        easy = sum(
+            1
+            for pid in sorted_problems
+            if get_problem_difficulty(pid, problems_data) == "Easy"
+        )
+        medium = sum(
+            1
+            for pid in sorted_problems
+            if get_problem_difficulty(pid, problems_data) == "Medium"
+        )
+        hard = sum(
+            1
+            for pid in sorted_problems
+            if get_problem_difficulty(pid, problems_data) == "Hard"
+        )
+        unknown = len(sorted_problems) - easy - medium - hard
+
+        print(f"  {title}: Sorted {len(sorted_problems)} problems")
+        print(
+            f"    Easy: {easy}, Medium: {medium}, Hard: {hard}"
+            + (f", Unknown: {unknown}" if unknown > 0 else "")
+        )
+        print(f"    First: {sorted_problems[0]}, Last: {sorted_problems[-1]}")
+
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Sort problems in book-sets.json by difficulty (Easy -> Medium -> Hard)"
+    )
+    parser.add_argument(
+        "--all",
+        action="store_true",
+        help="Sort all book sets (default: only LeetCode 75, Top 150, and Top 100 Liked)",
+    )
+    parser.add_argument("--set", type=str, help="Sort a specific book set by title")
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be sorted without making changes",
+    )
+    parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Show detailed output"
+    )
+
+    args = parser.parse_args()
+
+    # Load data
+    print("Loading data files...")
+    book_sets = load_json_file(BOOK_SETS_PATH)
+    problems_data = load_json_file(LEETCODE_PROBLEMS_PATH)
+
+    # Determine which sets to sort
+    if args.set:
+        sets_to_sort = [args.set]
+    elif args.all:
+        sets_to_sort = [
+            book_set["title"] for book_set in book_sets if "problems" in book_set
+        ]
+    else:
+        sets_to_sort = DEFAULT_SETS
+
+    print(f"\nSorting {len(sets_to_sort)} book set(s)...")
+    if args.verbose:
+        print(f"Sets to sort: {', '.join(sets_to_sort)}")
+    print()
+
+    # Sort each set
+    updated_count = 0
+    for book_set in book_sets:
+        title = book_set.get("title", "Unknown")
+
+        if title not in sets_to_sort:
+            continue
+
+        if args.verbose or args.dry_run:
+            print(f"Processing: {title}")
+
+        if sort_book_set(book_set, problems_data, verbose=args.verbose or args.dry_run):
+            updated_count += 1
+
+        if args.verbose or args.dry_run:
+            print()
+
+    # Save if not dry run
+    if args.dry_run:
+        print(f"Dry run complete. Would update {updated_count} set(s).")
+    else:
+        if updated_count > 0:
+            # Save updated book-sets.json
+            with open(BOOK_SETS_PATH, "w", encoding="utf-8") as f:
+                json.dump(book_sets, f, indent=2)
+            print(f"✓ Updated {updated_count} book set(s) in {BOOK_SETS_PATH}")
+        else:
+            print("No changes needed. All sets are already sorted.")
+
+
+if __name__ == "__main__":
+    main()