Minimum Number of Moves to Make Palindrome - Problem

You are given a string s consisting only of lowercase English letters.

In one move, you can select any two adjacent characters of s and swap them.

Return the minimum number of moves needed to make s a palindrome.

Note: The input will be generated such that s can always be converted to a palindrome.

Input & Output

Example 1 — Basic Case

$ Input: s = "aab"

› Output: 1

💡 Note: We can swap the second 'a' with 'b' to get 'aba', which is a palindrome. Only 1 adjacent swap is needed.

Example 2 — Already Palindrome

$ Input: s = "aba"

› Output: 0

💡 Note: The string is already a palindrome, so no moves are needed.

Example 3 — Multiple Swaps

$ Input: s = "letelt"

› Output: 2

💡 Note: We need 2 swaps to transform 'letelt' to a palindrome like 'tleelt'. Match 'l' at ends first, then match 'e' at next positions.

Constraints

1 ≤ s.length ≤ 2000
s consists only of lowercase English letters
s can be rearranged to form a palindrome

Visualization

Tap to expand

Asked in

G Google 28 f Facebook 15 a Amazon 12

The key insight is to use a greedy two-pointer approach, matching characters from the ends toward the center. For each position, find the nearest matching character and bubble it using adjacent swaps. Best approach is Two Pointers with Greedy Matching. Time: O(n²), Space: O(1)

Common Approaches

✓ Brute Force Simulation

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

Generate all possible sequences of adjacent swaps and find the shortest one that creates a palindrome. This involves exploring all permutations reachable by adjacent swaps.

Optimized Greedy with Character Counting

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

Pre-count all character frequencies to determine the palindrome structure. Then use greedy assignment of characters to positions, always choosing the assignment that requires minimum adjacent swaps.

Two Pointers with Greedy Matching

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

Place pointers at start and end of string. For each position, find the nearest matching character and bubble it to the correct position using adjacent swaps. Handle the middle character specially for odd-length strings.

Brute Force Simulation — Algorithm Steps

Generate all possible adjacent swap sequences
Check if each sequence results in a palindrome
Return the minimum length sequence

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with input string 'aab'

Try All Swaps

Generate all possible sequences of adjacent swaps

Find Minimum

Return shortest sequence that creates palindrome

Code -

solution.c — C

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

int solution(char* s) {
    int n = strlen(s);
    int moves = 0;
    
    for (int i = 0; i < n / 2; i++) {
        int left = i;
        int right = n - 1 - i;
        
        if (s[left] == s[right]) {
            continue;
        }
        
        // Find matching character for s[left] from the right side
        int j = right - 1;
        while (j > left && s[j] != s[left]) {
            j--;
        }
        
        // If found, move it to position right using adjacent swaps
        if (j > left) {
            while (j < right) {
                char temp = s[j];
                s[j] = s[j + 1];
                s[j + 1] = temp;
                j++;
                moves++;
            }
        }
    }
    
    return moves;
}

int main() {
    char s[2001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    printf("%d\n", solution(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n!)

Need to explore all possible sequences of swaps, which can be factorial in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Need space to store current string state and recursion stack

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

892 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

Minimum Number of Moves to Make Palindrome - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler