 Open in App
Not now

# Count subarrays made up of single-digit integers only

• Difficulty Level : Basic
• Last Updated : 31 Mar, 2021

Given an array arr[] consisting of N positive integers, the task is to count subarrays consisting of single-digit elements only.

Examples:

Input: arr[] = {0, 1, 14, 2, 5}
Output: 6
Explanation: All subarrays made of only single digit numbers are {{0}, {1}, {2}, {5}, {0, 1}, {2, 5}}. Therefore, the total count of subarrays is 6.

Input: arr[] ={12, 5, 14, 17}
Output: 1
Explanation: All subarrays made of only single digit numbers are {5}.
Therefore, the total count of subarrays is 1.

Naive Approach: The simplest approach is to traverse the array and generate all possible subarrays. For each subarray, check if all integers in it are single-digit integers or not.

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

Efficient Approach: To optimize the above approach, the idea is to find the size of each block of contiguous single-digit integers and increment the count by total subarrays of that length. Follow the steps below to solve the problem:

• Initialize a variable, say res = 0 and c = 0, to store the total count of subarrays and the total count of single-digit integers in a subarray.
• Traverse the array and perform the following operations:
• If arr[i] < 10, increment the count of c by one and count of res by c.
• Otherwise, assign c = 0.
• Finally, print the total count of single-digit integer subarrays.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count of subarrays made``// up of single digit integers only``int` `singleDigitSubarrayCount(``int` `arr[],``                             ``int` `N)``{``    ``// Stores count of subarrays``    ``int` `res = 0;` `    ``// Stores the count of consecutive``    ``// single digit numbers in the array``    ``int` `count = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``if` `(arr[i] <= 9) {` `            ``// Increment size of block by 1``            ``count++;` `            ``// Increment res by count``            ``res += count;``        ``}` `        ``else` `{` `            ``// Assign count = 0``            ``count = 0;``        ``}``    ``}` `    ``cout << res;``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { 0, 1, 14, 2, 5 };` `    ``// Size of the array``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``singleDigitSubarrayCount(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``class` `GFG``{` `// Function to count of subarrays made``// up of single digit integers only``static` `void` `singleDigitSubarrayCount(``int` `arr[],``                             ``int` `N)``{``  ` `    ``// Stores count of subarrays``    ``int` `res = ``0``;` `    ``// Stores the count of consecutive``    ``// single digit numbers in the array``    ``int` `count = ``0``;` `    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{``        ``if` `(arr[i] <= ``9``)``        ``{` `            ``// Increment size of block by 1``            ``count++;` `            ``// Increment res by count``            ``res += count;``        ``}` `        ``else``        ``{` `            ``// Assign count = 0``            ``count = ``0``;``        ``}``    ``}``    ``System.out.print(res);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ` `    ``// Given array``    ``int` `arr[] = { ``0``, ``1``, ``14``, ``2``, ``5` `};` `    ``// Size of the array``    ``int` `N = arr.length;``    ``singleDigitSubarrayCount(arr, N);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach` `# Function to count of subarrays made``# up of single digit integers only``def` `singleDigitSubarrayCount(arr, N):``    ` `    ``# Stores count of subarrays``    ``res ``=` `0` `    ``# Stores the count of consecutive``    ``# single digit numbers in the array``    ``count ``=` `0` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):``        ``if` `(arr[i] <``=` `9``):` `            ``# Increment size of block by 1``            ``count ``+``=` `1` `            ``# Increment res by count``            ``res ``+``=` `count``        ``else``:``            ``# Assign count = 0``            ``count ``=` `0``    ``print` `(res)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given array``    ``arr ``=` `[``0``, ``1``, ``14``, ``2``, ``5``]` `    ``# Size of the array``    ``N ``=` `len``(arr)``    ``singleDigitSubarrayCount(arr, N)` `    ``# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG{` `// Function to count of subarrays made``// up of single digit integers only``static` `void` `singleDigitSubarrayCount(``int``[] arr,``                             ``int` `N)``{``  ` `    ``// Stores count of subarrays``    ``int` `res = 0;` `    ``// Stores the count of consecutive``    ``// single digit numbers in the array``    ``int` `count = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``        ``if` `(arr[i] <= 9)``        ``{` `            ``// Increment size of block by 1``            ``count++;` `            ``// Increment res by count``            ``res += count;``        ``}``        ``else``        ``{` `            ``// Assign count = 0``            ``count = 0;``        ``}``    ``}``    ``Console.Write(res);``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``// Given array``    ``int``[] arr = { 0, 1, 14, 2, 5 };` `    ``// Size of the array``    ``int` `N = arr.Length;``    ``singleDigitSubarrayCount(arr, N);``}``}` `// This code is contributed by sanjoy_62.`

## Javascript

 ``

Output:

`6`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up