Minimum Number of Moves to Make Palindrome

Minimum Number of Moves to Make Palindrome - Problem

You are given a string s consisting only of lowercase English letters. Your task is to transform this string into a palindrome using the minimum number of adjacent swaps.

In one move, you can select any two adjacent characters of s and swap them. For example, in the string "abc", you can swap 'a' and 'b' to get "bac", or swap 'b' and 'c' to get "acb".

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

Note: The input will always be generated such that s can be converted to a palindrome (meaning each character appears an even number of times, or at most one character appears an odd number of times).

Example: For s = "aab", we need 2 moves: "aab" → "aba" (swap positions 1 and 2) requires 1 move, making it a palindrome with 1 total move.

Input & Output

example_1.py — Basic Case

$ Input: s = "aab"

› Output: 1

💡 Note: We can make "aab" a palindrome with 1 move: swap positions 1 and 2 to get "aba". This is a palindrome, so minimum moves = 1.

example_2.py — Multiple Swaps

$ Input: s = "letelt"

› Output: 2

💡 Note: Starting with "letelt": First, we need to match 'l' at position 0 with 'l' at position 4. We bubble the 'l' from position 4 to position 5 with 1 swap: "letelt" → "letlte". Then match the remaining characters. Total: 2 moves.

example_3.py — Already Palindrome

$ Input: s = "abccba"

› Output: 0

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

Constraints

1 ≤ s.length ≤ 2000
s consists only of lowercase English letters
s can always be converted to a palindrome (guaranteed by problem statement)

Visualization

Tap to expand

Understanding the Visualization

Start from Edges

Place pointers at both ends of the string, like focusing on the outer edges of a mirror

Find Matching Pair

For the left character, find its matching pair from the right side - this will be its mirror reflection

Bubble to Position

Use adjacent swaps to move the matching character to the correct mirror position

Move Inward

Move both pointers toward the center and repeat until the entire string forms a perfect mirror

Key Takeaway

🎯 Key Insight: The greedy approach of always moving the closest matching character to its mirror position is optimal because it minimizes the total number of adjacent swaps needed.

Asked in

G Google 15 f Facebook 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach uses a greedy two-pointers technique. Starting from both ends, we find the closest matching character for each position and use adjacent swaps to bubble it to the correct location. This greedy strategy works because moving the closest character always minimizes the number of swaps needed. Time complexity is O(n²) and space complexity is O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers Greedy Approach	O(n²)	O(1)	Use two pointers from ends, greedily move characters to correct positions
Brute Force (Try All Swaps)	O(n! × n)	O(n)	Try all possible sequences of adjacent swaps until palindrome is found

Two Pointers Greedy Approach — Algorithm Steps

Initialize left and right pointers at string ends
For current left position, find closest matching character from right side
Use adjacent swaps to bubble the matching character to correct position
Count swaps needed for bubbling process
Move pointers inward and repeat until they meet

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set left=0, right=n-1 at string ends

Find Match

Find closest character matching s[left] from right side

Bubble Character

Use adjacent swaps to move matching char to right position

Move Inward

Increment left, decrement right, repeat until pointers meet

Code -

solution.c — C

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

int minimumMovesToMakePalindrome(char* s) {
    int n = strlen(s);
    int moves = 0;
    int left = 0;
    int right = n - 1;
    
    while (left < right) {
        int tempRight = right;
        while (tempRight > left && s[left] != s[tempRight]) {
            tempRight--;
        }
        
        if (tempRight == left) {
            int mid = n / 2;
            while (left < mid) {
                char temp = s[left];
                s[left] = s[left + 1];
                s[left + 1] = temp;
                moves++;
                left++;
            }
        } else {
            while (tempRight < right) {
                char temp = s[tempRight];
                s[tempRight] = s[tempRight + 1];
                s[tempRight + 1] = temp;
                moves++;
                tempRight++;
            }
            
            left++;
            right--;
        }
    }
    
    return moves;
}

int main() {
    char s[1001];
    scanf("%s", s);
    
    char* start = s;
    if (s[0] == '"') start++;
    int len = strlen(start);
    if (start[len-1] == '"') start[len-1] = '\0';
    
    printf("%d\n", minimumMovesToMakePalindrome(start));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we may need to search and move characters across O(n) positions

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for pointers and counters

✓ Linear Space

28.5K Views

Medium-High 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two Pointers Greedy Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler