Number of Beautiful Integers in the Range

Number of Beautiful Integers in the Range - Problem

You're on a quest to find "beautiful integers" - numbers that possess a special mathematical harmony! 🎯

Given three positive integers low, high, and k, your task is to count how many integers in the range [low, high] are considered beautiful.

An integer is beautiful if it satisfies both of these conditions:

Digit Balance: The count of even digits (0, 2, 4, 6, 8) equals the count of odd digits (1, 3, 5, 7, 9)
Divisibility: The number is divisible by k

Example: The number 1234 has 2 even digits (2, 4) and 2 odd digits (1, 3), so it has digit balance. If k = 617 and 1234 % 617 = 0, then 1234 would be beautiful!

Goal: Return the count of beautiful integers in the given range.

Input & Output

example_1.py — Basic Range

$ Input: low = 10, high = 20, k = 3

› Output: 2

💡 Note: In range [10, 20], we check each number: 12 has 1 even digit (2) and 1 odd digit (1), and 12 % 3 = 0, so it's beautiful. 18 has 1 even digit (8) and 1 odd digit (1), and 18 % 3 = 0, so it's beautiful. Total: 2 beautiful integers.

example_2.py — Larger Numbers

$ Input: low = 1, high = 10, k = 1

› Output: 1

💡 Note: Only single-digit numbers can't be beautiful (except for 0, but it's not in range). We need equal even and odd digits. No numbers in [1, 10] satisfy this since they all have only 1 digit. Wait, let me recalculate: actually no number from 1-10 can have equal even/odd digits since they're all single digits. The answer should be 0.

example_3.py — Edge Case

$ Input: low = 4, high = 4, k = 4

› Output: 0

💡 Note: Only checking number 4. It has 1 even digit (4) and 0 odd digits, so even_count ≠ odd_count. Even though 4 % 4 = 0, it doesn't satisfy the balance condition, so it's not beautiful.

Constraints

1 ≤ low ≤ high ≤ 10⁹
1 ≤ k ≤ 20
Numbers can be up to 10 digits long
Range [low, high] is inclusive on both ends

Visualization

Tap to expand

Understanding the Visualization

Digit by Digit Construction

Like composing music note by note, we build numbers digit by digit

Balance Tracking

Keep count: +1 for each odd digit (wind), -1 for each even digit (string)

Rhythm Checking

Maintain remainder modulo k to ensure final number fits the rhythm

State Memoization

Remember results for identical states to avoid recalculation

Key Takeaway

🎯 Key Insight: Instead of checking millions of numbers individually, Digit DP constructs only valid beautiful numbers by building them digit by digit while maintaining the required mathematical properties!

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses Dynamic Programming with Digit Construction (Digit DP) to efficiently count beautiful integers without checking each number individually. We build numbers digit by digit while tracking the balance between even/odd digits and the remainder modulo k, using memoization to avoid redundant calculations. This approach handles large ranges up to 10⁹ efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Number)	O((high - low) * log(high))	O(1)	Iterate through every number in range and check both conditions
Dynamic Programming (Digit DP)	O(log(high) * 20 * k)	O(log(high) * 20 * k)	Use digit DP to construct valid numbers while tracking states

Brute Force (Check Every Number) — Algorithm Steps

Iterate through each number from low to high
For each number, count even and odd digits
Check if even count equals odd count
Check if the number is divisible by k
If both conditions are met, increment counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Check digits

Count even and odd digits

Verify balance

Ensure equal counts

Test divisibility

Check if divisible by k

Code -

solution.c — C

#include <stdio.h>

int isBeautiful(int num, int k) {
    int evenCount = 0;
    int oddCount = 0;
    int temp = num;
    
    while (temp > 0) {
        int digit = temp % 10;
        if (digit % 2 == 0) {
            evenCount++;
        } else {
            oddCount++;
        }
        temp /= 10;
    }
    
    return evenCount == oddCount && num % k == 0;
}

int numberOfBeautifulIntegers(int low, int high, int k) {
    int count = 0;
    for (int num = low; num <= high; num++) {
        if (isBeautiful(num, k)) {
            count++;
        }
    }
    return count;
}

int main() {
    int low, high, k;
    scanf("%d %d %d", &low, &high, &k);
    printf("%d\n", numberOfBeautifulIntegers(low, high, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((high - low) * log(high))

We check each number in range, and counting digits takes O(log(n)) time

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

31.2K Views

Medium Frequency

~35 min Avg. Time

892 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