Given an array of positive elements arr[] of length N, the task is to count all the subarrays such that the product of the subarray sum and length of the subarray should be strictly less than K.
Examples:
Input: arr[] = {6, 2, 1, 4, 3}, K = 10
Output: 6
Explanation: There are six valid subarrays: {6}, {2}, {1}, {4}, {3}, {2, 1}Input: arr[] = {1, 4, 3}, K = 5
Output: 3
Naive Approach:
Generate all the subarray and calculate the product of sum and length of the subarray, if it is strictly less than K then increment the count by 1. Finally return the count.
Follow the steps below to implement the above idea:
- Iterate over all the subarray
- Calculate the sum of the current subarray and its length
- Check if the product of sum and length is strictly less than K
- If true, increment the count by 1.
- Finally, return the count.
Below is the implementation of the above approach:
#include <bits/stdc++.h> using namespace std;
int countSubarrays(vector< int >& arr, int K)
{ int n = arr.size();
int count = 0;
// Iterate over all the subarray
for ( int i = 0; i < n; i++) {
long long sum = 0;
for ( int j = i; j < n; j++) {
// Calculate the sum of current subarray and its
// length
sum += arr[j];
int len = j - i + 1;
// Check if product of sum and length is
// strictly less than K If true, increment the
// count by 1.
if (sum * len < K)
count++;
}
}
// Finally, return the result.
return count;
} // Driver's code int main()
{ vector< int > arr = { 6, 2, 1, 4, 3 };
int K = 10;
int result = countSubarrays(arr, K);
cout << result << endl;
return 0;
} // This code is contributed by hkdass001 |
public class Main {
// Driver's code
public static void main(String[] args)
{
int [] arr = { 6 , 2 , 1 , 4 , 3 };
int K = 10 ;
int result = countSubarrays(arr, K);
System.out.println(result);
}
public static int countSubarrays( int [] arr, int K)
{
int n = arr.length;
int count = 0 ;
// Iterate over all the subarray
for ( int i = 0 ; i < n; i++) {
long sum = 0 ;
for ( int j = i; j < n; j++) {
// Calculate the sum of current subarray and
// its length
sum += arr[j];
int len = j - i + 1 ;
// Check if product of sum and length is
// strictly less than K If true, increment
// the count by 1.
if (sum * len < K)
count++;
}
}
// Finally, return the result.
return count;
}
} // This code is contributed by Tapesh(tapeshdua420) |
def countSubarrays(arr, K):
n = len (arr)
count = 0
# Iterate over all the subarray
for i in range (n):
sum = 0
for j in range (i, n):
# Calculate the sum of current subarray and its
# length
sum + = arr[j]
length = j - i + 1
# Check if product of sum and length is
# strictly less than K If true, increment the
# count by 1.
if sum * length < K:
count + = 1
# Finally, return the result.
return count
# Driver's code arr = [ 6 , 2 , 1 , 4 , 3 ]
K = 10
result = countSubarrays(arr, K)
print (result)
# This code is contributed by Tapesh(tapeshdua420) |
using System;
class Program {
// Driver's code
static void Main( string [] args)
{
int [] arr = { 6, 2, 1, 4, 3 };
int K = 10;
int result = countSubarrays(arr, K);
Console.WriteLine(result);
Console.ReadLine();
}
private static int countSubarrays( int [] arr, int K)
{
int n = arr.Length;
int count = 0;
// Iterate over all the subarray
for ( int i = 0; i < n; i++) {
long sum = 0;
for ( int j = i; j < n; j++) {
// Calculate the sum of current subarray and
// its length
sum += arr[j];
int len = j - i + 1;
// Check if product of sum and length is
// strictly less than K If true, increment
// the count by 1.
if (sum * len < K)
count++;
}
}
// Finally, return the result.
return count;
}
} // This code is contributed by Tapesh(tapeshdua420) |
function countSubarrays(arr, K)
{ let n = arr.length;
let count = 0;
// Iterate over all the subarray
for (let i = 0; i < n; i++) {
let sum = 0;
for (let j = i; j < n; j++) {
// Calculate the sum of current subarray and its
// length
sum += arr[j];
let len = j - i + 1;
// Check if product of sum and length is
// strictly less than K If true, increment the
// count by 1.
if (sum * len < K)
count++;
}
}
// Finally, return the result.
return count;
} // Driver's code let arr = [ 6, 2, 1, 4, 3 ]; let K = 10; let result = countSubarrays(arr, K); console.log(result); // This code is contributed by akashish__ |
6
Time Complexity: O(N2)
Auxiliary Space: O(1)
Efficient Approach: The problem can be solved using Two Pointer or Sliding Window Technique based on the following idea:
Keep two variables start and end, to represent the starting and ending position of any window.
- If the current window is a valid subarray then all the possible subarrays that ends at the ending index of the current window is a possible subarray. This number is the same as the length of the current window.
- If the current window is not a valid subarray then shrink the window. Keep adding all valid subarray into the result and finally return it.
Follow the steps below to implement the above idea:
- Initialize start = 0, end = 0, to represent the starting and ending position of the subarray
- Initialize a variable sum = 0, which represents the sum of elements in the current window.
- Initialize a variable result = 0 to keep track of the answer.
- While the end is less than N, do the following
- Add the element to sum.
- Calculate the length of the current window
- Check if sum * length ? K i.e., if the current window is not valid.
- Do the following until the current window becomes valid:
- Remove the contribution of the element at the starting position.
- Shift the start by 1.
- Decrement the current window length by 1.
- Check if the current window is a valid subarray:
- If true, add (end – start + 1) to result
- Shift the end by 1
- Do the following until the current window becomes valid:
- Otherwise, Include the (end – start + 1) into the result and shift the end by 1
- Finally, return the result.
Below is the implementation of the above approach:
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Function to find the count of the subarrays long long countSubarrays(vector< int >& arr, long long k)
{ long long n = arr.size();
// Initialise start = 0, end = 0, to
// represent the starting and ending
// position of the subarray
long long start = 0, end = 0;
// Initialise a variable sum, which
// represent the sum of elements in the
// current element.
long long sum = 0;
// Initialise a variable result to
// keep track of answer.
long long result = 0;
// While end is less than size of array
while (end < n) {
sum += arr[end];
int len = end - start + 1;
// Check if current window
// is not valid
if (sum * len >= k) {
// Until current window
// is not valid
while (sum * len >= k) {
// Remove the calculation
// of element at start
// position
sum -= arr[start];
start++;
len--;
}
// Check if current window
// is valid subarray
if (sum * len < k) {
// If true, add (end - start + 1)
// into result
result += end - start + 1;
}
end++;
}
// Otherwise, Include the (end - start + 1)
// into result and shift the
// end by 1
else {
result += end - start + 1;
end++;
}
}
// Finally, return the result
return result;
} // Driver code int main()
{ vector< int > arr = { 6, 2, 1, 4, 3 };
int K = 10;
// Function Call
cout << countSubarrays(arr, K);
return 0;
} // This code is contributed by hkdass001 |
// Java code to implement the approach import java.io.*;
class GFG {
// Function to find the count of the subarrays
static int countSubarrays( int [] arr, int k)
{
int n = arr.length;
// Initialise start = 0, end = 0, to
// represent the starting and ending
// position of the subarray
int start = 0 , end = 0 ;
// Initialise a variable sum, which
// represent the sum of elements in the
// current element.
int sum = 0 ;
// Initialise a variable result to
// keep track of answer.
int result = 0 ;
// While end is less than size of array
while (end < n) {
sum += arr[end];
int len = end - start + 1 ;
// Check if current window
// is not valid
if (sum * len >= k) {
// Until current window
// is not valid
while (sum * len >= k) {
// Remove the calculation
// of element at start
// position
sum -= arr[start];
start++;
len--;
}
// Check if current window
// is valid subarray
if (sum * len < k) {
// If true, add (end - start + 1)
// into result
result += end - start + 1 ;
}
end++;
}
// Otherwise, Include the (end - start + 1)
// into result and shift the
// end by 1
else {
result += end - start + 1 ;
end++;
}
}
// Finally, return the result
return result;
}
public static void main(String[] args)
{
int [] arr = { 6 , 2 , 1 , 4 , 3 };
int K = 10 ;
// Function call
System.out.print(countSubarrays(arr, K));
}
} // This code is contributed by lokeshmvs21. |
# Python code to implement the approach # Function to find the count of the subarrays def countSubarrays(arr, k):
n = len (arr)
# Initialise start = 0, end = 0, to
# represent the starting and ending
# position of the subarray
start = 0
end = 0
# Initialise a variable sum, which
# represent the sum of elements in the
# current element.
sum = 0
# Initialise a variable result to
# keep track of answer.
result = 0
# While end is less than size of array
while end < n:
sum + = arr[end]
length = end - start + 1
# Check if current window
# is not valid
if sum * length > = k:
# Until current window
# is not valid
while sum * length > = k:
# Remove the calculation
# of element at start
# position
sum - = arr[start]
start + = 1
length - = 1
# Check if current window
# is valid subarray
if sum * length < k:
# If true, add (end - start + 1)
# into result
result + = end - start + 1
end + = 1
# Otherwise, Include the (end - start + 1)
# into result and shift the
# end by 1
else :
result + = end - start + 1
end + = 1
# Finally, return the result
return result
# Driver code if __name__ = = '__main__' :
arr = [ 6 , 2 , 1 , 4 , 3 ]
K = 10
# Function Call
print (countSubarrays(arr, K))
# This code is contributed by Tapesh(tapeshdua420) |
// C# code to implement the approach using System;
class GFG {
// Function to find the count of the subarrays
static int countSubarrays( int [] arr, int k)
{
int n = arr.Length;
// Initialise start = 0, end = 0, to
// represent the starting and ending
// position of the subarray
int start = 0, end = 0;
// Initialise a variable sum, which
// represent the sum of elements in the
// current element.
int sum = 0;
// Initialise a variable result to
// keep track of answer.
int result = 0;
// While end is less than size of array
while (end < n) {
sum += arr[end];
int len = end - start + 1;
// Check if current window
// is not valid
if (sum * len >= k) {
// Until current window
// is not valid
while (sum * len >= k) {
// Remove the calculation
// of element at start
// position
sum -= arr[start];
start++;
len--;
}
// Check if current window
// is valid subarray
if (sum * len < k) {
// If true, add (end - start + 1)
// into result
result += end - start + 1;
}
end++;
}
// Otherwise, Include the (end - start + 1)
// into result and shift the
// end by 1
else {
result += end - start + 1;
end++;
}
}
// Finally, return the result
return result;
}
public static void Main()
{
int [] arr = { 6, 2, 1, 4, 3 };
int K = 10;
// Function call
Console.WriteLine(countSubarrays(arr, K));
}
} // This code is contributed by Samim Hossain Mondal. |
// Function to find the count of the subarrays function countSubarrays(arr, k) {
n = arr.length;
// Initialise start = 0, end = 0, to
// represent the starting and ending
// position of the subarray
start = 0;
end = 0;
// Initialise a variable sum, which
// represent the sum of elements in the
// current element.
sum = 0;
// Initialise a variable result to
// keep track of answer.
result = 0;
// While end is less than size of array
while (end < n) {
sum += arr[end];
length = end - start + 1;
// Check if current window
// is not valid
if (sum * length >= k) {
// Until current window
// is not valid
while (sum * length >= k) {
// Remove the calculation
// of element at start
// position
sum -= arr[start];
start += 1;
length -= 1;
}
// Check if current window
// is valid subarray
if (sum * length < k) {
// If true, add (end - start + 1)
// into result
result += end - start + 1;
}
end += 1;
}
// Otherwise, Include the (end - start + 1)
// into result and shift the
// end by 1
else {
result += end - start + 1;
end += 1;
}
}
// Finally, return the result
return result;
} // Driver code arr = [6, 2, 1, 4, 3]; K = 10; // Function Call console.log(countSubarrays(arr, K)); // This code is contributed by Tapesh(tapeshdua420) |
6
Time Complexity: O(N)
Auxiliary Space: O(1)
Related Articles: