# Number of sub-arrays that have at least one duplicate

• Difficulty Level : Medium
• Last Updated : 09 Sep, 2022

Given an array arr of n elements, the task is to find the number of the sub-arrays of the given array that contain at least one duplicate element.

Examples:

Input: arr[] = {1, 2, 3}
Output:
There is no sub-array with duplicate elements.

Input: arr[] = {4, 3, 4, 3}
Output:
Possible sub-arrays are {4, 3, 4}, {4, 3, 4, 3} and {3, 4, 3}

Approach:

• First, find the total number of sub-arrays that can be formed from the array and denote this by total then total = (n*(n+1))/2.
• Now find the sub-arrays that have all the elements distinct (can be found out using window sliding technique) and denote this by unique.
• Finally, the number of sub-arrays that have at least one element duplicate are (total – unique)

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``#define ll long long int``using` `namespace` `std;` `// Function to return the count of the``// sub-arrays that have at least one duplicate``ll count(ll arr[], ll n)``{``    ``ll unique = 0;` `    ``// two pointers``    ``ll i = -1, j = 0;` `    ``// to store frequencies of the numbers``    ``unordered_map freq;``    ``for` `(j = 0; j < n; j++) {``        ``freq[arr[j]]++;` `        ``// number is not distinct``        ``if` `(freq[arr[j]] >= 2) {``            ``i++;``            ``while` `(arr[i] != arr[j]) {``                ``freq[arr[i]]--;``                ``i++;``            ``}``            ``freq[arr[i]]--;``            ``unique = unique + (j - i);``        ``}``        ``else``            ``unique = unique + (j - i);``    ``}` `    ``ll total = n * (n + 1) / 2;` `    ``return` `total - unique;``}` `// Driver code``int` `main()``{``    ``ll arr[] = { 4, 3, 4, 3 };``    ``ll n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << count(arr, n) << endl;``    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `// Function to return the count of the``// sub-arrays that have at least one duplicate``static` `Integer count(Integer arr[], Integer n)``{``    ``Integer unique = ``0``;` `    ``// two pointers``    ``Integer i = -``1``, j = ``0``;` `    ``// to store frequencies of the numbers``    ``Map freq = ``new` `HashMap<>();``    ``for` `(j = ``0``; j < n; j++)``    ``{``        ``if``(freq.containsKey(arr[j]))``        ``{``            ``freq.put(arr[j], freq.get(arr[j]) + ``1``);``        ``}``        ``else``        ``{``            ``freq.put(arr[j], ``1``);``        ``}` `        ``// number is not distinct``        ``if` `(freq.get(arr[j]) >= ``2``)``        ``{``            ``i++;``            ``while` `(arr[i] != arr[j])``            ``{``                ``freq.put(arr[i], freq.get(arr[i]) - ``1``);``                ``i++;``            ``}``            ``freq.put(arr[i], freq.get(arr[i]) - ``1``);``            ``unique = unique + (j - i);``        ``}``        ``else``            ``unique = unique + (j - i);``    ``}` `    ``Integer total = n * (n + ``1``) / ``2``;` `    ``return` `total - unique;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``Integer arr[] = { ``4``, ``3``, ``4``, ``3` `};``    ``Integer n = arr.length;``    ``System.out.println(count(arr, n));``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of the approach``from` `collections ``import` `defaultdict` `# Function to return the count of the``# sub-arrays that have at least one duplicate``def` `count(arr, n):` `    ``unique ``=` `0` `    ``# two pointers``    ``i, j ``=` `-``1``, ``0` `    ``# to store frequencies of the numbers``    ``freq ``=` `defaultdict(``lambda``:``0``)``    ``for` `j ``in` `range``(``0``, n):``        ``freq[arr[j]] ``+``=` `1` `        ``# number is not distinct``        ``if` `freq[arr[j]] >``=` `2``:``            ``i ``+``=` `1``            ` `            ``while` `arr[i] !``=` `arr[j]:``                ``freq[arr[i]] ``-``=` `1``                ``i ``+``=` `1``            ` `            ``freq[arr[i]] ``-``=` `1``            ``unique ``=` `unique ``+` `(j ``-` `i)``        ` `        ``else``:``            ``unique ``=` `unique ``+` `(j ``-` `i)``    ` `    ``total ``=` `(n ``*` `(n ``+` `1``)) ``/``/` `2` `    ``return` `total ``-` `unique` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``4``, ``3``, ``4``, ``3``]``    ``n ``=` `len``(arr)``    ``print``(count(arr, n))` `# This code is contributed``# by Rituraj Jain`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;            ` `class` `GFG``{` `// Function to return the count of the``// sub-arrays that have at least one duplicate``static` `int` `count(``int` `[]arr, ``int` `n)``{``    ``int` `unique = 0;` `    ``// two pointers``    ``int` `i = -1, j = 0;` `    ``// to store frequencies of the numbers``    ``Dictionary<``int``,``               ``int``> freq = ``new` `Dictionary<``int``,``                                          ``int``>();``    ``for` `(j = 0; j < n; j++)``    ``{``        ``if``(freq.ContainsKey(arr[j]))``        ``{``            ``freq[arr[j]] = freq[arr[j]] + 1;``        ``}``        ``else``        ``{``            ``freq.Add(arr[j], 1);``        ``}` `        ``// number is not distinct``        ``if` `(freq[arr[j]] >= 2)``        ``{``            ``i++;``            ``while` `(arr[i] != arr[j])``            ``{``                ``freq[arr[i]] = freq[arr[i]] - 1;``                ``i++;``            ``}``            ``freq[arr[i]] = freq[arr[i]] - 1;``            ``unique = unique + (j - i);``        ``}``        ``else``            ``unique = unique + (j - i);``    ``}` `    ``int` `total = n * (n + 1) / 2;` `    ``return` `total - unique;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 4, 3, 4, 3 };``    ``int` `n = arr.Length;``    ``Console.WriteLine(count(arr, n));``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

```3
```

Complexity Analysis:

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

My Personal Notes arrow_drop_up