Minimum Moves to Convert String

Minimum Moves to Convert String - Problem

String Greedy Easy

You are given a string s consisting of n characters which are either 'X' or 'O'.

A move is defined as selecting three consecutive characters of s and converting them to 'O'. Note that if a move is applied to the character 'O', it will stay the same.

Return the minimum number of moves required so that all the characters of s are converted to 'O'.

Input & Output

Example 1 — Basic Case

$ Input: s = "XXX"

› Output: 1

💡 Note: We can convert all three X's to O's with a single move: one move converts "XXX" to "OOO"

Example 2 — Mixed Characters

$ Input: s = "XXOX"

› Output: 2

💡 Note: First move at position 0 converts "XXOX" to "OOOX", second move at position 3 converts it to "OOOO"

Example 3 — Already Converted

$ Input: s = "OOOO"

› Output: 0

💡 Note: All characters are already 'O', so no moves are needed

Constraints

1 ≤ s.length ≤ 1000
s[i] is either 'X' or 'O'

Visualization

Tap to expand

Asked in

M Microsoft 25 a Amazon 20

The key insight is that we can use a greedy approach: scan from left to right and make a move whenever we encounter an 'X'. This is optimal because delaying the move never helps. Best approach is greedy scanning with Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2ⁿ) Space: O(n)

Generate all possible sequences of moves and check which ones successfully convert all characters to 'O', then return the minimum count.

Greedy - Left to Right Scan

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

Use a greedy approach: scan the string from left to right, and whenever we encounter an 'X', immediately make a move starting at that position. This converts 3 consecutive characters to 'O' and we skip ahead 3 positions.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible move combinations
For each combination, simulate the moves
Check if all characters become 'O'
Track minimum moves needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Combinations

Create all possible move sequences

Simulate Each Sequence

Apply moves and check if all X's become O's

Find Minimum

Return the sequence with fewest moves

Code -

solution.c — C

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

int backtrack(char* currentS, int moves, int n) {
    if (strchr(currentS, 'X') == NULL) return moves;
    
    int minMoves = INT_MAX;
    for (int i = 0; i < n - 2; i++) {
        int hasX = 0;
        for (int j = i; j < i + 3; j++) {
            if (currentS[j] == 'X') {
                hasX = 1;
                break;
            }
        }
        if (hasX) {
            char newS[1001];
            strcpy(newS, currentS);
            newS[i] = newS[i+1] = newS[i+2] = 'O';
            int result = backtrack(newS, moves + 1, n);
            if (result < minMoves) minMoves = result;
        }
    }
    return minMoves;
}

int solution(char* s) {
    int n = strlen(s);
    if (strchr(s, 'X') == NULL) return 0;
    return backtrack(s, 0, n);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Each position can either be part of a move or not, creating exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and string copying for simulation

✓ Linear Space

28.5K Views

Medium Frequency

~8 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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler