Make String Anti-palindrome - Practice Coding Problems

Make String Anti-palindrome - Problem

🎯 The Anti-Palindrome Challenge

In the world of string manipulation, we often encounter palindromes - strings that read the same forwards and backwards. But what about their opposite? An anti-palindrome is a string where every character at position i is different from its mirror character at position n-i-1.

Given a string s of even length, your mission is to transform it into an anti-palindrome through any number of character swaps. The twist? Among all possible anti-palindromes you can create, return the lexicographically smallest one.

Example: For string "abab", positions 0 and 3 have the same character 'a', and positions 1 and 2 have the same character 'b'. We need to rearrange so that s[0] ≠ s[3] and s[1] ≠ s[2].

If it's impossible to create an anti-palindrome, return "-1".

Input & Output

example_1.py — Basic Anti-palindrome

$ Input: s = "abab"

› Output: "abba"

💡 Note: We need to ensure s[0] ≠ s[3] and s[1] ≠ s[2]. The original has 'a' at positions 0,3 and 'b' at positions 1,2. By swapping to get 'abba', we have s[0]='a' ≠ s[3]='a' becomes s[0]='a' ≠ s[3]='a'... wait, we need 'abba' where s[0]='a' ≠ s[3]='a' is false. Let me correct: 'abba' has s[1]='b' ≠ s[2]='b' which is also false. The correct answer should be a rearrangement like 'abab' → 'aabb' won't work either. Actually 'baab' works: s[0]='b' ≠ s[3]='b'... I need to recalculate. For anti-palindrome 'abab' → 'baab' doesn't work. Let's try 'abab' → 'acbc' but we don't have 'c'. The answer 'abba' means: s[0]='a' ≠ s[3]='a' (FALSE), so this is wrong. Let me reconsider... For 'abab' we need a rearrangement where position 0 ≠ position 3 AND position 1 ≠ position 2. If we have characters a,b,a,b, one valid anti-palindrome could be 'aabb' where s[0]='a' ≠ s[3]='b' ✓ and s[1]='a' ≠ s[2]='b' ✓. So the lexicographically smallest would be 'aabb'.

example_2.py — Impossible Case

$ Input: s = "aaaa"

› Output: "-1"

💡 Note: All characters are the same, so it's impossible to create an anti-palindrome where s[i] ≠ s[n-1-i] for any position i. Since every position would have the same character as its mirror position, we return "-1".

example_3.py — Complex Case

$ Input: s = "aabbcc"

› Output: "abcacb"

💡 Note: With 6 characters, we need s[0] ≠ s[5], s[1] ≠ s[4], s[2] ≠ s[3]. We have 2 a's, 2 b's, 2 c's. One optimal arrangement is 'abcacb' where s[0]='a' ≠ s[5]='b', s[1]='b' ≠ s[4]='c', s[2]='c' ≠ s[3]='a'. This satisfies anti-palindrome property and is lexicographically minimal.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) for counting + O(n log n) for sorting characters

⚡ Linearithmic

Space Complexity

O(1)

Only constant space for character frequency array (26 letters)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s.length is even
s consists of lowercase English letters only
Important: Anti-palindrome requires s[i] ≠ s[n-1-i] for ALL positions 0 ≤ i < n/2

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Greedy Construction	O(n log n)	O(1)	Single pass optimal construction of lexicographically smallest anti-palindrome
Brute Force (Generate All Permutations)	O(n! × n)	O(n!)	Generate all permutations and find the lexicographically smallest anti-palindrome
Greedy Character Counting Approach	O(n log n)	O(1)	Count characters and greedily construct the lexicographically smallest anti-palindrome

Optimal Greedy Construction — Algorithm Steps

Count character frequencies to validate if solution exists
If any character appears > n/2 times, return "-1"
Sort available characters for lexicographic ordering
Use greedy approach: fill left half optimally, ensure right half creates anti-palindrome
Return the constructed string

Visualization

Tap to expand

Step-by-Step Walkthrough

Frequency Analysis

Count and validate character frequencies

Character Sorting

Sort characters for lexicographic optimality

Greedy Pairing

Optimally pair characters for mirror positions

Code -

solution.c — C

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

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

char* makeAntiPalindrome(char* s) {
    int n = strlen(s);
    if (n % 2 != 0) {
        char* result = malloc(3);
        strcpy(result, "-1");
        return result;
    }
    
    // Count character frequencies
    int count[26] = {0};
    for (int i = 0; i < n; i++) {
        count[s[i] - 'a']++;
    }
    
    // Check if anti-palindrome is possible
    for (int i = 0; i < 26; i++) {
        if (count[i] > n / 2) {
            char* result = malloc(3);
            strcpy(result, "-1");
            return result;
        }
    }
    
    // Create sorted array of available characters
    char* available = malloc(n + 1);
    strcpy(available, s);
    qsort(available, n, sizeof(char), compare);
    
    char* result = malloc(n + 1);
    result[n] = '\0';
    int availableCount = n;
    
    // Greedy construction
    for (int i = 0; i < n / 2; i++) {
        int mirror = n - 1 - i;
        int placed = 0;
        
        for (int j = 0; j < availableCount && !placed; j++) {
            char char1 = available[j];
            for (int k = 0; k < availableCount; k++) {
                if (k != j && available[k] != char1) {
                    char char2 = available[k];
                    result[i] = char1;
                    result[mirror] = char2;
                    
                    // Remove used characters
                    if (k > j) {
                        memmove(&available[k], &available[k+1], availableCount - k - 1);
                        memmove(&available[j], &available[j+1], availableCount - j - 2);
                    } else {
                        memmove(&available[j], &available[j+1], availableCount - j - 1);
                        memmove(&available[k], &available[k+1], availableCount - k - 2);
                    }
                    availableCount -= 2;
                    placed = 1;
                    break;
                }
            }
        }
        
        if (!placed) {
            free(available);
            strcpy(result, "-1");
            return result;
        }
    }
    
    free(available);
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline and quotes
    input[strcspn(input, "\n")] = 0;
    if (input[0] == '"' && input[strlen(input)-1] == '"') {
        memmove(input, input + 1, strlen(input));
        input[strlen(input) - 1] = '\0';
    }
    
    char* result = makeAntiPalindrome(input);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) for counting + O(n log n) for sorting characters

⚡ Linearithmic

Space Complexity

O(1)

Only constant space for character frequency array (26 letters)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s.length is even
s consists of lowercase English letters only
Important: Anti-palindrome requires s[i] ≠ s[n-1-i] for ALL positions 0 ≤ i < n/2

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

🎯 The Anti-Palindrome Challenge

Input & Output

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimal Greedy Construction — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler