Algorithm to identify the highest sum of two numbers in a disorganized array of whole numbers

Question

Algorithm to identify the highest sum of two numbers in a disorganized array of whole numbers

I am looking to create a function that can identify the largest pair sum in an unordered sequence of numbers.

largestPairSum([10, 14, 2, 23, 19]) --> 42 (sum of 23 and 19)
largestPairSum([99, 2, 2, 23, 19])  --> 122 (sum of 99 and 23)
largestPairSum([-10,-20,-30,-40])   --> -30 (sum of -10 and -20)

My Attempt:

function largestPairSum(numbers)
{
   let counter = 0;
   let orderedNumbers = numbers.sort();

   if (orderedNumbers[0] === -orderedNumbers[0]) {
       orderedNumbers.reverse();
       counter = orderedNumbers[0] + orderedNumbers[1];
       }

   else {
       counter = orderedNumbers[-1] + orderedNumbers[-2];
    }
  return counter;
}

Upon running the function, it returns 'NaN'. I tried checking the type using:


console.log(typeof(orderedNumbers[0]));

The type was shown as 'number', so I'm uncertain about where the issue lies. Thank you for your assistance!

javascript

Answer 1

Answer №1

Unfortunately, your approach is not effective due to:

sorting by string ascending (standard without callback)
using negative indices.

Instead, consider sorting in descending order and selecting the first two elements.

function largestPairSum(numbers) {
    numbers.sort((a, b) => b - a);

    return numbers[0] + numbers[1];
}

console.log(largestPairSum([10, 14, 2, 23, 19])); // 42 (23 + 19)
console.log(largestPairSum([99, 2, 2, 23, 19]));  // 122 (99 + 23)
console.log(largestPairSum([-10, -20, -30, -40])) // -30 (-10 + -20)

An alternative solution that does not require sorting.

function largestPairSum(numbers) {
    let largest = numbers.slice(0, 2),
        smallest = largest[0] < largest[1] ? 0 : 1;

    for (let i = 2; i < numbers.length; i++) {
        if (largest[smallest] > numbers[i]) continue;
        largest[smallest] = numbers[i];
        smallest = largest[0] < largest[1] ? 0 : 1;
    }
    return largest[0] + largest[1];
}

console.log(largestPairSum([10, 14, 2, 23, 19])); // 42 (23 + 19)
console.log(largestPairSum([99, 2, 2, 23, 19]));  // 122 (99 + 23)
console.log(largestPairSum([-10, -20, -30, -40])) // -30 (-10 + -20)

Answer 2

Unfortunately, your approach is not effective due to:

sorting by string ascending (standard without callback)
using negative indices.

Instead, consider sorting in descending order and selecting the first two elements.

function largestPairSum(numbers) {
    numbers.sort((a, b) => b - a);

    return numbers[0] + numbers[1];
}

console.log(largestPairSum([10, 14, 2, 23, 19])); // 42 (23 + 19)
console.log(largestPairSum([99, 2, 2, 23, 19]));  // 122 (99 + 23)
console.log(largestPairSum([-10, -20, -30, -40])) // -30 (-10 + -20)

An alternative solution that does not require sorting.

function largestPairSum(numbers) {
    let largest = numbers.slice(0, 2),
        smallest = largest[0] < largest[1] ? 0 : 1;

    for (let i = 2; i < numbers.length; i++) {
        if (largest[smallest] > numbers[i]) continue;
        largest[smallest] = numbers[i];
        smallest = largest[0] < largest[1] ? 0 : 1;
    }
    return largest[0] + largest[1];
}

console.log(largestPairSum([10, 14, 2, 23, 19])); // 42 (23 + 19)
console.log(largestPairSum([99, 2, 2, 23, 19]));  // 122 (99 + 23)
console.log(largestPairSum([-10, -20, -30, -40])) // -30 (-10 + -20)

Answer 3

Answer №2

When working with a time complexity of O(n), as recommended by @VLAZ:

const findLargestPairSum = (arr) => {
  let firstLargest = -Infinity,
      secondLargest = -Infinity;
  
  for (let number of arr)
    if (number > firstLargest && secondLargest > -Infinity)
      firstLargest = number;
    else if (number > secondLargest)
      secondLargest = number;
      
  return firstLargest + secondLargest;
}

