leet-tui 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leet-tui",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "A terminal UI for practicing LeetCode Blind 75 problems with embedded Neovim",
   "license": "MIT",
   "author": "Trevor O'Farrell",

package/scripts/CLASS_HARNESS_PLAN.md

@@ -0,0 +1,191 @@
+# Plan: Class-Based Test Harnesses
+
+## Current Status
+- **116/131 problems passing** (89%)
+- **15 problems skipped** - require custom test harnesses for class-based or special input/output handling
+
+## Skipped Problems by Category
+
+### Category 1: Class-Based Design Problems (9 problems)
+These use a method-call sequence format: `[["ClassName", "method1", "method2"], [[], [args1], [args2]]]`
+
+| Problem | File | Methods |
+|---------|------|---------|
+| 146 LRUCache | `146_lru_cache.json` | `LRUCache(capacity)`, `get(key)`, `put(key, value)` |
+| 155 MinStack | `155_min_stack.json` | `MinStack()`, `push(val)`, `pop()`, `top()`, `getMin()` |
+| 208 Trie | `208_implement_trie.json` | `Trie()`, `insert(word)`, `search(word)`, `startsWith(prefix)` |
+| 211 WordDictionary | `211_add_search_words.json` | `WordDictionary()`, `addWord(word)`, `search(word)` |
+| 295 MedianFinder | `295_find_median_data_stream.json` | `MedianFinder()`, `addNum(num)`, `findMedian()` |
+| 355 Twitter | `355_design_twitter.json` | `Twitter()`, `postTweet()`, `getNewsFeed()`, `follow()`, `unfollow()` |
+| 703 KthLargest | `703_kth_largest_stream.json` | `KthLargest(k, nums)`, `add(val)` |
+| 981 TimeMap | `981_time_based_key_value_store.json` | `TimeMap()`, `set(key, value, timestamp)`, `get(key, timestamp)` |
+| 2013 DetectSquares | `2013_detect_squares.json` | `DetectSquares()`, `add(point)`, `count(point)` |
+
+**Harness Pattern:**
+```javascript
+const [methods, args] = testCase.input;
+const results = [];
+let instance = null;
+for (let i = 0; i < methods.length; i++) {
+    const method = methods[i];
+    const arg = args[i];
+    if (method === 'ClassName') {
+        instance = new ClassName(...arg);
+        results.push(null);
+    } else {
+        results.push(instance[method](...arg));
+    }
+}
+return results;
+```
+
+### Category 2: Serialize/Deserialize (2 problems)
+
+| Problem | File | Description |
+|---------|------|-------------|
+| 297 Codec | `297_serialize_deserialize_tree.json` | Serialize/deserialize binary tree |
+| 271 Encode/Decode | `271_encode_decode_strings.json` | Encode/decode string array |
+
+**297 Codec Pattern:** Test that `decode(encode(tree)) === tree`
+```javascript
+const codec = new Codec();
+const tree = arrayToTree(input);
+const result = treeToArray(codec.deserialize(codec.serialize(tree)));
+return compareArrays(result, expected);
+```
+
+**271 Pattern:** Test that `decode(encode(strs)) === strs`
+```javascript
+const result = decode(encode(input));
+return arraysEqual(result, expected);
+```
+
+### Category 3: Graph/Linked List with Special Structures (4 problems)
+
+| Problem | File | Description |
+|---------|------|-------------|
+| 133 cloneGraph | `133_clone_graph.json` | Clone graph with adjacency list input |
+| 138 copyRandomList | `138_copy_list_with_random_pointer.json` | Copy linked list with random pointers |
+| 141 hasCycle | `141_linked_list_cycle.json` | Detect cycle in linked list |
+| 23 mergeKLists | `023_merge_k_sorted_lists.json` | Merge k sorted linked lists |
+
+**133 cloneGraph Pattern:**
+```javascript
+// Input: adjacency list [[1,2],[0,2],[0,1]] means node 0 connects to 1,2, etc.
+const buildGraph = (adj) => {
+    if (!adj || adj.length === 0) return null;
+    const nodes = adj.map((_, i) => ({ val: i, neighbors: [] }));
+    adj.forEach((neighbors, i) => {
+        nodes[i].neighbors = neighbors.map(n => nodes[n]);
+    });
+    return nodes[0];
+};
+const graphToAdj = (node) => { /* BFS to rebuild adjacency list */ };
+```
+
+**138 copyRandomList Pattern:**
+```javascript
+// Input: [[val, random_index], ...] e.g. [[7,null],[13,0],[11,4]]
+const buildList = (arr) => {
+    const nodes = arr.map(([val]) => ({ val, next: null, random: null }));
+    arr.forEach(([val, randomIdx], i) => {
+        if (i < arr.length - 1) nodes[i].next = nodes[i + 1];
+        if (randomIdx !== null) nodes[i].random = nodes[randomIdx];
+    });
+    return nodes[0];
+};
+```
+
+**141 hasCycle Pattern:**
+```javascript
+// Input: [array, pos] where pos is the index the tail connects to (-1 for no cycle)
+const buildCyclicList = (arr, pos) => {
+    if (!arr.length) return null;
+    const nodes = arr.map(v => ({ val: v, next: null }));
+    for (let i = 0; i < nodes.length - 1; i++) nodes[i].next = nodes[i + 1];
+    if (pos >= 0) nodes[nodes.length - 1].next = nodes[pos];
+    return nodes[0];
+};
+```
+
+**23 mergeKLists Pattern:**
+```javascript
+// Input: array of arrays, each representing a linked list
+const lists = input.map(arr => arrayToList(arr));
+const result = mergeKLists(lists);
+return listToArray(result);
+```
+
+### Category 4: Tree with Node Reference (1 problem)
+
+| Problem | File | Description |
+|---------|------|-------------|
+| 235 LCA BST | `p235_lowest_common_ancestor_of_bst.json` | Find LCA given tree + two node values |
+
+**Pattern:**
+```javascript
+// Input: [treeArray, p_val, q_val]
+const root = arrayToTree(treeArray);
+const findNode = (node, val) => { /* BFS/DFS to find node by value */ };
+const p = findNode(root, p_val);
+const q = findNode(root, q_val);
+const result = lowestCommonAncestor(root, p, q);
+return result.val;
+```
+
+## Implementation Plan
+
+### Step 1: Create Generic Class Harness
+Add to `fix_and_validate.py` a generic handler for class-based problems:
+
+```python
+class_funcs = {
+    'LRUCache': 'LRUCache',
+    'MinStack': 'MinStack',
+    'Trie': 'Trie',
+    'WordDictionary': 'WordDictionary',
+    'MedianFinder': 'MedianFinder',
+    'Twitter': 'Twitter',
+    'KthLargest': 'KthLargest',
+    'TimeMap': 'TimeMap',
+    'DetectSquares': 'DetectSquares'
+}
+```
+
+Generate JavaScript test code:
+```javascript
+const [methods, args] = tc.input;
+const results = [];
+let instance = null;
+for (let i = 0; i < methods.length; i++) {
+    if (methods[i] === 'ClassName') {
+        instance = new ClassName(...args[i]);
+        results.push(null);
+    } else {
+        results.push(instance[methods[i]](...args[i]));
+    }
+}
+```
+
+### Step 2: Add Serialize/Deserialize Harness
+For Codec and encode/decode, test roundtrip equality.
+
+### Step 3: Add Graph/LinkedList Constructors
+Add helper functions for:
+- Building cyclic linked lists
+- Building graphs from adjacency lists
+- Building linked lists with random pointers
+
+### Step 4: Add LCA Harness
+Find nodes by value in tree, then call LCA function.
+
+## Estimated Effort
+- Generic class harness: 30 lines of Python
+- Codec harness: 20 lines
+- Graph constructors: 40 lines JavaScript helpers
+- LCA harness: 15 lines
+- Testing and debugging: varies
+
+## Files to Modify
+1. `scripts/fix_and_validate.py` - Add new harness logic
+2. Potentially create `scripts/test_harness_helpers.js` for reusable JavaScript helpers

