Cosmic Module

1Java Concepts Used:
2│
3├── HashMap          → store frequency, index mapping
4├── HashSet          → detect duplicates, seen elements
5├── Integer cache    → be careful with == on Integer keys
6└── getOrDefault()   → clean frequency counting
7
8Patterns solved:
9└── Two Sum, Contains Duplicate, Valid Anagram,
10   Group Anagram, First Unique Character

1// Frequency map pattern
2Map<Character, Integer> freq = new HashMap<>();
3for (char c : s.toCharArray()) {
4    freq.put(c, freq.getOrDefault(c, 0) + 1);
5}

1Java Concepts Used:
2│
3├── Array indexing          → leftPointer, rightPointer
4├── while loop              → condition-based convergence
5├── char arithmetic         → 'a' - 'z' range checks
6└── String.toCharArray()    → convert string to char array
7
8Patterns solved:
9└── Valid Palindrome, Two Sum II, 3Sum, Container with Water

1Java Concepts Used:
2│
3├── HashMap/int[] freq array → character frequency
4├── char - 'a'              → index mapping (char arithmetic!)
5├── for loop + inner while   → expand/shrink window
6└── Math.max()              → track max window size
7
8Patterns solved:
9└── Longest Substring Without Repeat, Min Window Substring

1// char - 'a' trick (used in almost every window problem)
2int[] freq = new int[26];
3freq[c - 'a']++;  // maps 'a'=0, 'b'=1, ..., 'z'=25

1Java Concepts Used:
2│
3├── Deque<Integer> stack = new ArrayDeque<>()
4├── Queue<Integer> queue = new LinkedList<>()
5├── push/pop/peek for stack
6└── offer/poll/peek for queue
7
8Patterns solved:
9└── Valid Parentheses, Daily Temperatures, Next Greater Element

1Java Concepts Used:
2│
3├── Class with references    → TreeNode, ListNode definition
4├── Recursion + base case    → tree traversals
5├── Queue (BFS)              → level order traversal
6├── Stack (DFS)              → iterative DFS
7├── HashMap (visited set)    → cycle detection, visited nodes
8└── Reference sharing        → modifying tree nodes
9
10Patterns solved:
11└── Inorder/Preorder/Postorder, Level Order, Path Sum, Diameter

1// Standard TreeNode definition
2class TreeNode {
3    int val;
4    TreeNode left, right;
5    TreeNode(int val) { this.val = val; }
6}

1Java Concepts Used:
2│
3├── Recursion + base case     → all DP problems start here
4├── HashMap memoization       → top-down DP
5├── int[] / int[][] arrays    → bottom-up DP table
6├── Stack frames              → understanding recursion depth
7└── StackOverflowError        → signal for infinite recursion
8
9Patterns solved:
10└── Fibonacci, Climb Stairs, House Robber, Coin Change

1// Memoization template
2Map<Integer, Integer> memo = new HashMap<>();
3
4int solve(int n) {
5    if (n <= 1) return n;               // base case
6    if (memo.containsKey(n)) return memo.get(n);  // cached
7    int result = solve(n-1) + solve(n-2);
8    memo.put(n, result);
9    return result;
10}

1Java Concepts Used:
2│
3├── int mid = left + (right - left) / 2  → overflow-safe midpoint
4├── while loop                            → iterative binary search
5├── Arrays.binarySearch()                 → built-in (sorted arrays)
6└── int overflow awareness                → (left + right) can overflow!
7
8Patterns solved:
9└── Binary Search, Search Rotated Array, Find Peak Element

1// ALWAYS use this (not left+right/2 which overflows!)
2int mid = left + (right - left) / 2;

1Java Concepts Used:
2│
3├── char arithmetic            → 'A'=65, 'a'=97, '0'=48
4├── (char)(ch + 1)             → next character
5├── ch - 'a'                   → alphabet index (0-25)
6├── Character.isLetterOrDigit() → alphanumeric check
7├── Character.toLowerCase()    → case normalization
8├── StringBuilder              → building result strings
9├── s.toCharArray()            → iterate characters
10└── s.charAt(i)                → access character by index
11
12Patterns solved:
13└── Reverse String, Anagram Check, Palindrome, Valid Parentheses

1Java Concepts Used:
2│
3├── Arrays.sort()              → O(n log n) primitive arrays
4├── Collections.sort()         → List sorting
5├── Comparator lambda          → custom sort order
6├── PriorityQueue              → heap-based sorting / top-K
7└── Comparator.reverseOrder()  → descending order
8
9Patterns solved:
10└── Meeting Rooms, Merge Intervals, Top K Elements

1// Custom sort by second element of int[]
2Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
3
4// Min heap (Top K)
5PriorityQueue<Integer> minHeap = new PriorityQueue<>();
6
7// Max heap
8PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());

1// 1. Integer.MAX_VALUE and MIN_VALUE
2int max = Integer.MAX_VALUE;  // 2147483647
3int min = Integer.MIN_VALUE;  // -2147483648
4
5// 2. Swap without temp
6a = a ^ b;
7b = a ^ b;
8a = a ^ b;
9
10// 3. Check power of 2
11boolean isPow2 = (n & (n-1)) == 0;
12
13// 4. Get rightmost set bit
14int rightmost = n & (-n);
15
16// 5. Modulo for large numbers
17int result = (a + b) % MOD;
18
19// 6. Convert char to int
20int digit = c - '0';  // '5' -> 5
21
22// 7. Convert int to char
23char c = (char)('0' + digit);  // 5 -> '5'
24
25// 8. StringBuilder for result
26StringBuilder sb = new StringBuilder();
27sb.append(val);
28return sb.toString();