Nested Array Frequencies — JavaScript Challenge | FineFrontend

Practice workspaceSign in

JavaScript/Nested Array Frequenciesmedium

00:00

Read here. Code on desktop. The coding workspace opens on screens 1024px and wider.

JavaScript interview question

Nested Array Frequencies

medium15 min

Write countFrequencies(values) to count how often each primitive value appears in a nested array. Return a new Map whose keys follow the order in which the values are first encountered during a depth-first, left-to-right traversal.

Requirements

Accept a finite, acyclic array whose entries are nested arrays or primitive leaves: strings, numbers, booleans, null, and undefined. Numbers may include NaN and infinities. Objects, functions, symbols, BigInt values, and cyclic arrays are outside this exercise.
Traverse every nesting level and count each leaf occurrence. Array containers and empty arrays do not become keys. A shared nested array is visited each time it occurs in the input.
Return a new Map from each distinct leaf to its positive integer frequency. Empty input, or input containing only empty arrays, returns an empty Map.
Use Map key equality (SameValueZero): 1 and '1' are distinct, false and 0 are distinct, all NaN values share one key, and -0 and 0 share one key. Keep null and undefined as distinct keys.
Keep keys in the order of their first occurrence during depth-first, left-to-right traversal. Updating an existing count must not change that order.
Skip sparse array holes, but count an explicit undefined entry. Leave the input and every nested array unchanged, including when arrays are frozen.
Traverse the arrays directly without flat() or flatMap(). Export countFrequencies from /index.js or /index.ts using the provided function signature.

Examples

Example 1

Input: Array.from(countFrequencies([1, [2, 1, ['a', 'a']], 2]))
Output: [[1, 2], [2, 2], ['a', 2]]

Example 2

Input: Array.from(countFrequencies([1, ['1', false, 0], 1, null, undefined]))
Output: [[1, 2], ['1', 1], [false, 1], [0, 1], [null, 1], [undefined, 1]]

Example 3

Input: Array.from(countFrequencies([[], [[]]]))
Output: []

countFrequencies(values) accepts one nested array and returns Map<FrequencyValue, number>. FrequencyValue is string | number | boolean | null | undefined. In TypeScript, NestedArray is a recursive read-only array interface, so mutable and frozen arrays can both be passed. The examples use Array.from(...) to display the returned Map as [value, count] pairs; the function itself must return a Map.

What the tests check

Empty input returns an empty Map
Unique flat values each have a count of one
Repeated flat values accumulate
Counts leaves across several nested branches
Counts leaves at different depths
The same value is counted across separate branches
Empty nested arrays contribute no leaves
Array containers are never frequency keys
Supports 300 nested array levels
Numbers and matching strings remain distinct keys
Booleans and numbers remain distinct keys
Null and undefined are counted as distinct leaves
Falsy leaves are never dropped
Object prototype names are ordinary string keys
Numeric-looking string keys retain their encounter order
New keys follow depth-first left-to-right order
Updating a count does not move the key
All NaN leaves use one Map key
Negative zero and zero share a Map key
Negative numbers, fractions, and infinities are valid keys
Sparse holes are skipped while explicit undefined is counted
The input and its nested array references stay unchanged
Frozen input arrays can be traversed without mutation
A shared acyclic branch is counted once per occurrence
Each call returns an independent new Map
Traverses nested arrays without flat or flatMap

References

Map Array.isArray()Array.prototype.forEach()

ArraysRecursionMapsRecursive traversalFrequency countingPrimitive key equalityImmutability

Back

Preparing your workspace…