Skip to content
Related Articles

Related Articles

Maximum sum of lengths of non-overlapping subarrays with k as the max element.

Improve Article
Save Article
Like Article
  • Difficulty Level : Medium
  • Last Updated : 09 May, 2022

Find the maximum sum of lengths of non-overlapping subarrays (contiguous elements) with k as the maximum element. 
Examples: 

Input : arr[] = {2, 1, 4, 9, 2, 3, 8, 3, 4} 
        k = 4
Output : 5
{2, 1, 4} => Length = 3
{3, 4} => Length = 2
So, 3 + 2 = 5 is the answer

Input : arr[] = {1, 2, 3, 2, 3, 4, 1} 
        k = 4
Output : 7
{1, 2, 3, 2, 3, 4, 1} => Length = 7

Input : arr = {4, 5, 7, 1, 2, 9, 8, 4, 3, 1}
        k = 4
Ans = 4
{4} => Length = 1
{4, 3, 1} => Length = 3
So, 1 + 3 = 4 is the answer

question source : https://www.geeksforgeeks.org/amazon-interview-experience-set-376-campus-internship/

Algorithm : 

Traverse the array starting from first element
   Take a loop and keep on incrementing count 
   If element is less than equal to k
       if array element is equal to k, then mark
       a flag
   
   If flag is marked, add this count to answer
   
   Take another loop and traverse the array 
   till element is greater than k
return ans

C++




// CPP program to calculate max sum lengths of
// non overlapping contiguous subarrays with k as
// max element
#include <bits/stdc++.h>
using namespace std;
  
// Returns max sum of lengths with maximum element
// as k
int calculateMaxSumLength(int arr[], int n, int k)
{
    int ans = 0; // final sum of lengths
  
    // number of elements in current subarray
    int count = 0;
  
    // variable for checking if k appeared in subarray
    int flag = 0;
  
    for (int i = 0; i < n;) {
        count = 0;
        flag = 0;
  
        // count the number of elements which are
        // less than equal to k
        while (arr[i] <= k && i < n) {
            count++;
            if (arr[i] == k)
                flag = 1;
            i++;
        }
  
        // if current element appeared in current
        // subarray add count to sumLength
        if (flag == 1)
            ans += count;   
  
        // skip the array elements which are
        // greater than k
        while (arr[i] > k && i < n)
            i++;    
    }
    return ans;
}
  
// driver program
int main()
{
    int arr[] = { 4, 5, 7, 1, 2, 9, 8, 4, 3, 1 };
    int size = sizeof(arr) / sizeof(arr[0]);
    int k = 4;
    int ans = calculateMaxSumLength(arr, size, k);
    cout << "Max Length :: " << ans << endl;
    return 0;
}

Java




// A Java program to calculate max sum lengths of
// non overlapping contiguous subarrays with k as
// max element
public class GFG
{
    // Returns max sum of lengths with maximum element
    // as k
    static int calculateMaxSumLength(int arr[], int n, int k) {
        int ans = 0; // final sum of lengths
 
        // number of elements in current subarray
        int count = 0;
 
        // variable for checking if k appeared in subarray
        int flag = 0;
 
        for (int i = 0; i < n;) {
            count = 0;
            flag = 0;
 
            // count the number of elements which are
            // less than equal to k
            while (i < n && arr[i] <= k) {
                count++;
                if (arr[i] == k)
                    flag = 1;
                i++;
            }
 
            // if current element appeared in current
            // subarray add count to sumLength
            if (flag == 1)
                ans += count;
 
            // skip the array elements which are
            // greater than k
            while (i < n && arr[i] > k)
                i++;
        }
        return ans;
    }
 
    // driver program to test above method
    public static void main(String[] args) {
 
        int arr[] = { 4, 5, 7, 1, 2, 9, 8, 4, 3, 1 };
        int size = arr.length;
        int k = 4;
        int ans = calculateMaxSumLength(arr, size, k);
        System.out.println("Max Length :: " + ans);
    }
}
// This code is contributed by Sumit Ghosh

Python3




# Python program to calculate max sum lengths of non
# overlapping contiguous subarrays with k as max element
 
# Returns max sum of lengths with max elements as k
def calculateMaxSumLength(arr, n, k):
    ans = 0 # final sum of lengths
    i=0
    while i < n :
         
        # number of elements in current sub array
        count = 0
         
        # Variable for checking if k appeared in the sub array
        flag = 0
         
        # Count the number of elements which are
        # less than or equal to k
        while i < n and arr[i] <= k :
            count = count + 1
            if arr[i] == k:
                flag = 1
            i = i + 1
             
        # if current element appeared in current
        # subarray and count to sumLength
        if flag == 1:
            ans = ans + count
             
        # skip the array elements which are greater than k
        while i < n and arr[i] > k :
            i = i + 1
              
    return ans
     
# Driver Program
arr = [4, 5, 7, 1, 2, 9, 8, 4, 3, 1]
size = len(arr)
k = 4
ans = calculateMaxSumLength(arr, size, k)
print ("Max Length ::",ans)
 
# Contributed by Rohit

C#




// A C# program to calculate max
// sum lengths of non overlapping
// contiguous subarrays with k as
// max element
using System;
class GFG {
     
    // Returns max sum of lengths
    // with maximum element as k
    static int calculateMaxSumLength(int []arr,
                                     int n,
                                     int k)
    {
         
        // final sum of lengths
        int ans = 0;
 
        // number of elements in
        // current subarray
        int count = 0;
 
        // variable for checking if
        // k appeared in subarray
        int flag = 0;
 
        for(int i = 0; i < n;)
        {
            count = 0;
            flag = 0;
 
            // count the number of
            // elements which are
            // less than equal to k
            while (i < n && arr[i] <= k)
            {
                count++;
                if (arr[i] == k)
                    flag = 1;
                i++;
            }
 
            // if current element
            // appeared in current
            // subarray add count
            // to sumLength
            if (flag == 1)
                ans += count;
 
            // skip the array
            // elements which are
            // greater than k
            while (i < n && arr[i] > k)
                i++;
        }
        return ans;
    }
 
    // Driver Code
    public static void Main()
    {
        int []arr = {4, 5, 7, 1, 2, 9, 8, 4, 3, 1};
        int size = arr.Length;
        int k = 4;
        int ans = calculateMaxSumLength(arr, size, k);
        Console.WriteLine("Max Length :: " + ans);
    }
}
 
// This code is contributed by anuj_67.

PHP




<?php
// PHP program to calculate max sum lengths
// of non overlapping contiguous subarrays
// with k as max element
 
