Developed technique for grouping arrays in JavaScript based on frequency of occurrence

Question

Developed technique for grouping arrays in JavaScript based on frequency of occurrence

I have a collection of arrays in javascript and I need to perform some calculations.

Here is how my array looks:

https://i.sstatic.net/m0tSw.png

In each array: - The first value represents a code. - The second value indicates the size. - And the third value denotes the count.

My objective is to identify all groups where the counts are all 0.

For instance:

If "NVY" "S" has a count of 0 (not 28), then I want to retrieve ["sjm-NVY"];

Here's what I've attempted so far:

var a    = [];
$.each(arr[21].splits, function(idx, val) {
    console.log(val);   
    var current_code = arr[21].splits[idx][0];

    a[current_code] = [];
    a[current_code].push(arr[21].splits[idx]);
});

However, I haven't been able to find the correct solution. Thank you for any help!

The dataset:

{"code":"sjm","splits":[["FOG","L","0"],["FOG","XL","-1"],["FOG","XXXL","2"],["FOG","S","7"],["FOG","M","0"],["FOG","XXL","6"],["BLK","LT","30"],["BLK","XLT","23"],["BLK","XXXLT","0"],["BLK","L","102"],["BLK","XL","302"],["BLK","XXXL","64"],["BLK","S","25"],["BLK","XXLT","0"],["BLK","M","485"],["BLK","XXL","159"],["BGE","L","106"],["BGE","XL","41"],["BGE","XXXL","15"],["BGE","S","4"],["BGE","M","39"],["BGE","XXL","0"],["RED","L","36"],["RED","XL","41"],["RED","XXXL","8"],["RED","S","5"],["RED","M","19"],["RED","XXL","2"],["NVY","L","0"],["NVY","XL","0"],["NVY","XXXL","0"],["NVY","S","28"],["NVY","M","0"],["NVY","XXL","0"]]}

P.S There are no color codes on the screen above where all values in the group are 0, hence nothing to display.

javascript arrays reduce

Answer 1

Answer №1

My assumption, based on your discussion about grouping, is that you would start by using the reduce function followed by the filter method

To group your arrays by the first index, you can implement it like this:

function groupBy( arr, t ) {
  return arr.reduce( (agg, c) => {
    const key = t(c);
    if (!agg[key]) {
      agg[key] = [];
    }
    agg[key].push( c );
    return agg;
  }, {} );
}

You can then utilize the above function as follows:

const result = groupBy( arr[21], item => item[0] );

This will give you an object structure similar to:

{ "NVY": [["NVY", "S", "28"], ...] }

Next, you can identify those items with a total count of 0:

function find( obj, predicate ) {
  return Object.keys( obj ).filter( key => predicate( obj[key] ) );
}

Usage example for the above function:

const groups = find( result, items => !items.some( i => i[2] !== "0" ) );

The output, in case NVY only contains items with a count of "0", would be:

["NVY", "..."]

You can further combine this information with your code property

In summary, combining all these steps will result in something like:

 // Code snippet provided here

Answer 2

My assumption, based on your discussion about grouping, is that you would start by using the reduce function followed by the filter method

To group your arrays by the first index, you can implement it like this:

function groupBy( arr, t ) {
  return arr.reduce( (agg, c) => {
    const key = t(c);
    if (!agg[key]) {
      agg[key] = [];
    }
    agg[key].push( c );
    return agg;
  }, {} );
}

You can then utilize the above function as follows:

const result = groupBy( arr[21], item => item[0] );

This will give you an object structure similar to:

{ "NVY": [["NVY", "S", "28"], ...] }

Next, you can identify those items with a total count of 0:

function find( obj, predicate ) {
  return Object.keys( obj ).filter( key => predicate( obj[key] ) );
}

Usage example for the above function:

const groups = find( result, items => !items.some( i => i[2] !== "0" ) );

The output, in case NVY only contains items with a count of "0", would be:

["NVY", "..."]

You can further combine this information with your code property

In summary, combining all these steps will result in something like:

 // Code snippet provided here

Answer 3

Answer №2

Answer:

If you want to manipulate your data in various ways, you can create an Inventory Constructor that allows flexible parsing options.

code:

