Given an array **arr[]** consisting of queries of the form **{L, R}**, the task for each query is to count the numbers in the range **[L, R]** that can be expressed as the sum of its digits raised to the power of count of digits.

**Examples:**

Input:arr[][] = {{8, 11}}Output:2Explanation:

From the given range [1, 9], the numbers that can be expressed as the sum of its digit raised to the power of count of digits are:

- 8: Sum of digits = 8, Count of digit = 1. Therefore, 8
^{1}is equal to the given number.- 9: Sum of digits = 9, Count of digit = 1. Therefore, 9
^{1}is equal to the given number.Therefore, the count of such numbers from the given range is 2.

Input:arr[][] = {{10, 100}, {1, 400}}Output:0 11

**Naive Approach:** The simplest approach is to iterate over the range **arr[i][0]** to **arr[i][1]** for each query and print the count of such numbers.

**Time Complexity:** O(Q*(R – L)*log_{10}R), where R and L denotes the limits of the longest range.**Auxiliary Space:** O(1)

**Efficient Approach:** The above approach can be optimized by precomputing and storing all the numbers whether they can be expressed as the sum of its digit raised to the power of count of digits or not. Finally, print the count for each query efficiently.

Follow the steps below to solve the problem:

- Initialize an auxiliary array, say
**ans[]**, to store at ans[i], whether i can be expressed as the sum of its digit raised to the power of count of digits. - Iterate over the range
**[1, 10**and update the array^{6}]**ans[]**accordingly. - Convert the array
**ans[]**to a prefix sum array. - Traverse the given array of queries
**arr[]**and for each query**{arr[i][0], arr[i][1]}**, print the value of**(ans[arr[i][1]] – ans[arr[i][1] – 1])**as the resultant count of numbers that can be expressed as the sum of its digit raised to the power of count of digits.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `#define R 100005` `int` `arr[R];` `// Function to check if a number N can be` `// expressed as sum of its digits raised` `// to the power of the count of digits` `bool` `canExpress(` `int` `N)` `{` ` ` `int` `temp = N;` ` ` `// Stores the number of digits` ` ` `int` `n = 0;` ` ` `while` `(N != 0) {` ` ` `N /= 10;` ` ` `n++;` ` ` `}` ` ` `// Stores the resultant number` ` ` `N = temp;` ` ` `int` `sum = 0;` ` ` `while` `(N != 0) {` ` ` `sum += ` `pow` `(N % 10, n);` ` ` `N /= 10;` ` ` `}` ` ` `// Return true if both the` ` ` `// numbers are same` ` ` `return` `(sum == temp);` `}` `// Function to precompute and store` `// for all numbers whether they can` `// be expressed` `void` `precompute()` `{` ` ` `// Mark all the index which` ` ` `// are plus perfect number` ` ` `for` `(` `int` `i = 1; i < R; i++) {` ` ` `// If true, then update the` ` ` `// value at this index` ` ` `if` `(canExpress(i)) {` ` ` `arr[i] = 1;` ` ` `}` ` ` `}` ` ` `// Compute prefix sum of the array` ` ` `for` `(` `int` `i = 1; i < R; i++) {` ` ` `arr[i] += arr[i - 1];` ` ` `}` `}` `// Function to count array elements that` `// can be expressed as the sum of digits` `// raised to the power of count of digits` `void` `countNumbers(` `int` `queries[][2], ` `int` `N)` `{` ` ` `// Precompute the results` ` ` `precompute();` ` ` `// Traverse the queries` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `int` `L1 = queries[i][0];` ` ` `int` `R1 = queries[i][1];` ` ` `// Print the resultant count` ` ` `cout << (arr[R1] - arr[L1 - 1])` ` ` `<< ` `' '` `;` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `queries[][2] = {` ` ` `{ 1, 400 },` ` ` `{ 1, 9 }` ` ` `};` ` ` `int` `N = ` `sizeof` `(queries)` ` ` `/ ` `sizeof` `(queries[0]);` ` ` `countNumbers(queries, N);` ` ` `return` `0;` `}` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG{` ` ` `static` `int` `R = 100005;` `static` `int` `[] arr = ` `new` `int` `[R];` `// Function to check if a number N can be` `// expressed as sum of its digits raised` `// to the power of the count of digits` `public` `static` `bool` `canExpress(` `int` `N)` `{` ` ` `int` `temp = N;` ` ` `// Stores the number of digits` ` ` `int` `n = 0;` ` ` `while` `(N != 0)` ` ` `{` ` ` `N /= 10;` ` ` `n++;` ` ` `}` ` ` `// Stores the resultant number` ` ` `N = temp;` ` ` `int` `sum = 0;` ` ` `while` `(N != 0)` ` ` `{` ` ` `sum += ((` `int` `)Math.Pow(N % 10, n));` ` ` `N /= 10;` ` ` `}` ` ` `// Return true if both the` ` ` `// numbers are same` ` ` `if` `(sum == temp)` ` ` `return` `true` `;` ` ` ` ` `return` `false` `;` `}` `// Function to precompute and store` `// for all numbers whether they can` `// be expressed` `public` `static` `void` `precompute()` `{` ` ` `// Mark all the index which` ` ` `// are plus perfect number` ` ` `for` `(` `int` `i = 1; i < R; i++)` ` ` `{` ` ` ` ` `// If true, then update the` ` ` `// value at this index` ` ` `if` `(canExpress(i))` ` ` `{` ` ` `arr[i] = 1;` ` ` `}` ` ` `}` ` ` `// Compute prefix sum of the array` ` ` `for` `(` `int` `i = 1; i < R; i++)` ` ` `{` ` ` `arr[i] += arr[i - 1];` ` ` `}` `}` `// Function to count array elements that` `// can be expressed as the sum of digits` `// raised to the power of count of digits` `public` `static` `void` `countNumbers(` `int` `[,] queries, ` `int` `N)` `{` ` ` ` ` `// Precompute the results` ` ` `precompute();` ` ` `// Traverse the queries` ` ` `for` `(` `int` `i = 0; i < N; i++)` ` ` `{` ` ` `int` `L1 = queries[i, 0];` ` ` `int` `R1 = queries[i, 1];` ` ` `// Print the resultant count` ` ` `Console.Write((arr[R1] - arr[L1 - 1]) + ` `" "` `);` ` ` `}` `}` `// Driver Code` `static` `public` `void` `Main()` `{` ` ` `int` `[,] queries = { { 1, 400 }, { 1, 9 } };` ` ` `int` `N = queries.GetLength(0);` ` ` `// Function call` ` ` `countNumbers(queries, N);` `}` `}` `// This code is contributed by Dharanendra L V.` |

## Python3

`# Python 3 program for the above approach` `R ` `=` `100005` `arr ` `=` `[` `0` `for` `i ` `in` `range` `(R)]` `# Function to check if a number N can be` `# expressed as sum of its digits raised` `# to the power of the count of digits` `def` `canExpress(N):` ` ` `temp ` `=` `N` ` ` `# Stores the number of digits` ` ` `n ` `=` `0` ` ` `while` `(N !` `=` `0` `):` ` ` `N ` `/` `/` `=` `10` ` ` `n ` `+` `=` `1` ` ` `# Stores the resultant number` ` ` `N ` `=` `temp` ` ` `sum` `=` `0` ` ` `while` `(N !` `=` `0` `):` ` ` `sum` `+` `=` `pow` `(N ` `%` `10` `, n)` ` ` `N ` `/` `/` `=` `10` ` ` `# Return true if both the` ` ` `# numbers are same` ` ` `return` `(` `sum` `=` `=` `temp)` `# Function to precompute and store` `# for all numbers whether they can` `# be expressed` `def` `precompute():` ` ` ` ` `# Mark all the index which` ` ` `# are plus perfect number` ` ` `for` `i ` `in` `range` `(` `1` `, R, ` `1` `):` ` ` ` ` `# If true, then update the` ` ` `# value at this index` ` ` `if` `(canExpress(i)):` ` ` `arr[i] ` `=` `1` ` ` `# Compute prefix sum of the array` ` ` `for` `i ` `in` `range` `(` `1` `,R,` `1` `):` ` ` `arr[i] ` `+` `=` `arr[i ` `-` `1` `]` `# Function to count array elements that` `# can be expressed as the sum of digits` `# raised to the power of count of digits` `def` `countNumbers(queries, N):` ` ` ` ` `# Precompute the results` ` ` `precompute()` ` ` `# Traverse the queries` ` ` `for` `i ` `in` `range` `(N):` ` ` `L1 ` `=` `queries[i][` `0` `]` ` ` `R1 ` `=` `queries[i][` `1` `]` ` ` `# Print the resultant count` ` ` `print` `((arr[R1] ` `-` `arr[L1 ` `-` `1` `]),end ` `=` `" "` `)` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `queries ` `=` `[[` `1` `, ` `400` `],[` `1` `, ` `9` `]]` ` ` `N ` `=` `len` `(queries)` ` ` `countNumbers(queries, N)` ` ` `# This code is contributed by SURENDRA_GANGWAR.` |

## Javascript

`<script>` `// javascript program for the above approach` ` ` `var` `R = 100005;` ` ` `var` `arr = Array(R).fill(0);` ` ` `// Function to check if a number N can be` ` ` `// expressed as sum of its digits raised` ` ` `// to the power of the count of digits` ` ` `function` `canExpress(N) {` ` ` `var` `temp = N;` ` ` `// Stores the number of digits` ` ` `var` `n = 0;` ` ` `while` `(N != 0) {` ` ` `N = parseInt(N/10);` ` ` `n++;` ` ` `}` ` ` `// Stores the resultant number` ` ` `N = temp;` ` ` `var` `sum = 0;` ` ` `while` `(N != 0) {` ` ` `sum += Math.pow(N % 10, n);` ` ` `N = parseInt(N/10);` ` ` `}` ` ` `// Return true if both the` ` ` `// numbers are same` ` ` `return` `(sum == temp);` ` ` `}` ` ` `// Function to precompute and store` ` ` `// for all numbers whether they can` ` ` `// be expressed` ` ` `function` `precompute() {` ` ` `// Mark all the index which` ` ` `// are plus perfect number` ` ` `for` `(` `var` `i = 1; i < R; i++) {` ` ` `// If true, then update the` ` ` `// value at this index` ` ` `if` `(canExpress(i)) {` ` ` `arr[i] = 1;` ` ` `}` ` ` `}` ` ` `// Compute prefix sum of the array` ` ` `for` `(` `var` `i = 1; i < R; i++) {` ` ` `arr[i] += arr[i - 1];` ` ` `}` ` ` `}` ` ` `// Function to count array elements that` ` ` `// can be expressed as the sum of digits` ` ` `// raised to the power of count of digits` ` ` `function` `countNumbers(queries , N) {` ` ` `// Precompute the results` ` ` `precompute();` ` ` `// Traverse the queries` ` ` `for` `(` `var` `i = 0; i < N; i++) {` ` ` `var` `L1 = queries[i][0];` ` ` `var` `R1 = queries[i][1];` ` ` `// Prvar the resultant count` ` ` `document.write((arr[R1] - arr[L1 - 1]) + ` `" "` `);` ` ` `}` ` ` `}` ` ` `// Driver Code` ` ` `var` `queries = [ [ 1, 400 ], [ 1, 9 ] ];` ` ` `var` `N = queries.length;` ` ` `// function call` ` ` `countNumbers(queries, N);` `// This code is contributed by Princi Singh` `</script>` |

**Output:**

12 9

**Time Complexity:** O(Q + 10^{6}) **Auxiliary Space:** O(10^{6})

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.