Minimum Moves to Convert String - Practice Coding Problems

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

Example: For string "XXOX", one optimal approach is to apply a move to positions [0,1,2] which converts "XXO" to "OOO", resulting in "OOOX". Then apply another move to positions [1,2,3] to get "OOOO". Total moves: 2.

Input & Output

example_1.py — Basic Case

$ Input: s = "XXOX"

› Output: 2

💡 Note: Apply move at position 0: "XXOX" → "OOOX". Apply move at position 1: "OOOX" → "OOOO". Total: 2 moves.

example_2.py — Already Converted

$ Input: s = "OOOO"

› Output: 0

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

example_3.py — Edge Case

$ Input: s = "XXX"

› Output: 1

💡 Note: One move at position 0 converts the entire string: "XXX" → "OOO".

Constraints

1 ≤ n ≤ 1000
s[i] is either 'X' or 'O'
Each move converts exactly 3 consecutive characters

Visualization

Tap to expand

Understanding the Visualization

Identify Problem

Locate unpainted sections (X) on the wall

Apply Greedy Strategy

Always start painting from the leftmost unpainted section

Cover 3 Sections

Each brush stroke covers exactly 3 consecutive sections

Skip Covered Areas

Jump over the sections already covered by the current stroke

Key Takeaway

🎯 Key Insight: Greedy works because painting from the leftmost X never wastes strokes - it can only help cover future X's efficiently!

Asked in

⊞ Microsoft 15 a Amazon 12 G Google 8 Apple 5

The optimal solution uses a greedy approach with a single left-to-right scan. When we encounter an 'X', we immediately apply a move covering the next 3 positions and skip ahead. This works because covering an X as early as possible never hurts and can help cover future X's for free. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^n)	O(n)	Try all possible sequences of moves using recursion
Greedy Single Pass (Optimal)	O(n)	O(1)	Scan left to right, apply move whenever we encounter 'X'

Brute Force (Try All Combinations) — Algorithm Steps

Use recursion to try applying moves at each possible position
For each state, try all valid starting positions for the next move
Keep track of minimum moves found across all possibilities
Return when all characters are 'O'

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original string containing X's

Try All Moves

For each position, try applying a move

Recursive Exploration

Recursively explore all possible next states

Find Minimum

Track the minimum moves across all paths

Code -

solution.c — C

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

int solve(char* s, int moves) {
    if (strchr(s, 'X') == NULL) {
        return moves;
    }
    
    int len = strlen(s);
    int minMoves = INT_MAX;
    
    for (int i = 0; i <= len - 3; i++) {
        if (s[i] == 'X' || s[i+1] == 'X' || s[i+2] == 'X') {
            char* newS = malloc((len + 1) * sizeof(char));
            strncpy(newS, s, i);
            newS[i] = '\0';
            strcat(newS, "OOO");
            strcat(newS, s + i + 3);
            
            int result = solve(newS, moves + 1);
            if (result < minMoves) {
                minMoves = result;
            }
            free(newS);
        }
    }
    
    return minMoves;
}

int minMovesToConvertString(char* s) {
    return solve(s, 0);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

For each of the n-2 possible starting positions, we can choose to apply a move or not, leading to exponential combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth proportional to string length

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~12 min Avg. Time

847 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