🧠 DSA Animator

// int → String (3 ways)
String s = Integer.toString(42);
String s = String.valueOf(42);
String s = 42 + "";          // quick but slow

// String → int
int n = Integer.parseInt("42");
int n = Integer.valueOf("42");  // returns Integer (autoboxed)

// String → long/double
long l = Long.parseLong("123456789");
double d = Double.parseDouble("3.14");

// char → 0-based alphabet index
int idx = 'c' - 'a';          // 2
int idx = 'C' - 'A';          // 2

// char digit → int value
int d = '7' - '0';             // 7
int d = Character.getNumericValue('7'); // 7

// int → char
char c = (char)('a' + 2);      // 'c'
char c = (char)(65);            // 'A'  (ASCII)

// char → ASCII int
int ascii = (int)'A';           // 65

// String → char[]
char[] arr = s.toCharArray();

// char[] → String
String s = new String(arr);
String s = String.valueOf(arr);

// int[] → List<Integer>
List<Integer> list = Arrays.stream(arr)
    .boxed().collect(Collectors.toList());

// List<Integer> → int[]
int[] arr = list.stream()
    .mapToInt(Integer::intValue).toArray();

// int → binary/hex/octal string
Integer.toBinaryString(10);   // "1010"
Integer.toHexString(255);    // "ff"
Integer.toOctalString(8);    // "10"

// Sort int[] ascending
Arrays.sort(arr);

// Sort int[] descending — must use Integer[]
Integer[] boxed = Arrays.stream(arr).boxed()
    .toArray(Integer[]::new);
Arrays.sort(boxed, Collections.reverseOrder());

// Or: sort ascending, then reverse manually
Arrays.sort(arr);
for (int l=0,r=arr.length-1; l<r; l++,r--) {
    int tmp=arr[l]; arr[l]=arr[r]; arr[r]=tmp;
}

// Reverse a List
Collections.reverse(list);

Integer.MAX_VALUE    // 2^31 - 1  =  2,147,483,647
Integer.MIN_VALUE    // -2^31     = -2,147,483,648
Long.MAX_VALUE       // 2^63 - 1
Long.MIN_VALUE       // -2^63
Double.MAX_VALUE
Double.MIN_VALUE     // smallest positive (not most negative!)

// ⚠ OVERFLOW: Integer.MAX_VALUE + 1 wraps to MIN_VALUE!
// Safe add check:
boolean overflow = a > Integer.MAX_VALUE - b;

// Common safe "infinity" for DP/shortest path:
int INF = (int) 1e9;     // 1_000_000_000
int INF = Integer.MAX_VALUE / 2; // safe for addition

// ❌ Wrong — can overflow if lo+hi > MAX_VALUE
int mid = (lo + hi) / 2;

// ✅ Correct
int mid = lo + (hi - lo) / 2;

// ✅ Also correct (unsigned right shift)
int mid = (lo + hi) >>> 1;

// Long midpoint
long mid = lo + (hi - lo) / 2;

// Init DP array with "infinity"
Arrays.fill(dp, Integer.MAX_VALUE);   // ⚠ add carefully
Arrays.fill(dp, (int) 1e9);          // safer for addition

// Init 2D DP
for (int[] row : dp) Arrays.fill(row, (int) 1e9);

// Negative infinity (max-finding DP)
Arrays.fill(dp, Integer.MIN_VALUE);
Arrays.fill(dp, (int) -1e9);

Math.max(a, b)           // larger of two
Math.min(a, b)           // smaller of two
Math.abs(x)              // absolute value
Math.pow(base, exp)      // returns double! cast if needed
Math.sqrt(n)             // returns double
(int) Math.sqrt(n)        // integer square root

// Check if n is perfect square:
int sq = (int) Math.sqrt(n);
boolean isPerfect = sq * sq == n;

// Ceiling division (without float):
int ceil = (a + b - 1) / b;   // ceil(a/b) for positive b
int ceil = (int) Math.ceil((double) a / b);

Math.floor(d)            // rounds toward -∞
Math.ceil(d)             // rounds toward +∞
Math.round(d)            // rounds to nearest (ties → up)

Math.log(n)              // natural log (base e)
Math.log(n) / Math.log(2)  // log base 2
Math.log10(n)            // log base 10

