Efficient method for iterating through three arrays that have matching values and satisfy specified conditions in TypeScript

Question

Efficient method for iterating through three arrays that have matching values and satisfy specified conditions in TypeScript

Struggling to speed up my Excel sheet creation time, currently taking over 20 seconds. I'm using the code below to compare three arrays and get the desired output:

for (let i = 0; i < this.arrayNumberOne[0].length; i++) {
    let orangeOne = this.arrayNumberOne[0][i]['item_1'];
    let orangeTwo = this.arrayNumberOne[0][i]['item_2'];
    let orangeThree = orangeOne.concat(orangeTwo)

    for (let k = 0; k < this.arrayNumberTwo[0].length; k++) {
        let appleOne = this.arrayNumberTwo[0][k]['item_1'];
        
        for (let j = 0; j < this.arrayNumberThree[0].length; j++) {
            let grapeOne = this.arrayNumberThree[0][j]['item_1'];
            let grapeTwo = this.arrayNumberThree[0][j]['item_2'];
            let grapeThree = this.arrayNumberThree[0][j]['item_3'];
        
            if (orangeThree == grapeOne && appleOne == grapeTwo) {

                if (grapeThree == null || grapeThree == '') {
                    // print to response to excel
                }

                else if (grapeThree == 'sells') {
                    //  print stuff to excel
                }

                else if (grapeThree == 'buys') {
                    // print stuff to excel
                }
            }
        }
    }
}

Considering hashmaps and interfaces but need help implementing them here. Open to suggestions on how to optimize the process.

Edit:

https://i.stack.imgur.com/9kuPn.png

Playground Link

arrays typescript hashmap iteration

Answer 1

Answer №1

What catches my attention is the presence of 3 nested loops in this code snippet, even though the data being processed is 2D. Typically, you would only expect 2 nested loops - one for X and one for Y. The crucial aspect to consider here is optimizing the process of retrieving the value of each cell to ensure efficiency, as this operation occurs frequently.

An effective strategy is to preprocess the values (representing actions) that populate the cells in such a way that facilitates quick lookups.

For instance:

// Index all actions based on player id and item name
const indexedActions: {
    [playerId: string]: {
        [itemCatName: string]: string
    }
} = {}

// Iterate through all actions to create an index.
for (const {playerId, itemCatName, action} of actions) {
    if (!indexedActions[playerId]) indexedActions[playerId] = {}
    indexedActions[playerId][itemCatName] = action
}

As a result of this processing, the data will be structured like:

{
    "12": {
        "potionsmall-potion": 'buy'
        // etc...
    }
    // etc...
}

This indexing significantly simplifies the lookup process for any cell:

indexedActions[playerId][itemName]

By doing so, the innermost loop can be eliminated entirely.

// Loop through items
for (let i = 0; i < items.length; i++) {
    let itemCat = items[i]['itemCategory']
    let itemNam = items[i]['itemName']
    let combineCat = itemCat.concat(itemNam)
    
    // Iterate through players
    for (let k = 0; k < players.length; k++) {
        let playerIdentify = players[k]['playerId']
        
        // Retrieve the action taken by this player regarding this item
        const actionToDo = indexedActions[playerIdentify][combineCat]

        // perform actions based on retrieved action
    }
}

Before Optimization

for every item
- for every player
  - for every action
    - doLogic()

In this scenario, "doLogic" is executed

itemCount * playerCount * actionCount

times.

After Optimization

for every action
- index each action
for every item
- for every player
  - doLogic()

Though requiring additional upfront work, the optimization brings down the number of times doLogic is executed to itemCount * playerCount, resulting in a significant enhancement.

Moreover, the refactored code is more concise and easier to comprehend!

Explore playground

Answer 2

What catches my attention is the presence of 3 nested loops in this code snippet, even though the data being processed is 2D. Typically, you would only expect 2 nested loops - one for X and one for Y. The crucial aspect to consider here is optimizing the process of retrieving the value of each cell to ensure efficiency, as this operation occurs frequently.

An effective strategy is to preprocess the values (representing actions) that populate the cells in such a way that facilitates quick lookups.

For instance:

// Index all actions based on player id and item name
const indexedActions: {
    [playerId: string]: {
        [itemCatName: string]: string
    }
} = {}

// Iterate through all actions to create an index.
for (const {playerId, itemCatName, action} of actions) {
    if (!indexedActions[playerId]) indexedActions[playerId] = {}
    indexedActions[playerId][itemCatName] = action
}

As a result of this processing, the data will be structured like:

{
    "12": {
        "potionsmall-potion": 'buy'
        // etc...
    }
    // etc...
}

This indexing significantly simplifies the lookup process for any cell:

indexedActions[playerId][itemName]

By doing so, the innermost loop can be eliminated entirely.

// Loop through items
for (let i = 0; i < items.length; i++) {
    let itemCat = items[i]['itemCategory']
    let itemNam = items[i]['itemName']
    let combineCat = itemCat.concat(itemNam)
    
    // Iterate through players
    for (let k = 0; k < players.length; k++) {
        let playerIdentify = players[k]['playerId']
        
        // Retrieve the action taken by this player regarding this item
        const actionToDo = indexedActions[playerIdentify][combineCat]

        // perform actions based on retrieved action
    }
}

Before Optimization

for every item
- for every player
  - for every action
    - doLogic()

In this scenario, "doLogic" is executed

itemCount * playerCount * actionCount

times.

After Optimization

for every action
- index each action
for every item
- for every player
  - doLogic()

Though requiring additional upfront work, the optimization brings down the number of times doLogic is executed to itemCount * playerCount, resulting in a significant enhancement.

Moreover, the refactored code is more concise and easier to comprehend!

Explore playground

Efficient method for iterating through three arrays that have matching values and satisfy specified conditions in TypeScript

Answer №1

Before Optimization

After Optimization

Similar questions

Can you tell me the data type of IconButtons in Material UI when using TypeScript?

Sending an Ajax request using an array of parameters and then accessing them in PHP

React with Typescript allows us to refine the callback type depending on the presence of an optional boolean prop

Transforming substantial quantities of data into a string array in JavaScript

What is the best way to retrieve the value from a Material UI textfield after hitting the enter key

Using TypeScript, Material UI introduces a new property to the primary object on the palette

The Network plugin is having issues with the PWA application in Ionic 4

Issue with Angular 6 where data is not binding to the UI on initialization

Errors caused by Typescript transpilation only manifest on the production server

Is it possible to organize multiple tables within a single JSON structure without relying on JArray?

Converting data received from the server into a typescript type within an Angular Service

Utilizing a personalized (branched) @types package

Angular 7 - Implementing periodic JSON data retrieval from server and maintaining local storage within Angular application

Designing php/mysql data in a container

Error message encountered in Typescript eslint: File extension "ts" is missing in import statement for the specified file

Develop a PHP master-detail page for enhanced user experience

The function useNuxtApp() in Nuxt 3 is returning an unknown type

Angular 8 delivers an observable as a result following a series of asynchronous requests

Eliminate redundant arrays across several JSON files with Python

What is the best way to include multiple targets/executables within a single Node.js repository?