Tips on improving the efficiency of a nested 'for' loop through functional programming

Question

Tips on improving the efficiency of a nested 'for' loop through functional programming

Looking for a way to optimize my function that checks for repeated cell phone numbers in a list. Currently, I am using nested for loops and wondering how I can implement functional programming instead?

  checkDuplicate(): boolean {

    for (let i = 0; i < this.phoneList.length; i++) {
      for (let j = 0; j < this.phoneList.length; j++) {
        if (i != j) {
            if (this.phoneList[i].number === this.phoneList[j].number) {
              this.toastrService.error('Phone already in List!');
              return true;
            }
        }
      }
    }

    return false;
  }

javascript angular typescript

Answer 1

Answer №1

To identify duplicate numbers, create a Set that contains only unique numbers and then compare its length to the original array

checkForDuplicates(): boolean {
  return new Set(this.phoneNumberList.map(num => num)).size < this.phoneNumberList.length
}

Answer 2

To identify duplicate numbers, create a Set that contains only unique numbers and then compare its length to the original array

checkForDuplicates(): boolean {
  return new Set(this.phoneNumberList.map(num => num)).size < this.phoneNumberList.length
}

Answer 3

Answer №2

O(n) solution

Although it's not a functional approach, this solution is currently the fastest.

const checkDuplicate = (phones)=> {
    let counts = {};
    
    for(let phone of phones) {
        if(counts[phone.number]) return true;
        counts[phone.number] = 1;
    }

    return false;
}

if(checkDuplicate(this.phoneList)) {
  this.toastrService.error('Phone already in List!');
}

Answer 4

O(n) solution

Although it's not a functional approach, this solution is currently the fastest.

const checkDuplicate = (phones)=> {
    let counts = {};
    
    for(let phone of phones) {
        if(counts[phone.number]) return true;
        counts[phone.number] = 1;
    }

    return false;
}

if(checkDuplicate(this.phoneList)) {
  this.toastrService.error('Phone already in List!');
}

Answer 5

Answer №3

Instead of using the filter method, consider utilizing the Set data structure for a cleaner solution. While there are multiple ways to implement this, the use of .filter() may be seen as more 'functional' due to it being a Higher-Order Component.

let exampleArray = [1,2,1,3,3,5]
let uniqueValues = [...new Set(exampleArray)]

// => [1, 2, 3, 5]

Check out the Mozilla documentation on Sets for more information.

Answer 6

Instead of using the filter method, consider utilizing the Set data structure for a cleaner solution. While there are multiple ways to implement this, the use of .filter() may be seen as more 'functional' due to it being a Higher-Order Component.

let exampleArray = [1,2,1,3,3,5]
let uniqueValues = [...new Set(exampleArray)]

// => [1, 2, 3, 5]

Check out the Mozilla documentation on Sets for more information.

Answer 7

Answer №4

One way to approach this is by using the following code snippet:

let duplicates = this.phoneList.filter(item =>
    this.phoneList.filter(item2 => item.number == item2.number).length > 1
);
if (duplicates.length) {
    this.toastrService.error('Phone number already exists in the list!');
    return true;
}

However, it may not be the most readable solution.

Answer 8

One way to approach this is by using the following code snippet:

let duplicates = this.phoneList.filter(item =>
    this.phoneList.filter(item2 => item.number == item2.number).length > 1
);
if (duplicates.length) {
    this.toastrService.error('Phone number already exists in the list!');
    return true;
}

However, it may not be the most readable solution.

Answer 9

Answer №5

Instead of focusing on Angular, this discussion revolves around JavaScript optimization. One way to improve performance is by short-circuiting the loop within the list for faster execution.

The inner loops can be made n-i faster in processing since we have already checked those elements.

var xObj = {
  // phoneList and phoneList2 objects containing contact information
  toastrService: {
    error: function(message) {
      console.log(message);
    }
  },
  checkDuplicate: function() {
    let hasDupe = false;
    for (let i = 0; i < this.phoneList.length; i++) {
      for (let j = i + 1; j < this.phoneList.length; j++) {
        if (this.phoneList[i].number === this.phoneList[j].number) {
          hasDupe = true;
          break;
        }
      }
      if (hasDupe) break;
    }
    if (hasDupe) this.toastrService.error('Phone already in List!');
    return hasDupe;
  },
  checkDuplicate2: function() {
    let hasDupe = false;
    for (let i = 0; i < this.phoneList2.length; i++) {
      for (let j = i + 1; j < this.phoneList2.length; j++) {
        if (this.phoneList2[i].number === this.phoneList2[j].number) {
          hasDupe = true;
          break;
        }
      }
      if (hasDupe) break;
    }
    if (hasDupe) this.toastrService.error('Phone already in List!');
    return hasDupe;
  }
};
let cdup = xObj.checkDuplicate();
let cdup2 = xObj.checkDuplicate2();

console.log("Duplicates found:", cdup, cdup2);

Answer 10

Instead of focusing on Angular, this discussion revolves around JavaScript optimization. One way to improve performance is by short-circuiting the loop within the list for faster execution.

The inner loops can be made n-i faster in processing since we have already checked those elements.

var xObj = {
  // phoneList and phoneList2 objects containing contact information
  toastrService: {
    error: function(message) {
      console.log(message);
    }
  },
  checkDuplicate: function() {
    let hasDupe = false;
    for (let i = 0; i < this.phoneList.length; i++) {
      for (let j = i + 1; j < this.phoneList.length; j++) {
        if (this.phoneList[i].number === this.phoneList[j].number) {
          hasDupe = true;
          break;
        }
      }
      if (hasDupe) break;
    }
    if (hasDupe) this.toastrService.error('Phone already in List!');
    return hasDupe;
  },
  checkDuplicate2: function() {
    let hasDupe = false;
    for (let i = 0; i < this.phoneList2.length; i++) {
      for (let j = i + 1; j < this.phoneList2.length; j++) {
        if (this.phoneList2[i].number === this.phoneList2[j].number) {
          hasDupe = true;
          break;
        }
      }
      if (hasDupe) break;
    }
    if (hasDupe) this.toastrService.error('Phone already in List!');
    return hasDupe;
  }
};
let cdup = xObj.checkDuplicate();
let cdup2 = xObj.checkDuplicate2();

console.log("Duplicates found:", cdup, cdup2);

Answer 11

Answer №6

Utilize the Array.some method to verify if a phone number is a duplicate, as demonstrated below. Within the loop's callback function, the phone number serves as the key for a boolean value that gets added to the exists object. The loop terminates when the callback function returns true, indicating discovery of a key/value pair matching the current item in the loop within exists.

checkDuplicate(): boolean {
  let exists: { [key: number]: boolean } = {};
  return this.phoneList.some(phoneListItem => {
    if (exists[phoneListItem.number]) {
      return true;
    } else {
      exists[phoneListItem.number] = true;
      return false;
    }
  });
}

For a demonstration, refer to this stackblitz.

Answer 12

Utilize the Array.some method to verify if a phone number is a duplicate, as demonstrated below. Within the loop's callback function, the phone number serves as the key for a boolean value that gets added to the exists object. The loop terminates when the callback function returns true, indicating discovery of a key/value pair matching the current item in the loop within exists.

checkDuplicate(): boolean {
  let exists: { [key: number]: boolean } = {};
  return this.phoneList.some(phoneListItem => {
    if (exists[phoneListItem.number]) {
      return true;
    } else {
      exists[phoneListItem.number] = true;
      return false;
    }
  });
}

For a demonstration, refer to this stackblitz.

Tips on improving the efficiency of a nested 'for' loop through functional programming

Answer №1

Answer №2

O(n) solution

Answer №3

Answer №4

Answer №5

Answer №6

Similar questions

Concealing a form after submission using JavaScript

Resolving the Challenge of Disabling typescript-eslint/typedef in Angular 13 with ESlint

Attempting to save the result of a fetch call into a variable for the purpose of rendering it as a list in a

Is there a way to verify the presence of months in a column related to departments?

Is there a Joomla extension available that can display or conceal content upon clicking?

"Encountering problem when configuring DataSourcePaginator as the primary Paginator component in Angular

What is the best way to determine if this specific radio button has been selected?

Error in Angular5 httpClient GET request: Unable to access the 'toLowerCase' property because it is undefined

Having difficulty in loading Socket.io client .js file?

What is the correct way to understand nested and intricate types in Typescript?

Integrating a sleek Bootstrap 5 search bar drop-down functionality

Minimum requirement for browsers such as IE9 and other compatible versions

Utilizing the .finally method on a promise that is already being handled with try/catch statements elsewhere may lead to an UnhandledPromiseRejection

How can I use Java script to find specific text within table rows on a website?

Using jQuery to include a sub-object in the "data" object for each AJAX request made on the webpage

What causes the error message "Why does Angular 10 display the error 'Cannot set properties of undefined...'" to pop up?

Tips for correctly loading all elements on an HTML page before making CSS modifications

Tips for selecting array [0] and turning it into a clickable link with JavaScript

Unable to show the total number of rows in a table depending on the selection from a drop-down menu or input field

WebRTC error encountered: Unable to add ICE candidate to 'RTCPeerConnection'