// Returns max sum of lengths with maximum
// element as k
function calculateMaxSumLength(&$arr, $n, $k)
{
    $ans = 0; // final sum of lengths
 
    // number of elements in current subarray
    $count = 0;
 
    // variable for checking if k
    // appeared in subarray
    $flag = 0;
 
    for ($i = 0; $i < $n😉
    {
        $count = 0;
        $flag = 0;
 
        // count the number of elements which
        // are less than equal to k
        while ($arr[$i] <= $k && $i < $n)
        {
            $count++;
            if ($arr[$i] == $k)
                $flag = 1;
            $i++;
        }
 
        // if current element appeared in current
        // subarray add count to sumLength
        if ($flag == 1)
            $ans += $count;
 
        // skip the array elements which are
        // greater than k
        while ($arr[$i] > $k && $i < $n)
            $i++;    
    }
    return $ans;
}
 
// Driver Code
$arr = array( 4, 5, 7, 1, 2,   
              9, 8, 4, 3, 1 );
$size = sizeof($arr);
$k = 4;
$ans = calculateMaxSumLength($arr, $size, $k);
echo "Max Length :: " . $ans . "\n";
 
// This code is contributed by ita_c
?>

Javascript




<script>
// A Javascript program to calculate max sum lengths of
// non overlapping contiguous subarrays with k as
// max element
     
    // Returns max sum of lengths with maximum element
    // as k
    function calculateMaxSumLength(arr,n,k)
    {
        let ans = 0; // final sum of lengths
  
        // number of elements in current subarray
        let count = 0;
  
        // variable for checking if k appeared in subarray
        let flag = 0;
  
        for (let i = 0; i < n;) {
            count = 0;
            flag = 0;
  
            // count the number of elements which are
            // less than equal to k
            while (i < n && arr[i] <= k) {
                count++;
                if (arr[i] == k)
                    flag = 1;
                i++;
            }
  
            // if current element appeared in current
            // subarray add count to sumLength
            if (flag == 1)
                ans += count;
  
            // skip the array elements which are
            // greater than k
            while (i < n && arr[i] > k)
                i++;
        }
        return ans;
    }
     
    // driver program to test above method
    let arr=[4, 5, 7, 1, 2, 9, 8, 4, 3, 1];
    let size = arr.length;
    let k = 4;
    let ans = calculateMaxSumLength(arr, size, k);
    document.write("Max Length :: " + ans);
     
    //This code is contributed by avanitrachhadiya2155
     
</script>
Output
Max Length :: 4

Time Complexity : O(n) 
It may look like O(n2), but if you take a closer look, array is traversed only once
This article is contributed by Mandeep Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Another approach:

Algorithm:

Traverse the array from first element to last element
    if the element is less than k increment the count
    if the element is equals to k 
        if k is not found
            increment the count and mark flag as 1
        if k is found
            add the value of count to ans and mark count as 1
    if the element is greater than k
            if k is present in the subarray add the value of count to ans and
            assign value of count and flag variables as 0
finally check again if k value is found in subarray or not
    if k is found return sum of answer and count
    if not return ans

            

C++




// C++ program to find Maximum sum of lengths of
// non-overlapping subarrays with k as the max element.
#include <bits/stdc++.h>
using namespace std;
// Below function calculates the Maximum sum of lengths of
// non-overlapping subarrays with k as the max element.
int calculateMaxSumLength(int arr[], int n, int k)
{
    // maximum sum of lengths
    int ans = 0;
    // number of elements in current subarray
    int count = 0;
    // flag variable for checking if k is present
    // in current subarray or not
    int flag = 0;
    for (int i = 0; i < n; i++) {
        // increment the count if element in arr is less
        // than k
        if (arr[i] < k) {
            count++;
        }
        // if the element is equals to k
        else if (arr[i] == k) {
            if (flag == 0) {
                count++;
                flag = 1;
            }
            // if flag is 1, we can say k is already present
            // in that subarray. So, add the value of count
            // to ans variable and make the count value as 1
            // because we found the k
            else {
                ans += count;
                count = 1;
            }
        }
        // if element in arr is greater than k
        else {
            // if k is present in the subarray
            // add the value of count to ans variable
            if (flag == 1) {
                ans += count;
            }
            // assign value of count and flag variables as 0
            count = 0;
            flag = 0;
        }
    }
    // Check again if k value is found in subarray
    // if k is found, return sum of values of variables ans
    // and count if k is not found, return value of variable
    // ans.
    if (flag == 1) {
        return ans + count;
    }
    return ans;
}
// driver program
int main()
{
    int arr[] = { 4, 5, 7, 1, 2, 9, 8, 4, 3, 1 };
    int size = sizeof(arr) / sizeof(arr[0]);
    int k = 4;
    int ans = calculateMaxSumLength(arr, size, k);
    cout << "Max Length :: " << ans << endl;
    return 0;
}
// Contributed by Ravi Teja Kuchipudi

Java




// JAVA program to find Maximum sum of lengths of
// non-overlapping subarrays with k as the max element.
class GFG {
    // Below function calculates the Maximum sum of lengths
    // of non-overlapping subarrays with k as the max
    // element.
    static int calculateMaxSumLength(int arr[], int n,
                                     int k)
    {
        // maximum sum of lengths
        int ans = 0;
        // number of elements in current subarray
        int count = 0;
        // flag variable for checking if k is present
        // in current subarray or not
        int flag = 0;
        for (int i = 0; i < n; i++) {
            // increment the count if element in arr is less
            // than k
            if (arr[i] < k) {
                count++;
            }
            // if the element is equals to k
            else if (arr[i] == k) {
                // if flag is equals to 0 then make flag
                // variable value as 1 and increment the
                // count.
                if (flag == 0) {
                    count++;
                    flag = 1;
                }
                // if flag is 1, we can say k is already
                // present in that subarray. So, add the
                // value of count to ans variable and make
                // the count value as 1 because we found the
                // k
                else {
                    ans += count;
                    count = 1;
                }
            }
            // if element in arr is greater than k
            else {
                // if k is present in the subarray
                // add the value of count to ans variable
                if (flag == 1) {
                    ans += count;
                }
                // assign value of count and flag variables
                // as 0
                count = 0;
                flag = 0;
            }
        }
        // Check again if k value is found in subarray
        // if k is found, return sum of values of variables
        // ans and count if k is not found, return value of
        // variable ans.
        if (flag == 1) {
            return ans + count;
        }
        return ans;
    }
    // driver program to test above method
    public static void main(String[] args)
    {
        int arr[] = { 4, 5, 7, 1, 2, 9, 8, 4, 3, 1 };
        int size = arr.length;
        int k = 4;
        int ans = calculateMaxSumLength(arr, size, k);
        System.out.println("Max Length :: " + ans);
    }
}
// Contributed by Ravi Teja Kuchipudi

Python3




# program to find Maximum sum of lengths of
# non-overlapping subarrays with k as the max element.
 
 
def calculateMaxSumLength(arr, n, k):
    # maximum sum of lengths
    ans = 0
    # number of elements in current subarray
    count = 0
    # flag variable for checking if k is present in current subarray or not
    flag = 0
 
    for i in range(n):
        # increment the count if element in arr is less than k
        if arr[i] < k:
            count = count+1
        # if the element is equals to k
        elif arr[i] == k:
            # if flag is equals to 0 then make flag variable value as 1 and
            # increment the count.
            if flag == 0:
                count = count + 1
                flag = 1
            # if flag is 1, we can say k is already present in that subarray.
            # So, add the value of count to ans variable and
            # make the count value as 1 because we found the k
            else:
                ans = ans + count
                count = 1
        # if element in arr is greater than k
        else:
            # if k is present in the subarray
            # add the value of count to ans variable
            if flag == 1:
                ans = ans + count
            # assign value of count and flag variables as 0
            count = 0
            flag = 0
    # Check again if k value is found in subarray
    # if k is found, return sum of values of variables ans and count
    # if k is not found, return value of variable ans.
    if flag == 1:
        return ans + count
    return ans
 
 
# Driver Program
arr = [4, 5, 7, 1, 2, 9, 8, 4, 3, 1]
size = len(arr)
k = 4
ans = calculateMaxSumLength(arr, size, k)
print("Max Length ::", ans)
 
# Contributed by Ravi Teja Kuchipudi

Javascript




<script>
 
// JavaScript program to find Maximum sum of lengths of
// non-overlapping subarrays with k as the max element.
 
// Below function calculates the Maximum sum of lengths of
// non-overlapping subarrays with k as the max element.
function calculateMaxSumLength(arr, n, k)
{
    // maximum sum of lengths
    let ans = 0;
     
    // number of elements in current subarray
    let count = 0;
     
    // flag variable for checking if k is present
    // in current subarray or not
    let flag = 0;
    for (let i = 0; i < n; i++)
    {
     
        // increment the count if element in arr is less
        // than k
        if (arr[i] < k) {
            count++;
        }
         
        // if the element is equals to k
        else if (arr[i] == k) {
            if (flag == 0) {
                count++;
                flag = 1;
            }
             
            // if flag is 1, we can say k is already present
            // in that subarray. So, add the value of count
            // to ans variable and make the count value as 1
            // because we found the k
            else {
                ans += count;
                count = 1;
            }
        }
         
        // if element in arr is greater than k
        else
        {
         
            // if k is present in the subarray
            // add the value of count to ans variable
            if (flag == 1)
            {
                ans += count;
            }
             
            // assign value of count and flag variables as 0
            count = 0;
            flag = 0;
        }
    }
     
    // Check again if k value is found in subarray
    // if k is found, return sum of values of variables ans
    // and count if k is not found, return value of variable
    // ans.
    if (flag == 1) {
        return ans + count;
    }
    return ans;
}
 
// driver program
let arr = [ 4, 5, 7, 1, 2, 9, 8, 4, 3, 1 ];
let size = arr.length;
let k = 4;
let ans = calculateMaxSumLength(arr, size, k);
document.write("Max Length :: ",ans,"</br>");
 
// This code is contributed by shinjanpatra
 
</script>
Output
Max Length :: 4

Time Complexity : O(n) 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!