Maximum sum bitonic subarray

<script>

    // Javascript implementation to find 
    // the maximum sum bitonic subarray
    
    // function to find the maximum 
    // sum bitonic subarray
    function maxSumBitonicSubArr(arr, n)
    {
      // 'msis[]' to store the maximum 
      // sum increasing subarray up to
      // each index of 'arr' from the 
      // beginning 'msds[]' to store 
      // the maximum sum decreasing 
      // subarray from each index of 
      // 'arr' up to the end
      let msis = new Array(n);
      msis.fill(0);
      let msds = new Array(n);
      msds.fill(0);
        
      // to store the maximum 
      // sum bitonic subarray
      let max_sum = Number.MIN_VALUE;

      // building up the maximum 
      // sum increasing subarray
      // for each array index
      msis[0] = arr[0];
      for (let i = 1; i < n; i++)
          if (arr[i] > arr[i - 1])
              msis[i] = msis[i - 1] + arr[i];
          else
              msis[i] = arr[i]; 

      // building up the maximum 
      // sum decreasing subarray
      // for each array index
      msds[n - 1] = arr[n - 1];
      for (let i = n - 2; i >= 0; i--)
          if (arr[i] > arr[i + 1])
              msds[i] = msds[i + 1] + arr[i];
          else
              msds[i] = arr[i];

      // for each array index, calculating 
      // the maximum sum of bitonic subarray
      // of which it is a part of
      for (let i = 0; i < n; i++)    

          // if true , then update 
          // 'max' bitonic subarray sum
          if (max_sum < (msis[i] + msds[i] - arr[i]))
              max_sum = msis[i] + msds[i] - arr[i];

      // required maximum sum
      return max_sum;
    }
    
    let arr = [5, 3, 9, 2, 7, 6, 4];
    let n = arr.length;
    document.write("Maximum Sum = " 
    + maxSumBitonicSubArr(arr, n));
    
</script>

<script>
// Javascript implementation to find the
// maximum sum bitonic subarray
    
    function find_partial_sum(arr,start,end)
    {
        let sum = 0;
    for(let i = start; i < end; i++)
        sum += arr[i];
         
    return sum;
    }

// Function to find the maximum sum bitonic
// subarray.
function maxSumBitonicSubArr(arr,n)
{
    // To store the maximum sum
    // bitonic subarray
    let max_sum = -1000000;
 
    let i = 0;
    while (i < n)
    {
         
        // Find the longest increasing
        // subarray starting at i.
        let j = i;
        while (j + 1 < n && arr[j] < arr[j + 1])
            j++;
 
        // Now we know that a[i..j] is an
        // increasing subarray. Remove non-
        // positive elements from the left
        // side as much as possible.
        while (i < j && arr[i] <= 0)
            i++;
 
        // Find the longest decreasing subarray
        // starting at j.
        let k = j;
        while (k + 1 < n && arr[k] > arr[k + 1])
            k++;
 
        // Now we know that a[j..k] is a
        // decreasing subarray. Remove non-
        // positive elements from the right
        // side as much as possible.
        // last is needed to keep the last
        // seen element.
        let last = k;
        while (k > j && arr[k] <= 0)
            k--;
 
        // Compute the max sum of the
        // increasing part.
        let sum_inc = find_partial_sum(arr, i,
                                       j + 1);
 
        // Compute the max sum of the
        // decreasing part.
        let sum_dec = find_partial_sum(arr, j,
                                       k + 1);
 
        // The overall max sum is the sum of
        // both parts minus the peak element,
        // because it was counted twice.
        let sum_all = sum_inc + sum_dec - arr[j];
 
        max_sum = Math.max(Math.max(max_sum, sum_inc),
                           Math.max(sum_dec, sum_all));
 
        // If the next element is equal to the
        // current, i.e. arr[i+1] == arr[i],
        // last == i.
        // To ensure the algorithm has progress,
        // get the max of last and i+1.
        i = Math.max(last, i + 1);
    }
     
    // Required maximum sum
    return max_sum;
}

// The example from the article, the
// answer is 19.
let arr = [ 5, 3, 9, 2, 7, 6, 4 ];
let n = arr.length;
document.write("Maximum sum = " +
                   maxSumBitonicSubArr(arr, n)+"<br>");

// Always increasing, the answer is 15.
let arr2 = [ 1, 2, 3, 4, 5 ];
let n2 = arr2.length;
document.write("Maximum sum = " +
                   maxSumBitonicSubArr(arr2, n2)+"<br>");

// Always decreasing, the answer is 15.
let arr3 = [ 5, 4, 3, 2, 1 ];
let n3 = arr3.length;
document.write("Maximum sum = " +
                   maxSumBitonicSubArr(arr3, n3)+"<br>");

// All are equal, the answer is 5.
let arr4 = [ 5, 5, 5, 5 ];
let n4 = arr4.length;
document.write("Maximum sum = " +
                   maxSumBitonicSubArr(arr4, n4)+"<br>");

// The whole array is bitonic,
// but the answer is 7.
let arr5 = [ -1, 0, 1, 2, 3,
              1, 0, -1, -10 ];
let n5 = arr5.length;
document.write("Maximum sum = " +
                   maxSumBitonicSubArr(arr5, n5)+"<br>");

// The answer is 4 (the tail).
let arr6 = [ -1, 0, 1, 2, 0,
              -1, -2, 0, 1, 3 ];
let n6 = arr6.length;
document.write("Maximum sum = " +
                   maxSumBitonicSubArr(arr6, n6)+"<br>");


// This code is contributed by patel2127
</script>