Skip to content
Related Articles

Related Articles

Count of Subarrays which Contain the Length of that Subarray

View Discussion
Improve Article
Save Article
  • Difficulty Level : Basic
  • Last Updated : 17 Jun, 2022
View Discussion
Improve Article
Save Article

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 = 3
Output: 1
Explanation: Only the subarray {1}, with a length 1, contains its own length.

Input: A = [1, 2, 3, 4, 5], N = 5
Output: 9
Explanation: The subarrays {1}, {1, 2}, {2, 3}, {1, 2, 3}, {2, 3, 4}, {3, 4, 5},  
{1, 2, 3, 4}, {2, 3, 4, 5}, {1, 2, 3, 4, 5} contain their own length.

 

Approach: Follow the below idea to solve the problem:

First, form each and every subarray of A. Then, check if the length of the subarray is present in that subarray.

Follow the steps mentioned below to implement the idea:

  • Iterate over the array from i = 0 to N:
    • Iterate in a nested loop from j = i to N:
    • The subarray created is from i to j.
    • Traverse the subarray and check if the length is present in the subarray.
    • If present, then increment the count.
  • The final count is the required answer.

Below is the implementation for the above approach:

C++




// C++ code to implement the approach
#include <iostream>
using namespace std;
 
// Function to find the count of the subarrays
// that contain their own length
int findCount(int arr[], int N)
{
    int counts = 0;
 
    // Forming all possible subarrays
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N + 1; j++) {
 
            // Checking if the length is present
            // in the subarray
            for (int k = i; k <= j; k++) {
                if ((j - i) == arr[k])
                    counts += 1;
            }
        }
    }
    return counts;
}
// Driver Code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int N = 5;
 
    // Function Call
    cout << findCount(arr, N);
    return 0;
}
 
// This code is contributed by Rohit Pradhan


Java




// Java code to implement the approach
import java.io.*;
class GFG
{
   
  // Function to find the count of the subarrays
  // that contain their own length
  static int findCount(int[] arr, int N)
  {
    int counts = 0;
 
    // Forming all possible subarrays
    for (int i = 0; i < N; i++) {
      for (int j = i + 1; j < N + 1; j++) {
 
        // Checking if the length is present
        // in the subarray
        for (int k = i; k <= j; k++) {
          if ((j - i) == arr[k])
            counts += 1;
        }
      }
    }
    return counts;
  }
 
  // Driver Code
  public static void main (String[] args) {
    int arr[] = { 1, 2, 3, 4, 5 };
    int N = 5;
 
    // Function Call
    System.out.println( findCount(arr, N));
  }
}
 
// This code is contributed by hrithikgarg03188.


Python3




# Python3 code to implement the approach
 
# Function to find the count of the subarrays
# that contain their own length
def findCount(arr, N):
    counts = 0
     
    # Forming all possible subarrays
    for i in range(N):
        for j in range(i + 1, N + 1):
           
            # Checking if the length is present
            # in the subarray
            if j - i in arr[i: j]:
                counts += 1
    return counts
 
 
# Driver Code
if __name__ == '__main__':
    arr = [1, 2, 3, 4, 5]
    N = 5
     
    # Function Call
    print(findCount(arr, N))


C#




// C# code to implement the above approach
using System;
 
public class GFG
{
 
  // Function to find the count of the subarrays
  // that contain their own length
  static int findCount(int[] arr, int N)
  {
    int counts = 0;
 
    // Forming all possible subarrays
    for (int i = 0; i < N; i++) {
      for (int j = i + 1; j < N + 1; j++) {
 
        // Checking if the length is present
        // in the subarray
        for (int k = i; k < j; k++) {
          if ((j - i) == arr[k])
            counts += 1;
        }
      }
    }
    return counts;
  }
 
  // Driver Code
  public static void Main (string[] args) {
    int []arr = { 1, 2, 3, 4, 5 };
    int N = 5;
 
    // Function Call
    Console.WriteLine(findCount(arr, N));
  }
}
 
// This code is contributed by AnkThon


Javascript




<script>
        // JavaScript code for the above approach
 
        // Function to find the count of the subarrays
        // that contain their own length
        function findCount(arr, N) {
            let counts = 0
 
            // Forming all possible subarrays
            for (let i = 0; i < N; i++) {
                for (let j = i + 1; j < N + 1; j++) {
 
                    // Checking if the length is present
                    // in the subarray
                    for (let k = i; k <= j; k++) {
                        if (arr[k] == j - i) {
                            counts++;
                        }
                    }
                }
            }
            return counts
        }
 
        // Driver Code
 
        let arr = [1, 2, 3, 4, 5]
        let N = 5
 
        // Function Call
        document.write(findCount(arr, N))
    // This code is contributed by Potta Lokesh
    </script>


Output

9

Time complexity: O(N3)
Auxiliary Space: O(1)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!