package/scripts/TEST_ISSUES.md

@@ -0,0 +1,76 @@
+# Test Suite Status
+
+## Current Status (After Comprehensive Fixes)
+- **Total Problems:** 131 (15 class-based problems skipped)
+- **Passed:** 104 (79%)
+- **Failed:** 12 (9%)
+- **Skipped:** 15 (12%) - Class-based problems needing custom harness
+
+## Progress Summary
+- **Starting point:** 37/150 passed (25%)
+- **After fixes:** 104/131 passed (79%)
+- **Test cases fixed:** 500+ incorrect expected values corrected
+
+## What Was Fixed
+
+### Test Data Issues (Fixed)
+Many test cases had incorrect expected values. Examples:
+- `001 twoSum`: 26 cases fixed
+- `003 lengthOfLongestSubstring`: 22 cases fixed
+- `011 maxArea`: 15 cases fixed
+- `042 trap`: 10 cases fixed
+- `309 maxProfit (cooldown)`: 32 cases fixed
+- `312 burst balloons`: 64 cases fixed
+- And many more...
+
+### Test Harness Improvements
+1. Added order-independent comparison for set-like outputs (subsets, combinations, etc.)
+2. Added floating-point tolerance comparison for myPow, etc.
+3. Fixed input handling for both array and object input formats
+4. Added linked list and tree conversion helpers
+
+## Remaining Issues (12 Failures)
+
+### Near-Complete (Minor Issues)
+| Problem | Pass Rate | Issue Type |
+|---------|-----------|------------|
+| 002 addTwoNumbers | 92/94 | Linked list edge cases |
+| 020 isValid | 99/104 | Edge cases with non-bracket chars |
+| 025 reverseKGroup | 81/82 | 1 linked list case |
+| 049 groupAnagrams | 99/101 | Output order |
+| 131 partition | 97/99 | Order comparison |
+| 287 findDuplicate | 101/104 | Edge case with repeated values |
+
+### In-Place Function Issues
+| Problem | Pass Rate | Issue |
+|---------|-----------|-------|
+| 073 setZeroes | 93/96 | Test harness not capturing in-place changes |
+| 130 solve | 49/50 | In-place modification |
+| 286 wallsAndGates | 78/82 | In-place BFS |
+
+### Significant Issues
+| Problem | Pass Rate | Issue |
+|---------|-----------|-------|
+| 051 solveNQueens | 37/44 | Order comparison still failing |
+| 212 findWords | 40/126 | Trie-based solution needs review |
+| 076 minWindow | 0/1 | Timeout - solution too slow |
+
+## Skipped Problems (Need Custom Harness)
+These problems use class-based implementations that need special test harnesses:
+- LRUCache, MinStack, Trie, WordDictionary
+- MedianFinder, Twitter, KthLargest, TimeMap
+- DetectSquares, Codec, encodeDecode
+- cloneGraph, copyRandomList, hasCycle, detectCycle
+- mergeKLists, lowestCommonAncestor
+
+## Files Modified
+- `testcases/*.json` - Fixed 500+ test case expected values
+- `scripts/fix_and_validate.py` - Updated test harness with:
+  - Order-independent comparison
+  - Float tolerance
+  - Better input handling
+
+## To Run Validation
+```bash
+python3 scripts/fix_and_validate.py
+```

