Array Methods interview questions

Implement findLast and findLastIndex — scan an array from the end for the last element matching a predicate.

Implement Array.prototype.myAt — return the element at a given index, supporting negative offsets from the end.

Implement Array.prototype.every — return false as soon as an element fails the predicate, true when empty.

Implement Array.prototype.filter from scratch as a method on the array prototype.

Implement Array.prototype.flat — flatten nested arrays to a given depth (default 1, Infinity for all levels), dropping holes.

Implement Array.prototype.forEach — run a callback on each element as (value, index, array), skipping sparse holes.

Implement Array.prototype.includes — test membership with SameValueZero so NaN matches, honoring negative fromIndex.

Implement Array.prototype.indexOf — first index of a value by strict equality, supporting a negative fromIndex.

Implement Array.prototype.some — return true as soon as any element passes the predicate, false when empty.

Implement a custom Array.prototype.square method that returns a new array with each value squared.

Implement a function that splits an array into groups of a given size, with the last group holding the remainder.

Implement a function that returns a new array with every falsy value stripped out.

Implement a function that consolidates rows sharing the same user into a single grouped record.

Implement a function that returns the elements from the first array that do not appear in the second.

Implement a function that drops trailing array elements as long as a predicate keeps returning truthy.

Implement a function that drops leading array elements as long as a predicate keeps returning truthy.

Implement a function that replaces array elements with a given value between an optional start and end index.

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

Implement a function that returns the index of the first array element matching a predicate, or -1 if none match.

Implement a function that returns the index of the last array element matching a predicate, or -1 if none match.

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

Implement a function that builds an object from an array of [key, value] pair tuples.

Implement a function that returns the unique values present in every input array.

Implement lodash keyBy — index a collection into an object keyed by an iteratee's return, keeping the last item for each key.

Implement Map.groupBy — group an iterable into a Map whose keys can be any value, preserving key insertion order.

Implement a function that returns the array element producing the largest value when run through an iteratee.

Implement a function that computes the arithmetic mean of the numbers in an array.

Implement a function that returns the array element producing the smallest value when run through an iteratee.

Implement nth — return the element at index n, counting from the end when n is negative, so head is nth(0) and last is nth(-1).

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.

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 take and takeWhile — grab the leading n elements, or the leading run that satisfies a predicate.

Implement times — invoke a function n times and collect the results into an array.

Implement a function that returns a new array with duplicate values removed while preserving original order.

Implement without — return a copy of an array with the given values excluded, matched by SameValueZero.

Implement Array.prototype.myConcat — merge arrays and values into a new array, spreading nested arrays one level deep.

Implement Array.prototype.find and findLast — return the first or last element matching a predicate, or undefined.

Implement Array.prototype.flatMap — map each element, then flatten the mapped results by one level.

Implement Array.prototype.myMap — return a new array with the callback applied to each element, skipping holes.

Implement Array.prototype.myReduce — fold an array down to one value, handling sparse arrays and missing initial values.

Implement Array.prototype.reduceRight — fold an array right-to-left, throwing on an empty array with no initial value.

Implement Array.prototype.splice — remove and insert elements in place, returning the removed ones, with clamped indices.

Implement a utility that conditionally joins class name arguments into a single space-separated string.

Implement a function that tallies how many array elements map to each key produced by an iteratee.

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

Implement a function that recursively flattens a nested array into a single-level array.

Implement a function that buckets array elements into an object keyed by the value an iteratee returns for each.

Implement the ES2023 change-by-copy trio — toSorted, toReversed, and with — that copy an array instead of mutating it.

Implement a function that intersects arrays by comparing values produced by an iteratee, keeping uniqueness.

Implement a function that intersects arrays using a user-supplied comparator to decide equality between elements.

Implement a function that applies an async mapper to every item in an array and resolves with the results.

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 orderBy — stably sort objects by multiple keys, each ascending or descending.

Implement partition — split an array into elements that pass a predicate and those that fail, in one pass.

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

Implement a function that returns unique values across input arrays using a custom iteratee to determine identity.

Implement a hook that manages an array along with helpers to push, remove, update, and clear items.

Implement zip, unzip, and zipObject — interleave arrays into tuples and back, padding ragged lengths.

Extend the classNames utility to dedupe class names and resolve function arguments lazily.

Implement a function that filters an array of row objects by a flexible field-and-condition specification.