Count Good Numbers

Count Good Numbers - Problem

Math Recursion Medium

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 10^9 + 7.

A digit string is a string consisting of digits 0 through 9 that may contain leading zeros.

Input & Output

Example 1 — Small Case

$ Input: n = 1

› Output: 5

💡 Note: Single digit at even position 0. Valid digits: 0,2,4,6,8. Total = 5.

Example 2 — Two Positions

$ Input: n = 2

› Output: 20

💡 Note: Position 0 (even): 5 choices, Position 1 (odd): 4 choices. Total = 5 × 4 = 20.

Example 3 — Larger Input

$ Input: n = 50

› Output: 564908303

💡 Note: Even positions: 25, Odd positions: 25. Result = 5²⁵ × 4²⁵ mod (10⁹ + 7).

Constraints

1 ≤ n ≤ 10¹⁵

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is recognizing that positions have independent digit choices. Even positions must use digits {0,2,4,6,8} and odd positions must use {2,3,5,7}. Best approach is mathematical formula: 5^even_positions × 4^odd_positions using fast exponentiation. Time: O(log n), Space: O(1)

Common Approaches

✓ Brute Force Recursion

⏱️ Time: O(10^n) Space: O(n)

Generate all possible strings of length n by trying each digit at each position and checking if it forms a valid good string. This explores every combination.

Mathematical Formula

⏱️ Time: O(log n) Space: O(1)

Recognize that each position has independent choices. Even positions have 5 choices (0,2,4,6,8) and odd positions have 4 choices (2,3,5,7). Use exponentiation to compute the result efficiently.

Brute Force Recursion — Algorithm Steps

For each position, try all digits 0-9
Check if digit satisfies even/odd position rule
Recursively build remaining positions
Count valid complete strings

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0 (Even)

Try digits 0,2,4,6,8

Position 1 (Odd)

Try digits 2,3,5,7

Count Valid

Sum all valid complete strings

Code -

solution.c — C

#include <stdio.h>

const int MOD = 1000000007;

int backtrack(int pos, int n) {
    if (pos == n) {
        return 1;
    }
    
    long long count = 0;
    if (pos % 2 == 0) { // Even position - need even digit
        int evenDigits[] = {0, 2, 4, 6, 8};
        for (int i = 0; i < 5; i++) {
            count = (count + backtrack(pos + 1, n)) % MOD;
        }
    } else { // Odd position - need prime digit
        int primeDigits[] = {2, 3, 5, 7};
        for (int i = 0; i < 4; i++) {
            count = (count + backtrack(pos + 1, n)) % MOD;
        }
    }
    
    return count;
}

int solution(int n) {
    return backtrack(0, n);
}

int main() {
    int n;
    scanf("%d", &n);
    
    int result = solution(n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(10^n)

At each of n positions, we try up to 10 digits, leading to 10^n combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals string length n

⚡ Linearithmic Space

32.5K Views

Medium Frequency

~25 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 Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler