Make String Anti-palindrome

Make String Anti-palindrome - Problem

We call a string s of even length n an anti-palindrome if for each index 0 <= i < n, s[i] != s[n - i - 1].

Given a string s, your task is to make s an anti-palindrome by doing any number of operations (including zero). In one operation, you can select two characters from s and swap them.

Return the resulting string. If multiple strings meet the conditions, return the lexicographically smallest one. If it can't be made into an anti-palindrome, return "-1".

Input & Output

Example 1 — Basic Case

$ Input: s = "abab"

› Output: "abab"

💡 Note: The string "abab" is already an anti-palindrome: a≠b at positions (0,3) and b≠a at positions (1,2), so no swaps needed.

Example 2 — Need Rearrangement

$ Input: s = "baca"

› Output: "aabc"

💡 Note: Sort to get "aabc": positions (0,3) have a≠c and positions (1,2) have a≠b, making it a valid anti-palindrome.

Example 3 — Impossible Case

$ Input: s = "aaaa"

› Output: "-1"

💡 Note: All characters are the same, so it's impossible to make any position different from its mirror position.

Constraints

2 ≤ s.length ≤ 10⁵
s.length is even
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is that if any character appears more than n/2 times, creating an anti-palindrome is impossible. Otherwise, sorting the string gives the lexicographically smallest valid arrangement. Best approach uses greedy sorting with frequency check. Time: O(n log n), Space: O(1).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Try All Permutations

⏱️ Time: O(n! × n) Space: O(n!)

Generate all permutations of the string, check if each one satisfies the anti-palindrome condition, and return the lexicographically smallest valid one. This approach examines every possible character arrangement.

Frequency Count + Greedy Placement

⏱️ Time: O(n log n) Space: O(n)

First count the frequency of each character. If any character appears more than n/2 times, it's impossible to create an anti-palindrome. Otherwise, sort characters and place them greedily to ensure no character matches its mirror position.

Optimal Greedy Sorting

⏱️ Time: O(n log n) Space: O(1)

The key insight is that if we can create an anti-palindrome, we can do it by sorting the string and checking if the sorted arrangement works. If not, we need to check if it's even possible based on character frequencies.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.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