Minimum Cost to Make Array Equalindromic - Practice Coding Problems

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

Understanding the Visualization

Sort & Find Center

Arrange all values in order and identify the median - this is our starting point

Generate Symmetric Targets

Create palindromic numbers around the median systematically

Calculate Adjustment Costs

For each palindromic target, sum up the cost to change all elements

Select Minimum

Choose the palindromic target that requires least total adjustment cost

Key Takeaway

🎯 Key Insight: The optimal palindromic target is typically close to the median, so we generate palindromes systematically around the median instead of checking all possibilities.

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

Approach	Time	Space	Notes
✓ Optimized Palindrome Generation	O(n log n + k*n)	O(1)	Generate palindromes smartly around the median value
Brute Force (Check All Palindromes)	O(n * P)	O(P)	Generate all possible palindromes and test each one

Optimized Palindrome Generation — Algorithm Steps

Sort the array and find the median
Generate palindromes in increasing distance from the median
Calculate cost for each nearby palindrome until cost starts increasing
Return the minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Median

Sort array and find median value - this minimizes sum of absolute differences

Generate Nearby Palindromes

Create palindromes around the median using systematic generation

Test Candidates

Calculate cost for each candidate palindrome and find minimum

Code -

solution.c — C

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

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

int isPalindrome(int x) {
    char s[20];
    sprintf(s, "%d", x);
    int len = strlen(s);
    for (int i = 0; i < len / 2; i++) {
        if (s[i] != s[len - 1 - i]) {
            return 0;
        }
    }
    return 1;
}

long long minimumCost(int* nums, int numsSize) {
    qsort(nums, numsSize, sizeof(int), compare);
    
    int median;
    if (numsSize % 2 == 1) {
        median = nums[numsSize / 2];
    } else {
        median = (nums[numsSize / 2 - 1] + nums[numsSize / 2]) / 2;
    }
    
    long long minCost = LLONG_MAX;
    
    // Check palindromes around median
    int start = (median > 1000) ? median - 1000 : 1;
    int end = median + 1000;
    if (end > 1000000) end = 1000000;
    
    for (int target = start; target <= end; target++) {
        if (isPalindrome(target)) {
            long long cost = 0;
            for (int i = 0; i < numsSize; i++) {
                cost += abs(nums[i] - target);
            }
            if (cost < minCost) {
                minCost = cost;
            }
        }
    }
    
    return minCost;
}

int main() {
    int n;
    scanf("%d", &n);
    int* nums = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    printf("%lld\n", minimumCost(nums, n));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + k*n)

O(n log n) for sorting, O(k*n) for checking k palindromes near median

⚡ Linearithmic

Space Complexity

O(1)

Only need constant extra space for palindrome generation

✓ 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

Optimized Palindrome Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler