2631. Group By

 

Enhancing JavaScript Arrays with a Custom groupBy Method

In the world of JavaScript, extending native prototypes can often make our code more efficient and readable. Today, I'm excited to share a method to group array elements based on a function you provide. This custom groupBy method is simple yet powerful, leveraging the capabilities of JavaScript's array methods.

The Problem

Grouping elements in an array is a common task in many applications. For example, given the array [1, 2, 3] and the grouping function String, we want the output to be:

json
{"1":[1],"2":[2],"3":[3]}

To achieve this, we will create a custom groupBy method that categorizes array elements efficiently.

The Solution

Here’s the code for our groupBy method:

javascript
/**
 * @param {Function} fn
 * @return {Object}
 */
Array.prototype.groupBy = function(fn) {
    return this.reduce((group, item) => {
        const key = fn(item);
        if (!group[key]) {
            group[key] = [];
        }
        group[key].push(item);
        return group;
    }, {});
};

/**
 * Example:
 * [1,2,3].groupBy(String) // {"1":[1],"2":[2],"3":[3]}
 */

Intuition

The idea behind this solution is to use JavaScript's reduce method to build an object that groups elements. By applying the provided function to each element, we determine the key for each group and categorize elements accordingly. This approach ensures efficiency by iterating through the array just once.

Approach

  1. Adding the Method: Extend Array.prototype with a groupBy method, making it available to all array instances.

  2. Using reduce: Utilize the reduce function to iterate over the array and construct a grouped object.

  3. Generating Keys: Apply the function fn to each element to determine the grouping key.

  4. Grouping Elements: Initialize an array for the key if it doesn't exist and push the current element into the corresponding group.

  5. Returning the Grouped Object: The final grouped object is returned, containing arrays of grouped elements.

Example Usage

Here's how you can use the groupBy method:

javascript
let arr = [1, 2, 3];
let result = arr.groupBy(String);
console.log(result); 
// Output: {"1":[1],"2":[2],"3":[3]}

Complexity Analysis

  • Time Complexity: O(n), where n is the number of elements in the array. This efficiency is achieved by iterating through the array once.

  • Space Complexity: O(n), due to the space required to store the grouped elements.

Conclusion

Extending Array.prototype with a groupBy method provides a flexible and efficient way to categorize array elements. By harnessing the power of reduce, we can group data based on custom logic with minimal effort. This method is versatile, useful for various scenarios where data needs to be organized or categorized.

For a more detailed explanation and other solutions, check out my LeetCode Solution and stay tuned for more tips and tricks!

Happy coding! šŸš€

Comments

Post a Comment

Popular posts from this blog

3Sum Closest: O(n²) Two-Pointer Magic šŸš€ leetcode: 16

Three Sum Closest - LeetCode Solution In this blog post, we'll dive into the Three Sum Closest problem, a popular coding challenge on LeetCode. We'll explore the intuition behind the solution, discuss the approach, analyze the complexity, and provide a detailed explanation of the code. Additionally, I'll share my LeetCode solution link for further reference. Problem Statement Given an integer array nums of length n and an integer target , find three integers in nums such that the sum is closest to target . Return the sum of the three integers. You may assume that each input would have exactly one solution. Intuition The problem requires finding three numbers in the array whose sum is as close as possible to the target. To efficiently find such a triplet, we can use a combination of sorting and the two-pointer technique . Sorting : First, sort the array. This allows us to use the two-po...
Read more

Kadane's Algorithm: Maximum Subarray Problem - LeetCode(53) Solution

Maximum Subarray Problem - LeetCode Solution Maximum Subarray Problem - LeetCode Solution Problem Statement Given an integer array nums , find the contiguous subarray (containing at least one number) that has the largest sum and return its sum. Intuition The problem requires finding the contiguous subarray with the maximum sum. A brute force approach would involve checking all subarrays, but this would be inefficient. Instead, we use Kadane's Algorithm , which efficiently finds the maximum sum subarray in O(n) time. Approach Initialize two variables: total (running sum) and maxi (maximum sum encountered so far). Iterate through the array: Add the current element to total . Update maxi with the maximum of maxi and total . If total becomes negative, reset it to zero. Return maxi as the maximum sub...
Read more

14. Longest Common Prefix

  Finding the Longest Common Prefix in JavaScript When working with arrays of strings, a common problem is finding the longest common prefix among these strings. The longest common prefix is the initial portion of all strings in the array that is identical. This is a frequent problem on coding platforms like LeetCode, and it's essential to understand how to tackle it efficiently. In this blog post, we'll dive into the intuition, approach, and complexity of finding the longest common prefix in JavaScript. Intuition The intuition behind finding the longest common prefix is simple. By sorting the array of strings lexicographically (alphabetically), we can bring the smallest and largest strings to the beginning and end of the array. The common prefix between the first and last string in this sorted array will give us the longest common prefix for the entire array. This approach leverages the natural order of strings to simplify our task. Approach Sort the Array : First, we sort the...
Read more