Count subarrays which contains both the maximum and minimum array element
Last Updated :
11 Nov, 2023
Given an array arr[] consisting of N distinct integers, the task is to find the number of subarrays which contains both the maximum and the minimum element from the given array.
Examples:
Input: arr[] = {1, 2, 3, 4}
Output: 1
Explanation:
Only a single subarray {1, 2, 3, 4} consists of both the maximum (= 4) and the minimum (= 1) array elements.
Input: arr[] = {4, 1, 2, 3}
Output: 3
Explanation:
Subarrays {4, 1} , {4, 1, 2}, {4, 1, 2, 3} consists of both the maximum(= 4) and the minimum(= 1) array elements .
Naive Approach: The simplest approach is to first, traverse the array and find the maximum and minimum of the array and then generate all possible subarrays of the given array. For each subarray, check if it contains both the maximum and the minimum array element. For all such subarrays, increase the count by 1. Finally, print the count of such subarrays.
Code-
C++
#include <bits/stdc++.h>
using namespace std;
int countSubArray( int arr[], int n)
{
int maxi=INT_MIN;
int mini=INT_MAX;
for ( int i=0;i<n;i++){
maxi=max(maxi,arr[i]);
mini=min(mini,arr[i]);
}
int count=0;
for ( int i=0;i<n;i++){
int temp_max=arr[i];
int temp_min=arr[i];
for ( int j=i;j<n;j++){
if (arr[j]>temp_max){temp_max=arr[j];}
if (arr[j]<temp_min){temp_min=arr[j];}
if ((mini==temp_min) && (maxi==temp_max) ){
count++;
}
}
}
return count;
}
int main()
{
int arr[] = { 4,1,2,3 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << countSubArray(arr, n);
return 0;
}
|
Java
import java.util.*;
import java.io.*;
public class GFG {
public static int countSubArray( int [] arr, int n) {
int maxi = Integer.MIN_VALUE;
int mini = Integer.MAX_VALUE;
for ( int i = 0 ; i < n; i++) {
maxi = Math.max(maxi, arr[i]);
mini = Math.min(mini, arr[i]);
}
int count = 0 ;
for ( int i = 0 ; i < n; i++) {
int tempMax = arr[i];
int tempMin = arr[i];
for ( int j = i; j < n; j++) {
if (arr[j] > tempMax) {
tempMax = arr[j];
}
if (arr[j] < tempMin) {
tempMin = arr[j];
}
if (mini == tempMin && maxi == tempMax) {
count++;
}
}
}
return count;
}
public static void main(String[] args) {
int [] arr = { 4 , 1 , 2 , 3 };
int n = arr.length;
System.out.println(countSubArray(arr, n));
}
}
|
Python3
def countSubArray(arr):
maxi = float ( '-inf' )
mini = float ( 'inf' )
for element in arr:
maxi = max (maxi, element)
mini = min (mini, element)
count = 0
for i in range ( len (arr)):
temp_max = arr[i]
temp_min = arr[i]
for j in range (i, len (arr)):
if arr[j] > temp_max:
temp_max = arr[j]
if arr[j] < temp_min:
temp_min = arr[j]
if mini = = temp_min and maxi = = temp_max:
count + = 1
return count
arr = [ 4 , 1 , 2 , 3 ]
result = countSubArray(arr)
print (result)
|
C#
using System;
class GFG
{
static int CountSubArray( int [] arr, int n)
{
int maxi = int .MinValue;
int mini = int .MaxValue;
for ( int i = 0; i < n; i++)
{
maxi = Math.Max(maxi, arr[i]);
mini = Math.Min(mini, arr[i]);
}
int count = 0;
for ( int i = 0; i < n; i++)
{
int tempMax = arr[i];
int tempMin = arr[i];
for ( int j = i; j < n; j++)
{
if (arr[j] > tempMax) tempMax = arr[j];
if (arr[j] < tempMin) tempMin = arr[j];
if (mini == tempMin && maxi == tempMax)
{
count++;
}
}
}
return count;
}
static void Main( string [] args)
{
int [] arr = { 4, 1, 2, 3 };
int n = arr.Length;
Console.WriteLine(CountSubArray(arr, n));
}
}
|
Javascript
function countSubArray(arr) {
let maxi = Number.MIN_SAFE_INTEGER;
let mini = Number.MAX_SAFE_INTEGER;
for (let i = 0; i < arr.length; i++) {
maxi = Math.max(maxi, arr[i]);
mini = Math.min(mini, arr[i]);
}
let count = 0;
for (let i = 0; i < arr.length; i++) {
let temp_max = arr[i];
let temp_min = arr[i];
for (let j = i; j < arr.length; j++) {
if (arr[j] > temp_max) {
temp_max = arr[j];
}
if (arr[j] < temp_min) {
temp_min = arr[j];
}
if (mini == temp_min && maxi == temp_max) {
count++;
}
}
}
return count;
}
let arr = [4, 1, 2, 3];
console.log(countSubArray(arr));
|
Output-
3
Time Complexity: O(N2)
Auxiliary Space: O(1)
Efficient Approach: Follow the steps below to optimize the above approach:
- Find the index of the maximum and minimum elements. Let i and j be the respective indices such that i < j.
- All the subarray which starts from indices up to i and ends at indices after j will contain the maximum as well as the minimum array element.
- Therefore, the possible indices for the starting index of the subarray are [0, i] (total = i + 1 ).
- Therefore, the possible indices for the ending index of the subarray are [j, N – 1] (total = N – j).
- Therefore, the count of subarrays is given by (i + 1) * ( N – j).
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int countSubArray( int arr[], int n)
{
if (n < 2)
return n;
int i
= max_element(arr, arr + n) - arr;
int j
= min_element(arr, arr + n) - arr;
if (i > j)
swap(i, j);
return (i + 1) * (n - j);
}
int main()
{
int arr[] = { 4, 1, 2, 3 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << countSubArray(arr, n);
return 0;
}
|
Java
import java.util.*;
import java.lang.*;
class GFG{
static int countSubArray( int arr[], int n)
{
if (n < 2 )
return n;
int i = max_element(arr);
int j = min_element(arr);
if (i > j)
{
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
return (i + 1 ) * (n - j);
}
static int max_element( int [] arr)
{
int idx = 0 ;
int max = arr[ 0 ];
for ( int i = 1 ; i < arr.length; i++)
{
if (max < arr[i])
{
max = arr[i];
idx = i;
}
}
return idx;
}
static int min_element( int [] arr)
{
int idx = 0 ;
int min = arr[ 0 ];
for ( int i = 1 ; i < arr.length; i++)
{
if (arr[i] < min)
{
min = arr[i];
idx = i;
}
}
return idx;
}
public static void main (String[] args)
{
int arr[] = { 4 , 1 , 2 , 3 };
int n = arr.length;
System.out.println(countSubArray(arr, n));
}
}
|
Python3
def countSubArray(arr, n):
if (n < 2 ):
return n;
i = max_element(arr);
j = min_element(arr);
if (i > j):
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
return (i + 1 ) * (n - j);
def max_element(arr):
idx = 0 ;
max = arr[ 0 ];
for i in range ( 1 , len (arr)):
if ( max < arr[i]):
max = arr[i];
idx = i;
return idx;
def min_element(arr):
idx = 0 ;
min = arr[ 0 ];
for i in range ( 1 , len (arr)):
if (arr[i] < min ):
min = arr[i];
idx = i;
return idx;
if __name__ = = '__main__' :
arr = [ 4 , 1 , 2 , 3 ];
n = len (arr);
print (countSubArray(arr, n));
|
C#
using System;
class GFG{
static int countSubArray( int []arr,
int n)
{
if (n < 2)
return n;
int i = max_element(arr);
int j = min_element(arr);
if (i > j)
{
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
return (i + 1) * (n - j);
}
static int max_element( int [] arr)
{
int idx = 0;
int max = arr[0];
for ( int i = 1; i < arr.Length; i++)
{
if (max < arr[i])
{
max = arr[i];
idx = i;
}
}
return idx;
}
static int min_element( int [] arr)
{
int idx = 0;
int min = arr[0];
for ( int i = 1; i < arr.Length; i++)
{
if (arr[i] < min)
{
min = arr[i];
idx = i;
}
}
return idx;
}
public static void Main(String[] args)
{
int []arr = {4, 1, 2, 3};
int n = arr.Length;
Console.WriteLine(countSubArray(arr, n));
}
}
|
Javascript
<script>
function countSubArray(arr, n)
{
if (n < 2)
return n;
let i = max_element(arr);
let j = min_element(arr);
if (i > j)
{
let tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
return (i + 1) * (n - j);
}
function max_element(arr)
{
let idx = 0;
let max = arr[0];
for (let i = 1; i < arr.length; i++)
{
if (max < arr[i])
{
max = arr[i];
idx = i;
}
}
return idx;
}
function min_element(arr)
{
let idx = 0;
let min = arr[0];
for (let i = 1; i < arr.length; i++)
{
if (arr[i] < min)
{
min = arr[i];
idx = i;
}
}
return idx;
}
let arr = [ 4, 1, 2, 3 ];
let n = arr.length;
document.write(countSubArray(arr, n));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...