Solution in Rust without DP
IntuitionThe main idea is to identify and change characters in the string such that no two adjacent characters are almost-equal. Almost-equal characters are eit
# Intuition
The main idea is to identify and change characters in the string such that no two adjacent characters are almost-equal. Almost-equal characters are either the same or adjacent in the alphabet.

# Approach
1. **Track Adjacent and Same Characters**:
   - Iterate through the string and keep track of the characters and their positions.
   - Check for adjacent almost-equal characters and record their positions.
2. **Modify Characters**:
   - To remove adjacent almost-equal characters, we count the minimum number of operations needed to change one of the characters to a different letter that does not create new adjacent almost-equal pairs.

# Complexity
- **Time complexity**: $$O(n)$$, where 'n' is the length of the string. This is because we iterate through the string a constant number of times.
- **Space complexity**: $$O(1)$$, as we are using a constant amount of extra space.

# Code
```rust []
impl Solution {
    pub fn remove_almost_equal_characters(word: String) -> i32 {
        let word = word.as_bytes(); 
        let mut operations = 0; 
        let mut i = 0;
        while i < word.len() - 1 {
            if word[i] == word[i + 1] || (word[i] as i32 - word[i + 1] as i32).abs() == 1 {
                operations += 1;
                i += 2; 
            } else {
                i += 1;
            }
        }
        operations
    }
}
```
['String', 'Rust']