Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count subarrays having a single distinct element that can be obtained from a given array

  • Last Updated : 17 May, 2021

Given an array arr[] of size N, the task is to count the number of subarrays consisting of a single distinct element that can be obtained from a 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: N = 4, arr[] = { 2, 2, 2, 2 }
Output: 7
Explanation: All such subarrays {{2}, {2}, {2}, {2}, {2, 2}, {2, 2, 2}, {2, 2, 2, 2}}. Therefore, total count of such subarrays are 7.



Input: N = 3, arr[] = { 1, 1, 3 }
Output: 4

Approach: Follow the steps below to solve the problem:

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count subarrays of
// single distinct element into
// which given array can be split
void divisionalArrays(int arr[3], int N)
{
    // Stores the count
    int sum = N;
 
    // Stores frequency of
    // array elements
    unordered_map<int, int> mp;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
        mp[arr[i]]++;
    }
 
    // Traverse the map
    for (auto x : mp) {
        if (x.second > 1) {
 
            // Increase count of
            // subarrays by (frequency-1)
            sum += x.second - 1;
        }
    }
    cout << sum << endl;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 1, 3 };
    int N = sizeof(arr)
            / sizeof(arr[0]);
    divisionalArrays(arr, N);
}
Java



// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG
{
 
  // Function to count subarrays of
  // single distinct element into
  // which given array can be split
  static void divisionalArrays(int arr[], int N)
  {
 
    // Stores the count
    int sum = N;
 
    // Stores frequency of
    // array elements
    HashMap<Integer, Integer> mp
      = new HashMap<Integer, Integer>();
 
    // Traverse the array
    for (int i = 0; i < N; i++)
    {
      if (mp.containsKey(arr[i]))
      {
        mp.put(arr[i], mp.get(arr[i]) + 1);
      }
      else
      {
        mp.put(arr[i], 1);
      }
    }
 
    // Traverse the map
    for (Map.Entry x : mp.entrySet())
    {
 
      if ((int)x.getValue() > 1)
      {
 
        // Increase count of
        // subarrays by (frequency-1)
        sum += (int)x.getValue() - 1;
      }
    }
 
    System.out.println(sum);
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    int arr[] = { 1, 1, 3 };
    int N = arr.length;
    divisionalArrays(arr, N);
  }
}
 
// This code is contributed by Dharanendra L V
Python3



# python 3 program for the above approach
from collections import defaultdict
 
# Function to count subarrays of
# single distinct element into
# which given array can be split
def divisionalArrays(arr, N):
 
    # Stores the count
    sum = N
 
    # Stores frequency of
    # array elements
    mp = defaultdict(int)
 
    # Traverse the array
    for i in range(N):
        mp[arr[i]] += 1
 
    # Traverse the map
    for x in mp:
        if (mp[x] > 1):
 
            # Increase count of
            # subarrays by (frequency-1)
            sum += mp[x] - 1
    print(sum)
 
# Driver Code
if __name__ == "__main__":
 
    arr = [1, 1, 3]
    N = len(arr)
    divisionalArrays(arr, N)
 
    # This code is contributed by ukasp.
C#



// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to count subarrays of
// single distinct element into
// which given array can be split
static void divisionalArrays(int []arr, int N)
{
     
    // Stores the count
    int sum = N;
     
    // Stores frequency of
    // array elements
    Dictionary<int,
               int> mp = new Dictionary<int,
                                        int>();
     
    // Traverse the array
    for (int i = 0; i < N; i++)
    {
        if (mp.ContainsKey(arr[i]))
        {
            mp[arr[i]] =  mp[arr[i]] + 1;
        }
        else
        {
            mp.Add(arr[i], 1);
        }
    }
     
    // Traverse the map
    foreach(KeyValuePair<int, int> x in mp)
    {
        if ((int)x.Value > 1)
        {
             
            // Increase count of
            // subarrays by (frequency-1)
            sum += (int)x.Value - 1;
        }
    }
     
    Console.WriteLine(sum);
}
 
// Driver Code
public static void Main(String[] args)
{
    int []arr = { 1, 1, 3 };
    int N = arr.Length;
     
    divisionalArrays(arr, N);
}
}
 
// This code is contributed by shikhasingrajput
Javascript



<script>
 
// JavaScript program for the above approach
 
// Function to count subarrays of
// single distinct element into
// which given array can be split
function divisionalArrays(arr, N)
{
    // Stores the count
    var sum = N;
 
    // Stores frequency of
    // array elements
    var mp = new Map();
 
    // Traverse the array
    for (var i = 0; i < N; i++) {
        if(mp.has(arr[i]))
        {
            mp.set(arr[i], mp.get(arr[i])+1);
        }
        else
        {
            mp.set(arr[i],1);
        }
    }
 
    // Traverse the map
    mp.forEach((value, key) => {
        if (value > 1) {
 
            // Increase count of
            // subarrays by (frequency-1)
            sum += value - 1;
        }
    });
 
    document.write( sum);
}
 
// Driver Code
var arr =[1, 1, 3];
var N = arr.length;
divisionalArrays(arr, N);
 
</script>
Output: 
4
 
Time Complexity: O(N)
Auxiliary Space: O(N)



My Personal Notes
arrow_drop_up
Previous
Count inversions in a sequence generated by appending given array K times
Next

Maximize element at index K in an array with at most sum M and difference between adjacent elements at most 1
Recommended Articles
Page :
Count distinct sequences obtained by replacing all elements of subarrays having equal first and last elements with the first element any number of times
29, Jun 21
Check if an array can be split into K consecutive non-overlapping subarrays of length M consisting of single distinct element
12, Feb 21
Split array into maximum subarrays such that every distinct element lies in a single subarray
27, Sep 20
Count of distinct sums that can be obtained by adding prime numbers from given arrays
28, Mar 19
Count subarrays having each distinct element occurring at least twice
25, Oct 20
Count subarrays having total distinct elements same as original array
21, Jun 17
Construct array B as last element left of every suffix array obtained by performing given operations on every suffix of given array
20, Jul 21
Total distinct pairs from two arrays such that second number can be obtained by inverting bits of first
04, Apr 19
Count new pairs of strings that can be obtained by swapping first characters of pairs of strings from given array
14, Apr 21
Check if quantities of 3 distinct colors can be converted to a single color by given merge-pair operations
07, Sep 20
Count of subarrays having exactly K distinct elements
18, Dec 19
Maximize sum of product of same-indexed elements of equal length subarrays obtained from two given arrays
30, Apr 21
Number obtained by reducing sum of digits of 2N into a single digit
23, Mar 21
Queries to count array elements from a given range having a single set bit
27, Jan 21
Queries to count array elements from a given range having a single set bit
01, Feb 21
Minimum cost required to convert all Subarrays of size K to a single element
07, Aug 20
Maximize sum that can be obtained from two given arrays based on given conditions
30, Jun 21
Check if sum Y can be obtained from the Array by the given operations
19, Aug 20
Counts 1s that can be obtained in an Array by performing given operations
03, Jan 21
Lexicographically smallest permutation of length 2N that can be obtained from an N-length array satisfying given conditions
17, Jun 21
Split given Array in minimum number of subarrays such that rearranging the order of subarrays sorts the array
03, Sep 21
Maximum subsequence sum obtained by concatenating disjoint subarrays whose lengths are prime
25, Oct 20
Queries to print count of distinct array elements after replacing element at index P by a given element
16, Oct 20
Check if an Array is made up of Subarrays of continuous repetitions of every distinct element
05, Aug 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
sagnikmukherjee2
@sagnikmukherjee2
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!