Google

Calculate the time complexity of a JavaScript algorithm containing sequential and nested loops.

Calculate the auxiliary space complexity of a JavaScript algorithm, including its recursion stack.

Replace repeated searches or computations with lookup-based preprocessing.

Compact a sorted array in place with read and write pointers.

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.

Find a maximum-sum contiguous subarray with Kadane's algorithm.

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.

Detect a string permutation using a frequency-constrained sliding window.

Compute trapped rainwater with two pointers and running boundary maxima.

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

Trace recursive calls and returns on a concrete input.

Implement merge sort using divide, solve, and combine steps.

Implement binary search for an exact target without boundary errors.

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

Search for a target in a rotated sorted array.

Use binary search on an answer space to compute an integer square root.

Implement insertion and deletion in a singly linked list.

Reverse a singly linked list in place with three pointers.

Find the middle node of a linked list with slow and fast 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.

Add numbers represented by reversed linked lists while propagating carry.

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

Validate nested delimiters with a stack.

Evaluate a reverse-Polish-notation expression with a stack.

Design a stack that returns its minimum element in constant time.

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.

Implement iterative depth-first traversal of a binary tree with an explicit stack.

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

Compute the maximum depth of a binary tree recursively.

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

Compute a binary tree's diameter with postorder information.

Validate a binary search tree using allowable value bounds.

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

Restore min-heap order after inserting an element.

Restore min-heap order after extracting the root.

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

Maintain the kth-largest element in a numeric stream with a heap.

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.

Model a backtracking solution as choices, constraints, and undo operations.

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.

Partition a string into palindromic substrings with backtracking.

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

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

Convert a memoized one-dimensional solution into bottom-up tabulation.

Reduce the space usage of a fixed-width one-dimensional recurrence.

Solve the non-adjacent maximum-sum problem with dynamic programming.

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

Count paths through a rectangular grid with dynamic programming.

Decide whether an array can be partitioned into equal-sum subsets with subset-sum dynamic programming.

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

Traverse a graph breadth-first while preventing repeated visits.

Traverse a graph depth-first while preventing repeated visits.

Count connected components in an undirected graph.

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

Produce a topological ordering with Kahn's algorithm.

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

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

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

Explain a brute-force approach and its bottleneck before presenting an optimized solution.

State and maintain the key invariant of an array or pointer-based solution.

Test a solution against empty, singleton, duplicate, and boundary-value inputs.

Solve an unfamiliar easy DSA problem within a 20-minute limit in JavaScript.

Solve a common-pattern medium DSA problem within a 35-minute limit in JavaScript.

Use an error log to select the next problem for deliberate practice.