fix: Handle integer output parsing in JUDGE_FUNC for 7 solutions

The test framework uses ast.literal_eval() to parse solution outputs,
which converts single numbers like "1" to integers. The judge functions
in 7 solutions were only checking for str or list types, causing test
failures when outputs were parsed as integers.

Fixed solutions:
- 0021_merge_two_sorted_lists: Handle int input + fix empty line parsing
- 0027_remove_element: Handle int input for k=0 single-line output case
- 0075_sort_colors: Handle int input for single-element arrays
- 0088_merge_sorted_array: Handle int input + fix empty array parsing
- 0283_move_zeroes: Handle int input for single-element arrays
- 0876_middle_of_the_linked_list: Handle int input for single-node lists
- 0905_sort_array_by_parity: Handle int input for single-element arrays

Changes:
- Added isinstance(actual, int) checks in all judge functions
- Convert single integers to single-element lists: [actual]
- Improved input parsing to preserve empty lines correctly
- No changes to solution algorithms (all were already correct)

Test Results:
- All 92 tests pass (7 skipped for problems without static tests)
- Static tests: 33/33 passing
- Generated tests: 59/59 passing
- Combined tests: 99/99 passing

Root Cause:
The compare.py module uses ast.literal_eval() to parse outputs before
passing to JUDGE_FUNC. Single numbers get parsed as int, not str,
which the judge functions didn't handle.

Author: lufftw

solutions/0021_merge_two_sorted_lists.py

@@ -91,22 +91,29 @@ def judge(actual, expected, input_data: str) -> bool:
     Validate result: check if actual output is correctly merged sorted list.
     
     Args:
-        actual: Program output (space-separated integers as string)
+        actual: Program output (space-separated integers as string, list, or single int)
         expected: Expected output (None if from generator)
         input_data: Raw input string (Line 1: list1, Line 2: list2)
     
     Returns:
         bool: True if correctly merged
     """
-    lines = input_data.strip().split('\n')
+    # Parse input - preserve empty lines by splitting before strip
+    lines = input_data.split('\n')
+    # Handle trailing newline by removing empty last element if present
+    if lines and lines[-1] == '':
+        lines = lines[:-1]
+    
     list1_vals = list(map(int, lines[0].split())) if lines[0].strip() else []
     list2_vals = list(map(int, lines[1].split())) if len(lines) > 1 and lines[1].strip() else []
 
     # Compute correct answer
     correct = sorted(list1_vals + list2_vals)
 
-    # Parse actual output
-    if isinstance(actual, str):
+    # Parse actual output - handle int (from ast.literal_eval), str, or list
+    if isinstance(actual, int):
+        actual_vals = [actual]
+    elif isinstance(actual, str):
         actual_vals = list(map(int, actual.strip().split())) if actual.strip() else []
     elif isinstance(actual, list):
         actual_vals = actual

solutions/0027_remove_element.py

@@ -79,7 +79,7 @@ def judge(actual, expected, input_data: str) -> bool:
     Validate result: check if actual output correctly removes all occurrences of val.
     
     Args:
-        actual: Program output (may be string with newlines or tuple)
+        actual: Program output (may be string with newlines, tuple, or int when k=0)
         expected: Expected output (None if from generator)
         input_data: Raw input string (Line 1: nums, Line 2: val)
     
@@ -90,14 +90,19 @@ def judge(actual, expected, input_data: str) -> bool:
     nums = list(map(int, lines[0].split())) if lines[0] else []
     val = int(lines[1]) if len(lines) > 1 else 0
 
-    # Parse actual output
-    if isinstance(actual, str):
+    # Parse actual output - handle various formats
+    if isinstance(actual, int):
+        # ast.literal_eval parsed single number (k=0 case, no second line)
+        k = actual
+        result_nums = []
+    elif isinstance(actual, str):
         lines_out = actual.strip().split('\n')
-        if len(lines_out) >= 2:
-            k = int(lines_out[0])
-            result_nums = list(map(int, lines_out[1].split())) if lines_out[1] else []
+        k = int(lines_out[0])
+        if len(lines_out) >= 2 and lines_out[1]:
+            result_nums = list(map(int, lines_out[1].split()))
         else:
-            return False
+            # k=0 case: no elements remaining
+            result_nums = []
     elif isinstance(actual, tuple) and len(actual) == 2:
         k, result_nums = actual
     else:

solutions/0075_sort_colors.py

@@ -84,7 +84,7 @@ def judge(actual, expected, input_data: str) -> bool:
     Validate result: check if actual output is correctly sorted (0s, 1s, 2s).
     
     Args:
-        actual: Program output (space-separated integers as string)
+        actual: Program output (space-separated integers as string, list, or single int)
         expected: Expected output (None if from generator)
         input_data: Raw input string (space-separated integers 0, 1, or 2)
     
@@ -94,8 +94,10 @@ def judge(actual, expected, input_data: str) -> bool:
     line = input_data.strip()
     nums = list(map(int, line.split())) if line else []
 
-    # Parse actual output
-    if isinstance(actual, str):
+    # Parse actual output - handle int (from ast.literal_eval), str, or list
+    if isinstance(actual, int):
+        actual_nums = [actual]
+    elif isinstance(actual, str):
         actual_nums = list(map(int, actual.strip().split())) if actual.strip() else []
     elif isinstance(actual, list):
         actual_nums = actual

solutions/0088_merge_sorted_array.py

@@ -90,27 +90,34 @@ def judge(actual, expected, input_data: str) -> bool:
     Validate result: check if actual output is correctly merged sorted array.
     
     Args:
-        actual: Program output (space-separated integers as string)
+        actual: Program output (space-separated integers as string, list, or single int)
         expected: Expected output (None if from generator)
         input_data: Raw input string (Line 1: nums1, Line 2: m, Line 3: nums2, Line 4: n)
     
     Returns:
         bool: True if correctly merged
     """
