Remove custom JSON formatting functions, use Prettier for all formatting

Author: vikahaze

scripts/normalize_book_sets.py

@@ -13,93 +13,10 @@
 import json
 import os
 import argparse
-import re
 import subprocess
 from pathlib import Path
 
 
-def compact_json_arrays(json_str: str, max_line_length: int = 150) -> str:
-    """
-    Compact number arrays in JSON string to have multiple numbers per line.
-
-    Args:
-        json_str: JSON string with arrays formatted one number per line
-        max_line_length: Maximum characters per line (default: 150)
-
-    Returns:
-        Compacted JSON string
-    """
-    lines = json_str.split("\n")
-    result = []
-    i = 0
-
-    while i < len(lines):
-        line = lines[i]
-
-        # Check if this line starts an array of numbers
-        # Pattern: some indentation, "key": [
-        array_start_match = re.match(r'^(\s*)"[^"]+": \[$', line)
-
-        if array_start_match:
-            indent = array_start_match.group(1)
-            result.append(line)
-            i += 1
-
-            # Collect all numbers from subsequent lines
-            numbers = []
-            while i < len(lines):
-                num_line = lines[i].strip()
-
-                # Check if it's a closing bracket
-                if num_line == "]" or num_line == "],":
-                    # Format numbers compactly
-                    if numbers:
-                        # Group numbers to fit within max_line_length
-                        number_indent = indent + "    "
-                        current_line = number_indent
-
-                        for idx, num in enumerate(numbers):
-                            num_str = str(num)
-                            # Add comma if not the last number
-                            if idx < len(numbers) - 1:
-                                num_str += ", "
-
-                            # Check if adding this number would exceed max length
-                            if (
-                                len(current_line + num_str) > max_line_length
-                                and current_line != number_indent
-                            ):
-                                result.append(current_line.rstrip())
-                                current_line = number_indent + num_str
-                            else:
-                                current_line += num_str
-
-                        # Add the last line
-                        if current_line.strip():
-                            result.append(current_line.rstrip())
-
-                    # Add closing bracket
-                    result.append(indent + num_line)
-                    i += 1
-                    break
-
-                # Check if it's a number (with optional comma)
-                num_match = re.match(r"^(\d+),?$", num_line)
-                if num_match:
-                    numbers.append(int(num_match.group(1)))
-                    i += 1
-                else:
-                    # Not a number array, just add the line as-is
-                    result.append(lines[i])
-                    i += 1
-                    break
-        else:
-            result.append(line)
-            i += 1
-
-    return "\n".join(result)
-
-
 def check_solution_exists(problem_number: int, solutions_dir: Path) -> bool:
     """Check if solution exists for a problem number."""
     solution_path = solutions_dir / str(problem_number) / "01.py"

scripts/normalize_json.py

@@ -2,9 +2,8 @@
 
 """
 Reads a JSON file, sorts its top-level keys numerically,
-and writes the sorted data to a new JSON file following Prettier style.
-
-Prettier config: printWidth=150, tabWidth=2, useTabs=false, trailingComma=es5, bracketSpacing=false
+and writes the sorted data to a new JSON file.
+Prettier will format the output according to .prettierrc config.
 
 python scripts/normalize_json.py data/leetcode-problems.json
 """
@@ -15,66 +14,6 @@
 from collections import OrderedDict
 
 
-def format_json_value(value, indent_level=0, print_width=150):
-    """Format a JSON value with custom formatting following Prettier style."""
-    indent = "  " * indent_level
-    next_indent = "  " * (indent_level + 1)
-
-    if isinstance(value, dict):
-        if not value:
-            return "{}"
-        items = []
-        for k, v in sorted(value.items()):
-            formatted_key = json.dumps(k, ensure_ascii=False)
-            formatted_value = format_json_value(v, indent_level + 1, print_width)
-            items.append(f"{next_indent}{formatted_key}: {formatted_value}")
-        return "{\n" + ",\n".join(items) + "\n" + indent + "}"
-    elif isinstance(value, list):
-        if not value:
-            return "[]"
-        # Check if it's a list of numbers (for problems arrays) - format multiple per line
-        if value and isinstance(value[0], (int, float)):
-            # Calculate available width (print_width minus indentation and brackets)
-            available_width = print_width - len(next_indent) - 2
-            lines = []
-            current_line = []
-            current_length = 0
-            
-            for i, item in enumerate(value):
-                item_str = str(item)
-                # Add comma and space length (2) if not first item on line
-                item_length = len(item_str) + (2 if current_line else 0)
-                
-                if current_length + item_length > available_width and current_line:
-                    # Start a new line
-                    lines.append(", ".join(str(x) for x in current_line))
-                    current_line = [item]
-                    current_length = len(item_str)
-                else:
-                    current_line.append(item)
-                    current_length += item_length
-            
-            if current_line:
-                lines.append(", ".join(str(x) for x in current_line))
-            
-            # Format with proper indentation
-            formatted_lines = [f"{next_indent}{line}" for line in lines]
-            return "[\n" + ",\n".join(formatted_lines) + "\n" + indent + "]"
-        else:
-            # Format other arrays - check if they fit on one line
-            formatted_items = [format_json_value(item, indent_level + 1, print_width) for item in value]
-            total_length = sum(len(str(item)) for item in formatted_items)
-            if total_length < 100 and len(value) <= 5:
-                # Short arrays on one line
-                return "[" + ", ".join(str(item).replace("\n", " ") for item in formatted_items) + "]"
-            else:
-                # Long arrays with line breaks
-                items = [f"{next_indent}{item}" for item in formatted_items]
-                return "[\n" + ",\n".join(items) + "\n" + indent + "]"
-    else:
-        return json.dumps(value, ensure_ascii=False)
-
-
 def sort_json_by_numeric_keys(input_file, output_file):
     """
     Sort JSON file by numeric keys and format according to Prettier style.
@@ -94,18 +33,9 @@ def sort_json_by_numeric_keys(input_file, output_file):
         sorted_items = sorted(data.items(), key=lambda item: int(item[0]))
         sorted_data = OrderedDict(sorted_items)
 
-        # Format the JSON with custom formatting following Prettier style
-        lines = ["{"]
-        items = []
-        for key, value in sorted_data.items():
-            formatted_key = json.dumps(key, ensure_ascii=False)
-            formatted_value = format_json_value(value, 1, print_width=150)
-            items.append(f'  {formatted_key}: {formatted_value}')
-        lines.append(",\n".join(items))
-        lines.append("}")
-
+        # Write JSON (Prettier will format it)
         with open(output_file, "w", encoding="utf-8") as f:
-            f.write("\n".join(lines) + "\n")
+            json.dump(sorted_data, f, ensure_ascii=False)
 
         # Format with prettier
         try: