Find the Largest Palindrome Divisible by K

Find the Largest Palindrome Divisible by K - Problem

Math String Dynamic Programming Greedy Number Theory Hard

You're tasked with finding the largest palindromic number with exactly n digits that is divisible by k.

A number is k-palindromic if it satisfies two conditions:

It reads the same forwards and backwards (palindrome)
It's evenly divisible by k

For example, with n = 3 and k = 5, the answer would be "595" because it's the largest 3-digit palindrome divisible by 5.

Important: The result cannot have leading zeros, so it must be a valid n-digit number.

Input & Output

example_1.py — Basic Case

$ Input: n = 3, k = 5

› Output: "595"

💡 Note: The largest 3-digit palindrome divisible by 5. Since divisible by 5 means ending in 0 or 5, and we want the largest, we choose 5 for both ends. The middle digit should be as large as possible, which is 9.

example_2.py — Even Divisor

$ Input: n = 4, k = 2

› Output: "8998"

💡 Note: For divisibility by 2, the number must be even. The largest 4-digit even palindrome has 8 at both ends (since 9998 would be odd). The middle two digits can both be 9.

example_3.py — Single Digit

$ Input: n = 1, k = 7

› Output: "7"

💡 Note: With only one digit, we need the largest single digit divisible by 7, which is 7 itself.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ k ≤ 9
The result must have exactly n digits (no leading zeros)
The result must be both a palindrome and divisible by k

Visualization

Tap to expand

Understanding the Visualization

Foundation

Place the largest valid digits at the ends

Symmetry

Work inward, mirroring each digit placement

Constraints

Ensure divisibility rules are maintained

Completion

Fill the center digit for odd-length palindromes

Key Takeaway

🎯 Key Insight: By understanding divisibility rules and constructing the palindrome greedily from outside to inside, we can build the optimal solution without checking all possibilities.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a constructive greedy approach that builds the palindrome from the outside in, placing the largest possible digits while ensuring divisibility by k. Special handling is needed for different values of k based on their mathematical properties, making this much more efficient than checking all possible palindromes.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Palindromes)	O(10^n)	O(n)	Generate all possible n-digit palindromes and find the largest one divisible by k
Constructive Greedy (Optimal)	O(n * 10)	O(n)	Build the largest palindrome digit by digit using divisibility rules

Brute Force (Check All Palindromes) — Algorithm Steps

Start with the largest possible n-digit number (999...9)
For each number, check if it's a palindrome
If it's a palindrome, check if it's divisible by k
Return the first one that satisfies both conditions
Continue until we find a valid k-palindromic number

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Maximum

Begin with 999...9 (n digits)

Check Palindrome

Test if current number reads same forwards/backwards

Check Divisibility

If palindrome, test if divisible by k

Return or Continue

Return if found, otherwise try next smaller number

Code -

solution.c — C

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

int isPalindrome(char* s) {
    int len = strlen(s);
    for (int i = 0; i < len/2; i++) {
        if (s[i] != s[len-1-i]) {
            return 0;
        }
    }
    return 1;
}

void largestPalindrome(int n, int k, char* result) {
    long long start = 1;
    for (int i = 0; i < n; i++) start *= 10;
    start--;
    
    long long end = 1;
    for (int i = 0; i < n-1; i++) end *= 10;
    
    for (long long num = start; num >= end; num--) {
        sprintf(result, "%lld", num);
        if (isPalindrome(result) && num % k == 0) {
            return;
        }
    }
    
    strcpy(result, "");
}

int main() {
    int n, k;
    char result[20];
    scanf("%d %d", &n, &k);
    largestPalindrome(n, k, result);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(10^n)

In worst case, we might need to check all n-digit numbers

✓ Linear Growth

Space Complexity

O(n)

Only need space to store the current number as a string

⚡ Linearithmic Space

31.5K Views

Medium Frequency

~25 min Avg. Time

890 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 (Check All Palindromes) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler