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