Algorithms interview questions

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 splits an array into groups of a given size, with the last group holding the remainder.

Implement a function that constrains a number to lie within an inclusive minimum and maximum range.

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.

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 checks whether a number lies within a half-open range, swapping bounds when needed.

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 computes the arithmetic mean of the numbers in an array.

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 builds an array of numbers from start up to end, stepping by a given increment.

Implement a function that builds an array of numbers from end down to start in descending order.

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

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.

Assign users to weighted experiment variants deterministically, with a traffic gate and independent buckets per experiment.

Tokenize and evaluate a math expression string with operator precedence, parentheses, and unary minus.

Add and multiply arbitrarily large non-negative integers given as decimal strings, using digit-by-digit schoolbook arithmetic with carries.

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

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

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.

Build a two-player Connect Four game where discs fall to the lowest empty slot and four-in-a-row wins.

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.

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.

Convert between Excel column titles and numbers in both directions — A is 1, Z is 26, AA is 27 — the classic bijective base-26 system with no zero digit.

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

Evaluate feature flags with targeting rules and a deterministic percentage rollout that stays sticky per user.

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.

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 counts the number of connected components in an undirected graph given its edges.

Parse and format ICU MessageFormat strings with plural, select, and nested argument substitution.

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.

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

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 sliding-window rate limiter that decides which task timestamps fit within the allowed quota.

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.

Convert between Roman numerals and integers in both directions, handling subtractive notation like IV, IX, and XL.

Implement run-length encoding: compress runs of repeated characters into count+char pairs, and decode them back.

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 lodash shuffle and sampleSize with an unbiased Fisher-Yates swap, taking an injectable RNG so shuffles are testable.

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

Implement a function that overwrites the style on a given text range and normalizes the resulting range list.

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.

Build a two-player tic-tac-toe game that detects wins and draws on a 3x3 board.

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.

Order distributed events with vector clocks, detecting whether two events are causal or concurrent.

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.

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

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

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

Build Minesweeper with flood-fill reveal, flagging, and win/lose detection.

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.

Transform concurrent insert and delete operations so replicas converge to the same text.

Implement a function that converts a list of styled text ranges into a canonical, properly nested HTML string.

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

Build a spreadsheet that recomputes dependent cells when inputs change and detects circular references.

Build a state-machine engine with events, guards, entry and exit actions, and context updates.

Implement a slice operation over text annotated with overlapping style ranges, preserving alignment.

Implement a function that replaces a text range and keeps the surrounding style ranges normalized.

Implement a function that patches shallow style objects over a text range without clobbering unrelated keys.

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.

Build a generalized tic-tac-toe game on an N x N board where M consecutive marks wins.

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.

Build the Wordle word-guessing game with row-by-row guesses and per-letter color feedback.