// Number of digits in n (n > 0):
(int) Math.log10(n) + 1

// GCD using Math (Java 5+, not in older contest):
// Implement manually (see DSA Blocks section)

Math.PI                  // 3.14159...
Math.E                   // 2.71828...

Character.isDigit(c)          // '0'..'9'
Character.isLetter(c)         // a-z, A-Z (and Unicode)
Character.isLetterOrDigit(c)  // alphanumeric
Character.isAlphabetic(c)     // broader than isLetter
Character.isWhitespace(c)     // space, tab, newline
Character.isUpperCase(c)      // A-Z
Character.isLowerCase(c)      // a-z

// Fast inline check (ASCII only):
c >= 'a' && c <= 'z'   // lowercase letter
c >= 'A' && c <= 'Z'   // uppercase letter
c >= '0' && c <= '9'   // digit

Character.toUpperCase(c)      // 'a' → 'A'
Character.toLowerCase(c)      // 'A' → 'a'

// Bit-level case tricks (ASCII letters only):
c | ' '    // force lowercase  ('A'→'a', 'a'→'a')
c & '_'    // force uppercase  ('a'→'A', 'A'→'A')
c ^ ' '    // toggle case      ('a'↔'A')

// (' ' = 32 = 0b0010_0000, '_' = 95 = 0b0101_1111)

// Vowel check:
"aeiouAEIOU".indexOf(c) != -1
"aeiou".indexOf(Character.toLowerCase(c)) != -1

s.length()
s.charAt(i)                 // char at index i
s.substring(i)              // [i, end)
s.substring(i, j)           // [i, j) — j exclusive
s.indexOf("sub")            // first occurrence, -1 if not found
s.indexOf("sub", fromIdx)   // search starting at fromIdx
s.lastIndexOf("sub")        // last occurrence
s.contains("sub")           // boolean
s.startsWith("pre")         // boolean
s.endsWith("suf")           // boolean
s.isEmpty()                 // length == 0
s.isBlank()                 // all whitespace (Java 11+)

s.toLowerCase()
s.toUpperCase()
s.trim()                    // remove leading/trailing ASCII whitespace
s.strip()                   // Unicode-aware trim (Java 11+)
s.replace('a', 'b')         // all char replacements
s.replace("old", "new")     // all substring replacements
s.replaceAll("[^a-z]", "") // regex remove non-alpha
s.split(" ")               // split by space
s.split("\\s+")            // split by any whitespace
s.split(",", -1)           // -1 keeps trailing empty strings
String.join("-", list)      // join with delimiter
"ab".repeat(3)              // "ababab" (Java 11+)

s.equals(other)             // ✅ structural equality
s == other                  // ❌ reference equality (don't use)
s.equalsIgnoreCase(other)
s.compareTo(other)          // lexicographic: neg/0/pos
s.compareToIgnoreCase(other)

// Sort by canonical form (anagram grouping):
char[] arr = s.toCharArray();
Arrays.sort(arr);
String key = new String(arr);  // sorted key

// Sorted string == sorted other → anagrams
// Freq array as key (no sort needed):
int[] freq = new int[26];
for (char c : s.toCharArray()) freq[c-'a']++;
Arrays.toString(freq);       // use as HashMap key

StringBuilder sb = new StringBuilder();
sb.append("text");
sb.append(c);               // append char
sb.append(n);               // append int
sb.insert(idx, "text");     // insert at position
sb.delete(i, j);            // delete [i, j)
sb.deleteCharAt(i);
sb.replace(i, j, "new");    // replace range
sb.reverse();               // in-place reverse ← very useful!
sb.charAt(i);
sb.setCharAt(i, c);
sb.indexOf("text");
sb.length();
sb.toString();              // convert to String

// Chaining:
new StringBuilder(s).reverse().toString(); // reverse string

Arrays.sort(arr)                   // ascending, O(n log n)
Arrays.sort(arr, from, to)         // sort range [from, to)
Arrays.fill(arr, val)              // fill entire array
Arrays.fill(arr, from, to, val)    // fill range

// 2D array fill:
for (int[] row : grid) Arrays.fill(row, -1);

// Sort 2D array by first column:
Arrays.sort(intervals, (a, b) -> a[0] - b[0]);

Arrays.copyOf(arr, newLen)         // copy, pad/trim to newLen
Arrays.copyOfRange(arr, from, to)  // copy [from, to)
Arrays.equals(arr1, arr2)          // element-wise equality
Arrays.deepEquals(a, b)            // for 2D arrays
Arrays.toString(arr)               // "[1, 2, 3]" — debug print
Arrays.deepToString(grid)          // 2D print

// Clone array:
int[] copy = arr.clone();
int[] copy = Arrays.copyOf(arr, arr.length);

// Binary search (array MUST be sorted!):
int idx = Arrays.binarySearch(arr, key);
// Returns: index if found, else -(insertionPoint)-1
// Insertion point: if not found, idx = -(insertionPoint)-1
// So insertionPoint = -(idx+1)

// Stream operations:
Arrays.stream(arr).sum()
Arrays.stream(arr).min().getAsInt()
Arrays.stream(arr).max().getAsInt()
Arrays.stream(arr).average().getAsDouble()
Arrays.stream(arr).distinct().toArray()

// List from array (fixed-size!):
List<Integer> list = Arrays.asList(1, 2, 3);

Collections.sort(list)                    // natural order
Collections.sort(list, comparator)        // custom order
Collections.reverse(list)                 // reverse in-place
Collections.shuffle(list)                 // random shuffle
Collections.swap(list, i, j)              // swap two elements
Collections.rotate(list, dist)            // rotate right by dist

// Reverse comparator (for sort descending):
Collections.reverseOrder()                // Comparator
list.sort(Collections.reverseOrder());

Collections.min(list)
Collections.max(list)
Collections.min(list, comparator)
Collections.max(list, comparator)
Collections.frequency(list, element)      // count occurrences
Collections.disjoint(list1, list2)        // true if no common elements
Collections.nCopies(n, val)               // immutable list of n copies

Collections.emptyList()                   // immutable empty list
Collections.emptyMap()
Collections.emptySet()
Collections.singletonList(val)            // immutable 1-element list
Collections.unmodifiableList(list)        // read-only view

// Mutable list from array values:
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3));

// List.of (Java 9+, immutable):
List<Integer> list = List.of(1, 2, 3);

// Set.of / Map.of (Java 9+, immutable):
Set<Integer> s = Set.of(1, 2, 3);

map.put(key, val)
map.get(key)                         // null if missing
map.getOrDefault(key, 0)            // ← most common pattern
map.containsKey(key)
map.containsValue(val)
map.remove(key)
map.size()
map.isEmpty()
map.putIfAbsent(key, val)            // only if key not present
map.computeIfAbsent(key, k -> new ArrayList<>())
map.getOrDefault(key, defVal)
map.entrySet()                       // Set<Entry<K,V>>
map.keySet()                         // Set<K>
map.values()                         // Collection<V>

// Option 1: getOrDefault + put
map.put(key, map.getOrDefault(key, 0) + 1);

// Option 2: merge (cleanest)
map.merge(key, 1, Integer::sum);

// Option 3: computeIfAbsent for grouped lists
map.computeIfAbsent(key, k -> new ArrayList<>()).add(val);

// Iterate and process
for (Map.Entry<String, Integer> e : map.entrySet()) {
    String k = e.getKey();
    int v = e.getValue();
}

// Decrement and remove if zero:
map.merge(key, -1, Integer::sum);
if (map.get(key) == 0) map.remove(key);

Set<Integer> set = new HashSet<>();
set.add(val)
set.contains(val)                    // O(1)
set.remove(val)
set.size()

// Set from array:
Set<Integer> set = new HashSet<>(Arrays.asList(arr));

// Intersection:
set1.retainAll(set2);

// Union:
set1.addAll(set2);

// Difference:
set1.removeAll(set2);

// Visited pattern (BFS/DFS):
Set<Integer> visited = new HashSet<>();
if (!visited.contains(node)) { visited.add(node); ... }

// Min-heap (default) — smallest element at top
PriorityQueue<Integer> minPQ = new PriorityQueue<>();

// Max-heap — largest element at top
PriorityQueue<Integer> maxPQ = new PriorityQueue<>(
    Collections.reverseOrder());
// OR:
PriorityQueue<Integer> maxPQ = new PriorityQueue<>((a,b) -> b-a);

