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:

java

// 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:

python

# 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:

markdown

## 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

java

// 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:

java

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

java-python-code-reviewer

NPX Install

Tags

SKILL.md Content

Java & Python Code Reviewer

When to use this Skill

Review Framework

1. Correctness Analysis

2. Time & Space Complexity

3. Code Quality - Java

4. Code Quality - Python

5. Algorithm Optimization

6. Comparison: Java vs Python

7. Review Output Format

Review Checklist

Example Reviews

Example 1: Two Sum

Project Context