Mastering Algorithms and Leetcode

Rewrite an interview problem as explicit inputs, outputs, constraints, and required behavior.

Construct representative, boundary, and adversarial test cases from a problem statement.

Trace an algorithm on a small example and identify a property that remains true after each step.

Determine the time complexity of algorithms containing sequential and nested loops.

Compare common complexity classes against input constraints to eliminate infeasible approaches.

Determine the auxiliary space complexity of an algorithm, including its growing data structures.

Evaluate a TypeScript implementation for Array, Map, and Set operation costs, Number precision, and BigInt compatibility.

Present a solution as a progression from brute force to bottleneck identification to optimization, and justify the optimized approach with a practical correctness argument.

Use a Set to detect repeated or previously encountered values in a single pass.

Apply frequency counting to solve lookup and comparison problems in linear time.

Use a value-to-index map to solve a complement-lookup problem in linear time.

Transform strings into canonical keys for grouping equivalent items.

Build a one-dimensional prefix-sum array and answer range-sum queries.

Modify an array in place while preserving the portion that has already been processed.

Traverse a matrix without omitting or revisiting cells at its boundaries.

Use inward-moving pointers to find a target pair in a sorted array.

Use same-direction pointers to compact or deduplicate an array in place.

Maintain a fixed-size sliding window using a rolling aggregate.

Maintain a variable-size window when expanding and shrinking have monotonic effects.

Maintain character frequencies and a satisfaction count inside a sliding window.

Find a minimum valid substring window by tracking fulfilled requirements.

Partition an array into regions around a chosen condition using pointers.

Choose between hashing, two pointers, and a sliding window from a problem's constraints.

Use TypeScript sort comparators and stable multi-key ordering correctly for numbers and tuples.

Explain when sorting can replace a more complicated search with a structured scan.

Implement iterative binary search for an exact value without boundary errors.

Implement lower-bound search for the first position satisfying an ordered condition.

Implement upper-bound search for the first position beyond a target value.

Search a rotated sorted array by identifying which half remains ordered.

Search a row-and-column sorted matrix by eliminating one row or column per comparison.

Binary-search the answer when feasibility changes monotonically across candidate values.

Implement insertion, deletion, and traversal for a singly linked list in TypeScript.

Use a dummy node to simplify linked-list operations at the head.

Reverse a singly linked list iteratively while preserving the unprocessed suffix.

Use slow and fast pointers to detect a cycle in a linked list.

Use a stack to validate properly nested delimiters.

Design an array-backed queue with constant-time amortized removal by maintaining a head index.

Use a monotonic stack to find the next greater or smaller element for every position.

Evaluate postfix expressions using an explicit operand stack.

Define a recursive function using an explicit state, base case, and progress step.

Trace recursive calls and returns using a call tree.

Estimate the call count, maximum recursion depth, and stack-space cost of a recursive search, including JavaScript stack-overflow risk.

Generate all subsets of a set using choose-or-skip recursion.

Generate all permutations while tracking which choices have already been used.

Generate combinations while preventing duplicate orderings.

Prune a backtracking search as soon as a partial candidate violates a constraint.

Restore mutable state correctly after exploring each backtracking branch.

Represent a binary tree in TypeScript and identify leaf, depth, height, and subtree relationships.

Traverse a binary tree with recursive preorder, inorder, and postorder depth-first search.

Traverse a binary tree level by level using a queue.

Compute a tree property such as height by combining the results returned from its children.

Validate a binary search tree by propagating permissible value bounds.

Find the lowest common ancestor of two nodes in a binary tree.

Implement a binary min-heap with insertion and extraction in TypeScript.

Use a bounded heap to retain the k largest or smallest items from a stream.

Convert relationship data into an adjacency-list graph representation.

Perform breadth-first search and record shortest distances in an unweighted graph.

Perform recursive depth-first search while using a visited set to prevent cycles.

Count connected components in a grid by treating neighboring cells as graph edges.

Detect a cycle in an undirected graph using parent-aware traversal.

Detect a cycle in a directed graph using node visitation states.

Produce a topological ordering of a directed acyclic graph using indegrees.

Compute shortest paths with nonnegative edge weights using Dijkstra's algorithm and a heap.

Identify the local choice and the property that would make it safe in a candidate greedy solution.

Validate a proposed greedy rule with an intuitive exchange argument or refute it with a counterexample.

Merge overlapping intervals after sorting by start position.

Select a maximum-size set of nonoverlapping intervals by earliest finishing time.

Determine the minimum concurrent resources required for a set of time intervals.

Solve a reachability problem by maintaining the farthest position reached so far.

Implement disjoint-set union with path compression and union by size.

Use disjoint-set union to determine whether adding an edge creates a cycle.

Identify the state, transition, base cases, and evaluation order of a dynamic program.

Convert a repeated recursive subproblem into top-down memoization.

Convert a memoized recurrence into bottom-up tabulation.

Reduce a dynamic program's memory when each state depends only on recent states.

Solve a one-dimensional take-or-skip optimization problem.

Solve a grid path-counting or minimum-cost problem with tabulation.

Solve a subset-sum decision problem with zero-one dynamic programming.

Compute the longest common subsequence of two strings with two-dimensional dynamic programming.

Use quickselect to find an order statistic without fully sorting the input.

Merge multiple sorted sequences using a heap of current candidates.

Use a monotonic deque to compute extrema over every fixed-size window.

Build a trie that supports insertion, exact lookup, and prefix lookup.

Use multi-source breadth-first search to model simultaneous expansion.

Explain how bitwise operators behave on JavaScript numbers and use them to set, clear, toggle, and check individual bits.

Represent a small set of Boolean choices as a bitmask and enumerate its subsets.

Combine a trie with backtracking to prune a board-based word search.

Solve an unseen Medium array or string problem without being told whether hashing, two pointers, prefix sums, or sliding windows is appropriate.

Solve an unseen Medium ordered-data or interval problem by selecting among sorting, binary search, heaps, and greedy sweeps.

Solve an unseen Medium linked-list, stack, or tree problem by defining the state preserved during pointer movement or traversal.

Solve an unseen Medium graph problem by constructing the graph and selecting an appropriate traversal, ordering, shortest-path, or connectivity method.

Solve an unseen Medium combinatorial problem by choosing between backtracking and dynamic programming and defining its state.

Repair a flawed TypeScript solution by locating a modeling, algorithmic, complexity, numeric, or data-structure error and verifying the fix with edge cases.

Complete a mock interview by clarifying, implementing, testing, and explaining a Medium problem within 45 minutes.

Decompose a selected LeetCode Hard problem into previously learned component patterns before attempting implementation.