// PQ operations:
pq.offer(val)    // add (returns false if capacity exceeded)
pq.add(val)      // add (throws exception)
pq.poll()        // remove & return top (null if empty)
pq.peek()        // view top without removing
pq.size()
pq.isEmpty()

// Sort int[] by second element:
new PriorityQueue<>((a,b) -> a[1] - b[1]);

// Sort by frequency (ascending):
new PriorityQueue<>((a,b) -> freq.get(a) - freq.get(b));

// Sort by frequency desc, then value asc:
new PriorityQueue<>((a,b) -> {
    if (!freq.get(a).equals(freq.get(b)))
        return freq.get(b) - freq.get(a); // desc freq
    return a - b;                         // asc value
});

// Comparator.comparing chain:
Comparator.comparingInt((int[] a) -> a[0])
          .thenComparingInt(a -> a[1]);

// ⚠ Use Integer subtraction only when no overflow risk!
// Safe: Comparator.comparingInt(x -> x)

// Sort intervals by start time:
Arrays.sort(intervals, (a,b) -> a[0] - b[0]);

// Sort intervals by end time:
Arrays.sort(intervals, (a,b) -> a[1] - b[1]);

// Sort strings by length:
Arrays.sort(strs, (a,b) -> a.length() - b.length());
Arrays.sort(strs, Comparator.comparingInt(String::length));

// Sort by length then alphabetically:
Arrays.sort(strs, Comparator.comparingInt(String::length)
                            .thenComparing(Comparator.naturalOrder()));

// Largest Number (#179) — custom concat comparison:
Arrays.sort(strs, (a,b) -> (b+a).compareTo(a+b));

// Sort 2D by start asc, end desc:
Arrays.sort(arr, (a,b) -> a[0]!=b[0] ? a[0]-b[0] : b[1]-a[1]);

Deque<Integer> stack = new ArrayDeque<>();

stack.push(x)      // push to top   = addFirst
stack.pop()        // pop from top  = removeFirst  (throws if empty)
stack.peek()       // peek top      = peekFirst    (null if empty)
stack.isEmpty()

// ✅ Prefer ArrayDeque over Stack class
// Stack is synchronized (slow); ArrayDeque is not

Deque<Integer> queue = new ArrayDeque<>();
// OR: Queue<Integer> queue = new LinkedList<>();

queue.offer(x)     // enqueue (addLast)  — returns false if full
queue.add(x)       // enqueue            — throws if full
queue.poll()       // dequeue front      — null if empty
queue.remove()     // dequeue front      — throws if empty
queue.peek()       // view front         — null if empty
queue.isEmpty()

Deque<Integer> dq = new ArrayDeque<>();

dq.offerFirst(x)   // add to front
dq.offerLast(x)    // add to back
dq.pollFirst()     // remove from front
dq.pollLast()      // remove from back
dq.peekFirst()     // view front
dq.peekLast()      // view back

// Sliding window maximum (monotonic decreasing deque):
// Store indices; front = max of window
while (!dq.isEmpty() && nums[dq.peekLast()] < nums[i])
    dq.pollLast();              // remove smaller from back
dq.offerLast(i);
if (dq.peekFirst() <= i - k) dq.pollFirst(); // out of window

// Check if bit i is set (0-indexed from right):
(n >> i) & 1          // 1 if set, 0 if not
(n & (1 << i)) != 0   // boolean check

// Set bit i (force to 1):
n |= (1 << i);

// Clear bit i (force to 0):
n &= ~(1 << i);

// Toggle bit i (flip):
n ^= (1 << i);

// Update bit i to value v (0 or 1):
n = (n & ~(1 << i)) | (v << i);

// Get lowest set bit (isolate rightmost 1):
n & (-n)               // e.g. 12(1100) → 4(0100)
n & (~n + 1)           // same (two's complement)

// Clear lowest set bit (Kernighan's trick):
n &= (n - 1);          // removes one '1' per iteration

// Count set bits — Kernighan's O(k):
int count = 0;
while (n != 0) { n &= (n-1); count++; }

// Count set bits — Java built-in O(1):
Integer.bitCount(n);

// Check power of 2:
n > 0 && (n & (n-1)) == 0

// Highest one bit (floor power of 2):
Integer.highestOneBit(n);

// Multiply / divide by power of 2:
n << k    // n × 2^k
n >> k    // n ÷ 2^k  (arithmetic — preserves sign)
n >>> k   // n ÷ 2^k  (logical — fills with 0)

// Even / odd:
(n & 1) == 0   // even
(n & 1) == 1   // odd

// XOR swap (no temp variable):
a ^= b;  b ^= a;  a ^= b;

// Sign of integer:
n >> 31    // -1 if negative, 0 if non-negative

// Negate using bits (two's complement):
~n + 1    // same as -n

// Midpoint (no overflow):
(lo + hi) >>> 1

// XOR identity rules:
a ^ 0 == a        // unchanged
a ^ a == 0        // self-cancels ← key for Single Number
a ^ b ^ a == b    // associative + self-cancel

// Bitmask for subset of n bits:
(1 << n) - 1    // e.g. n=4 → 0b1111 = 15

// Enumerate all subsets of bitmask m:
for (int sub = m; sub > 0; sub = (sub-1) & m) { ... }

// All bits set for n-bit number:
(1 << n) - 1

// Check if exactly one bit set (power of 2):
Integer.bitCount(n) == 1

// Number of trailing zeros:
Integer.numberOfTrailingZeros(n)
Integer.numberOfLeadingZeros(n)

// 4-directional (up, right, down, left):
int[] dr = {-1, 0, 1, 0};
int[] dc = { 0, 1, 0, -1};

// Or as a single array (pairs: dr[d], dr[d+1]):
int[] dirs = {-1,0, 1,0, 0,-1, 0,1};

// 8-directional (includes diagonals):
int[] dr = {-1,-1,-1, 0, 0, 1, 1, 1};
int[] dc = {-1, 0, 1,-1, 1,-1, 0, 1};

// Usage:
for (int d = 0; d < 4; d++) {
    int nr = r + dr[d], nc = c + dc[d];
    if (nr >= 0 && nr < rows && nc >= 0 && nc < cols)
        // valid neighbor
}

// 2D → 1D index:
int idx = r * cols + c;

// 1D → 2D index:
int r = idx / cols;
int c = idx % cols;

// Transpose (swap [i][j] and [j][i]):
for (int i = 0; i < n; i++)
    for (int j = i+1; j < n; j++) {
        int tmp = mat[i][j];
        mat[i][j] = mat[j][i]; mat[j][i] = tmp;
    }

// Rotate 90° clockwise: transpose → reverse each row
// Rotate 90° counter-clockwise: transpose → reverse each col
// Rotate 180°: reverse each row → reverse each col

// Spiral traversal: 4 boundaries shrinking
int top=0, bot=m-1, left=0, right=n-1;
while (top <= bot && left <= right) {
    // traverse top row, right col, bottom row, left col
    top++; right--; bot--; left++;
}

// Diagonal traversal:
// Main diagonal: matrix[i][i]
// Anti-diagonal: matrix[i][n-1-i]
// All same diagonal: (r - c) is constant
// All same anti-diagonal: (r + c) is constant

// DFS on grid (4-dir):
void dfs(int[][] g, boolean[][] vis, int r, int c) {
    if (r<0||r>=g.length||c<0||c>=g[0].length||vis[r][c]) return;
    vis[r][c] = true;
    dfs(g,vis,r-1,c); dfs(g,vis,r+1,c);
    dfs(g,vis,r,c-1); dfs(g,vis,r,c+1);
}

// GCD — Euclidean O(log min(a,b))
int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

// LCM (use long to avoid overflow)
long lcm(long a, long b) {
    return a / gcd((int)a, (int)b) * b;
}

// Is prime — O(√n)
boolean isPrime(int n) {
    if (n < 2) return false;
    for (int i = 2; (long)i*i <= n; i++)
        if (n % i == 0) return false;
    return true;
}

// Count digits in n (n > 0):
(int) Math.log10(n) + 1
String.valueOf(n).length()  // simpler

// Returns index of smallest element (rotation point)
int findPivot(int[] nums) {
    int lo = 0, hi = nums.length - 1;
    while (lo < hi) {
        int mid = lo + (hi - lo) / 2;
        if (nums[mid] > nums[hi]) lo = mid + 1;
        else                       hi = mid;
    }
    return lo;  // index of minimum
}

