Given an array **A[]** consisting of **N** integers, the task is to find the total number of subsequence which contain only one distinct number repeated throughout the subsequence.

**Examples:**

Input:A[] = {1, 2, 1, 5, 2}Output:7Explanation:

Subsequences {1}, {2}, {1}, {5}, {2}, {1, 1} and {2, 2} satisfy the required conditions.

Input:A[] = {5, 4, 4, 5, 10, 4}Output:11Explanation:

Subsequences {5}, {4}, {4}, {5}, {10}, {4}, {5, 5}, {4, 4}, {4, 4}, {4, 4} and {4, 4, 4} satisfy the required conditions.

**Approach:**

Follow the steps below to solve the problem:

- Iterate over the array and calculate the frequency of each element in a HashMap.
- Traverse the HashMap. For each element, calculate the number of desired subsequences possible by the equation:

Number of subsequences possible by

arr[i] = 2^{freq[arr[i]]}– 1

- Calculate the total possible subsequences from the given array.

Below is the implementation of the above approach:

## C++

`// C++ program to implement ` `// the above approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` `// Function to count subsequences in ` `// array containing same element ` `void` `CountSubSequence(` `int` `A[], ` `int` `N) ` `{ ` ` ` `// Stores the count ` ` ` `// of subsequences ` ` ` `int` `result = 0; ` ` ` `// Stores the frequency ` ` ` `// of array elements ` ` ` `map<` `int` `, ` `int` `> mp; ` ` ` `for` `(` `int` `i = 0; i < N; i++) { ` ` ` `// Update frequency of A[i] ` ` ` `mp[A[i]]++; ` ` ` `} ` ` ` `for` `(` `auto` `it : mp) { ` ` ` `// Calculate number of subsequences ` ` ` `result ` ` ` `= result + ` `pow` `(2, it.second) - 1; ` ` ` `} ` ` ` `// Print the result ` ` ` `cout << result << endl; ` `} ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `A[] = { 5, 4, 4, 5, 10, 4 }; ` ` ` `int` `N = ` `sizeof` `(A) / ` `sizeof` `(A[0]); ` ` ` `CountSubSequence(A, N); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to implement ` `// the above approach ` `import` `java.util.*;` `class` `GFG{` `// Function to count subsequences in` `// array containing same element` `static` `void` `CountSubSequence(` `int` `A[], ` `int` `N)` `{` ` ` ` ` `// Stores the count` ` ` `// of subsequences` ` ` `int` `result = ` `0` `;` ` ` `// Stores the frequency` ` ` `// of array elements` ` ` `Map<Integer, ` ` ` `Integer> mp = ` `new` `HashMap<Integer,` ` ` `Integer>();` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++)` ` ` `{` ` ` ` ` `// Update frequency of A[i]` ` ` `mp.put(A[i], mp.getOrDefault(A[i], ` `0` `) + ` `1` `);` ` ` `}` ` ` `for` `(Integer it : mp.values())` ` ` `{` ` ` ` ` `// Calculate number of subsequences` ` ` `result = result + (` `int` `)Math.pow(` `2` `, it) - ` `1` `;` ` ` `}` ` ` ` ` `// Print the result` ` ` `System.out.println(result);` `}` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `A[] = { ` `5` `, ` `4` `, ` `4` `, ` `5` `, ` `10` `, ` `4` `};` ` ` `int` `N = A.length;` ` ` ` ` `CountSubSequence(A, N);` `}` `}` `// This code is contributed by offbeat` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to implement ` `# the above approach ` `# Function to count subsequences in ` `# array containing same element ` `def` `CountSubSequence(A, N):` ` ` ` ` `# Stores the frequency ` ` ` `# of array elements ` ` ` `mp ` `=` `{}` ` ` ` ` `for` `element ` `in` `A:` ` ` `if` `element ` `in` `mp:` ` ` `mp[element] ` `+` `=` `1` ` ` `else` `:` ` ` `mp[element] ` `=` `1` ` ` ` ` `result ` `=` `0` ` ` ` ` `for` `key, value ` `in` `mp.items():` ` ` ` ` `# Calculate number of subsequences ` ` ` `result ` `+` `=` `pow` `(` `2` `, value) ` `-` `1` ` ` ` ` `# Print the result ` ` ` `print` `(result)` `# Driver code` `A ` `=` `[ ` `5` `, ` `4` `, ` `4` `, ` `5` `, ` `10` `, ` `4` `]` `N ` `=` `len` `(A)` `CountSubSequence(A, N)` `# This code is contributed by jojo9911` |

*chevron_right*

*filter_none*

## C#

`// C# program to implement ` `// the above approach ` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{ ` `// Function to count subsequences in ` `// array containing same element ` `public` `static` `void` `CountSubSequence(` `int` `[]A, ` `int` `N) ` `{ ` ` ` ` ` `// Stores the count ` ` ` `// of subsequences ` ` ` `int` `result = 0; ` ` ` `// Stores the frequency ` ` ` `// of array elements ` ` ` `var` `mp = ` `new` `Dictionary<` `int` `, ` `int` `>();` ` ` `for` `(` `int` `i = 0; i < N; i++) ` ` ` `{ ` ` ` ` ` `// Update frequency of A[i] ` ` ` `if` `(mp.ContainsKey(A[i]))` ` ` `mp[A[i]] += 1;` ` ` `else` ` ` `mp.Add(A[i], 1);` ` ` `} ` ` ` `foreach` `(` `var` `it ` `in` `mp) ` ` ` `{ ` ` ` ` ` `// Calculate number of subsequences ` ` ` `result = result + ` ` ` `(` `int` `)Math.Pow(2, it.Value) - 1; ` ` ` `} ` ` ` ` ` `// Print the result ` ` ` `Console.Write(result); ` `} ` `// Driver code ` `public` `static` `void` `Main() ` `{ ` ` ` `int` `[]A = { 5, 4, 4, 5, 10, 4 }; ` ` ` `int` `N = A.Length; ` ` ` ` ` `CountSubSequence(A, N); ` `} ` `} ` `// This code is contributed by grand_master` |

*chevron_right*

*filter_none*

**Output:**

11

**Time Complexity:** O(NlogN) **Auxiliary Space:** O(N)

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.