Codestin Search App

Group By - Problem

JavaScript Medium

Group By Array Enhancement

Your task is to enhance the JavaScript Array prototype by implementing a groupBy(fn) method that can be called on any array. This method should transform the array into a grouped object based on a provided callback function.

How it works:
• The callback function fn takes each array element and returns a string key
• Elements with the same key are grouped together in arrays
• The result is an object where keys are the function outputs and values are arrays of original elements
• The order within each group should match the original array order

Example:
[1, 2, 3].groupBy(x => x > 1 ? 'big' : 'small')
Returns: {'small': [1], 'big': [2, 3]}

Note: You cannot use lodash's _.groupBy function

Input & Output

example_1.js — Basic Even/Odd Grouping

$ Input: arr = [1, 2, 3, 4, 5] fn = x => x % 2 === 0 ? 'even' : 'odd'

› Output: {'odd': [1, 3, 5], 'even': [2, 4]}

💡 Note: Elements are grouped by whether they are even or odd. The order within each group matches the original array order.

example_2.js — String Length Grouping

$ Input: arr = ['apple', 'bat', 'car', 'elephant', 'dog'] fn = str => str.length.toString()

› Output: {'5': ['apple'], '3': ['bat', 'car', 'dog'], '8': ['elephant']}

💡 Note: Strings are grouped by their length. 'apple' has 5 characters, 'bat', 'car', and 'dog' each have 3 characters, and 'elephant' has 8 characters.

example_3.js — Object Property Grouping

$ Input: arr = [{age: 25, name: 'Alice'}, {age: 30, name: 'Bob'}, {age: 25, name: 'Charlie'}] fn = person => person.age.toString()

› Output: {'25': [{age: 25, name: 'Alice'}, {age: 25, name: 'Charlie'}], '30': [{age: 30, name: 'Bob'}]}

💡 Note: Objects are grouped by the 'age' property. Alice and Charlie are both 25, so they're in the same group, while Bob is 30 and in his own group.

Constraints

1 ≤ array.length ≤ 10⁵
The callback function will always return a string
Array elements can be of any type (numbers, strings, objects, etc.)
The callback function is pure (no side effects)
Keys in the result object can be in any order
Values within each group must maintain original array order

Visualization

Tap to expand

Understanding the Visualization

Receive Mail Batch

Start with a collection of letters (array elements) to sort

Read Address

For each letter, read the address (apply callback function) to determine destination

Find/Create Mailbox

Look for existing mailbox with that street name (hash map lookup) or create new one

Place Letter

Put the letter in the appropriate mailbox (add element to group array)

Repeat Process

Continue until all letters are sorted into their respective mailboxes

Key Takeaway

🎯 Key Insight: Hash maps provide O(1) average lookup time, making group operations incredibly efficient compared to searching through arrays linearly.

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a hash map (JavaScript object) to achieve O(n) time complexity with a single pass through the array. The key insight is leveraging JavaScript's object property access for O(1) key lookups, avoiding the need to search through existing keys. This approach is both time and space efficient while maintaining the required ordering.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Map (Optimal)	O(n)	O(n)	Use object property lookup for instant key checking
Brute Force (Object Property Search)	O(n²)	O(n)	Check all existing keys for each element

One-Pass Hash Map (Optimal) — Algorithm Steps

Create an empty result object
Iterate through each element in the array
Apply the callback function to get the grouping key
Use object property access to check if key exists (O(1) operation)
If key exists, push element to existing array; otherwise create new array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Hash Map

Create empty object to store groups

Process Each Element

Apply callback function and get grouping key

Instant Key Lookup

Use hash table for O(1) key existence check

Add to Group

Append element to existing group or create new one

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_GROUPS 100
#define MAX_GROUP_SIZE 1000
#define MAX_KEY_LENGTH 50
#define HASH_SIZE 101

typedef struct Group {
    char key[MAX_KEY_LENGTH];
    int values[MAX_GROUP_SIZE];
    int count;
    struct Group* next;
} Group;

// Simple hash function
unsigned int hash(const char* key) {
    unsigned int hash = 0;
    while (*key) {
        hash = (hash << 5) + *key++;
    }
    return hash % HASH_SIZE;
}

void groupBy(int* arr, int size, Group* hashTable[]) {
    for (int i = 0; i < size; i++) {
        int element = arr[i];
        char key[MAX_KEY_LENGTH];
        
        // Simple grouping function: even/odd
        if (element % 2 == 0) {
            strcpy(key, "even");
        } else {
            strcpy(key, "odd");
        }
        
        unsigned int hashIndex = hash(key);
        Group* current = hashTable[hashIndex];
        
        // Search for existing group in hash chain
        while (current != NULL) {
            if (strcmp(current->key, key) == 0) {
                current->values[current->count++] = element;
                break;
            }
            current = current->next;
        }
        
        // If not found, create new group
        if (current == NULL) {
            Group* newGroup = (Group*)malloc(sizeof(Group));
            strcpy(newGroup->key, key);
            newGroup->values[0] = element;
            newGroup->count = 1;
            newGroup->next = hashTable[hashIndex];
            hashTable[hashIndex] = newGroup;
        }
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    Group* hashTable[HASH_SIZE] = {NULL};
    
    groupBy(arr, size, hashTable);
    
    // Print results
    for (int i = 0; i < HASH_SIZE; i++) {
        Group* current = hashTable[i];
        while (current != NULL) {
            printf("%s: ", current->key);
            for (int j = 0; j < current->count; j++) {
                printf("%d ", current->values[j]);
            }
            printf("\n");
            Group* temp = current;
            current = current->next;
            free(temp);
        }
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, with O(1) hash table operations for key lookup and insertion

✓ Linear Growth

Space Complexity

O(n)

Space to store the result object containing all n elements grouped by keys

⚡ Linearithmic Space

24.6K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler