We are going to implement a JavaScript program to remove consecutive duplicate characters from a string. In this program, we will eliminate all the consecutive occurrences of the same character from a string.

Example:

Input: string: "geeks" 
Output: "geks"
Explanation :consecutive "e" should be removed

Using Iterative Loop

In this approach, we are using the for loop and if else statement to check if the current letter is the same as the last character or not. If it is, then we are skipping it, and if not, we are adding that character to the output string.

Syntax:

for (const letter of inputData) {
            if (letter !== lastChar) {
                output += letter;
                lastChar = letter;
        }
}

Example: This example shows the use of the above-explained approach.

const eleminateSameConsecutiveCharacters =
    (inputData) => {
        let output = "";
        let lastChar = "";

        for (const letter of inputData) {
            if (letter !== lastChar) {
                output += letter;
                lastChar = letter;
            }
        }

        return output;
    };

const testString = "Geeks For Geeks";
console.log(
    eleminateSameConsecutiveCharacters(
        testString
    )
);

Geks For Geks

Using Regular Expressions

In this approach, we are traversing each character of the string and checking if it is the same as the last character or not using the replace method. If it is the same, then we skip it; otherwise, we return it.

Syntax:

inputData.replace(/(.)\1+/g, '$1');

Example: This example shows the use of the above-explained approach.

const eleminateSameConsecutiveCharacters =
    (inputData) => {
        return inputData.replace(
            /(.)\1+/g,
            "$1"
        );
    };

const testString = "Geeks For Geeks";
console.log(
    eleminateSameConsecutiveCharacters(
        testString
    )
);

Geks For Geks

Using Array Methods

Using array methods to remove consecutive duplicate characters involves splitting the string into an array of characters, filtering out characters that are equal to their next character, then joining the filtered array back into a string.

Example: In this example we removes consecutive duplicate characters from a string by splitting it into an array, filtering out duplicates, and joining it back into a string.

function removeConsecutiveDuplicates(str) {
    return str.split('').filter((char, index, arr) => 
    char !== arr[index - 1]).join('');
}

console.log(removeConsecutiveDuplicates("aaabbbccc"));

abc

Using Index Comparison

In this approach, we utilize an iterative loop and compare characters using their indices to identify consecutive duplicate characters. We iterate through the string and compare each character with the next character. If they are different, we append the current character to the output string. This approach does not rely on an additional data structure.

Example:

function removeConsecutiveDuplicates(inputData) {
    let output = "";
    for (let i = 0; i < inputData.length; i++) {
        // If current character is not the same as next character
        if (inputData[i] !== inputData[i + 1]) {
            output += inputData[i];
        }
    }
    return output;
}

const testString = "Geeks For Geeks";
console.log(removeConsecutiveDuplicates(testString));

Geks For Geks

Using Set Data Structure

In this approach, we leverage the Set data structure to keep track of the last seen characters in a way that allows us to easily identify and eliminate consecutive duplicates. This approach is particularly useful when dealing with large strings, as Set operations are generally faster due to their O(1) average time complexity for insertions and lookups.

Example: This example shows the use of the Set data structure to remove consecutive duplicate characters.

const eliminateConsecutiveDuplicatesUsingSet = (inputData) => {
    let output = "";
    let seenChars = new Set();
    let lastChar = null;

    for (const letter of inputData) {
        if (letter !== lastChar) {
            output += letter;
            seenChars.add(letter);
            lastChar = letter;
        }
    }

    return output;
};

const testString = "Geeks For Geeks";
console.log(eliminateConsecutiveDuplicatesUsingSet(testString));

Geks For Geks

Using Stack Data Structure

In this approach, we utilize a stack to keep track of the characters. We iterate through the string, and for each character, we check if it is the same as the character at the top of the stack. If it is, we skip it; otherwise, we push it onto the stack. Finally, we join the stack into a string to get the desired output.

Example: This example shows the use of the stack data structure to remove consecutive duplicate characters from a string.

function removeConsecutiveDuplicatesUsingStack(inputData) {
    let stack = [];
    
    for (const char of inputData) {
        if (stack.length === 0 || stack[stack.length - 1] !== char) {
            stack.push(char);
        }
    }
    
    return stack.join('');
}

const testString = "Geeks For Geeks";
console.log(removeConsecutiveDuplicatesUsingStack(testString));

Geks For Geks

Using Sliding Window Technique

Another approach to remove consecutive duplicate characters from a string is by using the sliding window technique. This method involves maintaining a window of characters and dynamically adjusting the window size as we iterate through the string. We compare the current character with the previous character and only add it to the result if it is different.

Example:

function removeConsecutiveDuplicates(s) {
    let result = "";
    let lastChar = "";

    for (let i = 0; i < s.length; i++) {
        let currentChar = s[i];
        if (currentChar !== lastChar) {
            result += currentChar;
            lastChar = currentChar;
        }
    }

    return result;
}

// Example usage:
const inputStr = 'aabbccdde';
const output = removeConsecutiveDuplicates(inputStr);
console.log(output);  // Output should be "abcde"

abcde