Count Beautiful Numbers

Count Beautiful Numbers - Problem

Dynamic Programming Hard

You are given two positive integers l and r. A positive integer is called beautiful if the product of its digits is divisible by the sum of its digits.

Return the count of beautiful numbers between l and r, inclusive.

Example: For number 144, digit product = 1×4×4 = 16, digit sum = 1+4+4 = 9. Since 16 % 9 ≠ 0, 144 is not beautiful.

Input & Output

Example 1 — Small Range

$ Input: l = 1, r = 10

› Output: 10

💡 Note: All single digits 1-9 are beautiful (digit product equals digit sum), plus number 10 (product=0, sum=1, 0%1=0).

Example 2 — Including Zero Digits

$ Input: l = 10, r = 20

› Output: 2

💡 Note: Numbers 10 and 20 are beautiful. 10: product=1×0=0, sum=1+0=1, 0%1=0. 20: product=2×0=0, sum=2+0=2, 0%2=0.

Example 3 — Larger Range

$ Input: l = 1, r = 100

› Output: 19

💡 Note: Beautiful numbers include: all single digits 1-9, plus numbers with 0 digits where the remaining product is divisible by the sum (like 10, 20, 30, 40, 50, 60, 70, 80, 90, 100).

Constraints

1 ≤ l ≤ r ≤ 10¹²
Both l and r are positive integers

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is recognizing that any number containing a zero digit will have a product of zero, making it automatically beautiful since 0 % sum = 0. For numbers without zeros, we need to check if the product of digits is divisible by their sum. The optimal approach uses digit DP with memoization to efficiently count beautiful numbers without checking each one individually. Time: O(log₁₀(r) × states), Space: O(states).

Common Approaches

✓ Brute Force

⏱️ Time: O((r-l) × log₁₀(r)) Space: O(1)

For each number from l to r, extract all digits, calculate their product and sum, then check if product is divisible by sum.

Digit DP with Memoization

⏱️ Time: O(log₁₀(r) × 9¹⁰ × sum_limit × product_limit) Space: O(log₁₀(r) × sum_limit × product_limit)

Build numbers digit by digit using recursion, memoizing states based on position, constraints, and current digit properties to avoid recalculating similar patterns.

Brute Force — Algorithm Steps

Step 1: Iterate through each number from l to r
Step 2: For each number, extract digits and calculate product and sum
Step 3: Check if product % sum == 0, increment counter if true

Visualization

Tap to expand

Step-by-Step Walkthrough

Iterate Range

Go through each number from l to r

Calculate Properties

For each number, find digit product and sum

Check Beautiful

Test if product % sum == 0

Code -

solution.c — C

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

int solution(int l, int r) {
    int count = 0;
    for (int num = l; num <= r; num++) {
        int digitProduct = 1;
        int digitSum = 0;
        int temp = num;
        
        while (temp > 0) {
            int digit = temp % 10;
            digitProduct *= digit;
            digitSum += digit;
            temp /= 10;
        }
        
        if (digitSum > 0 && digitProduct % digitSum == 0) {
            count++;
        }
    }
    
    return count;
}

int main() {
    int l, r;
    scanf("%d", &l);
    scanf("%d", &r);
    
    int result = solution(l, r);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((r-l) × log₁₀(r))

For each number in range, we process all digits (log₁₀(r) digits)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

25.0K 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler