# Count subarrays which contains both the maximum and minimum array element

• Last Updated : 07 Sep, 2021

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {1, 2, 3, 4}
Output:
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.
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++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count subarray``// containing  both maximum and``// minimum array elements``int` `countSubArray(``int` `arr[], ``int` `n)``{``    ``// If the length of the``    ``// array is less than 2``    ``if` `(n < 2)``        ``return` `n;` `    ``// Find the index of maximum element``    ``int` `i``        ``= max_element(arr, arr + n) - arr;` `    ``// Find the index of minimum element``    ``int` `j``        ``= min_element(arr, arr + n) - arr;` `    ``// If i > j, then swap``    ``// the value of i and j``    ``if` `(i > j)``        ``swap(i, j);` `    ``// Return the answer``    ``return` `(i + 1) * (n - j);``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 4, 1, 2, 3 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``// Function call``    ``cout << countSubArray(arr, n);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``import` `java.lang.*;` `class` `GFG{``    ` `// Function to count subarray``// containing both maximum and``// minimum array elements``static` `int` `countSubArray(``int` `arr[], ``int` `n)``{``    ` `    ``// If the length of the``    ``// array is less than 2``    ``if` `(n < ``2``)``        ``return` `n;` `    ``// Find the index of maximum element``    ``int` `i = max_element(arr);` `    ``// Find the index of minimum element``    ``int` `j = min_element(arr);` `    ``// If i > j, then swap``    ``// the value of i and j``    ``if` `(i > j)``    ``{``        ``int` `tmp = arr[i];``        ``arr[i] = arr[j];``        ``arr[j] = tmp;``    ``}``        ` `    ``// Return the answer``    ``return` `(i + ``1``) * (n - j);``}` `// Function to return max_element index``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;``}` `// Function to return min_element index``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;``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ``int` `arr[] = { ``4``, ``1``, ``2``, ``3` `};``    ``int` `n = arr.length;``    ` `    ``// Function call``    ``System.out.println(countSubArray(arr, n));``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 program for``# the above approach` `# Function to count subarray``# containing both maximum and``# minimum array elements``def` `countSubArray(arr, n):``  ` `    ``# If the length of the``    ``# array is less than 2``    ``if` `(n < ``2``):``        ``return` `n;` `    ``# Find the index of``    ``# maximum element``    ``i ``=` `max_element(arr);` `    ``# Find the index of``    ``# minimum element``    ``j ``=` `min_element(arr);` `    ``# If i > j, then swap``    ``# the value of i and j``    ``if` `(i > j):``        ``tmp ``=` `arr[i];``        ``arr[i] ``=` `arr[j];``        ``arr[j] ``=` `tmp;` `    ``# Return the answer``    ``return` `(i ``+` `1``) ``*` `(n ``-` `j);` `# Function to return``# max_element index``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;` `# Function to return``# min_element index``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;` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``4``, ``1``, ``2``, ``3``];``    ``n ``=` `len``(arr);` `    ``# Function call``    ``print``(countSubArray(arr, n));` `# This code is contributed by Rajput-Ji`

## C#

 `// C# program for``// the above approach``using` `System;``class` `GFG{``    ` `// Function to count subarray``// containing both maximum and``// minimum array elements``static` `int` `countSubArray(``int` `[]arr,``                         ``int` `n)``{   ``  ``// If the length of the``  ``// array is less than 2``  ``if` `(n < 2)``    ``return` `n;` `  ``// Find the index of maximum element``  ``int` `i = max_element(arr);` `  ``// Find the index of minimum element``  ``int` `j = min_element(arr);` `  ``// If i > j, then swap``  ``// the value of i and j``  ``if` `(i > j)``  ``{``    ``int` `tmp = arr[i];``    ``arr[i] = arr[j];``    ``arr[j] = tmp;``  ``}` `  ``// Return the answer``  ``return` `(i + 1) * (n - j);``}` `// Function to return max_element index``static` `int` `max_element(``int``[] arr)``{``  ``int` `idx = 0;``  ``int` `max = arr;``  ``for``(``int` `i = 1; i < arr.Length; i++)``  ``{``    ``if``(max < arr[i])``    ``{``      ``max = arr[i];``      ``idx = i;``    ``}``  ``}``  ``return` `idx;``}` `// Function to return min_element index``static` `int` `min_element(``int``[] arr)``{``  ``int` `idx = 0;``  ``int` `min = arr;``  ``for``(``int` `i = 1; i < arr.Length; i++)``  ``{``    ``if` `(arr[i] < min)``    ``{``      ``min = arr[i];``      ``idx = i;``    ``}``  ``}``  ``return` `idx;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ``int` `[]arr = {4, 1, 2, 3};``  ``int` `n = arr.Length;` `  ``// Function call``  ``Console.WriteLine(countSubArray(arr, n));``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``
Output:
`3`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up