java-python-code-reviewer

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