// After finding pivot p:
// Left sorted  portion: [0, p-1]
// Right sorted portion: [p, n-1]
// Standard binary search on the correct half

// String palindrome (two pointers):
boolean isPalin(String s) {
    int l = 0, r = s.length() - 1;
    while (l < r)
        if (s.charAt(l++) != s.charAt(r--)) return false;
    return true;
}

// Integer palindrome (no string):
boolean isPalinNum(int x) {
    if (x < 0 || (x % 10 == 0 && x != 0)) return false;
    int rev = 0;
    while (x > rev) { rev = rev*10 + x%10; x /= 10; }
    return x == rev || x == rev/10;
}

// Expand around center (longest palindrome):
int expand(String s, int l, int r) {
    while (l>=0 && r<s.length() && s.charAt(l)==s.charAt(r))
        { l--; r++; }
    return r - l - 1; // length
}

// ListNode (Linked List)
static class ListNode {
    int val;
    ListNode next;
    ListNode(int v) { val = v; }
}

// TreeNode (Binary Tree)
static class TreeNode {
    int val;
    TreeNode left, right;
    TreeNode(int v) { val = v; }
}

// TrieNode
static class TrieNode {
    TrieNode[] children = new TrieNode[26];
    boolean isEnd;
}

// Graph node (Clone Graph)
static class Node {
    int val;
    List<Node> neighbors = new ArrayList<>();
    Node(int v) { val = v; }
}

final int MOD = (int) 1e9 + 7; // common modulus

// Modular exponentiation O(log exp):
long modPow(long base, long exp, long mod) {
    long result = 1;
    base %= mod;
    while (exp > 0) {
        if ((exp & 1) == 1) result = result * base % mod;
        base = base * base % mod;
        exp >>= 1;
    }
    return result;
}

// Safe modular addition:
(int)(((long) a + b) % MOD)

// Safe modular multiplication:
(int)((long) a * b % MOD)

int[] parent, rank;

void init(int n) {
    parent = new int[n]; rank = new int[n];
    for (int i = 0; i < n; i++) parent[i] = i;
}
int find(int x) {           // path compression
    return parent[x] == x ? x : (parent[x] = find(parent[x]));
}
boolean union(int x, int y) { // union by rank
    int px = find(x), py = find(y);
    if (px == py) return false;
    if (rank[px] < rank[py]) { int t=px; px=py; py=t; }
    parent[py] = px;
    if (rank[px] == rank[py]) rank[px]++;
    return true;
}

// By length (ascending):
Arrays.sort(arr, (a,b) -> a.length() - b.length());

// By length descending:
Arrays.sort(arr, (a,b) -> b.length() - a.length());

// By length, then alphabetically (tie-break):
Arrays.sort(arr, Comparator.comparingInt(String::length)
                            .thenComparing(Comparator.naturalOrder()));

// Largest number concatenation (#179):
Arrays.sort(arr, (a,b) -> (b+a).compareTo(a+b));

// Case-insensitive alphabetical:
Arrays.sort(arr, String.CASE_INSENSITIVE_ORDER);

// By first column ascending:
Arrays.sort(arr, (a,b) -> a[0] - b[0]);

// By end time, then start time desc:
Arrays.sort(arr, (a,b) ->
    a[1] != b[1] ? a[1] - b[1] : b[0] - a[0]);

// Sort List<int[]>:
list.sort((a,b) -> a[0] - b[0]);

// Sort by absolute value:
Arrays.sort(arr, (a,b) -> Math.abs(a) - Math.abs(b));

// Reverse natural order:
Arrays.sort(arr, Collections.reverseOrder()); // Integer[] only
list.sort(Comparator.reverseOrder());

// ❌ OVERFLOW: use only when values safely fit in int
(a, b) -> a - b                // wrong if a=-2B, b=+2B

// ✅ Safe alternatives:
Integer.compare(a, b)          // returns -1, 0, or 1
Comparator.comparingInt(x -> x)
(a, b) -> a < b ? -1 : (a > b ? 1 : 0)

// ❌ Wrong for negative numbers mod:
a % n                          // Java: -7 % 3 = -1, not 2
// ✅ Always positive modulo:
((a % n) + n) % n

TreeMap<Integer,Integer> map = new TreeMap<>();

