Remove Adjacent Almost-Equal Characters

Remove Adjacent Almost-Equal Characters - Problem

You are given a 0-indexed string word. In one operation, you can pick any index i of word and change word[i] to any lowercase English letter.

Return the minimum number of operations needed to remove all adjacent almost-equal characters from word.

Two characters a and b are almost-equal if:

a == b (same character), or
a and b are adjacent in the alphabet (like 'a' and 'b', or 'p' and 'q')

Input & Output

Example 1 — Basic Conflict

$ Input: word = "abb"

› Output: 1

💡 Note: Characters at positions 1 and 2 are both 'b' (almost-equal). Change word[2] to any character that's not adjacent to 'b', like 'd'. Result: "abd" with 1 operation.

Example 2 — Adjacent Letters

$ Input: word = "abc"

› Output: 1

💡 Note: Characters 'b' and 'c' are adjacent in alphabet (almost-equal). Change 'c' to a non-adjacent character like 'e'. Result: "abe" with 1 operation.

Example 3 — No Changes Needed

$ Input: word = "ace"

› Output: 0

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

Constraints

1 ≤ word.length ≤ 10⁵
word consists only of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 M Meta 18 a Amazon 15

The key insight is to always change the right character in a conflict to prevent cascading changes. Best approach is greedy single-pass algorithm that fixes conflicts immediately. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Fix All Conflicts

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

Keep scanning the string for adjacent almost-equal characters. When found, change one of them and repeat until no conflicts remain.

Greedy - Single Pass Optimization

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

Make a single pass through the string. When we find adjacent almost-equal characters, always change the right character to the first available safe character that doesn't conflict with its neighbors.

Brute Force - Fix All Conflicts — Algorithm Steps

Step 1: Scan string for first conflict
Step 2: Change one character to resolve conflict
Step 3: Repeat until no conflicts exist

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Scan

Find first conflict in string

Fix Conflict

Change character to resolve conflict

Repeat

Continue until no conflicts remain

Code -

solution.c — C

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

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

char findSafeChar(char* word, int pos, int len) {
    for (char c = 'a'; c <= 'z'; c++) {
        int safe = 1;
        if (pos > 0 && areAlmostEqual(c, word[pos - 1])) safe = 0;
        if (pos < len - 1 && areAlmostEqual(c, word[pos + 1])) safe = 0;
        if (safe) return c;
    }
    return 'a';
}

int solution(char* word) {
    int len = strlen(word);
    int operations = 0;
    int changed = 1;
    
    while (changed) {
        changed = 0;
        for (int i = 0; i < len - 1; i++) {
            if (areAlmostEqual(word[i], word[i + 1])) {
                word[i + 1] = findSafeChar(word, i + 1, len);
                operations++;
                changed = 1;
            }
        }
    }
    
    return operations;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, need to scan entire string multiple times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

845 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 - Fix All Conflicts — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler