Minimum Cost to Make Array Equalindromic

Minimum Cost to Make Array Equalindromic - Problem

Transform Array to Palindromic Equality!

You're given an integer array nums and your mission is to make all elements equal to the same palindromic number with minimum cost.

The Rules:
• You can change any element nums[i] to any positive integer x
• Each change costs |nums[i] - x| (absolute difference)
• The final target must be a palindromic number (reads same forwards and backwards)
• Target must be less than 10⁹

Examples of palindromes: 1, 11, 121, 1331, 12321
Non-palindromes: 10, 123, 1234

Find the minimum total cost to make all array elements equal to some palindromic number!

Input & Output

example_1.py — Basic Case

$ Input: [1,2,3,4,5]

› Output: 6

💡 Note: We can change all elements to palindromic number 3. Cost = |1-3| + |2-3| + |3-3| + |4-3| + |5-3| = 2 + 1 + 0 + 1 + 2 = 6. This is the minimum possible cost.

example_2.py — Single Element

$ Input: [10,12,13,14,15]

› Output: 11

💡 Note: The optimal palindromic target is 11. Cost = |10-11| + |12-11| + |13-11| + |14-11| + |15-11| = 1 + 1 + 2 + 3 + 4 = 11.

example_3.py — Large Numbers

$ Input: [100,110,120]

› Output: 21

💡 Note: The optimal palindromic target is 111. Cost = |100-111| + |110-111| + |120-111| = 11 + 1 + 9 = 21. Other palindromes like 101 or 121 would give higher costs.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
Target palindrome must be less than 10⁹
All palindromic numbers from 1 to 9 are valid single-digit targets

Visualization

Tap to expand

Asked in

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

The optimal approach is to find palindromes around the median of the sorted array. Since the median minimizes the sum of absolute differences, we generate palindromic numbers systematically around this median value. This reduces the search space dramatically compared to checking all possible palindromes, achieving O(n log n + k×n) time complexity where k is a small constant.

Common Approaches

✓ Brute Force (Check All Palindromes)

⏱️ Time: O(n * P) Space: O(P)

Generate all palindromic numbers up to 10^9 and calculate the total cost for each palindrome as the target. This approach is straightforward but inefficient since there are many palindromes to check.

Optimized Palindrome Generation

⏱️ Time: O(n log n + k*n) Space: O(1)

Instead of checking all palindromes, first find the median of the array (which minimizes sum of absolute differences), then generate palindromes around this median value. This significantly reduces the search space.

Brute Force (Check All Palindromes) — Algorithm Steps

Generate all palindromic numbers from 1 to 10^9
For each palindrome, calculate total cost by summing |nums[i] - palindrome| for all elements
Return the minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Palindromes

Create list of all palindromic numbers: 1, 2, 3, ..., 11, 22, 33, ..., 101, 111, 121, ...

Test Each Palindrome

For each palindrome, calculate total cost by summing absolute differences

Find Minimum

Keep track of the palindrome that gives minimum total cost

Code -

solution.c — C

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

static int palindromes[200000];

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int removeDuplicates(int* arr, int size) {
    if (size == 0) return 0;
    int j = 0;
    for (int i = 1; i < size; i++) {
        if (arr[i] != arr[j]) {
            j++;
            arr[j] = arr[i];
        }
    }
    return j + 1;
}

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

void reverseString(char* str, char* rev) {
    int len = strlen(str);
    for (int i = 0; i < len; i++) {
        rev[i] = str[len - 1 - i];
    }
    rev[len] = '\0';
}

int generatePalindromes(int limit) {
    int count = 0;
    
    // Single digit palindromes
    for (int i = 1; i < 10; i++) {
        if (count >= 199999) break;
        palindromes[count++] = i;
    }
    
    // Generate palindromes by length
    for (int length = 2; length < 10; length++) {
        if (length % 2 == 0) { // Even length
            int halfLen = length / 2;
            int start = intPow(10, halfLen - 1);
            int end = intPow(10, halfLen);
            int maxIter = end;
            if (maxIter > 10000) {
                maxIter = 10000;
            }
            for (int i = start; i < maxIter; i++) {
                if (count >= 199999) break;
                char s[20], revS[20], palStr[40];
                sprintf(s, "%d", i);
                reverseString(s, revS);
                strcpy(palStr, s);
                strcat(palStr, revS);
                int pal = atoi(palStr);
                if (pal >= limit) {
                    break;
                }
                palindromes[count++] = pal;
            }
        } else { // Odd length
            int halfLen = length / 2;
            int start, end;
            if (halfLen > 0) {
                start = intPow(10, halfLen - 1);
                end = intPow(10, halfLen + 1);
            } else {
                start = 1;
                end = 10;
            }
            int maxIter = end;
            if (maxIter > 1000) {  // Reduced to prevent overflow
                maxIter = 1000;
            }
            for (int i = start; i < maxIter; i++) {
                if (count >= 199990) break;  // Leave room for 10 more palindromes
                char s[20];
                sprintf(s, "%d", i);
                int shouldBreak = 0;
                for (int mid = 0; mid < 10; mid++) {
                    if (count >= 199999) {
                        shouldBreak = 1;
                        break;
                    }
                    char revS[20], palStr[40];
                    reverseString(s, revS);
                    sprintf(palStr, "%s%d%s", s, mid, revS);
                    int pal = atoi(palStr);
                    if (pal >= limit) {
                        shouldBreak = 1;
                        break;
                    }
                    palindromes[count++] = pal;
                }
                char revS[20], checkStr[40];
                reverseString(s, revS);
                sprintf(checkStr, "%s0%s", s, revS);
                int checkVal = atoi(checkStr);
                if (checkVal >= limit) {
                    break;
                }
                if (shouldBreak) {
                    break;
                }
            }
        }
    }
    
    qsort(palindromes, count, sizeof(int), compare);
    return removeDuplicates(palindromes, count);
}

long long minimumCost(int* nums, int numsSize) {
    int palCount = generatePalindromes(1000000000);
    long long minCost = LLONG_MAX;
    
    for (int i = 0; i < palCount; i++) {
        long long cost = 0;
        for (int j = 0; j < numsSize; j++) {
            cost += abs(nums[j] - palindromes[i]);
        }
        if (cost < minCost) {
            minCost = cost;
        }
    }
    
    return minCost;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    int len = strlen(input);
    if (len > 0 && input[len-1] == '\n') {
        input[len-1] = '\0';
    }
    
    // Remove brackets and spaces
    char* start = input;
    while (*start == '[' || *start == ' ') start++;
    char* end = start + strlen(start) - 1;
    while (end >= start && (*end == ']' || *end == ' ')) {
        *end = '\0';
        end--;
    }
    
    if (strlen(start) == 0) {
        printf("0\n");
        return 0;
    }
    
    int nums[1000];
    int numsSize = 0;
    char* token = start;
    char* ptr;
    
    while (token && *token && numsSize < 1000) {
        // Skip whitespace
        while (*token == ' ') token++;
        if (!*token) break;
        
        long val = strtol(token, &ptr, 10);
        nums[numsSize++] = (int)val;
        
        // Find next comma or end
        token = ptr;
        while (*token == ' ') token++;
        if (*token == ',') {
            token++;
            while (*token == ' ') token++;
        } else {
            break;
        }
    }
    
    printf("%lld\n", minimumCost(nums, numsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * P)

Where P is the number of palindromes up to 10^9 (around 100,000), and n is array length

⚡ Linearithmic

Space Complexity

O(P)

Need to store all palindromic numbers

✓ Linear Space

31.5K Views

Medium Frequency

~25 min Avg. Time

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