Jobs

Interviews

Discussions

Count of Integers #81 Most Asked

Hard

Cisco

5 views

Topics:

StringsDynamic Programming

You are given two numeric strings num1 and num2 and two integers max_sum and min_sum. We denote an integer x to be good if:

num1 <= x <= num2
min_sum <= digit_sum(x) <= max_sum.

Return the number of good integers. Since the answer may be large, return it modulo 10⁹ + 7.

Note that digit_sum(x) denotes the sum of the digits of x.

Example 1:

Input: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Output: 11
Explanation: There are 11 integers whose sum of digits lies between 1 and 8 are 1,2,3,4,5,6,7,8,10,11, and 12. Thus, we return 11.

Example 2:

Input: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Output: 5
Explanation: The 5 integers whose sum of digits lies between 1 and 5 are 1,2,3,4, and 5. Thus, we return 5.

Constraints:

1 <= num1 <= num2 <= 10²²
1 <= min_sum <= max_sum <= 400

Try coding it in LeetCode

Count of Integers #81 Most Asked

Hard

Cisco

5 views

Topics:

StringsDynamic Programming

You are given two numeric strings num1 and num2 and two integers max_sum and min_sum. We denote an integer x to be good if:

num1 <= x <= num2
min_sum <= digit_sum(x) <= max_sum.

Return the number of good integers. Since the answer may be large, return it modulo 10⁹ + 7.

Note that digit_sum(x) denotes the sum of the digits of x.

Example 1:

Input: num1 = "1", num2 = "12", min_sum = 1, max_sum = 8
Output: 11
Explanation: There are 11 integers whose sum of digits lies between 1 and 8 are 1,2,3,4,5,6,7,8,10,11, and 12. Thus, we return 11.

Example 2:

Input: num1 = "1", num2 = "5", min_sum = 1, max_sum = 5
Output: 5
Explanation: The 5 integers whose sum of digits lies between 1 and 5 are 1,2,3,4, and 5. Thus, we return 5.

Constraints:

1 <= num1 <= num2 <= 10²²
1 <= min_sum <= max_sum <= 400

Try coding it in LeetCode

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What are the constraints for num1, num2, min_sum, and max_sum? What are the maximum possible values for these integers?
Are num1 and num2 inclusive in the range to be considered?
If no numbers within the range [num1, num2] have a digit sum between [min_sum, max_sum], what should the function return?
Are num1 and num2 always positive integers? Can they ever be zero?
Is min_sum always less than or equal to max_sum?

Brute Force Solution

Approach

We want to find how many numbers meet certain criteria. A brute force approach means we'll look at every single possible number within a given range and check if it satisfies all the conditions.

Here's how the algorithm would work step-by-step:

Start with the first number in the range we are given.
Check if this number meets all the conditions. For example, we might need to see if it's divisible by a certain number, if its digits add up to a certain value, or if it contains specific digits.
If the number meets all the conditions, we count it.
Move on to the next number in the range.
Repeat the process of checking and counting until we reach the last number in the range.
The total number of counted integers is our answer.

Code Implementation

def count_of_integers_brute_force(minimum_number, maximum_number, rule):
    valid_integers_count = 0
    #Iterate over all possible integers.

    for current_integer in range(minimum_number, maximum_number + 1):

        #Check against the rule
        if rule(current_integer):

            valid_integers_count += 1

    return valid_integers_count

Big(O) Analysis

Time Complexity

O(N * complexity_of_check) – The solution iterates through a range of numbers, where N represents the size of the range (the difference between the upper and lower bounds). For each number in this range, a 'check' operation is performed to verify if it meets the specified conditions. The complexity of this 'check' operation is dependent on the nature of the conditions. Therefore, the overall time complexity is proportional to N multiplied by the complexity of the check function. If the check function's complexity is constant, then the overall complexity is O(N).

Space Complexity

O(1) – The described brute-force approach iterates through numbers within a given range and checks each number against specified conditions. It only requires a counter variable to store the number of integers that meet the criteria, and loop variables to iterate through the range. The space required for these variables remains constant irrespective of the size of the range (N). Therefore, the auxiliary space complexity is O(1).

Optimal Solution

Approach

The optimal strategy involves carefully constructing valid numbers digit by digit. By leveraging the constraints of the problem and using a technique similar to dynamic programming, we avoid redundant calculations and efficiently count the valid numbers within the specified range.

Here's how the algorithm would work step-by-step:

First, represent the allowed digits as a set, and the bounds of the count range (if applicable).
Consider the number of digits available in the problem.
Start from the leftmost digit and determine, based on the allowed digits, how many choices we have for that position.
Account for whether the number being built is currently 'less than', 'equal to', or 'greater than' the upper and lower bounds of our valid number range.
If our current leftmost digit is smaller than the corresponding digit in the upper bound, all possible combinations of remaining digits are valid (respecting allowed digits). Similarly, if the current digit is greater than the corresponding digit in the lower bound, all combinations are valid.
If the current digit is equal to the corresponding digits in the upper and lower bounds, continue the process with the next digit.
Repeat this process for each subsequent digit position, keeping track of the 'less than', 'equal to', or 'greater than' status at each stage.
Return the final count of valid numbers after considering all possible combinations while respecting all constraints.

Code Implementation

def count_integers(low_range, high_range, digit_sum_lower_bound, digit_sum_upper_bound):

    def count_valid_numbers(up_to_value, digit_sum_lower_bound_inner, digit_sum_upper_bound_inner):
        number_as_string = str(up_to_value)
        length_of_number = len(number_as_string)

        # dp[i][j] stores the count of numbers with digit sum j using first i digits
        dp_table = [[0] * (100) for _ in range(length_of_number + 1)]
        dp_table[0][0] = 1

        for index in range(1, length_of_number + 1):
            digit = int(number_as_string[index - 1])

            for current_sum in range(100):
                # Consider all possible digits less than the current digit
                for smaller_digit in range(10):
                    if current_sum >= smaller_digit:
                        dp_table[index][current_sum] += dp_table[index - 1][current_sum - smaller_digit]

                # If we take the current digit, add the count from the previous state where the prefix matched
                if current_sum >= digit:
                    is_prefix_matching = True
                    for prefix_index in range(index - 1):
                        if int(number_as_string[prefix_index]) != int(number_as_string[prefix_index]):
                            is_prefix_matching = False
                            break

                    if is_prefix_matching:
                        dp_table[index][current_sum] += dp_table[index - 1][current_sum - digit]

        total_valid_numbers = 0
        for digit_sum in range(digit_sum_lower_bound_inner, digit_sum_upper_bound_inner + 1):
            total_valid_numbers += dp_table[length_of_number][digit_sum]
        return total_valid_numbers

    # The number of integers meeting the condition up to high_range.
    count_up_to_high = count_valid_numbers(high_range, digit_sum_lower_bound, digit_sum_upper_bound)

    # The number of integers meeting the condition up to (low_range - 1).
    count_up_to_low = count_valid_numbers(low_range - 1, digit_sum_lower_bound, digit_sum_upper_bound)

    # Final count is obtained by subtracting the two counts.
    final_count = count_up_to_high - count_up_to_low
    return final_count

Big(O) Analysis

Time Complexity

O(d * a * 2^2) – The algorithm iterates through each digit position 'd' of the input numbers. For each digit position, it explores each allowed digit 'a' in the digit set. The 'less than', 'equal to', or 'greater than' status relative to upper and lower bounds effectively creates a state space of size at most 2 * 2, considering both lower and upper bounds simultaneously. Thus, the total number of operations is proportional to d * a * 2^2. Since 2^2 is constant and d is the number of digits and a is the size of allowed digits (which can be at most 10), the time complexity can be simplified to O(1).

Space Complexity

O(N) – The described solution uses a dynamic programming-like approach, implying storage of intermediate results. The number of digits in the input number range (represented as N) determines the depth of the digit-by-digit construction. Thus, auxiliary space is required to store the count of valid numbers calculated for each digit position and constraint combination, potentially using a memoization table of size proportional to N. Therefore, the space complexity is O(N), where N is the number of digits in the input range.