let tests = [
  findLargestPairSum([10, 14, 2, 23, 19]),
  findLargestPairSum([99, 2, 2, 23, 19]),
  findLargestPairSum([-10,-20,-30,-40]),
];

console.log(tests);
console.log("Nina's test:", findLargestPairSum([20, 50, 10, 1, 2]));

Answer 4

When working with a time complexity of O(n), as recommended by @VLAZ:

const findLargestPairSum = (arr) => {
  let firstLargest = -Infinity,
      secondLargest = -Infinity;
  
  for (let number of arr)
    if (number > firstLargest && secondLargest > -Infinity)
      firstLargest = number;
    else if (number > secondLargest)
      secondLargest = number;
      
  return firstLargest + secondLargest;
}

let tests = [
  findLargestPairSum([10, 14, 2, 23, 19]),
  findLargestPairSum([99, 2, 2, 23, 19]),
  findLargestPairSum([-10,-20,-30,-40]),
];

console.log(tests);
console.log("Nina's test:", findLargestPairSum([20, 50, 10, 1, 2]));

Answer 5

Answer №3

Your code has encountered three issues.

First off, the line

counter=numbersord[-1]+numbersord[-2]

is incorrect. Accessing a negative index in an array will result in undefined, as there is no element at that position. To retrieve elements from the end of an array, you should use arrayLength - negativeIndex:

const arr = ["a", "b", "c", "d", "e"];

console.log(arr[1]);
console.log(arr[2]);

console.log(arr[-1]);
console.log(arr[-2]);

console.log(arr[arr.length - 1]);
console.log(arr[arr.length - 2]);

Secondly, using numbers.sort() does not sort numbers correctly. It sorts them lexicographically rather than numerically, leading to unexpected results such as 10 < 2. For proper numeric sorting, refer to the link provided:

const arr = [1, 2, 10, 20]

arr.sort();
console.log("default (lexicographical) sort", arr);

arr.sort((a, b) => a - b);
console.log("ascending sort", arr);

arr.sort((a, b) => b - a);
console.log("descending sort", arr);

Lastly, the condition

if(numbersord[0] === -numbersord[0])

is unnecessary. The only number that equals its negative counterpart is zero:

console.log(0 === -0);
console.log(1 === -1);
console.log(42 === -42);
console.log(Infinity === -Infinity);
console.log(NaN === -NaN);

Instead of these checks, conducting a descending sort allows you to easily obtain the largest two items every time.

The revised code incorporating these changes looks like this:

function largestPairSum(numbers)
{
   let counter =0;
   //perform a descending sort
   let numbersord = numbers.sort((a, b) => b - a);
   
   //always take the first two items
   counter=numbersord[0]+numbersord[1]
       
   return counter
}

console.log(largestPairSum([10, 14, 2, 23, 19]))// --> 42 (i.e. sum of 23 and 19)
console.log(largestPairSum([99, 2, 2, 23, 19])) // --> 122 (i.e. sum of 99 and 23)
console.log(largestPairSum([-10,-20,-30,-40]))  // --> -30 (i.e sum of -10 and -20)

Answer 6

Your code has encountered three issues.

First off, the line

counter=numbersord[-1]+numbersord[-2]

is incorrect. Accessing a negative index in an array will result in undefined, as there is no element at that position. To retrieve elements from the end of an array, you should use arrayLength - negativeIndex:

const arr = ["a", "b", "c", "d", "e"];

console.log(arr[1]);
console.log(arr[2]);

console.log(arr[-1]);
console.log(arr[-2]);

console.log(arr[arr.length - 1]);
console.log(arr[arr.length - 2]);

Secondly, using numbers.sort() does not sort numbers correctly. It sorts them lexicographically rather than numerically, leading to unexpected results such as 10 < 2. For proper numeric sorting, refer to the link provided:

const arr = [1, 2, 10, 20]

arr.sort();
console.log("default (lexicographical) sort", arr);

arr.sort((a, b) => a - b);
console.log("ascending sort", arr);

arr.sort((a, b) => b - a);
console.log("descending sort", arr);

Lastly, the condition

if(numbersord[0] === -numbersord[0])

is unnecessary. The only number that equals its negative counterpart is zero:

console.log(0 === -0);
console.log(1 === -1);
console.log(42 === -42);
console.log(Infinity === -Infinity);
console.log(NaN === -NaN);

