Algorithms interview questions

Implement a function that checks whether a string of brackets is properly opened and closed in order.

Implement a function that returns whether two binary trees have identical structure and node values.

Implement a function that returns the maximum depth from root to leaf in a binary tree.

Implement a function that reverses the order of the bits in the binary representation of a number.

Implement bubble sort, repeatedly swapping adjacent out-of-order pairs until the array is sorted.

Implement a function that merges two sorted linked lists into a single sorted linked list.

Implement a function that counts the number of 1 bits in the binary representation of an integer.

Implement a function that checks whether an array contains any duplicate numbers.

Implement a function that returns the single missing number from a sorted sequence of integers.

Find the first failing version among 1..n where a monotonic isBad check flips from false to true — a boundary binary search using the fewest checks.

Implement a function that mirrors a binary tree by swapping the left and right children of every node.

Implement insertion sort by building the sorted portion one element at a time from the input.

Implement a function that reverses a singly linked list in place and returns the new head.

Implement a function that determines whether a person can attend every meeting given their time intervals.

Move all zeroes to the end of an array in place while keeping the non-zero elements in their original order.

Implement a function that computes the maximum profit obtainable from one buy and one sell of a stock.

Implement a function that finds two numbers in an array that add up to a given target.

Build a queue data structure supporting enqueue, dequeue, peek, and size in FIFO order.

Convert a Roman numeral string to its integer value, handling subtractive pairs like IV and IX.

Implement selection sort to order an array by repeatedly picking the smallest remaining element.

Build a stack data structure that supports the standard push, pop, peek, and size operations.

Implement a function that counts the distinct ways to climb to the top of a staircase taking one or two steps.

Implement a function that determines whether two strings are anagrams of each other.

Implement a function that returns whether a string reads the same forwards and backwards.

Maximize the value packed into a weight-limited knapsack when each item can be taken at most once — the classic 0/1 dynamic-programming table.

Return an array where each entry is the product of every element except the one at that index, without division and in O(n).

Implement binary search on a sorted array, returning the index of the target or -1 when absent.

Implement a function that returns the kth smallest value in a binary search tree.

Implement a function that finds the lowest common ancestor of two nodes in a binary search tree.

Build a binary tree data structure with the essential insert, traverse, and search operations.

Implement a function that returns the values of a binary tree grouped by level from top to bottom.

Implement a function that reconstructs a binary tree given its preorder and inorder traversal sequences.

Implement a function that determines whether one binary tree appears as a subtree of another.

Implement a function that returns an array of set-bit counts for every integer from 0 up to n.

Build a Bloom filter — a compact probabilistic set that answers membership with no false negatives but possible false positives, using a bit array and several hash functions.

Implement breadth-first traversal of a directed graph, visiting nodes level by level from a start vertex.

Implement a function that returns every unique combination of reusable candidates that sums to a target.

Implement a function that counts the number of distinct islands of connected cells in a 2D binary grid.

Sort integers without comparisons — counting sort tallies occurrences into buckets, and radix sort applies it digit by digit from the least significant.

Implement a function that decides whether a set of courses can be finished given their prerequisite pairs.

Implement a function that counts how many ways a digit string can be decoded into letters using a 1 to 26 mapping.

Implement a function that removes the nth-from-end node from a singly linked list in one pass.

Implement depth-first traversal of a directed graph, exploring each branch fully before backtracking.

Build a double-ended queue with constant-time push and pop at both the front and the back, backed by a doubly linked list.

Implement a function that returns the minimum number of intervals to remove so the remaining ones do not overlap.

Implement a function that counts the number of unique paths a robot can take from the top-left to bottom-right of an m by n grid.

Compute the minimum number of insertions, deletions, and replacements to turn one string into another — the Levenshtein distance via a 2D dynamic-programming table.

Implement a function that decides whether you can reach the last index of an array using each element as a max jump.

Raise a base to an integer exponent in logarithmic time using exponentiation by squaring, handling negative exponents.

Implement a function that locates a target integer in a sorted array that has been rotated at an unknown pivot.

Implement a function that returns the longest palindromic substring contained within a given string.

Implement a function that checks whether a target word can be traced through adjacent cells in a 2D character grid.

Compute the greatest common divisor with Euclid's algorithm and the least common multiple, for two numbers or a whole list.

Generate every well-formed combination of n pairs of parentheses by backtracking — add an open bracket while any remain, and a close bracket only while it stays balanced.

Implement a function that produces a deep copy of a connected, undirected graph given a reference node.

Implement a function that counts the number of connected components in an undirected graph given its edges.

Compute the integer square root — the floor of the real square root — using Newton's method, without Math.sqrt.

Implement a function that determines whether a given undirected graph forms a valid tree.

Build a singly linked list data structure with the standard insert, remove, and traversal operations.

Implement a function that detects whether a singly linked list contains a cycle.

Implement a function that returns the length of the longest subsequence common to two input strings.

Implement a function that returns the length of the longest run of consecutive integers found in an unsorted array.

Implement a function that returns the length of the longest strictly increasing subsequence in an array.

Implement a function that returns the length of the longest substring containing no duplicate characters.

Implement a function that finds the longest substring made of one repeated character allowing up to k swaps.

Implement a class that records timestamped writes and returns the most recent value at or before a queried timestamp.

Rotate an n×n matrix 90 degrees clockwise and return the result as a new array.

Implement a function that walks a 2D matrix in clockwise spiral order and returns the visited values.

