# Solving Leetcode Interviews in Seconds with AI: Count Good Numbers


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1922" 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
	> A digit string is good if the digits (0-indexed) at even indices are even and the digits at odd indices are prime (2, 3, 5, or 7).  For example, "2582" is good because the digits (2 and 8) at even positions are even and the digits (5 and 2) at odd positions are prime. However, "3245" is not good because 3 is at an even index but is not even.  Given an integer n, return the total number of good digit strings of length n. Since the answer may be large, return it modulo 109 + 7. A digit string is a string consisting of digits 0 through 9 that may contain leading zeros.   Example 1:  Input: n = 1 Output: 5 Explanation: The good numbers of length 1 are "0", "2", "4", "6", "8".  Example 2:  Input: n = 4 Output: 400  Example 3:  Input: n = 50 Output: 564908303    Constraints:  1 <= n <= 1015  

	# Explanation
	Here's the solution to the problem:

*   The number of choices for even positions (0, 2, 4, ...) are 0, 2, 4, 6, 8 which gives 5 options.
*   The number of choices for odd positions (1, 3, 5, ...) are 2, 3, 5, 7 which gives 4 options.
*   The total number of good digit strings of length *n* is thus 5<sup>ceil(n/2)</sup> \* 4<sup>floor(n/2)</sup>. We need to calculate this modulo 10<sup>9</sup> + 7 using the property of modular exponentiation to avoid overflow issues since n can be very large.

*   **Runtime Complexity:** O(log n), due to the modular exponentiation. **Storage Complexity:** O(1).

	
	# Code
	```python
	def countGoodNumbers(n: int) -> int:
    """
    Given an integer n, return the total number of good digit strings of length n.
    Since the answer may be large, return it modulo 109 + 7.
    """
    MOD = 10**9 + 7

    def power(base, exp, mod):
        res = 1
        base %= mod
        while exp > 0:
            if exp % 2 == 1:
                res = (res * base) % mod
            base = (base * base) % mod
            exp //= 2
        return res

    even_count = (n + 1) // 2
    odd_count = n // 2

    return (power(5, even_count, MOD) * power(4, odd_count, MOD)) % MOD
	```