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

What is the best way to end a Google OAuth session using Firebase on an Ionic 2 application?

Unable to modify the theme provider in Styled Components

I am unable to refresh the table data in Angular

The Azure function encounters an AuthorizationFailure error while attempting to retrieve a non-public file from Azure Blob Storage

What is the process for modifying href generation in UI-Router for Angular 2?

The issue arises when using Angular Material as it seems that passing a data object to a matdialog dialog

Nestjs struggles with resolving dependencies

The ng2-intl encounters an issue when trying to resolve symbol values statically

Angular 7 and its scrolling div

Using type definitions in non-TS files with VSCode: A beginner's guide

Retrieve data from an array of objects nested within another object

How to access JSON array data in PHP without using a loop to iterate through the keys

Seamlessly incorporating Storybook with Tailwind CSS, Create Next App, and TypeScript

Master the art of manipulating JSON arrays with jQuery

Mocking Firestore v9 getDocs() in Jest: A Comprehensive Guide

Having trouble fixing TypeScript bugs in Visual Studio Code

The delay function in RxJS allows for waiting to return a value until a specific condition is met within a stream and

Why does HttpClient in Angular 4 automatically assume that the request I am sending is in JSON format?

Typescript - using optional type predicates

Inserting Array Type Values into Node.js and MongoDB