🗺️ Problem Map

Pattern: Hash Table - Use hash map to store complements for O(n) lookup

Pattern: Hash Table / Set - Use a HashSet/Unordered Set to track seen numbers.

Pattern: Hash Table, Frequency Counter - Use a Hash Map to count input string frequencies in O(N), then lookup queries in O(1).

Pattern: Linear Traversal / Simple Scan - Initialize a variable to the smallest possible value and iterate through the array, updating the maximum value encountered.

Pattern: Summation/XOR Logic - Use the arithmetic series formula (N*(N+1)/2) to find the expected sum, and subtract the actual sum of the array elements to find the missing number.

Pattern: Conditional Summation - Use a single linear pass to check each element's parity and accumulate separate sums for odd and even numbers.

Pattern: Cycle Detection (Floyd's Tortoise and Hare) - Treat the array as a linked list where the index i points to the value nums[i]. A duplicate creates a cycle.

Pattern: Frequency Counting / Hashing - Use a hash map to count the occurrences of each number. Then, iterate through the map to find the counts of required numbers.

Pattern: Geometry / Inequality Rule - Check the triangle inequality theorem: the sum of the lengths of any two sides of a triangle must be greater than the length of the third side.

Pattern: Conditional Logic / Switch - Read two numbers and a character operator. Use conditional logic (if/else or switch) to perform the correct operation.

Pattern: Sequence Check / Difference - Calculate the difference between the first two elements. Then, iterate through the rest of the array, checking if the difference between all consecutive pairs is constant.

Pattern: Iteration / Recursion - Use an iterative loop starting from 1 up to N, multiplying the result at each step. Must handle data type overflow for large N.

Pattern: Arithmetic Series Formula - Use Gauss's formula, $S = rac{N(N+1)}{2}$, to calculate the sum in constant time.

Pattern: Streaming Input / 1D Array Simulation - Calculate Row Sums by streaming and Column Sums using an auxiliary 1D array.

Pattern: Index-based Traversal / Conditionals - Iterate through the matrix and only sum elements where the row index (i) is greater than or equal to the column index (j), i.e., i >= j.

Pattern: Range Query / 2D Prefix Sum (Optimized) - Brute force sum for small N (O(N^2)) or 2D Prefix Sum for optimization (O(1) query).

Pattern: Basic Nested Loops - Use two nested loops (i for rows, j for columns). For Hollow, add a conditional check for boundaries.

Pattern: Symmetry Combination - Print the pattern in two halves: the increasing part (top) and the decreasing part (bottom).

Pattern: Row-Index Dependent Printing - Use the row index (i) to determine the number of characters or spaces to print in the inner loop.

Pattern: Index-based Conditional Traversal - Iterate through the string index and check the parity (i % 2) of the index to route the character to the odd or even result string.

Pattern: Character Type Check - Iterate through the string and use a built-in character method (e.g., isdigit() or Character.isDigit()) to check if every character is a numerical digit.

Pattern: Boolean Array / Frequency Hashing - Use a fixed-size boolean array (size 26) to mark the presence of each letter (a-z) encountered during a single pass.

Pattern: Character Set Check - Use a predefined set (HashSet in Java/C++, set in Python) of vowels for fast O(1) lookups during a single string traversal.

Pattern: Run-Length Encoding / Two Pointers - Use a two-pointer approach (read pointer and write pointer) to count consecutive identical characters and replace the sequence with the character followed by the count.

Pattern: Word Traversal / Stack / Two Pointers - Split the string into words, then process the list of words in reverse order, ignoring extra spaces. Or, use two pointers to reverse each word in-place, then reverse the entire string.

Pattern: Two Pointers / Filtering - Use two pointers (one at start, one at end). Move pointers inward, skipping non-alphanumeric characters. Compare the characters after converting them to the same case.

Pattern: Conditional Traversal / Hash Map Lookup - Iterate through the string from left to right. If the current symbol's value is less than the next symbol's value, subtract it; otherwise, add it.

Pattern: Two-Pass Hashing / Frequency Count - Use a two-pass approach: 1) Count frequencies in a Hash Map. 2) Iterate through the string again and return the index of the first character with a count of 1.

Pattern: Greedy Lookup / Paired Hash Map - Use a lookup table of Roman values and symbols, sorted from largest to smallest. Greedily subtract the largest possible value until the integer reaches zero.

Pattern: Stack / Hash Map Lookup - Use a Stack to store opening brackets. Use a Hash Map for O(1) lookup to find the matching opener when a closing bracket is encountered.

Pattern: In-Place Transpose & Reverse - To achieve a 90-degree clockwise rotation in-place, first transpose the matrix (swap A[i][j] with A[j][i]), and then reverse each row.

Pattern: Index Grouping - Elements on the same anti-diagonal share the same sum of indices (i + j). Group elements by this sum and process the groups.

Pattern: Boundary Pointers - Use four pointers (top, bottom, left, right) to define boundaries. Iterate through the four sides, shifting the boundaries inward after each pass.

Pattern: Digit Traversal (Modulo/Division) - Use a while loop that continues while N > 0. Inside the loop, extract the last digit (N % 10) and update N (N /= 10).

Pattern: Euclidean Algorithm - Use the efficient Euclidean Algorithm, which relies on the property: GCD(a, b) = GCD(b, a % b).

Pattern: Digit Reversal and Power Summation - Both require reversing the digits. For Palindrome, check if the original number equals the reversed number. For Armstrong, check if the original number equals the sum of its digits raised to the power of the total digit count.

Pattern: Backtracking / DFS - Use a recursive function to explore all possibilities. At each element, make a choice: 1) Include the element and recurse. 2) Exclude the element and recurse. Backtrack by removing the element.

Pattern: Backtracking / State Management - Use a recursive function. At each step, iterate through the elements not yet included in the current permutation. This requires tracking the state of which numbers are used.

Pattern: Bit-Manipulation (Masking) - A positive integer N is a power of two if and only if N has exactly one bit set to 1. The bitwise trick N & (N - 1) clears the rightmost set bit.

Pattern: Bit-Manipulation (XOR) - Utilize the XOR property A ^ A = 0 and A ^ 0 = A. XORing all elements in the array will cancel out all paired numbers, leaving only the unique single number.