Google

Build a frequency map to compare or group array and string elements.

Solve a complement-search problem with a one-pass hash map.

Build a prefix-sum array to answer immutable range-sum queries.

Count target-sum subarrays with prefix sums and a frequency map.

Compute each array element's product-except-self without division.

Validate a normalized palindrome with inward-moving pointers.

Find a target-sum pair in a sorted array with opposing pointers.

Find unique three-element target-sum combinations by sorting and scanning.

Compute a fixed-width window aggregate in linear time.

Find the longest substring without repeated characters using a variable window.

Define terminating base cases and shrinking state for a recursive function.

Trace recursive calls and returns on a concrete input.

Implement binary search for an exact target without boundary errors.

Find the first position satisfying a monotonic condition with boundary binary search.

Find the minimum feasible integer in a monotonic answer space with binary search.

Represent and traverse a singly linked list in JavaScript without losing the head reference.

Reverse a singly linked list in place with three pointers.

Detect a linked-list cycle with Floyd's algorithm.

Merge two sorted linked lists by relinking existing nodes.

Remove the nth node from the end with a one-pass pointer gap.

Implement an efficient FIFO queue in JavaScript using a head index.

Validate nested delimiters with a stack.

Find each element's next greater value with a monotonic stack.

Maintain a monotonic deque to find each sliding-window maximum.

Implement recursive depth-first traversal of a binary tree.

Perform level-order traversal of a binary tree with a queue.

Determine whether a binary tree is height-balanced with bottom-up height computation.

Validate a binary search tree using allowable value bounds.

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

Implement a comparator-based binary heap in JavaScript that supports insertion and root extraction.

Use a bounded heap to find the k most frequent elements.

Merge overlapping intervals after sorting their endpoints.

Remove the minimum number of intervals needed to eliminate overlaps with a greedy rule.

Schedule cooldown-constrained tasks using frequencies and a priority queue.

Generate every subset of a list with depth-first backtracking.

Generate every permutation of distinct values with used-state tracking.

Find target-sum combinations with pruning and controlled candidate reuse.

Search for a word in a character grid with in-place visited-state restoration.

Identify the state, recurrence, and base cases of a one-dimensional dynamic program.

Convert a recursive recurrence into a memoized top-down solution.

Solve the non-adjacent maximum-sum problem with bottom-up dynamic programming and constant extra space.

Compute the minimum number of coins for a target amount with dynamic programming.

Count paths through a rectangular grid with dynamic programming.

Build an adjacency-list representation of a directed or undirected graph.

Find shortest-path distances in an unweighted graph with breadth-first search.

Count connected regions in a binary grid with depth-first traversal and visited-state tracking.

Produce a topological ordering with Kahn's algorithm.

Classify an unfamiliar problem by its likely data-structure or algorithmic pattern.

Solve one unfamiliar array-or-hashing easy problem within 20 minutes in JavaScript.

Solve one unfamiliar linked-list, stack, or tree easy problem within 20 minutes in JavaScript.

Solve one common-pattern array or string medium problem within 35 minutes in JavaScript.

Solve one common-pattern tree, heap, or interval medium problem within 35 minutes in JavaScript.

Solve one common-pattern dynamic-programming or graph medium problem within 35 minutes in JavaScript.

Diagnose one failed timed solution, record the root cause, and re-solve it from a blank editor.

Complete a 45-minute mock interview by clarifying the problem, explaining an approach, coding it, testing it, and stating its complexity.