# Number of subarrays whose minimum and maximum are same

Given an array of n integers, find the no of subarrays whose minimal and maximum elements are same. Subarray is defined as non-empty sequence of consecutive elements.

Examples :

```Input: 2 3 1 1
Output: 5
Explanation: The subarrays are (2),
(3), (1), (1) and (1, 1)

Input: 2 4 5 3 3 3
Output: 9
Explanation: The subarrays are (2), (4),
(5), (3), (3, 3), (3, 3, 3), (3), (3, 3) and
(3)
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

The first thing to observe is that only those subarrays whose all elements are same will have the same minimum and maximum. Having different elements clearly means different minimum and maximum. Hence we just need to calculate the number of continuous same elements(say d), then by combinations formula we get the no of subarrays to be –

No of subarrays possible with d elements = ( d * (d+1) / 2 )
where d is number of continuous same elements.

We traverse from 1-n and then from I+1 to n and then find the number of continuous same elements and then add to the result the no subarrays possible.

## C++

 `// CPP program to count number of subarrays  ` `// having same minimum and maximum. ` `#include ` `using` `namespace` `std; ` ` `  `// calculate the no of contiguous subarrays ` `// which has same minimum and maximum ` `int` `calculate(``int` `a[], ``int` `n) ` `{ ` `    ``// stores the answer ` `    ``int` `ans = 0; ` ` `  `    ``// loop to traverse from 0-n ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// start checking subarray from next element ` `        ``int` `r = i + 1; ` ` `  `        ``// traverse for finding subarrays ` `        ``for` `(``int` `j = r; j < n; j++) { ` ` `  `            ``// if the elements are same then  ` `            ``// we check further and keep a count ` `            ``// of same numbers in 'r' ` `            ``if` `(a[i] == a[j]) ` `                ``r += 1;  ` `            ``else` `                ``break``;  ` `        ``} ` ` `  `        ``// the no of elements in between r and i ` `        ``// with same elements. ` `        ``int` `d = r - i; ` ` `  `        ``// the no of subarrays that can be formed  ` `        ``// between i and r ` `        ``ans += (d * (d + 1) / 2); ` ` `  `        ``// again start checking from the next index ` `        ``i = r - 1; ` `    ``} ` ` `  `    ``// returns answer ` `    ``return` `ans; ` `} ` ` `  `// drive program to test the above function ` `int` `main() ` `{ ` `    ``int` `a[] = { 2, 4, 5, 3, 3, 3 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a); ` `    ``cout << calculate(a, n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to count number of subarrays  ` `// having same minimum and maximum. ` ` `  `class` `Subarray  ` `{ ` `    ``// calculate the no of contiguous subarrays ` `    ``// which has same minimum and maximum ` `    ``static` `int` `calculate(``int` `a[], ``int` `n) ` `    ``{ ` `        ``// stores the answer ` `        ``int` `ans = ``0``; ` ` `  `        ``// loop to traverse from 0-n ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` ` `  `            ``// start checking subarray from ` `            ``// next element ` `            ``int` `r = i + ``1``; ` ` `  `            ``// traverse for finding subarrays ` `            ``for` `(``int` `j = r; j < n; j++) { ` ` `  `                ``// if the elements are same then  ` `                ``// we check further and keep a  ` `                ``// count of same numbers in 'r' ` `                ``if` `(a[i] == a[j]) ` `                    ``r += ``1``;  ` `                ``else` `                    ``break``;  ` `            ``} ` ` `  `            ``// the no of elements in between r  ` `            ``// and i with same elements. ` `            ``int` `d = r - i; ` ` `  `            ``// the no. of subarrays that can be  ` `            ``// formed between i and r ` `            ``ans += (d * (d + ``1``) / ``2``); ` ` `  `            ``// again start checking from the next ` `            ``// index ` `            ``i = r - ``1``; ` `        ``} ` ` `  `        ``// returns answer ` `        ``return` `ans; ` `    ``} ` `     `  `    ``// Driver program to test above functions ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `    ``int` `a[] = {  ``2``, ``4``, ``5``, ``3``, ``3``, ``3` `}; ` `    ``System.out.println(calculate(a, a.length)); ` `    ``} ` `} ` `// This code is contributed by Prerna Saini `

## Python3

 `# Python3 program to count  ` `# number of subarrays having  ` `# same minimum and maximum. ` ` `  `# calculate the no of contiguous  ` `# subarrays which has same  ` `# minimum and maximum ` `def` `calculate(a, n): ` `     `  `    ``# stores the answer ` `    ``ans ``=` `0``; ` `    ``i ``=` `0``; ` ` `  `    ``# loop to traverse from 0-n ` `    ``while``(i < n):  ` `         `  `        ``# start checking subarray  ` `        ``# from next element ` `        ``r ``=` `i ``+` `1``; ` ` `  `        ``# traverse for ` `        ``# finding subarrays ` `        ``for` `j ``in` `range``(r, n):  ` `             `  `            ``# if the elements are same  ` `            ``# then we check further  ` `            ``# and keep a count of same  ` `            ``# numbers in 'r' ` `            ``if` `(a[i] ``=``=` `a[j]): ` `                ``r ``=` `r ``+` `1``;  ` `            ``else``: ` `                ``break``;  ` ` `  `        ``# the no of elements in  ` `        ``# between r and i with ` `        ``# same elements. ` `        ``d ``=` `r ``-` `i; ` ` `  `        ``# the no of subarrays that  ` `        ``# can be formed between i and r ` `        ``ans ``=` `ans ``+` `(d ``*` `(d ``+` `1``) ``/` `2``); ` ` `  `        ``# again start checking  ` `        ``# from the next index ` `        ``i ``=` `r ``-` `1``; ` `        ``i ``=` `i ``+` `1``; ` ` `  `    ``# returns answer ` `    ``return` `int``(ans); ` ` `  `# Driver Code ` `a ``=` `[ ``2``, ``4``, ``5``, ``3``, ``3``, ``3` `]; ` `n ``=` `len``(a); ` `print``(calculate(a, n)); ` ` `  `# This code is contributed by mits `

## C#

 `// Program to count number ` `// of subarrays having same ` `// minimum and maximum. ` `using` `System; ` ` `  `class` `Subarray { ` `    ``// calculate the no of contiguous ` `    ``// subarrays which has the same ` `    ``// minimum and maximum ` `    ``static` `int` `calculate(``int``[] a, ``int` `n) ` `    ``{ ` `        ``// stores the answer ` `        ``int` `ans = 0; ` ` `  `        ``// loop to traverse from 0-n ` `        ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `            ``// start checking subarray ` `            ``// from next element ` `            ``int` `r = i + 1; ` ` `  `            ``// traverse for finding subarrays ` `            ``for` `(``int` `j = r; j < n; j++) { ` ` `  `                ``// if the elements are same then ` `                ``// we check further and keep a ` `                ``// count of same numbers in 'r' ` `                ``if` `(a[i] == a[j]) ` `                    ``r += 1; ` `                ``else` `                    ``break``; ` `            ``} ` ` `  `            ``// the no of elements in between ` `            ``// r and i with same elements. ` `            ``int` `d = r - i; ` ` `  `            ``// the no. of subarrays that can ` `            ``// be formed between i and r ` `            ``ans += (d * (d + 1) / 2); ` ` `  `            ``// again start checking from ` `            ``// the next index ` `            ``i = r - 1; ` `        ``} ` ` `  `        ``// returns answer ` `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver program ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[] a = { 2, 4, 5, 3, 3, 3 }; ` `        ``Console.WriteLine(calculate(a, a.Length)); ` `    ``} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

## PHP

 ` `

Output :

```9
```

Time complexity : O(n^2)
Auxiliary Space : O(1)

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.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.