function Inventory( from ) {
    return {
        data: from,
        getBy: function( type ) {
            if ( ![ "code", "size", "quantity" ].includes( type.toLowerCase() ) ) throw new Error( "Incorrect Inventory::getBy Type" );
            return function( value ) {
                return Inventory( 
                    from.filter( ( [ code, size, quantity ] ) => 
                        new Function( "code, size, quantity", `return ${type} === '${value.toUpperCase()}'` )( code, size, quantity ) 
                    ) 
                );
            }
        }
    }
}

Example:

let data={splits:[["FOG","L","0"],["FOG","M","0"],["FOG","XL","-1"],["FOG","XXXL","2"],["NVY","M","0"],["NVY","L","0"],["NVY","S","0"]]};


function Inventory(from) {
return {
data: from,
getBy: function(type) {
if (!["code", "size", "quantity"].includes(type.toLowerCase())) throw new Error("Incorrect Inventory::getBy Type");
return function(value) {
return Inventory(from.filter(([code, size, quantity]) => new Function("code, size, quantity", `return ${type} === '${value.toUpperCase()}'`)(code, size, quantity)));
}
}
}
}

let Inv = Inventory(data.splits),
noQuantity = Inv.getBy("quantity")("0").data;

console.log("Items with 0 Quantity: ");
console.log(noQuantity);

Why so detailed?

At first glance, this solution may seem elaborate. But it offers versatility and adaptability, unlike other answers. It enables nested searches and ensures maintainability and reusability of code.

Why choose this approach?

Nested searches are possible
Enhanced maintainability and reusability

This solution addresses evolving needs and edge cases efficiently with minimal code. The explanation below delves deeper into how it functions.

Explanation: How it works

We start by creating a simple Inventory Constructor to store and manipulate the data provided.

For example:

function Inventory(from) {
   return { 
      data: from
  }
}

The constructor stores the inventory data within its property. You can access this data for further manipulation.

Example:

let data={splits:[["FOG","L","0"],["FOG","M","0"],["FOG","XL","-1"],["FOG","XXXL","2"],["NVY","M","0"],["NVY","L","0"],["NVY","S","0"]]};

function Inventory(from) {
     return {
        data: from
      }
    }

let Inv = Inventory(data.splits);
console.log(Inv);

To enable searching through the data based on specific criteria like quantity or size, we implemented a filtering method called getBy.

For instance:

function Inventory(from) {
    return {
        data: from,
        getByQuantity: function(quantity) {
            return from.filter(([, , q]) => quantity === q);
        }
    }
}

Example:

let data={splits:[["FOG","L","0"],["FOG","M","0"],["FOG","XL","-1"],["FOG","XXXL","2"],["NVY","M","0"],["NVY","L","0"],["NVY","S","0"]}];

function Inventory(from) {
  return {
    data: from,
    getByQuantity: function(quantity) {
      return from.filter(([, , q]) => quantity === q);
    }
  }
}

let Inv = Inventory(data.splits),
noQty = Inv.getByQuantity("0");

console.log( noQty );

However, when multiple filters are required, the implementation might become cumbersome. To address this issue, we introduced the Templating Pattern along with recursion in our Inventory Constructor.

With this enhancement, you can perform successive searches on the data until you obtain the desired result effortlessly.

Here's a brief overview of the steps involved:

Flexible search capability with getBy method
Comparison operations using the filterBy method

Through iterative searches, you can navigate through the inventory data, reducing complexity while ensuring precise results.

Final Solution:

function Inventory(from) {
    return {
        data: from,
        getBy: function(type) {
            if (!["code", "size", "quantity"].includes(type.toLowerCase())) throw new Error("Incorrect Inventory::getBy Type");
            return function(value) {
                return Inventory(from.filter(([code, size, quantity]) => new Function("code, size, quantity", `return ${type} === '${value.toUpperCase()}'`)(code, size, quantity)));
            }
        },
        filterBy: function(comparison) {
            return Inventory(from.filter(([code, size, quantity]) => new Function("code, size, quantity", `return ${comparison};`)(code, size, quantity)));
        }
    }
}

let noQty = Inventory(data.splits).getBy("quantity")("0");

Final Example:

let data={splits:[["FOG","L","0"],["FOG","M","0"],["FOG","XL","-1"],["FOG","XXXL","2"],["NVY","M","0"],["NVY","L","0"],["NVY","S","0"]}};

function Inventory(from) {
return {
data: from,
getBy: function(type) {
if (!["code", "size", "quantity"].includes(type.toLowerCase())) throw new Error("Incorrect Inventory::getBy Type");
return function(value) {
return Inventory(from.filter(([code, size, quantity]) => new Function("code, size, quantity", `return ${type} === '${value.toUpperCase()}'`)(code, size, quantity)));
}
},
filterBy: function(comparison) {
return Inventory(from.filter(([code, size, quantity]) => new Function("code, size, quantity", `return ${comparison};`)(code, size, quantity)));
}
}
}

let Inv = Inventory(data.splits),
allNvyNoQuantity = Inv.getBy("code")("NVY").getBy("quantity")("0").data;

console.log("All NVY items with 0 Quantity: ");
console.log(allNvyNoQuantity);

Conclusion:

In conclusion, the enhanced Inventory Constructor provides a versatile and efficient way to manage and analyze inventory data. Its flexibility in search criteria and comparison operations make it a powerful tool for data manipulation.

Happy coding!

Answer 4

Answer:

If you want to manipulate your data in various ways, you can create an Inventory Constructor that allows flexible parsing options.

code:

function Inventory( from ) {
    return {
        data: from,
        getBy: function( type ) {
            if ( ![ "code", "size", "quantity" ].includes( type.toLowerCase() ) ) throw new Error( "Incorrect Inventory::getBy Type" );
            return function( value ) {
                return Inventory( 
                    from.filter( ( [ code, size, quantity ] ) => 
                        new Function( "code, size, quantity", `return ${type} === '${value.toUpperCase()}'` )( code, size, quantity ) 
                    ) 
                );
            }
        }
    }
}

Example:

let data={splits:[["FOG","L","0"],["FOG","M","0"],["FOG","XL","-1"],["FOG","XXXL","2"],["NVY","M","0"],["NVY","L","0"],["NVY","S","0"]]};


function Inventory(from) {
return {
data: from,
getBy: function(type) {
if (!["code", "size", "quantity"].includes(type.toLowerCase())) throw new Error("Incorrect Inventory::getBy Type");
return function(value) {
return Inventory(from.filter(([code, size, quantity]) => new Function("code, size, quantity", `return ${type} === '${value.toUpperCase()}'`)(code, size, quantity)));
}
}
}
}

let Inv = Inventory(data.splits),
noQuantity = Inv.getBy("quantity")("0").data;

console.log("Items with 0 Quantity: ");
console.log(noQuantity);

Why so detailed?

At first glance, this solution may seem elaborate. But it offers versatility and adaptability, unlike other answers. It enables nested searches and ensures maintainability and reusability of code.

Why choose this approach?

Nested searches are possible
Enhanced maintainability and reusability

This solution addresses evolving needs and edge cases efficiently with minimal code. The explanation below delves deeper into how it functions.

Explanation: How it works

We start by creating a simple Inventory Constructor to store and manipulate the data provided.

For example:

function Inventory(from) {
   return { 
      data: from
  }
}

The constructor stores the inventory data within its property. You can access this data for further manipulation.

Example:

let data={splits:[["FOG","L","0"],["FOG","M","0"],["FOG","XL","-1"],["FOG","XXXL","2"],["NVY","M","0"],["NVY","L","0"],["NVY","S","0"]]};

function Inventory(from) {
     return {
        data: from
      }
    }

let Inv = Inventory(data.splits);
console.log(Inv);

To enable searching through the data based on specific criteria like quantity or size, we implemented a filtering method called getBy.

For instance:

function Inventory(from) {
    return {
        data: from,
        getByQuantity: function(quantity) {
            return from.filter(([, , q]) => quantity === q);
        }
    }
}

Example:

let data={splits:[["FOG","L","0"],["FOG","M","0"],["FOG","XL","-1"],["FOG","XXXL","2"],["NVY","M","0"],["NVY","L","0"],["NVY","S","0"]}];

function Inventory(from) {
  return {
    data: from,
    getByQuantity: function(quantity) {
      return from.filter(([, , q]) => quantity === q);
    }
  }
}

let Inv = Inventory(data.splits),
noQty = Inv.getByQuantity("0");

console.log( noQty );

However, when multiple filters are required, the implementation might become cumbersome. To address this issue, we introduced the Templating Pattern along with recursion in our Inventory Constructor.

With this enhancement, you can perform successive searches on the data until you obtain the desired result effortlessly.

Here's a brief overview of the steps involved:

Flexible search capability with getBy method
Comparison operations using the filterBy method

Through iterative searches, you can navigate through the inventory data, reducing complexity while ensuring precise results.

Final Solution:

function Inventory(from) {
    return {
        data: from,
        getBy: function(type) {
            if (!["code", "size", "quantity"].includes(type.toLowerCase())) throw new Error("Incorrect Inventory::getBy Type");
            return function(value) {
                return Inventory(from.filter(([code, size, quantity]) => new Function("code, size, quantity", `return ${type} === '${value.toUpperCase()}'`)(code, size, quantity)));
            }
        },
        filterBy: function(comparison) {
            return Inventory(from.filter(([code, size, quantity]) => new Function("code, size, quantity", `return ${comparison};`)(code, size, quantity)));
        }
    }
}

let noQty = Inventory(data.splits).getBy("quantity")("0");

Final Example:

let data={splits:[["FOG","L","0"],["FOG","M","0"],["FOG","XL","-1"],["FOG","XXXL","2"],["NVY","M","0"],["NVY","L","0"],["NVY","S","0"]}};

function Inventory(from) {
return {
data: from,
getBy: function(type) {
if (!["code", "size", "quantity"].includes(type.toLowerCase())) throw new Error("Incorrect Inventory::getBy Type");
return function(value) {
return Inventory(from.filter(([code, size, quantity]) => new Function("code, size, quantity", `return ${type} === '${value.toUpperCase()}'`)(code, size, quantity)));
}
},
filterBy: function(comparison) {
return Inventory(from.filter(([code, size, quantity]) => new Function("code, size, quantity", `return ${comparison};`)(code, size, quantity)));
}
}
}

let Inv = Inventory(data.splits),
allNvyNoQuantity = Inv.getBy("code")("NVY").getBy("quantity")("0").data;

console.log("All NVY items with 0 Quantity: ");
console.log(allNvyNoQuantity);

Conclusion:

In conclusion, the enhanced Inventory Constructor provides a versatile and efficient way to manage and analyze inventory data. Its flexibility in search criteria and comparison operations make it a powerful tool for data manipulation.

Happy coding!

Answer 5

Answer №3

Below is a handy function that can be used to search for specific counts within an array based on the provided structure:

function findCountInArray(arr, code, count) {
    var results = [];

    $.each(arr, function (index, subArr) {
        var currentCount = subArr[2];
        var groupCode = code + "-" + subArr[0];
        
        if (currentCount == count && results.indexOf(groupCode) === -1) {
            results.push(groupCode);
        }
    });

    return results;
}

console.log(findCountInArray(data.splits, data.code, 0));

Answer 6

Below is a handy function that can be used to search for specific counts within an array based on the provided structure:

function findCountInArray(arr, code, count) {
    var results = [];

    $.each(arr, function (index, subArr) {
        var currentCount = subArr[2];
        var groupCode = code + "-" + subArr[0];
        
        if (currentCount == count && results.indexOf(groupCode) === -1) {
            results.push(groupCode);
        }
    });

    return results;
}

console.log(findCountInArray(data.splits, data.code, 0));

Developed technique for grouping arrays in JavaScript based on frequency of occurrence

Answer №1

Answer №2

Answer:

Example:

Why so detailed?

Explanation: How it works

Example:

Example:

Final Solution:

Final Example:

Conclusion:

Answer №3

Similar questions

I have noticed that there are 3 images following the same logical sequence, however only the first 2 images seem to be functioning correctly. Can you help

The click event is activated following the :active selector being triggered

Adjust the contents of an HTTP POST request body (post parameter) upon activation of the specified POST request

How to properly remove a 2D array?

Fetching data in a post request seems to be causing an issue with FormData image being

Adding a stylesheet dynamically in Angular 2: A step-by-step guide

Enable the ability to scroll and click to navigate an overlapping Div element

Tips for incorporating a favicon in a React application

What is the best way to showcase a local image in the console using nwjs?

Trouble with Mocha async hooks execution?

Presenting JSON data in a table format on-the-fly even without prior knowledge of the data's structure or field names

What is more effective: utilizing document fragments or string concatenation for adding HTML to the DOM?

Arrange the elements of the array in alphabetical order and categorize them based on their initial letter

The getElementBy method is failing to pass the value in the document

The nodemailer module in Node.js encountered an issue while trying to send an email, resulting

What is the best method for gathering information from multiple input fields?

Tips for Utilizing jQuery each Loop

How can I extract the page's output using JQuery?

Having trouble setting up Strongloop for Loopback v.3 on macOS Catalina?

Converting dates in Javascript