Instead of these checks, conducting a descending sort allows you to easily obtain the largest two items every time.

The revised code incorporating these changes looks like this:

function largestPairSum(numbers)
{
   let counter =0;
   //perform a descending sort
   let numbersord = numbers.sort((a, b) => b - a);
   
   //always take the first two items
   counter=numbersord[0]+numbersord[1]
       
   return counter
}

console.log(largestPairSum([10, 14, 2, 23, 19]))// --> 42 (i.e. sum of 23 and 19)
console.log(largestPairSum([99, 2, 2, 23, 19])) // --> 122 (i.e. sum of 99 and 23)
console.log(largestPairSum([-10,-20,-30,-40]))  // --> -30 (i.e sum of -10 and -20)

Answer 7

Answer №4

When dealing with the NaN type, it's important to understand that it is a number, even though it may appear confusing at first. This occurs when attempting to access elements in an array with indexes such as "-1" or "-2" which do not exist. To retrieve elements from the end of an array, you should utilize the following syntax:

arr[arr.length - 1] // returns the last element

Additionally,

let numbersord = numbers.sort(); // Note: sort() method modifies the original array, proceed with caution

numbersord[0] === -numbersord[0] // The result is true only for 0
// To check if a number is negative, use Math.abs()

The question arises - can an array contain both negative and positive elements simultaneously? In cases like [-10, -5, -2, 10], simply reversing the array will not yield the desired outcome (-15). Instead, consider using the reduce method as shown below:

function largestPairSum(arr) {
  const initialAcc = [-Infinity, -Infinity]
  const highestNumbers = arr.reduce((acc, rec)=> {
    if (rec <= acc[0]) return acc
    if (rec >= acc[1]) return [acc[1], rec]
    return [rec, acc[1]]
  },initialAcc)
  return highestNumbers[0] + highestNumbers[1]
}

Answer 8

When dealing with the NaN type, it's important to understand that it is a number, even though it may appear confusing at first. This occurs when attempting to access elements in an array with indexes such as "-1" or "-2" which do not exist. To retrieve elements from the end of an array, you should utilize the following syntax:

arr[arr.length - 1] // returns the last element

Additionally,

let numbersord = numbers.sort(); // Note: sort() method modifies the original array, proceed with caution

numbersord[0] === -numbersord[0] // The result is true only for 0
// To check if a number is negative, use Math.abs()

The question arises - can an array contain both negative and positive elements simultaneously? In cases like [-10, -5, -2, 10], simply reversing the array will not yield the desired outcome (-15). Instead, consider using the reduce method as shown below:

function largestPairSum(arr) {
  const initialAcc = [-Infinity, -Infinity]
  const highestNumbers = arr.reduce((acc, rec)=> {
    if (rec <= acc[0]) return acc
    if (rec >= acc[1]) return [acc[1], rec]
    return [rec, acc[1]]
  },initialAcc)
  return highestNumbers[0] + highestNumbers[1]
}

Algorithm to identify the highest sum of two numbers in a disorganized array of whole numbers

Answer №1

Answer №2

Answer №3

Answer №4

Similar questions

Building Next.js with a designated maximum number of processes/threads

Ways to prevent styles from being overridden by those specified in JavaScript

Middleware in Express can be executed more than once

Ways to update the component's state externally

Manually detecting changes in the query string using AngularJS

Converting a jQuery DOM element into a string representation

Problem with APIGEE search function

Submitting data from a dropdown menu using Ajax in Struts 2: A step-by-step guide

What are some ways to personalize a scrollbar?

Module for managing optional arguments in Node.js applications

Retrieving information from an Angular service using a specified function

I am unfamiliar with this scenario but I can utilize Axios, async/await, and TypeScript to navigate it

Embed API allows users to showcase a variety of charts all on one page

Using AJAX in JavaScript within an HTML document is a valuable skill to have

Updating of an Angular Directive within a nested Directive ceases once the inner Directive has been modified

Display a different string from an array at random, revealing each one gradually with a time delay

Guide on building a Vue Js input name field with string-variable schema

Create a rectangle when the mouse is pressed down

"Trying to access jQuery .slide and .slideUp features, but unfortunately they are

VueJS: What is the easiest way to create a new instance of a div with just a click of a button?