🗺️ 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.