Edge Cases

Case	How to Handle
num1 or num2 is negative	Adjust the range to start from 0 if num1 is negative, and if num2 is negative return 0
num1 is greater than num2	Swap num1 and num2 or return 0 to handle an invalid range
min_sum is greater than max_sum	Return 0 as no digit sums can satisfy this condition
min_sum is negative	Clamp min_sum to 0, since digit sums cannot be negative
max_sum is greater than the maximum possible digit sum given num2	Clamp max_sum to the maximum possible digit sum to avoid unnecessary computations
num1 and num2 are large numbers (close to max int)	Use dynamic programming with memoization to avoid recomputation of digit sums to optimize for larger numbers
num1 and num2 are same and min_sum and max_sum are also same but digit_sum(num1) is not equal to min_sum	Return 0, as the single number does not meet the criteria
Zero as num1 or num2	The algorithm should correctly account for zero's digit sum being 0 when included in the range

num1 or num2 is negative

How to Handle:

Adjust the range to start from 0 if num1 is negative, and if num2 is negative return 0

num1 is greater than num2

How to Handle:

Swap num1 and num2 or return 0 to handle an invalid range

min_sum is greater than max_sum

How to Handle:

Return 0 as no digit sums can satisfy this condition

min_sum is negative

How to Handle:

Clamp min_sum to 0, since digit sums cannot be negative

max_sum is greater than the maximum possible digit sum given num2

How to Handle:

Clamp max_sum to the maximum possible digit sum to avoid unnecessary computations

num1 and num2 are large numbers (close to max int)

How to Handle:

Use dynamic programming with memoization to avoid recomputation of digit sums to optimize for larger numbers

num1 and num2 are same and min_sum and max_sum are also same but digit_sum(num1) is not equal to min_sum

How to Handle:

Return 0, as the single number does not meet the criteria

Zero as num1 or num2

How to Handle:

The algorithm should correctly account for zero's digit sum being 0 when included in the range

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What are the constraints for num1, num2, min_sum, and max_sum? What are the maximum possible values for these integers?
Are num1 and num2 inclusive in the range to be considered?
If no numbers within the range [num1, num2] have a digit sum between [min_sum, max_sum], what should the function return?
Are num1 and num2 always positive integers? Can they ever be zero?
Is min_sum always less than or equal to max_sum?

Brute Force Solution

Approach

We want to find how many numbers meet certain criteria. A brute force approach means we'll look at every single possible number within a given range and check if it satisfies all the conditions.

Here's how the algorithm would work step-by-step:

Start with the first number in the range we are given.
Check if this number meets all the conditions. For example, we might need to see if it's divisible by a certain number, if its digits add up to a certain value, or if it contains specific digits.
If the number meets all the conditions, we count it.
Move on to the next number in the range.
Repeat the process of checking and counting until we reach the last number in the range.
The total number of counted integers is our answer.

Code Implementation

def count_of_integers_brute_force(minimum_number, maximum_number, rule):
    valid_integers_count = 0
    #Iterate over all possible integers.

    for current_integer in range(minimum_number, maximum_number + 1):

        #Check against the rule
        if rule(current_integer):

            valid_integers_count += 1

    return valid_integers_count

Big(O) Analysis

Time Complexity

Space Complexity

Optimal Solution

Approach

Here's how the algorithm would work step-by-step:

First, represent the allowed digits as a set, and the bounds of the count range (if applicable).
Consider the number of digits available in the problem.
Start from the leftmost digit and determine, based on the allowed digits, how many choices we have for that position.
Account for whether the number being built is currently 'less than', 'equal to', or 'greater than' the upper and lower bounds of our valid number range.
If our current leftmost digit is smaller than the corresponding digit in the upper bound, all possible combinations of remaining digits are valid (respecting allowed digits). Similarly, if the current digit is greater than the corresponding digit in the lower bound, all combinations are valid.
If the current digit is equal to the corresponding digits in the upper and lower bounds, continue the process with the next digit.
Repeat this process for each subsequent digit position, keeping track of the 'less than', 'equal to', or 'greater than' status at each stage.
Return the final count of valid numbers after considering all possible combinations while respecting all constraints.

