Count of subarrays which start and end with the same element
Last Updated :
11 Jul, 2022
Given an array A of size N where the array elements contain values from 1 to N with duplicates, the task is to find the total number of subarrays that start and end with the same element.
Examples:
Input: A[] = {1, 2, 1, 5, 2}
Output: 7
Explanation:
Total 7 sub-array of the given array are {1}, {2}, {1}, {5}, {2}, {1, 2, 1} and {2, 1, 5, 2} are start and end with same element.
Input: A[] = {1, 5, 6, 1, 9, 5, 8, 10, 8, 9}
Output: 14
Explanation:
Total 14 sub-array {1}, {5}, {6}, {1}, {9}, {5}, {8}, {10}, {8}, {9}, {1, 5, 6, 1}, {5, 6, 1, 9, 5}, {9, 5, 8, 10, 8, 9} and {8, 10, 8} start and end with same element.
Naive approach: For each element in the array, if it is present at a different index as well, we will increase our result by 1. Also, all 1-size subarray are part of counted in the result. Therefore, add N to the result.
Below is the implementation of the above approach:
C++
// C++ program to Count total sub-array
// which start and end with same element
#include <bits/stdc++.h>
using namespace std;
// Function to find total sub-array
// which start and end with same element
void cntArray(int A[], int N)
{
// initialize result with 0
int result = 0;
for (int i = 0; i < N; i++) {
// all size 1 sub-array
// is part of our result
result++;
// element at current index
int current_value = A[i];
for (int j = i + 1; j < N; j++) {
// Check if A[j] = A[i]
// increase result by 1
if (A[j] == current_value) {
result++;
}
}
}
// print the result
cout << result << endl;
}
// Driver code
int main()
{
int A[] = { 1, 5, 6, 1, 9,
5, 8, 10, 8, 9 };
int N = sizeof(A) / sizeof(int);
cntArray(A, N);
return 0;
}
// Java program to Count total sub-array
// which start and end with same element
public class Main {
// function to find total sub-array
// which start and end with same element
public static void cntArray(int A[], int N)
{
// initialize result with 0
int result = 0;
for (int i = 0; i < N; i++) {
// all size 1 sub-array
// is part of our result
result++;
// element at current index
int current_value = A[i];
for (int j = i + 1; j < N; j++) {
// Check if A[j] = A[i]
// increase result by 1
if (A[j] == current_value) {
result++;
}
}
}
// print the result
System.out.println(result);
}
// Driver code
public static void main(String[] args)
{
int[] A = { 1, 5, 6, 1, 9,
5, 8, 10, 8, 9 };
int N = A.length;
cntArray(A, N);
}
}
# Python3 program to count total sub-array
# which start and end with same element
# Function to find total sub-array
# which start and end with same element
def cntArray(A, N):
# Initialize result with 0
result = 0
for i in range(0, N):
# All size 1 sub-array
# is part of our result
result = result + 1
# Element at current index
current_value = A[i]
for j in range(i + 1, N):
# Check if A[j] = A[i]
# increase result by 1
if (A[j] == current_value):
result = result + 1
# Print the result
print(result)
print("\n")
# Driver code
A = [ 1, 5, 6, 1, 9, 5, 8, 10, 8, 9 ]
N = len(A)
cntArray(A, N)
# This code is contributed by PratikBasu
// C# program to Count total sub-array
// which start and end with same element
using System;
class GFG{
// function to find total sub-array
// which start and end with same element
public static void cntArray(int []A, int N)
{
// initialize result with 0
int result = 0;
for (int i = 0; i < N; i++)
{
// all size 1 sub-array
// is part of our result
result++;
// element at current index
int current_value = A[i];
for (int j = i + 1; j < N; j++)
{
// Check if A[j] = A[i]
// increase result by 1
if (A[j] == current_value)
{
result++;
}
}
}
// print the result
Console.Write(result);
}
// Driver code
public static void Main()
{
int[] A = { 1, 5, 6, 1, 9,
5, 8, 10, 8, 9 };
int N = A.Length;
cntArray(A, N);
}
}
// This code is contributed by Code_Mech
<script>
// Javascript program to Count total sub-array
// which start and end with same element
// Function to find total sub-array
// which start and end with same element
function cntArray(A, N)
{
// initialize result with 0
var result = 0;
for (var i = 0; i < N; i++) {
// all size 1 sub-array
// is part of our result
result++;
// element at current index
var current_value = A[i];
for (var j = i + 1; j < N; j++) {
// Check if A[j] = A[i]
// increase result by 1
if (A[j] == current_value) {
result++;
}
}
}
// print the result
document.write( result );
}
// Driver code
var A = [1, 5, 6, 1, 9,
5, 8, 10, 8, 9];
var N = A.length;
cntArray(A, N);
// This code is contributed by noob2000.
</script>
Time Complexity: O(N2), where N is the size of the array
Space complexity: O(1)
Efficient approach: We can optimize the above method by observing that the answer just depends on frequencies of numbers in the original array.
For example in array {1, 5, 6, 1, 9, 5, 8, 10, 8, 9}, frequency of 1 is 2 and sub-array contributing to answer are {1}, {1} and {1, 5, 6, 1} respectively, i.e., a total of 3.
Therefore, calculate the frequency of each element in the array. Then for each element, the increment the count by the result yielded by the following formula:
((frequency of element)*(frequency of element + 1)) / 2
Below is the implementation of the above approach:
C++
// C++ program to Count total sub-array
// which start and end with same element
#include <bits/stdc++.h>
using namespace std;
// function to find total sub-array
// which start and end with same element
void cntArray(int A[], int N)
{
// initialize result with 0
int result = 0;
// array to count frequency of 1 to N
int frequency[N + 1] = { 0 };
for (int i = 0; i < N; i++) {
// update frequency of A[i]
frequency[A[i]]++;
}
for (int i = 1; i <= N; i++) {
int frequency_of_i = frequency[i];
// update result with sub-array
// contributed by number i
result += +((frequency_of_i)
* (frequency_of_i + 1))
/ 2;
}
// print the result
cout << result << endl;
}
// Driver code
int main()
{
int A[] = { 1, 5, 6, 1, 9, 5,
8, 10, 8, 9 };
int N = sizeof(A) / sizeof(int);
cntArray(A, N);
return 0;
}
// Java program to Count total sub-array
// which start and end with same element
public class Main {
// function to find total sub-array which
// start and end with same element
public static void cntArray(int A[], int N)
{
// initialize result with 0
int result = 0;
// array to count frequency of 1 to N
int[] frequency = new int[N + 1];
for (int i = 0; i < N; i++) {
// update frequency of A[i]
frequency[A[i]]++;
}
for (int i = 1; i <= N; i++) {
int frequency_of_i = frequency[i];
// update result with sub-array
// contributed by number i
result += ((frequency_of_i)
* (frequency_of_i + 1))
/ 2;
}
// print the result
System.out.println(result);
}
// Driver code
public static void main(String[] args)
{
int[] A = { 1, 5, 6, 1, 9, 5,
8, 10, 8, 9 };
int N = A.length;
cntArray(A, N);
}
}
# Python3 program to count total sub-array
# which start and end with same element
# Function to find total sub-array
# which start and end with same element
def cntArray(A, N):
# Initialize result with 0
result = 0
# Array to count frequency of 1 to N
frequency = [0] * (N + 1)
for i in range(0, N):
# Update frequency of A[i]
frequency[A[i]] = frequency[A[i]] + 1
for i in range(1, N + 1):
frequency_of_i = frequency[i]
# Update result with sub-array
# contributed by number i
result = result + ((frequency_of_i) *
(frequency_of_i + 1)) / 2
# Print the result
print(int(result))
print("\n")
# Driver code
A = [ 1, 5, 6, 1, 9, 5, 8, 10, 8, 9 ]
N = len(A)
cntArray(A, N)
# This code is contributed by PratikBasu
// C# program to Count total sub-array
// which start and end with same element
using System;
class GFG{
// function to find total sub-array which
// start and end with same element
public static void cntArray(int []A, int N)
{
// initialize result with 0
int result = 0;
// array to count frequency of 1 to N
int[] frequency = new int[N + 1];
for (int i = 0; i < N; i++)
{
// update frequency of A[i]
frequency[A[i]]++;
}
for (int i = 1; i <= N; i++)
{
int frequency_of_i = frequency[i];
// update result with sub-array
// contributed by number i
result += ((frequency_of_i) *
(frequency_of_i + 1)) / 2;
}
// print the result
Console.Write(result);
}
// Driver code
public static void Main()
{
int[] A = { 1, 5, 6, 1, 9, 5,
8, 10, 8, 9 };
int N = A.Length;
cntArray(A, N);
}
}
// This code is contributed by Nidhi_Biet
<script>
// Javascript program to Count total sub-array
// which start and end with same element
// function to find total sub-array which
// start and end with same element
function cntArray(A, N)
{
// initialize result with 0
let result = 0;
// array to count frequency of 1 to N
let frequency = Array.from({length: N+1}, (_, i) => 0);
for (let i = 0; i < N; i++) {
// update frequency of A[i]
frequency[A[i]]++;
}
for (let i = 1; i <= N; i++) {
let frequency_of_i = frequency[i];
// update result with sub-array
// contributed by number i
result += ((frequency_of_i)
* (frequency_of_i + 1))
/ 2;
}
// print the result
document.write(result);
}
// Driver Code
let A = [ 1, 5, 6, 1, 9, 5,
8, 10, 8, 9 ];
let N = A.length;
cntArray(A, N);
</script>
Time Complexity: O(N), where N is the size of the array
Space complexity: O(N)
Related Topic: Subarrays, Subsequences, and Subsets in Array
Similar Reads
Count subarrays with same even and odd elements Given an array of N integers, count number of even-odd subarrays. An even - odd subarray is a subarray that contains the same number of even as well as odd integers. Examples : Input : arr[] = {2, 5, 7, 8} Output : 3 Explanation : There are total 3 even-odd subarrays. 1) {2, 5} 2) {7, 8} 3) {2, 5, 7
15+ min read
Count subarrays with all elements greater than K Given an array of n integers and an integer k, the task is to find the number of subarrays such that all elements in each subarray are greater than k.Examples: Input: arr[] = {3, 4, 5, 6, 7, 2, 10, 11}, k= 5 Output: 6 The possible subarrays are {6}, {7}, {6, 7}, {10}, {11} and {10, 11}.Input: arr[]
9 min read
Count of Subarrays which Contain the Length of that Subarray Given an array A[] of length N, the task is to count the number of subarrays of A[] that contain the length of that subarray. Examples: Input: A = {10, 11, 1}, N = 3Output: 1Explanation: Only the subarray {1}, with a length 1, contains its own length. Input: A = [1, 2, 3, 4, 5], N = 5Output: 9Explan
8 min read
Count of elements which is the sum of a subarray of the given Array Given an array arr[], the task is to count elements in an array such that there exists a subarray whose sum is equal to this element.Note: Length of subarray must be greater than 1. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7} Output: 4 Explanation: There are 4 such elements in array - arr[2] = 3
7 min read
Count subarrays with equal number of 1's and 0's Given an array arr[] of size n containing 0 and 1 only. The problem is to count the subarrays having an equal number of 0's and 1's. Examples: Input: arr[] = {1, 0, 0, 1, 0, 1, 1}Output: 8Explanation: The index range for the 8 sub-arrays are: (0, 1), (2, 3), (0, 3), (3, 4), (4, 5)(2, 5), (0, 5), (1,
14 min read