java-python-code-reviewer

name	java-python-code-reviewer
description	Comprehensive code reviewer for Java and Python implementations focusing on correctness, efficiency, code quality, and algorithmic optimization. Reviews LeetCode solutions, data structures, and algorithm implementations. Use when reviewing code, checking solutions, or providing feedback on implementations.
allowed-tools	Read, Glob, Grep, LSP

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