# Solving Leetcode Interviews in Seconds with AI: Count the Number of Powerful Integers # Introduction In this blog post, we will explore how to solve the LeetCode problem "2999" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months. # Problem Statement > 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.   Example 1: Input: start = 1, finish = 6000, limit = 4, s = "124" Output: 5 Explanation: The powerful integers in the range [1..6000] are 124, 1124, 2124, 3124, and, 4124. All these integers have each digit <= 4, and "124" as a suffix. Note that 5124 is not a powerful integer because the first digit is 5 which is greater than 4. It can be shown that there are only 5 powerful integers in this range. Example 2: Input: start = 15, finish = 215, limit = 6, s = "10" Output: 2 Explanation: The powerful integers in the range [15..215] are 110 and 210. All these integers have each digit <= 6, and "10" as a suffix. It can be shown that there are only 2 powerful integers in this range. Example 3: Input: start = 1000, finish = 2000, limit = 4, s = "3000" Output: 0 Explanation: All integers in the range [1000..2000] are smaller than 3000, hence "3000" cannot be a suffix of any integer in this range.   Constraints: 1 <= start <= finish <= 1015 1 <= limit <= 9 1 <= s.length <= floor(log10(finish)) + 1 s only consists of numeric digits which are at most limit. s does not have leading zeros. # Explanation Here's a breakdown of the solution: * **Determine the Range of Possible Prefixes:** Calculate the minimum and maximum possible numbers with `s` as a suffix that fall within the `[start, finish]` range and whose digits are all less than or equal to `limit`. * **Count Valid Prefixes:** Iterate through the possible lengths of the prefix and for each length, determine the range of numbers that could form a valid prefix. A prefix is valid if appending it to `s` results in a number within the `[start, finish]` range and all digits are less than or equal to `limit`. * **Efficient Calculation:** Optimize the counting process by calculating the number of valid prefixes directly without explicitly generating and checking each one, using the digit constraint efficiently. * **Runtime Complexity:** O(log(finish)), where finish is the upper bound of the given range. * **Storage Complexity:** O(1) # Code ```python def solve(): start, finish, limit, s = map(eval, [input(), input(), input(), input()]) def count_powerful(num): s_len = len(s) num_str = str(num) num_len = len(num_str) if s_len > num_len: return 0 s_val = int(s) if s_val > num: return 0 count = 0 for prefix_len in range(num_len - s_len + 1): min_prefix_val = 0 max_prefix_val = 0 if prefix_len > 0: min_powerful = int('1' + '0' * (prefix_len - 1) + s) max_powerful = int('9' * prefix_len + s) if min_powerful > num: continue prefix_min = 0 if min_powerful >= start: prefix_min = int(str(min_powerful)[:-s_len]) prefix_max = float('inf') if max_powerful <= num: prefix_max = int(str(max_powerful)[:-s_len]) temp_max = int('0' + '9' * (prefix_len -1)) if prefix_max > temp_max: prefix_max = temp_max min_prefix_val = prefix_min max_prefix_val = prefix_max else: if s_val >= start and s_val <= num: min_prefix_val = 0 max_prefix_val = 0 else: continue valid_min = 0 if prefix_len > 0 : valid_min = min_prefix_val valid_max = max_prefix_val if prefix_len > 0: temp_valid_min = 0 power_of_10 = 1 for _ in range(prefix_len -1): power_of_10 *= 10 if start > int(str(valid_min).zfill(prefix_len) + s): temp_valid_min = (start - int(s)) // (power_of_10 * (10 ** len(s))) valid_min = temp_valid_min while int(str(valid_min).zfill(prefix_len)+ s) < start: valid_min +=1 valid_count = 0 if prefix_len > 0: max_possible_digit = limit temp_valid_max = 0 for i in range(prefix_len): temp_valid_max = temp_valid_max * 10 + max_possible_digit if valid_max > temp_valid_max: valid_max = temp_valid_max if int(s) >= start and int(s) <= num and len(str(int(s))) == len(str(num)): all_digits_valid = True for digit in str(int(s)): if int(digit) > limit: all_digits_valid = False if all_digits_valid: count+=1 if prefix_len ==0 and int(s) > num: count +=0 elif prefix_len > 0: all_digits_valid = True temp_range_count = valid_max - valid_min +1 for i in range(prefix_len): if limit < 0: all_digits_valid = False temp_range_count = 0 if all_digits_valid and temp_range_count >=0: valid = True for digit in str(int(s)): if int(digit) > limit: valid = False temp_range_count = 0 if valid: count += temp_range_count return count result = count_powerful(finish) - count_powerful(start - 1) print(result) solve() ```