-    lines = input_data.strip().split('\n')
-    nums1 = list(map(int, lines[0].split())) if lines[0] else []
-    m = int(lines[1]) if len(lines) > 1 else 0
+    # Parse input - preserve empty lines by splitting before strip
+    lines = input_data.split('\n')
+    # Handle trailing newline by removing empty last element if present
+    while lines and lines[-1] == '':
+        lines.pop()
+    
+    nums1 = list(map(int, lines[0].split())) if lines[0].strip() else []
+    m = int(lines[1]) if len(lines) > 1 and lines[1].strip() else 0
     nums2 = list(map(int, lines[2].split())) if len(lines) > 2 and lines[2].strip() else []
-    n = int(lines[3]) if len(lines) > 3 else 0
+    n = int(lines[3]) if len(lines) > 3 and lines[3].strip() else 0
 
     # Extract actual elements from nums1 (first m elements)
     nums1_actual = nums1[:m] if m > 0 else []
 
     # Compute correct answer
     correct = sorted(nums1_actual + nums2)
 
-    # Parse actual output
-    if isinstance(actual, str):
+    # Parse actual output - handle int (from ast.literal_eval), str, or list
+    if isinstance(actual, int):
+        actual_vals = [actual]
+    elif isinstance(actual, str):
         actual_vals = list(map(int, actual.strip().split())) if actual.strip() else []
     elif isinstance(actual, list):
         actual_vals = actual

solutions/0283_move_zeroes.py

@@ -91,7 +91,7 @@ def judge(actual, expected, input_data: str) -> bool:
     Validate result: check if actual output has all zeros moved to end.
     
     Args:
-        actual: Program output (space-separated integers as string)
+        actual: Program output (space-separated integers as string, list, or single int)
         expected: Expected output (None if from generator)
         input_data: Raw input string (space-separated integers)
     
@@ -101,8 +101,10 @@ def judge(actual, expected, input_data: str) -> bool:
     line = input_data.strip()
     nums = list(map(int, line.split())) if line else []
 
-    # Parse actual output
-    if isinstance(actual, str):
+    # Parse actual output - handle int (from ast.literal_eval), str, or list
+    if isinstance(actual, int):
+        actual_nums = [actual]
+    elif isinstance(actual, str):
         actual_nums = list(map(int, actual.strip().split())) if actual.strip() else []
     elif isinstance(actual, list):
         actual_nums = actual

solutions/0876_middle_of_the_linked_list.py

@@ -89,7 +89,7 @@ def judge(actual, expected, input_data: str) -> bool:
     Validate result: check if actual output is the middle node values.
     
     Args:
-        actual: Program output (space-separated integers as string)
+        actual: Program output (space-separated integers as string, list, or single int)
         expected: Expected output (None if from generator)
         input_data: Raw input string (space-separated node values)
     
@@ -106,8 +106,10 @@ def judge(actual, expected, input_data: str) -> bool:
         mid_idx = len(values) // 2
         correct = values[mid_idx:]
 
-    # Parse actual output
-    if isinstance(actual, str):
+    # Parse actual output - handle int (from ast.literal_eval), str, or list
+    if isinstance(actual, int):
+        actual_vals = [actual]
+    elif isinstance(actual, str):
         actual_vals = list(map(int, actual.strip().split())) if actual.strip() else []
     elif isinstance(actual, list):
         actual_vals = actual

solutions/0905_sort_array_by_parity.py

@@ -79,7 +79,7 @@ def judge(actual, expected, input_data: str) -> bool:
     Validate result: check if actual output has evens before odds.
     
     Args:
-        actual: Program output (space-separated integers as string)
+        actual: Program output (space-separated integers as string, list, or single int)
         expected: Expected output (None if from generator)
         input_data: Raw input string (space-separated integers)
     
@@ -89,8 +89,10 @@ def judge(actual, expected, input_data: str) -> bool:
     line = input_data.strip()
     nums = list(map(int, line.split())) if line else []
 
-    # Parse actual output
-    if isinstance(actual, str):
+    # Parse actual output - handle int (from ast.literal_eval), str, or list
+    if isinstance(actual, int):
+        actual_nums = [actual]
+    elif isinstance(actual, str):
         actual_nums = list(map(int, actual.strip().split())) if actual.strip() else []
     elif isinstance(actual, list):
         actual_nums = actual