Grouping objects in a JavaScript array by category and counting them

Time complexity

During coding interviews, it's important to pay attention to time complexity. It's good to assess the time complexity of an algorithm before jumping into coding, and consider alternatives that might be better, while also not forgetting about space complexity too.

The time complexity of sorting is generally \$O(n \log n)\$. Counting unique elements can be done without sorting in \$O(n)\$, at the expense of additional space to store the counts. The additional space in this example can be at most \$O(n)\$, or possibly just \$O(1)\$, depending on more details about the possible inputs. Also an interesting discussion to have with the interviewer.

Loop over array elements using for..of

When the index of array elements is not needed, it's simpler to use for..of:

for (const ev of events) {
  categoryArray.push(ev.category);
}

Limit variables to the minimal necessary scope

The count variable is only needed in the loop body. So it's good to declare it in the initialization statement of the for loop, to avoid the mistake of accidentally using it outside of the loop.

for (let i = 0, count = 1; i < categoryArray.length; i++) {

Avoid unnecessary objects

Instead of:

let blankObject = { category: "", count: "" };
blankObject.category = categoryArray[i];
blankObject.count = count;
finalObjectArray.push(blankObject);

This is simpler:

finalObjectArray.push({
  category: categoryArray[i],
  count: count
});

Avoid type names in variable names

Including "Array" or "Object" in variable names doesn't make them easier to understand. These terms are very technical and overly specific to implementation details. It's better to use natural, simple, but descriptive terms, for example:

• categoryArray -> categories
• finalObjectArray -> categoryCounts

Use const

The problem description defines a const events = [ ... ]. This could have been a hint.

Variables that should not be reassigned should be declared with const, for example categoryArray.

Here's a one liner: events.reduce((m, x) => ({ ...m, [x.category]: (m[x.category] || 0) + 1 }), {})
– Jonah, CC BY-SA 4.0, 2022-07-26 04:09:26