Code Implementation

def count_integers(low_range, high_range, digit_sum_lower_bound, digit_sum_upper_bound):

    def count_valid_numbers(up_to_value, digit_sum_lower_bound_inner, digit_sum_upper_bound_inner):
        number_as_string = str(up_to_value)
        length_of_number = len(number_as_string)

        # dp[i][j] stores the count of numbers with digit sum j using first i digits
        dp_table = [[0] * (100) for _ in range(length_of_number + 1)]
        dp_table[0][0] = 1

        for index in range(1, length_of_number + 1):
            digit = int(number_as_string[index - 1])

            for current_sum in range(100):
                # Consider all possible digits less than the current digit
                for smaller_digit in range(10):
                    if current_sum >= smaller_digit:
                        dp_table[index][current_sum] += dp_table[index - 1][current_sum - smaller_digit]

                # If we take the current digit, add the count from the previous state where the prefix matched
                if current_sum >= digit:
                    is_prefix_matching = True
                    for prefix_index in range(index - 1):
                        if int(number_as_string[prefix_index]) != int(number_as_string[prefix_index]):
                            is_prefix_matching = False
                            break

                    if is_prefix_matching:
                        dp_table[index][current_sum] += dp_table[index - 1][current_sum - digit]

        total_valid_numbers = 0
        for digit_sum in range(digit_sum_lower_bound_inner, digit_sum_upper_bound_inner + 1):
            total_valid_numbers += dp_table[length_of_number][digit_sum]
        return total_valid_numbers

    # The number of integers meeting the condition up to high_range.
    count_up_to_high = count_valid_numbers(high_range, digit_sum_lower_bound, digit_sum_upper_bound)

    # The number of integers meeting the condition up to (low_range - 1).
    count_up_to_low = count_valid_numbers(low_range - 1, digit_sum_lower_bound, digit_sum_upper_bound)

    # Final count is obtained by subtracting the two counts.
    final_count = count_up_to_high - count_up_to_low
    return final_count

Big(O) Analysis

Time Complexity

Space Complexity

Edge Cases

Case	How to Handle
num1 or num2 is negative	Adjust the range to start from 0 if num1 is negative, and if num2 is negative return 0
num1 is greater than num2	Swap num1 and num2 or return 0 to handle an invalid range
min_sum is greater than max_sum	Return 0 as no digit sums can satisfy this condition
min_sum is negative	Clamp min_sum to 0, since digit sums cannot be negative
max_sum is greater than the maximum possible digit sum given num2	Clamp max_sum to the maximum possible digit sum to avoid unnecessary computations
num1 and num2 are large numbers (close to max int)	Use dynamic programming with memoization to avoid recomputation of digit sums to optimize for larger numbers
num1 and num2 are same and min_sum and max_sum are also same but digit_sum(num1) is not equal to min_sum	Return 0, as the single number does not meet the criteria
Zero as num1 or num2	The algorithm should correctly account for zero's digit sum being 0 when included in the range

num1 or num2 is negative

How to Handle:

Adjust the range to start from 0 if num1 is negative, and if num2 is negative return 0

num1 is greater than num2

How to Handle:

Swap num1 and num2 or return 0 to handle an invalid range

min_sum is greater than max_sum

How to Handle:

Return 0 as no digit sums can satisfy this condition

min_sum is negative

How to Handle:

Clamp min_sum to 0, since digit sums cannot be negative

max_sum is greater than the maximum possible digit sum given num2

How to Handle:

Clamp max_sum to the maximum possible digit sum to avoid unnecessary computations

num1 and num2 are large numbers (close to max int)

How to Handle:

Use dynamic programming with memoization to avoid recomputation of digit sums to optimize for larger numbers

num1 and num2 are same and min_sum and max_sum are also same but digit_sum(num1) is not equal to min_sum

How to Handle:

Return 0, as the single number does not meet the criteria

Zero as num1 or num2

How to Handle:

The algorithm should correctly account for zero's digit sum being 0 when included in the range

0/0 Cisco questions completed

0/0 completed