Remove Adjacent Almost-Equal Characters - Practice Coding Problems

Remove Adjacent Almost-Equal Characters - Problem

Remove Adjacent Almost-Equal Characters

You're given a string word containing lowercase English letters. Your task is to eliminate all pairs of adjacent characters that are "almost-equal" by changing some characters to different letters.

Two characters are considered almost-equal if:
• They are identical (like 'a' and 'a')
• They are consecutive in the alphabet (like 'a' and 'b', or 'p' and 'q')

In each operation, you can pick any index and change that character to any lowercase letter. Find the minimum number of operations needed so that no two adjacent characters in the final string are almost-equal.

Example: In "abcc", we have almost-equal pairs: (a,b) and (c,c). We need at least 1 operation to fix this.

Input & Output

example_1.py — Basic case with multiple conflicts

$ Input: word = "abcc"

› Output: 2

💡 Note: We have conflicts: (a,b) are consecutive in alphabet, and (c,c) are identical. We can change 'b' to 'd' and the last 'c' to 'f', giving us "adcf". This requires 2 operations.

example_2.py — Single character

$ Input: word = "a"

› Output: 0

💡 Note: A single character has no adjacent pairs, so no operations are needed.

example_3.py — No conflicts initially

$ Input: word = "aceg"

› Output: 0

💡 Note: No adjacent characters are almost-equal. 'a' and 'c' differ by 2, 'c' and 'e' differ by 2, 'e' and 'g' differ by 2. No operations needed.

Constraints

1 ≤ word.length ≤ 10⁵
word consists of lowercase English letters only
Almost-equal characters: identical (a==a) or consecutive in alphabet (a,b or p,q)

Visualization

Tap to expand

Understanding the Visualization

Survey the Path

Walk along the garden path and identify pairs of adjacent stones that have conflicting colors

Strategic Repainting

When you find conflicting stones, always repaint the second stone in the pair to give maximum flexibility

Choose Wisely

Pick a new color that won't conflict with the stone before it or the stone after it

Continue Forward

Move to the next stone and repeat the process until the entire path is conflict-free

Key Takeaway

🎯 Key Insight: The greedy strategy of always changing the second character in a conflicting pair is optimal because it preserves all previous decisions while providing maximum flexibility for future choices.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal greedy approach processes the string left-to-right, fixing conflicts immediately by changing the second character in each conflicting pair. This strategy is optimal because it provides maximum flexibility for future decisions. Time complexity: O(n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(26^n * n^2)	O(n)	Try all possible ways to change characters and find the minimum
Optimized Greedy Approach	O(n)	O(1)	Scan left to right and fix conflicts immediately by changing the second character

Brute Force (Try All Combinations) — Algorithm Steps

For each possible number of operations (1 to n)
Generate all combinations of positions to change
For each combination, try all possible character replacements
Check if the resulting string has no adjacent almost-equal characters
Return the minimum operations found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original string, identify conflicts

Branch Creation

Create branches for each possible character change

Recursive Exploration

Recursively explore each branch until no conflicts remain

Find Minimum

Compare all valid solutions and return minimum operations

Code -

solution.c — C

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

int areAlmostEqual(char a, char b) {
    return a == b || abs(a - b) == 1;
}

int hasAdjacentAlmostEqual(char* s) {
    int len = strlen(s);
    for (int i = 0; i < len - 1; i++) {
        if (areAlmostEqual(s[i], s[i + 1])) {
            return 1;
        }
    }
    return 0;
}

int backtrack(char* s, int operations) {
    if (!hasAdjacentAlmostEqual(s)) {
        return operations;
    }
    
    int len = strlen(s);
    if (operations >= len) {
        return INT_MAX;
    }
    
    int minOps = INT_MAX;
    
    for (int i = 0; i < len; i++) {
        char original = s[i];
        for (char c = 'a'; c <= 'z'; c++) {
            if (c != original) {
                s[i] = c;
                int result = backtrack(s, operations + 1);
                if (result < minOps) {
                    minOps = result;
                }
                s[i] = original;
            }
        }
    }
    
    return minOps;
}

int minimumOperations(char* word) {
    return backtrack(word, 0);
}

int main() {
    char word[1000];
    scanf("%s", word);
    printf("%d\n", minimumOperations(word));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26^n * n^2)

For each of n positions, we try 26 characters, and for each combination we scan the string

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current string configuration and recursion stack

⚡ Linearithmic Space

42.3K Views

Medium-High Frequency

~18 min Avg. Time

1.8K 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