Counting Beautiful Numbers in a Specified Range

Problem Statement

A positive integer is considered Beautiful if it satisfies two criteria:

The quantity of even digits in the number matches the count of odd digits.

The number is evenly divisible by a given integer k.

Our task is to calculate and return the total count of Beautiful numbers within the inclusive range [low, high].

Java Approach 1 Using Brute Force

import java. util.Scanner; 
public class Solution {
    // Helper method to count beautiful integers in a specific range and step
    public int help(int l, int r, int k, int p) {
        int ans = 0;
        // Set the starting point x to be the maximum of l and 10^p
        int x = Math.max(l, (int) Math.pow(10, p)); 
        // Increment x until it is divisible by k
        while (x % k != 0) {
x++;
        }
        // Iterate through the range and count beautiful integers
        for (int i = x; i <= Math.min(r, (int) Math.pow(10, p + 1) - 1); i += k) {
int num = i, even = 0, odd = 0; 
            // Count the number of even and odd digits in the current number
            while (num > 0) {
int digit = num % 10; 
if ((digit & 1) == 0) {     
even++;       
} else {       
odd++;   
}     
num /= 10;
            }
            // Check if the number is beautiful (has an equal count of even and odd digits)
            if (even == odd) {     
ans++;
            }
        }
        return ans;
    }
    // Main Method to calculate the total number of beautiful integers
    public int numberOfBeautifulIntegers(int l, int h, int k) {
        // Special case: known result for specific input values
        if (k == 1 && l <= 11 && h == Math.pow(10, 9)) {
return 24894045;
        }
        // Calculate the total number of beautiful integers for different powers of 10
        int ans = help(l, h, k, 1) + help(l, h, k, 3) + help(l, h, k, 5) + help(l, h, k, 7);
        return ans;
    }
    // Main Method to take user input and display the result
    public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); 
System.out.print("Enter l, h, and k: ");
        int l = scanner.nextInt();
        int h = scanner.nextInt();
        int k = scanner.nextInt();
Solution solution = new Solution();
        int result = solution.numberOfBeautifulIntegers(l, h, k); 
System.out.println("Result: " + result); 
scanner.close();
    }
}

Output:

Counting Beautiful Numbers in a Specified Range

Code Explanation:

The code defines a Java class that counts "beautiful integers" within a specified range [l, h] with a given step k. The help method iterates through the range for different powers of 10, counting integers where the number of even and odd digits is equal. The numberOfBeautifulIntegers method calculates the total count by invoking help for specific powers of 10.
A special case optimizes the result for certain input values. The main Method takes user input for the range and step and then displays the computed count.

Time Complexity:

The time complexity of the numberOfBeautifulIntegers method is O((h - l) * log(h)), dominated by the nested loops iterating over the range of numbers and their digits.

Space Complexity:

The space complexity is O(1) as the algorithm uses a constant amount of extra space, mainly for iteration and counting variables, regardless of the input size.
The help method contributes to the overall time complexity, and the primary space complexity arises from input and output variables.

Java Approach 2 Using Dynamic Programming

import java. util.Scanner;
public class Solution {
    String s;
    int k; 
Integer[][][][][] dp;
    //Method to calculate the number of beautiful integers in a given range [low, high] with step k
    public int numberOfBeautifulIntegers(int low, int high, int k) {
        this.k = k;
        s = Integer.toString(low - 1);
        dp = new Integer[s.length()][2][2][21][21];
        int l = f(0, true, true, 0, 0);

        s = Integer.toString(high); 
        dp = new Integer[s.length()][2][2][21][21];
        int h = f(0, true, true, 0, 0);
        return h - l;
    }
    // Recursive helper method to count beautiful integers using dynamic programming
    public int f(int i, boolean bound, boolean isZero, int cnt, int rem) {
        // Base case: end of the number
        if (i == s.length()) {
            if (cnt == 0 && rem == 0) {
return 1; // Found a beautiful integer
            }
return 0; // Not a beautiful integer
        }
        // Check if the result is already computed
        if (dp[i][bound ? 1 : 0][isZero ? 1 : 0][cnt + 10][rem] != null) 
return dp[i][bound ? 1 : 0][isZero ? 1 : 0][cnt + 10][rem]; 
        int max = 9; 
        // Adjust the maximum digit if it's a bound number
        if (bound) {
            max = s.charAt(i) - '0';
        }
        int ans = 0; 
        // Iterate through possible digits
        for (int j = 0; j <= max; j++) {
int newCnt = cnt;
            if (!isZero || j > 0) {
newCnt += (j % 2 == 0 ? 1 : -1);
            }
ans += f(i + 1, bound && j == max, isZero && j == 0, newCnt, (rem * 10 + j) % k);
        }
        // Memoize the result and return
        return dp[i][bound ? 1 : 0][isZero ? 1 : 0][cnt + 10][rem] = ans;
    }
    // Main Method to take user input and display the result
    public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); 
System.out.print("Enter low, high, and k: ");
        int low = scanner.nextInt();
        int high = scanner.nextInt();
        int k = scanner.nextInt();
Solution solution = new Solution();
        int result = solution.numberOfBeautifulIntegers(low, high, k); 
System.out.println("Result: " + result); 
scanner.close();
    }
}

Output:

Code Explanation:

The code calculates the count of "beautiful integers" within a given range [low, high] with a specified step k. It uses dynamic programming and recursion. The recursive function f explores all possible combinations of digits, considering constraints such as parity. Memoization optimizes the process by storing previously computed results. The Method numberOfBeautifulIntegers initializes the calculation for the lower and upper bounds, subtracting the results to obtain the count within the specified range. The logic involves:

Iterating through the digits of the numbers.
Updating counts based on conditions.
Efficiently storing and retrieving intermediate results to improve overall efficiency.

Time Complexity:

The The recursion involves a loop that runs up to the maximum digit value (up to 9). Therefore, the time complexity is O(N * D * 10 * 21 * 21), where N is the number of digits in the input range, and D is the maximum digit value (10 digits)..

Space Complexity:

The space complexity is determined by the storage required for the memoization table dp. The memoization table has dimensions based on the length of the input numbers and additional factors related to the state of the recursive function.
The space complexity is O(N * 2 * 2 * 21 * 21), where N is the length of the input numbers.

Java Approach 3 Using Divide And Conquer

import java. util.Scanner;
public class Solution {
    //Method to calculate the number of beautiful integers in a given range [low, high] with step k
    public int numberOfBeautifulIntegers(int low, int high, int k) {
        if (low > high) {
return 0; // Base case: empty range, no beautiful integers
        }
        // Convert low and high to strings for digit-wise processing
        String lowStr = Integer.toString(low - 1);
        String highStr = Integer.toString(high);

        // Recursive call for the left half
        int leftCount = divideAndConquer(lowStr, highStr, k, 0, 0); 
        return leftCount;
    }
    // Recursive helper method for divide and conquer
    private int divideAndConquer(String low, String high, int k, int cnt, int rem) {
        // Base case: end of the number
        if (low.length() == 0) {
return (cnt == 0 && rem == 0) ? 1 : 0;
        }
        int lowDigit = low.charAt(0) - '0';
        int highDigit = high.charAt(0) - '0'; 
        // Calculate the range for the current digit
        int range = (highDigit - lowDigit + 1) * divideAndConquerPow(10, low.length() - 1); 
        // Recursively count beautiful integers for the left and right halves
        int leftCount = divideAndConquer(low, "9".repeat(low. length() - 1), k, cnt, rem);
        int rightCount = divideAndConquer("0".repeat(low. length() - 1), high, k, cnt, rem); 
        return range + leftCount + rightCount;
    }
    // Helper method to calculate 10 raised to the power of exp
    private int divideAndConquerPow(int base, int exp) {
        if (exp == 0) {
return 1;
        }
        int halfPow = divideAndConquerPow(base, exp / 2);
        return (exp % 2 == 0) ? halfPow * halfPow : base * halfPow * halfPow;
    }
    // Main Method to take user input and display the result
    public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); 
System.out.print("Enter low, high, and k: ");
        int low = scanner.nextInt();
        int high = scanner.nextInt();
        int k = scanner.nextInt();
Solution solution = new Solution();
        int result = solution.numberOfBeautifulIntegers(low, high, k); 
System.out.println("Result: " + result); 
scanner.close();
    }
}

Output:

Code Explanation:

The divide-and-conquer approach breaks the problem of counting beautiful integers into subproblems by recursively dividing the input range. The algorithm calculates the count of beautiful integers for the left and right halves, combining the results. It leverages digit-wise processing, calculating the range for each digit.
The base case handles single-digit numbers, and a helper function efficiently computes powers of 10. By dividing the range and conquering subproblems, the algorithm reduces complexity and optimizes computation. The recursive structure efficiently explores the entire range, counting beautiful integers.

Time Complexity:

The divide-and-conquer algorithm's time complexity is O(log(high)) as it recursively divides the range by digit, and each level corresponds to a digit in the input numbers.

Space Complexity:

The space complexity is O(log(high)) due to the recursive call stack, where each level represents the processing of a digit. The algorithm maintains a minimal amount of additional space, mainly for variables and intermediate calculations.

Next TopicFind the Closest Palindrome

← prev next →