Find the Count of Good Integers - Practice Coding Problems

Find the Count of Good Integers - Problem

The Challenge: You need to find how many good integers exist with exactly n digits.

An integer is k-palindromic if:
• It reads the same forwards and backwards (palindrome)
• It's divisible by k

An integer is good if you can rearrange its digits to form a k-palindromic number.

Examples:
• For k=2: 2020 → 2002 (palindrome ✓, divisible by 2 ✓)
• For k=2: 1010 → No valid arrangement (can't form palindrome divisible by 2)

Important: No leading zeros allowed, before or after rearrangement!

Input & Output

example_1.py — Basic Case

$ Input: n = 3, k = 5

› Output: 1

💡 Note: For n=3 digits and k=5: Valid palindromes divisible by 5 must end in 0 or 5. The palindrome "505" works, giving us digit pattern {0:1, 5:2}. This represents 1 good integer pattern.

example_2.py — Even Length

$ Input: n = 4, k = 2

› Output: 4

💡 Note: For n=4 digits and k=2: Even-digit palindromes divisible by 2 must be even. Examples include "1001", "1111", "1221", "1331", etc. After counting unique digit patterns, we get 4 different patterns.

example_3.py — Edge Case

$ Input: n = 1, k = 1

› Output: 9

💡 Note: For n=1 digit and k=1: All single digits 1-9 are palindromes divisible by 1 (no leading zeros allowed). Each represents a unique pattern, so answer is 9.

Visualization

Tap to expand

Understanding the Visualization

Half Production

Generate all possible first halves (much fewer than full numbers)

Mirror Assembly

Complete each palindrome by mirroring the first half

Quality Control

Test if the palindrome is divisible by k

Pattern Catalog

Count unique digit frequency patterns

Key Takeaway

🎯 Key Insight: Generate palindromes systematically from their first half instead of checking all possible numbers. This reduces the search space exponentially while guaranteeing we find all valid patterns.

Time & Space Complexity

Time Complexity

⏱️

O(10^(n/2))

Generate O(10^(n/2)) palindromes, constant time combinatorial calculation

✓ Linear Growth

Space Complexity

O(1)

Only store current palindrome and digit counts

✓ Linear Space

Constraints

1 ≤ n ≤ 10
1 ≤ k ≤ 9
All palindromes must have exactly n digits
No leading zeros allowed before or after rearrangement
Count unique digit patterns, not individual numbers

Asked in

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

The optimal solution uses systematic palindrome generation by creating the first half and mirroring it, then checking divisibility by k. This reduces complexity from O(10^n) to O(10^(n/2)) while using combinatorics to count unique digit arrangements efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Generate Palindromes + Count Patterns	O(10^(n/2) × n)	O(10^(n/2))	First generate all valid palindromes divisible by k, then count unique digit patterns
Optimal Palindrome Generation with Combinatorics	O(10^(n/2))	O(1)	Generate valid palindromes and use mathematical formulas to count arrangements efficiently
Brute Force (Generate All Numbers)	O(10^n × n! × n)	O(n!)	Check every n-digit number to see if its digits can form a k-palindromic number

Generate Palindromes + Count Patterns — Algorithm Steps

Generate all possible first halves of n-digit palindromes
Mirror each half to create full palindrome
Check if palindrome is divisible by k
Store digit frequency pattern of valid palindromes
Count unique patterns

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Half

Create all possible first halves of palindromes

Mirror to Full

Mirror each half to create complete palindrome

Check Divisibility

Filter palindromes divisible by k

Count Patterns

Count unique digit frequency patterns

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

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

void reverse_string(char* str, int start, int end) {
    while (start < end) {
        char temp = str[start];
        str[start] = str[end];
        str[end] = temp;
        start++;
        end--;
    }
}

int countGoodIntegers(int n, int k) {
    int count = 0;
    int halfLen = (n + 1) / 2;
    int start = power(10, halfLen - 1);
    int end = power(10, halfLen);
    
    char patterns[10000][100]; // Simple pattern storage
    int patternCount = 0;
    
    for (int half = start; half < end && half < 10000; half++) {
        char palindrome[20];
        sprintf(palindrome, "%d", half);
        
        int len = strlen(palindrome);
        if (n % 2 == 0) {
            // Mirror complete string
            for (int i = len - 1; i >= 0; i--) {
                palindrome[2 * len - len + i] = palindrome[len - 1 - i];
            }
            palindrome[2 * len] = '\0';
        } else {
            // Mirror without last character
            for (int i = len - 2; i >= 0; i--) {
                palindrome[len + len - 2 - i] = palindrome[i];
            }
            palindrome[2 * len - 1] = '\0';
        }
        
        if (strlen(palindrome) == n && palindrome[0] != '0') {
            long long num = atoll(palindrome);
            if (num % k == 0) {
                count++; // Simplified counting
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(10^(n/2) × n)

Generate 10^(n/2) palindromes, n time to process each

✓ Linear Growth

Space Complexity

O(10^(n/2))

Store unique digit patterns

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10
1 ≤ k ≤ 9
All palindromes must have exactly n digits
No leading zeros allowed before or after rearrangement
Count unique digit patterns, not individual numbers

52.3K Views

High Frequency

~35 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Generate Palindromes + Count Patterns — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler