Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
JavaScript Program for Maximum Sum of i*arr[i] Among all Rotations of a Given Array
In this article, we will implement the JavaScript program for the Maximum sum of i*arr[i] among all the rotations of the given array. Here i*arr[i] expression indicates that we have to maximize the sum of all the elements of the array by taking the product of them with the current position. We can rotate the given array elements in the left of the right position to get the maximum answer. For this problem, we will see a complete code and a deep explanation.
Introduction to Problem
In this problem, we are given an array and if we multiply all the elements with their respective index numbers then taking the sum of all will produce a number. By one rotation we can move the leftmost or the rightmost element to the opposite side of the array, which leads to changing the index of each element and we can apply this rotation any number of times (but after the number of rotations equal to the length of the array we will get the same array as the first), by rotating the array we can change the index of the elements and hence can change the sum of the i*arr[i].
We will try to maximize the sum with two approaches, first, let us see the example −
Given array: 1 3 2 4 2 0th rotation sum: 1*0 + 3*1 + 2*2 + 4*3 + 2*4 = 27 1st rotation sum: 2*0 + 1*1 + 3*2 + 2*3 + 4*4 = 29 2nd rotation sum: 4*0 + 2*1 + 1*2 + 3*3 + 2*4 = 21 3rd rotation sum: 2*0 + 4*1 + 2*2 + 1*3 + 3*4 = 23 4th rotation sum: 3*0 + 2*1 + 4*2 + 2*3 + 1*4 = 20
We can see that on the first rotation, we are getting the highest sum which is the 29.
Approach
There are two approaches that we can implement to find the required sum, let’s see both of them −
Approach one is the naive approach in which we will find all the rotations of the array in O(N) time and for each rotation, we will find the sum of all the elements by traversing over the array in O(N) time, without using any extra space.
Example
// function to find the maximum rotation sum
function maxSum(arr){
var len = arr.length
var ans = -10000000000 // variable to store the answer
// for loop to find all the rotations of the array
for(var i = 0; i < len; i++) {
var cur_sum = 0;
for(var j = 0; j <len ;j++) {
cur_sum += j*arr[j];
}
if(ans < cur_sum){
ans = cur_sum;
}
var temp = arr[len-1];
var temp2
for(var j=0; j<len; j++){
temp2 = arr[j];
arr[j] = temp;
temp = temp2
}
}
console.log("The required maximum sum is: " + ans)
}
// defining the array
arr = [1, 3, 2, 4, 2]
maxSum(arr)
Time and Space Complexity
The time complexity of the above code is O(N*N) where N is the size of the array and the space complexity of the above code is O(1).
At each iteration, we have only a difference of a single factor for the last element only because its factor will be updated from array length - 1 to 0 for the other elements their one more factor will be added. So we can write code as −
Example
// function to find the maximum rotation sum
function maxSum(arr){
var len = arr.length
var ans = -10000000000 // variable to store the answer
// for loop to find all the rotations of the array
var total_sum = 0;
for (var i=0; i<len; i++){
total_sum += arr[i];
}
var cur_val = 0;
for (var i=0; i<len; i++){
cur_val += i*arr[i];
}
// Initialize result
var ans = cur_val;
// Compute values for other iterations
for (var i=1; i<len; i++) {
var val = cur_val - (total_sum - arr[i-1]) + arr[i-1] * (len-1);
cur_val = val;
if(ans < val) {
ans = val
}
}
console.log("The required maximum sum is: " + ans)
}
// defining the array
arr = [1, 3, 2, 4, 2]
maxSum(arr)
Time and Space Complexity
The time complexity of the above code is O(N), where N is the size of the array and the space complexity of the above code is O(1). This approach is very better as compared to the previous one.
Conclusion
In this tutorial, we have implemented the JavaScript program for the Maximum sum of i*arr[i] among all the rotations of the given array. We have seen two approaches one with finding all the rotations of the given array and then comparing their result for the expression i*arr[i]. In the second approach, we have obtained the time complexity of O(N) over the O(N*N) by using the mathematical approach.
92 Views
