Count the Number of Powerful Integers - Practice Coding Problems

Count the Number of Powerful Integers - Problem

Imagine you're a data analyst working with special numbers called "powerful integers". Your task is to count how many of these numbers exist within a given range.

A positive integer x is considered powerful if it satisfies two conditions:

It ends with a specific suffix string s (the string s must appear at the very end of the number)
Every digit in x is at most a given limit value

Given:

start and finish - defining the range [start, finish]
limit - maximum allowed value for any digit (0-9)
s - the required suffix string

Example: If limit = 3 and s = "123", then 3123 is powerful (ends with "123" and all digits ≤ 3), but 4123 is not (digit 4 > limit 3).

Return the total count of powerful integers in the given range.

Input & Output

example_1.py — Basic Example

$ Input: start = 1, finish = 6000, limit = 4, s = "124"

› Output: 5

💡 Note: The powerful integers are: 124, 1124, 2124, 3124, 4124. Each ends with '124' and all digits are ≤ 4.

example_2.py — Single Digit Suffix

$ Input: start = 15, finish = 215, limit = 6, s = "10"

› Output: 2

💡 Note: The powerful integers are: 110, 210. Both end with '10' and have digits ≤ 6.

example_3.py — Edge Case

$ Input: start = 1000, finish = 2000, limit = 4, s = "3000"

› Output: 0

💡 Note: No numbers in [1000,2000] can end with '3000' since they would need to be at least 3000.

Constraints

1 ≤ start ≤ finish ≤ 10¹⁵
1 ≤ s.length ≤ min(15, log₁₀(finish) + 1)
0 ≤ limit ≤ 9
s contains only digits and represents a positive integer without leading zeros

Visualization

Tap to expand

Smart Production: Only create digit combinations that can lead to valid results2. Early Filtering: Reject invalid paths immediately, don't waste time on impossible numbers3. Memory Efficiency: Remember previous computations to avoid duplicate work4. Systematic Counting: Count valid paths instead of checking every possible number⚡ Result: O(log²n) vs O(n) - Massive Speedup!

Understanding the Visualization

Setup Assembly Line

Initialize stations for each digit position, with knowledge of constraints

Progressive Assembly

Each station adds valid digits, considering the suffix requirement

Quality Control

Ensure digits don't exceed limit and suffix matches exactly

Count Production

Sum all valid assembly paths to get final count

Key Takeaway

🎯 Key Insight: Instead of checking billions of numbers individually, digit DP builds only valid combinations by making smart choices at each digit position, reducing complexity from O(finish-start) to O(log²finish).

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses Digit Dynamic Programming to count powerful integers without checking each number individually. By building valid numbers digit by digit and maintaining state about bounds and suffix constraints, we achieve O(log²n) complexity, making it efficient even for very large ranges up to 10¹⁵.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Number)	O((finish - start) × log(finish))	O(log(finish))	Iterate through all numbers in range and check each one
Digit Dynamic Programming (Optimal)	O(log²(finish))	O(log²(finish))	Use digit DP to count valid numbers without checking each one

Brute Force (Check Every Number) — Algorithm Steps

Iterate through each number from start to finish
Convert number to string and check if it ends with suffix s
Check if all digits in the number are ≤ limit
Count valid numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Iteration

Begin checking from start number

Check Suffix

Verify if number ends with required suffix

Check Digits

Ensure all digits are within limit

Count Valid

Increment counter for powerful numbers

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

bool isPowerful(long long num, int limit, char* s) {
    char numStr[20];
    sprintf(numStr, "%lld", num);
    
    // Check suffix
    int numLen = strlen(numStr);
    int sLen = strlen(s);
    if (numLen < sLen || strcmp(numStr + numLen - sLen, s) != 0) {
        return false;
    }
    
    // Check digit limit
    for (int i = 0; i < numLen; i++) {
        if (numStr[i] - '0' > limit) {
            return false;
        }
    }
    return true;
}

long long numberOfPowerfulInts(long long start, long long finish, int limit, char* s) {
    long long count = 0;
    for (long long num = start; num <= finish; num++) {
        if (isPowerful(num, limit, s)) {
            count++;
        }
    }
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O((finish - start) × log(finish))

We check each number in range, and for each number we examine all its digits

⚡ Linearithmic

Space Complexity

O(log(finish))

Space for converting numbers to strings

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check Every Number) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler