Count Good Numbers - Practice Coding Problems

Count Good Numbers - Problem

Math Recursion Medium

Count Good Numbers is a fascinating combinatorics problem that challenges you to count valid digit strings with specific constraints.

A digit string is considered "good" if it follows these rules:
• Digits at even positions (0, 2, 4, ...) must be even (0, 2, 4, 6, 8)
• Digits at odd positions (1, 3, 5, ...) must be prime (2, 3, 5, 7)

For example:
• "2582" is good: positions 0,2 have even digits (2,8), positions 1,3 have prime digits (5,2)
• "3245" is not good: position 0 has odd digit (3)

Given an integer n, return the total count of good digit strings of length n. Since the answer can be very large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: n = 1

› Output: 5

💡 Note: For length 1, only position 0 exists (even position). Valid digits are 0,2,4,6,8 - total of 5 good numbers.

example_2.py — Small Even Length

$ Input: n = 4

› Output: 400

💡 Note: Positions 0,2 are even (5 choices each), positions 1,3 are odd (4 choices each). Total = 5² × 4² = 25 × 16 = 400.

example_3.py — Small Odd Length

$ Input: n = 50

› Output: 564908303

💡 Note: 25 even positions and 25 odd positions. Result is (5²⁵ × 4²⁵) mod (10⁹ + 7) = 564908303.

Constraints

1 ≤ n ≤ 10¹⁵
The answer must be returned modulo 10⁹ + 7
Large input size requires efficient O(log n) solution

Visualization

Tap to expand

Understanding the Visualization

Analyze Position Rules

Even positions (0,2,4...) need even digits (0,2,4,6,8), odd positions (1,3,5...) need prime digits (2,3,5,7)

Count Position Types

For length n: even positions = ceil(n/2), odd positions = floor(n/2)

Apply Multiplication Principle

Total combinations = 5^(even_positions) × 4^(odd_positions)

Use Fast Exponentiation

Compute large powers efficiently using binary exponentiation in O(log n) time

Key Takeaway

🎯 Key Insight: Independence of positions allows us to use the multiplication principle. Fast exponentiation makes it efficient for very large n values up to 10^15.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 25

The optimal solution uses mathematical pattern recognition and fast exponentiation. Key insight: each position is independent, so we can multiply choices per position type. Even positions have 5 valid digits, odd positions have 4. Result is 5^(even_count) × 4^(odd_count) computed efficiently in O(log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Pattern Recognition	O(log n)	O(1)	Use combinatorics and fast exponentiation to count valid combinations efficiently

Mathematical Pattern Recognition — Algorithm Steps

Count even positions: ceil(n/2) positions with 5 choices each
Count odd positions: floor(n/2) positions with 4 choices each
Use fast exponentiation to compute 5^even_count * 4^odd_count
Return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Patterns

Even positions have 5 valid digits, odd positions have 4 valid digits

Count Positions

Calculate number of even and odd positions

Apply Multiplication

Use fast exponentiation to compute 5^even * 4^odd

Code -

solution.c — C

#include <stdio.h>

#define MOD 1000000007

long long fastPower(long long base, long long exp, long long mod) {
    long long result = 1;
    base = base % mod;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        exp = exp >> 1;
        base = (base * base) % mod;
    }
    return result;
}

int countGoodNumbers(int n) {
    // Even positions can have 5 choices: 0, 2, 4, 6, 8
    long long evenPositions = (n + 1) / 2;
    // Odd positions can have 4 choices: 2, 3, 5, 7
    long long oddPositions = n / 2;
    
    long long evenChoices = fastPower(5, evenPositions, MOD);
    long long oddChoices = fastPower(4, oddPositions, MOD);
    
    return (evenChoices * oddChoices) % MOD;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Fast exponentiation takes O(log n) time for computing powers

⚡ Linearithmic

Space Complexity

O(1)

Only using a constant amount of extra space

✓ Linear Space

39.5K Views

Medium Frequency

~18 min Avg. Time

1.4K 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

Mathematical Pattern Recognition — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler