Find the Count of Good Integers - Problem

You are given two positive integers n and k.

An integer x is called k-palindromic if:

x is a palindrome
x is divisible by k

An integer is called good if its digits can be rearranged to form a k-palindromic integer.

For example, for k = 2, 2020 can be rearranged to form the k-palindromic integer 2002, whereas 1010 cannot be rearranged to form a k-palindromic integer.

Return the count of good integers containing n digits.

Note: Any integer must not have leading zeros, neither before nor after rearrangement. For example, 1010 cannot be rearranged to form 101.

Input & Output

Example 1 — Basic Case

$ Input: n = 3, k = 5

› Output: 27

💡 Note: For 3-digit numbers, we need palindromes like ABA where A∈{1-9}, B∈{0-9}. Count arrangements that form palindromes divisible by 5.

Example 2 — Single Digit

$ Input: n = 1, k = 4

› Output: 2

💡 Note: Single digits divisible by 4: only 4 and 8. So count is 2.

Example 3 — Even Length

$ Input: n = 2, k = 6

› Output: 4

💡 Note: 2-digit palindromes divisible by 6: must be divisible by both 2 and 3. Examples: 66 (rearrangement of 66).

Constraints

1 ≤ n ≤ 15
1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12

This problem requires combinatorial enumeration to count digit arrangements that can form k-palindromic numbers. The key insight is to generate palindrome patterns and use mathematical formulas rather than checking all permutations. Best approach uses mathematical formulas with palindrome structure analysis. Time: O(10^(n/2)), Space: O(1)

Common Approaches

✓ Brute Force - Check All Numbers

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

For each n-digit number, generate all permutations of its digits to see if any forms a palindrome divisible by k. This approach is extremely slow but conceptually straightforward.

Combinatorial Enumeration

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

Instead of checking all numbers, generate possible digit frequency patterns that can form palindromes, then use combinatorics to count how many valid arrangements exist for each pattern.

Mathematical Formula Approach

⏱️ Time: O(10^(n/2)) Space: O(1)

Leverage mathematical properties of palindromes and divisibility rules to derive formulas that can compute the answer without explicit enumeration. This involves understanding digit patterns and modular arithmetic.

Brute Force - Check All Numbers — Algorithm Steps

Generate all n-digit numbers
For each number, generate all digit permutations
Check if any permutation is palindrome and divisible by k

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Numbers

Create all n-digit numbers

Check Permutations

For each number, try all digit arrangements

Verify

Check if any arrangement is palindrome and divisible by k

Code -

solution.c — C

#include <stdio.h>

long long power(int base, int exp) {
    long long result = 1;
    int i;
    for (i = 0; i < exp; i++) {
        result *= base;
    }
    return result;
}

long long countPalindromes(int length, int divisor) {
    if (length == 1) {
        long long count = 0;
        int i;
        for (i = 1; i <= 9; i++) {
            if (i % divisor == 0) {
                count++;
            }
        }
        return count;
    }
    
    /* For even length palindromes */
    if (length % 2 == 0) {
        int halfLen = length / 2;
        /* First digit can't be 0 */
        long long firstDigitChoices = 9;
        long long remainingDigits = power(10, halfLen - 1);
        
        /* Apply divisibility constraint */
        long long total = firstDigitChoices * remainingDigits;
        
        /* Filter by divisibility */
        long long validCount = total / divisor;
        return validCount > 0 ? validCount : 0;
    }
    
    /* For odd length palindromes */
    else {
        int halfLen = length / 2;
        long long firstDigitChoices = 9;
        long long middleDigitChoices = 10;
        long long remainingDigits = power(10, halfLen);
        
        long long total = firstDigitChoices * middleDigitChoices * remainingDigits;
        long long validCount = total / divisor;
        return validCount > 0 ? validCount : 0;
    }
}

long long solution(int n, int k) {
    return countPalindromes(n, k);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(10^n × n!)

10^n numbers, each with n! permutations to check

✓ Linear Growth

Space Complexity

O(n)

Space to store current number and generate permutations

✓ Linear Space

12.5K Views

Medium Frequency

~45 min Avg. Time

280 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

Find the Count of Good Integers - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Numbers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler