JavaScript program to maximize elements using another array

In this article, we will implement a JavaScript program to maximize elements using another array. We have two arrays and have to pick some elements from the second array and replace the elements of the first array. We will see the complete code that implements the concepts that will be discussed.

Problem Introduction

In this problem we have two arrays and we have to make all the elements of the first array the largest possible, or simply we have to make the sum of all the elements of the first array the largest. We can select elements from the second array, but the point is that we have to select an element from the second array only once, after which we can only select another element. For example -

We have two arrays -

Array1: 1 2 3 4 5 
Array2: 5 6 2 1 9

We can see that many elements in the second array are larger than those present in the first array.

We can choose 9 instead of 3, 6 instead of 2, and 5 instead of 1. This makes the final array look like this -

5 6 9 4 5 

We will see two methods, both implemented by sorting an array and two pointers, but the only difference is where we will select the pointer.

method

We have seen the above example, from which we can see that we can swap the small elements in the first array with the largest element in the second array.

• Step 1 - First, we will sort both arrays in ascending order and then reverse the second array so that it is sorted in descending order.

• Step 2 - We will maintain two pointers to the first index of both arrays.

• Step 3 - Since the first element pointer will point to the smallest number, we can trade that number with the largest number of the second array.

• Step 4 - On each iteration we will swap the two array pointers and increment the pointers.

• Step 5 - If the element of the current index of the first array becomes larger compared to the element of the second array, then we can stop further steps.

• Step 6 - Finally, we will print the elements of the array.

Example

// function to find the maximum array
function maximumArray(array1, array2){
   var len1 = array1.length
   var len2 = array2.length
   
   // sorting the elements of both arrays
   array1.sort()
   array2.sort()
   
   // reversing the arrays
   array1.reverse()
   array2.reverse()
   
   // traversing over the arrays
   var ptr1 = 0
   var ptr2 = 0
   var ptr3 = 0
   
   // creating new array to store the answer
   var ans = new Array(len1);
   while(ptr3 < len1){
      if(ptr2 == len2){
         while(ptr3 != len1){
            ans[ptr3] = array1[ptr1];
            ptr3++;
            ptr1++;
         }
      }
      else if(array1[ptr1] > array2[ptr2]){
         ans[ptr3] = array1[ptr1];
         ptr1++;
      } else {
         ans[ptr3] = array2[ptr2];
         ptr2++;
      }
      ptr3++;
   }
   console.log("The final array is: ")
   console.log(ans)
}
// declaring arrays
array1 = [1, 2, 4, 5, 3]
array2 = [5, 6, 2, 1, 9]

// calling the function
maximumArray(array1,array2)

Time and space complexity

The time complexity of the above code is O(N*log(N)), where N is the size of the given array, and the logarithmic factor here is due to the sorting function we use to sort the array. < /p>

We use an extra array to store the elements, which makes the space complexity O(N), but the array is needed to store its answer, which may or may not be considered extra space.

Direct sorting method

In the previous method we sorted the elements of the array and then used two pointer methods, but there is a direct method with the help of which we can do this simply -

• By using new keyword and Array keyword, we will create a new array whose size is the sum or length of the two given arrays.

• We fill all the elements of the two given arrays into the new array one by one.

• We will sort the newly created array to arrange the elements in ascending order.

• All the greatest elements appear at the end and we can get them easily.

Example

// function to find the maximum array
function maximumArray(array1, array2){
   var len1 = array1.length
   var len2 = array2.length
   var ans = new Array(len1+len2);
   for(var i = 0; i<len1; i++){
      ans[i] = array1[i];
   }
   for(var i = 0; i< len2; i++){
      ans[i+len1] = array2[i];
   }
   ans.sort();
   for(var i = 0;i<len1;i++){
      array1[i] = ans[len2+len1-i-1];
   }
   console.log("The final array is: ")
   console.log(array1)
}

// declaring arrays
array1 = [1, 2, 4, 5, 3]
array2 = [5, 6, 2, 1, 9]
// calling the function
maximumArray(array1,array2)

Time and space complexity

The time complexity of the above code is O(N*log(N)), where N is the size of the given array, and the logarithmic factor here is due to the sorting function we use to sort the array.

We use an extra array to store the elements, which makes the space complexity O(N).

in conclusion

In the tutorial above, we have implemented a JavaScript program that maximizes elements using another array. We have two arrays and have to pick some elements from the second array and replace the elements of the first array. We have seen that both methods use the concept of sorting. One method with two pointers takes O(N*log(N)) time and O(1) space, while the other method takes the same time but O(N) space.

The above is the detailed content of JavaScript program to maximize elements using another array. For more information, please follow other related articles on the PHP Chinese website!