java-python-code-reviewer（Java Python 代码 reviewer）

Java & Python Code Reviewer

When to use this Skill

Use this Skill when:

• Reviewing LeetCode problem solutions
• Checking code correctness and efficiency
• Comparing Java and Python implementations
• Providing feedback on algorithm implementations
• Optimizing existing solutions

Review Framework

1. Correctness Analysis

Check for:

• Edge cases handling (empty input, null, single element)
• Boundary conditions (array indices, loop termination)
• Logic errors in algorithm implementation
• Test case coverage (basic, edge, corner cases)

Common edge cases:

• Empty arrays/strings: [], ""
• Null inputs: null, None
• Single element: [1], "a"
• Duplicates: [1,1,1]
• Negative numbers: [-1, -5]
• Large inputs: Test time/space limits

2. Time & Space Complexity

Analyze and verify:

• Time complexity: Count operations relative to input size
• Space complexity: Count auxiliary space used
• Compare against optimal solution

Provide:

Current: O(n²) time, O(1) space
Optimal: O(n) time, O(n) space using HashMap
Trade-off: Use extra space for better time complexity

Complexity Reference:

• O(1): Direct access
• O(log n): Binary search, balanced tree
• O(n): Single pass, linear scan
• O(n log n): Efficient sorting, divide-and-conquer
• O(n²): Nested loops
• O(2ⁿ): Exponential (backtracking, brute force)

3. Code Quality - Java

Java Best Practices:

• Use appropriate data structures (ArrayList, HashMap, HashSet)
• Follow naming conventions (camelCase for methods/variables)
• Handle null checks and validation
• Use generics properly (List<Integer> not raw types)
• Prefer interfaces over implementations (List<> not ArrayList<>)

Java Anti-patterns to flag:

// Bad: Raw types
ArrayList list = new ArrayList();

// Good: Generics
List<Integer> list = new ArrayList<>();

// Bad: Manual array copying
for (int i = 0; i < arr.length; i++) { ... }

// Good: Built-in methods
Arrays.copyOf(arr, arr.length);

// Bad: String concatenation in loop
String s = "";
for (String str : list) { s += str; }

// Good: StringBuilder
StringBuilder sb = new StringBuilder();
for (String str : list) { sb.append(str); }

Check for:

• Integer overflow: Suggest long when needed
• Proper exception handling
• Memory leaks (unclosed resources)
• Thread safety if applicable

4. Code Quality - Python

Python Best Practices:

• Use Pythonic idioms (list comprehensions, enumerate, zip)
• Follow PEP 8 style guidelines
• Use appropriate data structures (set, dict, deque)
• Leverage built-in functions

Python Anti-patterns to flag:

# Bad: Manual index tracking
for i in range(len(arr)):
    print(i, arr[i])

# Good: enumerate
for i, val in enumerate(arr):
    print(i, val)

# Bad: Building list with append in loop
result = []
for x in arr:
    result.append(x * 2)

# Good: List comprehension
result = [x * 2 for x in arr]

# Bad: Multiple membership checks
if x == 'a' or x == 'b' or x == 'c':

# Good: Use set or tuple
if x in {'a', 'b', 'c'}:

Check for:

• Use of appropriate collections (collections.defaultdict, Counter)
• Generator expressions for memory efficiency
• Proper use of None checks
• Type hints for clarity (optional but helpful)

5. Algorithm Optimization

Suggest improvements for:

• Unnecessary nested loops → Use HashMap for O(n)
• Repeated calculations → Use memoization/DP
• Redundant sorting → Use heap or quick select
• Multiple passes → Combine into single pass
• Extra space usage → In-place modifications

Pattern Recognition:

• Two Sum pattern → Use HashMap
• Sliding Window → Two pointers
• Subarray sum → Prefix sum
• Longest substring → Sliding window + HashMap
• Tree traversal → DFS/BFS with proper data structure

6. Comparison: Java vs Python

When comparing implementations:

Java strengths:

• Explicit types catch errors early
• Better for performance-critical code
• Clear data structure usage

Python strengths:

• More concise and readable
• Rich standard library (collections, itertools)
• Better for rapid prototyping

Flag inconsistencies:

• Different algorithms used (should be same approach)
• Different time/space complexity
• Missing edge case handling in one version

7. Review Output Format

Structure your review as:

## Correctness: ✓ Pass / ⚠ Issues Found

[List any correctness issues]

## Complexity Analysis

- Time: O(?) - [Explain]
- Space: O(?) - [Explain]
- Optimal: [If current solution is not optimal]

## Code Quality

**Strengths:**
- [List positive aspects]

**Issues:**
- [Issue 1] at line X: [Explanation]
- [Issue 2] at line Y: [Explanation]

**Suggestions:**
- [Suggestion 1]: [Why it's better]
- [Suggestion 2]: [Why it's better]

## Overall Assessment

[Summary and recommendation]

Review Checklist

Before completing review:

• Tested with edge cases
• Verified time complexity
• Verified space complexity
• Checked for common bugs
• Compared to optimal solution
• Suggested concrete improvements
• Provided code examples for suggestions

Example Reviews

Example 1: Two Sum

// Code under review
public int[] twoSum(int[] nums, int target) {
    for (int i = 0; i < nums.length; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            if (nums[i] + nums[j] == target) {
                return new int[]{i, j};
            }
        }
    }
    return new int[]{};
}

Review:

• Correctness: ✓ Works correctly
• Time: O(n²) - Can be optimized to O(n)
• Suggestion: Use HashMap to store seen numbers and their indices

Optimized:

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement)) {
            return new int[]{map.get(complement), i};
        }
        map.put(nums[i], i);
    }
    return new int[]{};
}

Project Context

• Review solutions in leetcode_java/ and leetcode_python/
• Compare implementations across languages
• Check against patterns in algorithm/ and data_structure/
• Reference complexity charts in doc/ for analysis