Count the Number of Powerful Integers - Problem

You are given three integers start, finish, and limit. You are also given a 0-indexed string s representing a positive integer.

A positive integer x is called powerful if it ends with s (in other words, s is a suffix of x) and each digit in x is at most limit.

Return the total number of powerful integers in the range [start, finish].

A string x is a suffix of a string y if and only if x is a substring of y that starts from some index (including 0) in y and extends to the index y.length - 1. For example, 25 is a suffix of 5125 whereas 512 is not.

Input & Output

Example 1 — Basic Case

$ Input: start = 1, finish = 15, limit = 2, s = "2"

› Output: 2

💡 Note: The powerful integers are 2 and 12. Both end with "2" and have all digits ≤ 2. Numbers like 22 are > 15, and 32 has digit 3 > 2.

Example 2 — No Valid Numbers

$ Input: start = 1, finish = 15, limit = 1, s = "2"

› Output: 0

💡 Note: No numbers ending with "2" can have all digits ≤ 1, since "2" itself contains digit 2 > 1.

Example 3 — Larger Suffix

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

› Output: 1

💡 Note: Only 1124 is in range [1000,2000], ends with "124", and has all digits ≤ 4.

Constraints

1 ≤ start ≤ finish ≤ 10¹⁵
1 ≤ limit ≤ 9
1 ≤ s.length ≤ floor(log₁₀(finish)) + 1
s only contains digits, and doesn't have leading zeros

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 A Amazon 15

The key insight is to use digit dynamic programming instead of brute force enumeration. We build valid numbers position by position, tracking tight bounds and suffix constraints. Best approach uses memoized digit DP with Time: O(d × 10), Space: O(d) where d is the number of digits.

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Dfs

⏱️ Time: N/A Space: N/A

Brute Force Enumeration

⏱️ Time: O(n × m) Space: O(1)

Iterate through all numbers from start to finish, convert each to string, check if it ends with s and all digits are ≤ limit.

Digit DP with Memoization

⏱️ Time: O(d × 2 × 2 × 10) Space: O(d × 2 × 2)

Build numbers digit by digit using recursion with memoization. Track position, tight bound, and whether we've started placing digits.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int pos;
    bool tight;
    bool started;
    long long value;
    bool valid;
} MemoEntry;

MemoEntry memo[20][2][2];
bool memo_init = false;

void init_memo() {
    for (int i = 0; i < 20; i++) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 2; k++) {
                memo[i][j][k].valid = false;
            }
        }
    }
}

long long dp(const char* num_str, const char* s, int limit, int pos, bool tight, bool started) {
    int n = strlen(num_str);
    int suffix_len = strlen(s);
    
    if (pos == n) {
        return started ? 1 : 0;
    }
    
    if (memo[pos][tight ? 1 : 0][started ? 1 : 0].valid) {
        return memo[pos][tight ? 1 : 0][started ? 1 : 0].value;
    }
    
    int max_digit = tight ? (num_str[pos] - '0') : 9;
    long long result = 0;
    
    for (int digit = 0; digit <= (max_digit < limit ? max_digit : limit); digit++) {
        bool new_tight = tight && (digit == max_digit);
        bool new_started = started || (digit > 0);
        
        // Check suffix constraint
        if (pos >= n - suffix_len) {
            int suffix_pos = pos - (n - suffix_len);
            if (new_started && digit != (s[suffix_pos] - '0')) {
                continue;
            }
        }
        
        result += dp(num_str, s, limit, pos + 1, new_tight, new_started);
    }
    
    memo[pos][tight ? 1 : 0][started ? 1 : 0].value = result;
    memo[pos][tight ? 1 : 0][started ? 1 : 0].valid = true;
    return result;
}

long long count_powerful(const char* num_str, const char* s, int limit) {
    init_memo();
    return dp(num_str, s, limit, 0, true, false);
}

long long solution(int start, int finish, int limit, const char* s) {
    char finish_str[20], start_minus_one_str[20];
    sprintf(finish_str, "%d", finish);
    sprintf(start_minus_one_str, "%d", start - 1);
    
    return count_powerful(finish_str, s, limit) - count_powerful(start_minus_one_str, s, limit);
}

int main() {
    int start, finish, limit;
    char s[20];
    
    scanf("%d", &start);
    scanf("%d", &finish);
    scanf("%d", &limit);
    scanf("%s", s);
    
    printf("%lld\n", solution(start, finish, limit, s));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~35 min Avg. Time

340 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