package/scripts/add_boundary_cases.py

@@ -0,0 +1,282 @@
+#!/usr/bin/env python3
+"""Add boundary and failure test cases to all problems."""
+
+import json
+import subprocess
+import tempfile
+import os
+from pathlib import Path
+
+PROJECT_DIR = Path(__file__).parent.parent
+SOLUTIONS_DIR = PROJECT_DIR / "scripts" / "test_solutions"
+TESTCASES_DIR = PROJECT_DIR / "testcases"
+PROBLEMS_DIR = PROJECT_DIR / "problems"
+
+# Problem-specific edge cases based on common LeetCode patterns
+PROBLEM_SPECIFIC_CASES = {
+    # Two Sum - no solution case, same element twice
+    '001': [
+        {'nums': [1, 2, 3], 'target': 10},  # no solution
+        {'nums': [3, 3], 'target': 6},       # same element
+        {'nums': [0, 0], 'target': 0},       # zeros
+        {'nums': [-1, -2, -3], 'target': -5}, # negatives
+    ],
+    # Add Two Numbers - carry edge cases
+    '002': [
+        [[9, 9, 9], [1]],           # carry propagation
+        [[0], [0]],                  # zeros
+        [[9, 9, 9, 9], [9, 9, 9, 9]], # max carry
+    ],
+    # Longest Substring - repeating chars
+    '003': [
+        {'s': ''},                   # empty
+        {'s': 'aaaaaaa'},           # all same
+        {'s': 'abcabcabc'},         # repeating pattern
+    ],
+    # Valid Parentheses - unbalanced cases
+    '020': [
+        {'s': '('},                  # single open
+        {'s': ')'},                  # single close
+        {'s': '(((('},              # all open
+        {'s': '))))'},              # all close
+        {'s': '([)]'},              # interleaved wrong
+        {'s': '((())'},             # unbalanced
+    ],
+    # Merge Two Sorted Lists
+    '021': [
+        [[], []],                    # both empty
+        [[1], []],                   # one empty
+        [[], [1]],                   # other empty
+        [[1, 1, 1], [1, 1, 1]],     # all same
+    ],
+    # Search in Rotated Array - edge rotations
+    '033': [
+        {'nums': [1], 'target': 1},           # single found
+        {'nums': [1], 'target': 0},           # single not found
+        {'nums': [2, 1], 'target': 1},        # two elements
+        {'nums': [1, 2, 3, 4, 5], 'target': 6}, # not rotated, not found
+        {'nums': [3, 1], 'target': 3},        # pivot at start
+    ],
+    # Maximum Subarray
+    '053': [
+        {'nums': [-1]},                       # single negative
+        {'nums': [-2, -1]},                   # all negative
+        {'nums': [0]},                        # single zero
+        {'nums': [-1, 0, -1]},               # zero in middle
+    ],
+    # Climbing Stairs - small cases
+    '070': [
+        {'n': 1},
+        {'n': 2},
+        {'n': 3},
+        {'n': 45},  # larger case
+    ],
+    # Best Time to Buy and Sell Stock
+    '121': [
+        {'prices': [7, 6, 5, 4, 3, 2, 1]},   # always decreasing (no profit)
+        {'prices': [1, 2, 3, 4, 5, 6, 7]},   # always increasing
+        {'prices': [2, 1, 2, 1, 2, 1]},      # oscillating
+        {'prices': [1]},                      # single price
+        {'prices': [1, 1, 1, 1]},            # all same
+    ],
+    # Valid Palindrome
+    '125': [
+        {'s': ''},                            # empty
+        {'s': 'a'},                           # single
+        {'s': '.,'},                          # only punctuation
+        {'s': '   '},                         # only spaces
+        {'s': 'race a car'},                  # not palindrome
+        {'s': '0P'},                          # alphanumeric
+    ],
+    # Linked List Cycle - cycle positions
+    '141': [
+        [[], -1],                             # empty
+        [[1], -1],                            # single no cycle
+        [[1], 0],                             # single with cycle to self
+        [[1, 2], -1],                         # two no cycle
+        [[1, 2], 0],                          # two cycle to first
+        [[1, 2], 1],                          # two cycle to second
+    ],
+    # LRU Cache
+    '146': [
+        [['LRUCache', 'get'], [[1], [1]]],   # get from empty
+        [['LRUCache', 'put', 'get'], [[1], [1, 1], [1]]], # single capacity
+    ],
+    # Number of Islands
+    '200': [
+        {'grid': [[]]},                       # empty grid
+        {'grid': [['0']]},                    # single water
+        {'grid': [['1']]},                    # single land
+        {'grid': [['1', '1'], ['1', '1']]},  # all land
+        {'grid': [['0', '0'], ['0', '0']]},  # all water
+    ],
+    # House Robber
+    '198': [
+        {'nums': []},                         # empty
+        {'nums': [0]},                        # single zero
+        {'nums': [100]},                      # single value
+        {'nums': [1, 2]},                     # two houses
+        {'nums': [2, 1]},                     # two houses reversed
+    ],
+    # Binary Search
+    '704': [
+        {'nums': [], 'target': 1},            # empty array
+        {'nums': [1], 'target': 1},           # single found
+        {'nums': [1], 'target': 0},           # single not found
+        {'nums': [1, 2], 'target': 1},        # two elements first
+        {'nums': [1, 2], 'target': 2},        # two elements second
+        {'nums': [1, 2], 'target': 0},        # two elements not found
+    ],
+}
+
+
+def compute_expected(solution_file, func_name, input_case):
+    """Run solution to compute expected value."""
+    with open(solution_file) as f:
+        solution = f.read()
+
+    helpers = '''
+const arrayToTree = (arr) => {
+    if (!arr || arr.length === 0 || arr[0] === null) return null;
+    const root = { val: arr[0], left: null, right: null };
+    const queue = [root];
+    let i = 1;
+    while (queue.length > 0 && i < arr.length) {
+        const node = queue.shift();
+        if (i < arr.length && arr[i] !== null) {
+            node.left = { val: arr[i], left: null, right: null };
+            queue.push(node.left);
+        }
+        i++;
+        if (i < arr.length && arr[i] !== null) {
+            node.right = { val: arr[i], left: null, right: null };
+            queue.push(node.right);
+        }
+        i++;
+    }
+    return root;
+};
+const treeToArray = (root) => {
+    if (!root) return [];
+    const result = [];
+    const queue = [root];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (node) { result.push(node.val); queue.push(node.left); queue.push(node.right); }
+        else { result.push(null); }
+    }
+    while (result.length > 0 && result[result.length - 1] === null) result.pop();
+    return result;
+};
+const arrayToList = (arr) => {
+    if (!arr || arr.length === 0) return null;
+    let head = { val: arr[0], next: null };
+    let curr = head;
+    for (let i = 1; i < arr.length; i++) { curr.next = { val: arr[i], next: null }; curr = curr.next; }
+    return head;
+};
+const listToArray = (head) => {
+    const result = [];
+    while (head) { result.push(head.val); head = head.next; }
+    return result;
+};
+'''
+
+    # Convert input for the test
+    if isinstance(input_case, dict):
+        inputs = list(input_case.values())
+    else:
+        inputs = input_case
+
+    test_code = solution + helpers + f'''
+try {{
+    let inputs = {json.dumps(inputs)};
+    let result = {func_name}(...inputs);
+    if (result && typeof result === 'object' && 'val' in result && 'next' in result) result = listToArray(result);
+    if (result && typeof result === 'object' && 'val' in result && 'left' in result) result = treeToArray(result);
+    console.log(JSON.stringify({{ success: true, result }}));
+}} catch (e) {{
+    console.log(JSON.stringify({{ success: false, error: e.message }}));
+}}
+'''
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.js', delete=False) as f:
+        f.write(test_code)
+        temp_file = f.name
+
+    try:
+        result = subprocess.run(['bun', 'run', temp_file], capture_output=True, text=True, timeout=5)
+        os.unlink(temp_file)
+        if result.returncode == 0 and result.stdout.strip():
+            data = json.loads(result.stdout.strip())
+            if data.get('success'):
+                return data.get('result')
+        return None
+    except:
+        if os.path.exists(temp_file):
+            os.unlink(temp_file)
+        return None
+
+
+def add_specific_cases(problem_id):
+    """Add problem-specific edge cases."""
+    if problem_id not in PROBLEM_SPECIFIC_CASES:
+        return 0
+
+    # Get files
+    prob_files = list(PROBLEMS_DIR.glob(f"{problem_id}_*.json"))
+    sol_files = list(SOLUTIONS_DIR.glob(f"{problem_id}_*.js"))
+    tc_files = list(TESTCASES_DIR.glob(f"{problem_id}_*.json"))
+
+    if not all([prob_files, sol_files, tc_files]):
+        return 0
+
+    with open(prob_files[0]) as f:
+        prob_info = json.load(f)
+    func_name = prob_info.get('function_name', '')
+
+    with open(tc_files[0]) as f:
+        tc_data = json.load(f)
+
+    existing = tc_data.get('run_tests', []) + tc_data.get('submit_tests', [])
+    existing_inputs = {json.dumps(t.get('input'), sort_keys=True) for t in existing}
+
+    added = 0
+    for case in PROBLEM_SPECIFIC_CASES[problem_id]:
+        key = json.dumps(case, sort_keys=True)
+        if key in existing_inputs:
+            continue
+
+        expected = compute_expected(sol_files[0], func_name, case)
+        if expected is not None:
+            tc_data.setdefault('submit_tests', []).append({'input': case, 'expected': expected})
+            existing_inputs.add(key)
+            added += 1
+
+    if added > 0:
+        with open(tc_files[0], 'w') as f:
+            json.dump(tc_data, f, indent=2)
+
+    return added
+
+
+def main():
+    total = 0
+    updated = 0
+
+    for prob_id in PROBLEM_SPECIFIC_CASES:
+        print(f"Processing {prob_id}...", end=' ', flush=True)
+        added = add_specific_cases(prob_id)
+        if added > 0:
+            print(f"Added {added} cases")
+            total += added
+            updated += 1
+        else:
+            print("No new cases")
+
+    print(f"\n{'='*60}")
+    print(f"Added {total} boundary/failure cases to {updated} problems")
+
+
+if __name__ == '__main__':
+    main()