map.firstKey()              // smallest key
map.lastKey()               // largest key
map.floorKey(k)             // greatest key ≤ k  (null if none)
map.ceilingKey(k)           // smallest key ≥ k  (null if none)
map.lowerKey(k)             // greatest key < k
map.higherKey(k)            // smallest key > k
map.headMap(k)              // view of keys < k
map.tailMap(k)              // view of keys ≥ k
map.subMap(lo, hi)          // view of keys in [lo, hi)
map.pollFirstEntry()        // remove & return smallest
map.pollLastEntry()         // remove & return largest

// Descending order:
new TreeMap<>(Collections.reverseOrder())

TreeSet<Integer> ts = new TreeSet<>();
ts.floor(x)                 // greatest ≤ x
ts.ceiling(x)               // smallest ≥ x
ts.lower(x)                 // greatest < x
ts.higher(x)                // smallest > x
ts.first()                  // min element
ts.last()                   // max element
ts.subSet(lo, hi)           // [lo, hi)
ts.headSet(hi)              // < hi
ts.tailSet(lo)              // ≥ lo

// LinkedHashMap — insertion order preserved:
Map<K,V> lhm = new LinkedHashMap<>();

// LinkedHashMap access-order (LRU Cache):
new LinkedHashMap<>(capacity, 0.75f, true); // true=access-order

// 26 lowercase letters:
int[] freq = new int[26];
for (char c : s.toCharArray()) freq[c - 'a']++;

// 52 letters (upper + lower):
int[] freq = new int[52];
idx = c>='a' ? c-'a' : c-'A'+26;

// 10 digits:
int[] freq = new int[10];
for (char c : s.toCharArray()) freq[c - '0']++;

// 128 ASCII:
int[] freq = new int[128];
for (char c : s.toCharArray()) freq[c]++;

// Check two freq arrays equal:
Arrays.equals(freq1, freq2)

// Unweighted undirected:
List<List<Integer>> adj = new ArrayList<>();
for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
for (int[] e : edges) {
    adj.get(e[0]).add(e[1]);
    adj.get(e[1]).add(e[0]); // omit for directed
}

// Weighted: List<List<int[]>> where int[]{neighbor, weight}
List<List<int[]>> adj = new ArrayList<>();
for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
adj.get(u).add(new int[]{v, w});

// In-degree array (for Kahn's topo sort):
int[] inDeg = new int[n];
for (int[] e : edges) inDeg[e[1]]++;

// 1D DP:
int[] dp = new int[n + 1];         // zeros
int[] dp = new int[n + 1];
Arrays.fill(dp, Integer.MAX_VALUE); // infinity
dp[0] = 0;                          // base case

// 2D DP:
int[][] dp = new int[m + 1][n + 1];
for (int[] row : dp) Arrays.fill(row, (int) 1e9);

// Memoization (top-down):
int[] memo = new int[n];
Arrays.fill(memo, -1);             // -1 = uncomputed

// Boolean DP:
boolean[] dp = new boolean[n + 1];
dp[0] = true;                       // base: empty subset

// Find minimum:
int ans = Integer.MAX_VALUE;
ans = Math.min(ans, candidate);

// Find maximum:
int ans = Integer.MIN_VALUE;
ans = Math.max(ans, candidate);

// Count valid items:
int count = 0; count++;

// Collect results:
List<List<Integer>> res = new ArrayList<>();
res.add(new ArrayList<>(current));    // snapshot!

// Global variable for DFS/recursion:
int[] ans = {0};                      // int[] tricks lambda
// OR: use instance variable / int field

// Two-variable result:
int[] res = {start, end};
return new int[]{min, max};

// Integer.parseInt can throw NumberFormatException!
try { int n = Integer.parseInt(s); }
catch (NumberFormatException e) { /* handle */ }

// Parse with radix:
Integer.parseInt("FF", 16)     // hex → 255
Integer.parseInt("1010", 2)  // binary → 10

// Convert to different base:
Integer.toString(255, 16)     // "ff"
Integer.toString(10, 2)       // "1010"

// Null-safe comparison:
Objects.equals(a, b)           // handles null

// Autoboxing pitfall:
Integer a = 1000, b = 1000;
a == b    // ❌ false (reference compare above 127!)
a.equals(b) // ✅ true