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: 0
There is no sub-array with duplicate elements.Input: arr[] = {4, 3, 4, 3}
Output: 3
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 <bits/stdc++.h> #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<ll, ll> 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<Integer, Integer> 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
<script> // Javascript implementation of the approach // Function to return the count of the // sub-arrays that have at least one duplicate function count(arr, n)
{ let unique = 0;
// two pointers
let i = -1, j = 0;
// to store frequencies of the numbers
let freq = new Map();
for (j = 0; j < n; j++) {
if (freq.has(arr[j])){
freq.set(arr[j], freq.get(arr[j]) + 1)
} else {
freq.set(arr[j], 1)
}
// number is not distinct
if (freq.get(arr[j]) >= 2) {
i++;
while (arr[i] != arr[j]) {
freq.set(arr[i], freq.get(arr[i]) - 1)
i++;
}
freq.set(arr[i], freq.get(arr[i]) - 1)
unique = unique + (j - i);
}
else
unique = unique + (j - i);
}
let total = n *(n + 1) / 2;
return total - unique;
} // Driver code let arr = [ 4, 3, 4, 3 ];
let n = arr.length;
document.write(count(arr, n) + "<br>" );
// This code is contributed by _saurabh_jaiswal </script> |
Output
3
Complexity Analysis:
- Time Complexity: O(N)
- Auxiliary Space: O(N)