Implement a function that zeroes out every row and column in a matrix that originally contained a zero, ideally in place.

Find the area of the largest all-ones square in a binary matrix, where each cell's square size is one more than the smallest of its top, left, and top-left neighbors.

Implement a function that finds the contiguous subarray with the largest product, handling negatives and zeros.

Implement a function that finds the contiguous subarray with the largest sum.

Implement a function that finds the maximum amount of water that can be trapped between two walls.

Implement a function that inserts a new interval into a sorted list and merges any resulting overlaps.

Implement a function that merges all overlapping intervals in a list and returns the consolidated set in sorted order.

Implement merge sort recursively by splitting the array and merging the sorted halves back together.

Implement a function that returns the fewest coins needed to make a target amount, or -1 when no combination works.

Implement a function that returns the fewest meeting rooms required to host a list of time intervals without conflicts.

Find the cheapest path from the top-left to the bottom-right of a grid, moving only right or down, by summing each cell with the smaller of the two ways to reach it.

Implement a function that returns the k most frequent integers in an array, breaking ties consistently.

Implement a function that computes the maximum money you can rob from a row of houses without picking two adjacent ones.

Implement a function that maximizes loot from houses arranged in a circle without robbing two adjacent ones.

Implement a function that returns every grid cell from which water can flow to both the Pacific and Atlantic oceans.

Split a string every possible way so that each piece is a palindrome — backtrack over cut positions, extending a piece only while it reads the same both ways.

Implement a function that counts every palindromic substring within a string, including overlapping occurrences.

Decide whether an array can split into two subsets with equal sums — a subset-sum dynamic-programming problem over half the total.

Generate every permutation and every subset of an array with the same backtracking template — choose, recurse, and undo.

List every letter string a phone number could spell, mapping each digit to its keypad letters and backtracking through the choices.

Test whether a number is prime and generate all primes up to n with the Sieve of Eratosthenes.

Build a FIFO queue out of two LIFO stacks — pour one stack into the other so the reversed order dequeues oldest-first in amortized constant time.

Implement quick sort recursively, partitioning around a pivot and sorting each side independently.

Find the k-th smallest element of an unsorted array in average linear time by partitioning, without fully sorting it.

Implement a function that sorts positioned canvas elements into natural left-to-right, top-to-bottom reading order.

Implement a function that groups misaligned 2D canvas elements into rows, then sorts them into a natural reading order.

Implement a function that reorders a singly linked list by interleaving nodes from the front and the reversed back half.

Search a matrix whose rows and columns are both sorted by walking a staircase from the top-right corner, eliminating a whole row or column at each step.

Implement a function that decides whether a string can be broken into a sequence of words from a given dictionary.

Implement a function that finds the minimum value in a sorted array that has been rotated at an unknown pivot.

Implement a function that groups an array of strings so anagrams of each other end up in the same bucket.

Implement a function that adds two integers using only bitwise operators, without using + or -.

Implement a function that schedules tasks with a cooldown between identical ones and returns the minimum total time.

Implement a Trie data structure supporting insert, exact word search, and prefix lookup operations.

Implement a function that returns every unique triplet of distinct indices whose values sum to zero.

Build a disjoint-set structure with near-constant-time union and find, using path compression and union by rank to keep the trees flat.

Implement a function that determines whether a binary tree satisfies the binary search tree ordering invariant.

Pick items at random in proportion to their weights using prefix sums and a binary search, with an injectable RNG so picks are testable.

Implement a data structure that supports adding words and searching with a wildcard character that matches any letter.

Build a binary search tree with insert, search, and delete operations preserving the BST invariant.

Implement a function that returns the maximum sum of node values along any path in a binary tree.

Implement functions that convert a binary tree to a string and reconstruct the same tree back from that string.

Implement Dijkstra's algorithm to compute shortest paths from a source vertex in a weighted graph.

Given words sorted in an unknown alphabet's order, reconstruct the alphabet.

Build a Fenwick tree for logarithmic prefix-sum queries and point updates, using the lowest-set-bit trick to walk responsibility ranges.

Implement a function that returns every word from a dictionary that can be traced through adjacent cells in a grid.

Implement a binary heap data structure supporting push, pop, peek, and heapify with the standard ordering invariant.

Implement heap sort by building a max-heap and repeatedly extracting the largest element.

Merge k pre-sorted singly-linked lists into one sorted list in O(n log k) time.

Find the median of two sorted arrays in logarithmic time by binary-searching for the partition that splits all the elements into equal halves.

Place N queens on an N×N board so none attack another — a classic backtracking search that places one queen per row and prunes column and diagonal conflicts.

Implement a data structure that ingests integers one at a time and reports the running median in logarithmic time.

Build an immutable list where every update returns a new version that shares unchanged nodes with the old one — structural sharing over a cons list.

Build a segment tree over an array for logarithmic range-sum queries and point updates, each tree node holding the aggregate of its slice.

Implement a function that returns the smallest window of a string that contains every character of another string.

Build a skip list — a sorted set layered with express lanes of linked lists so search, insert, and delete run in expected logarithmic time.

Fill a 9×9 Sudoku grid by backtracking — try each digit in the next empty cell, checking its row, column, and 3×3 box, and undo on a dead end.

Implement a function that returns a topological ordering of nodes in a directed acyclic graph.

Decide whether a string matches a pattern containing `?` (any single character) and `*` (any sequence) — a two-dimensional dynamic-programming match over string and pattern.