Solution For Remove All Adjacent Duplicates In String
Problem:
Given a string S of lowercase letters, a duplicate removal consists of choosing two adjacent and equal letters, and removing them. We repeatedly make duplicate removals on S until we no longer can. Return the final string after all such duplicate removals have been made. It is guaranteed the answer is unique.
Example:
Input: “abbaca”
Output: “ca”
Explanation:
For example, in “abbaca” we could remove “bb” since the letters are adjacent and equal, and this is the only possible move. The result of this move is that the string is “aaca”, of which only “aa” is possible, so the final string is “ca”.
Solution:
We can solve this problem by using a stack data structure. We will iterate through each character of the input string and compare it with the top element of the stack. If they are equal, we will pop the element from the stack. Otherwise, we will push the character onto the stack. The final string will be the elements of the stack concatenated in reverse order.
Algorithm:
1. Initialize an empty stack
2. Iterate through each character of the input string:
a. If the stack is empty or the top element of the stack is not equal to the current character, push the character onto the stack
b. Otherwise, pop the top element of the stack
3. Concatenate the elements of the stack in reverse order to form the final string
4. Return the final string
Python code:
class Solution:
def removeDuplicates(self, S: str) -> str:
stack = []
for c in S:
if stack and stack[-1] == c:
stack.pop()
else:
stack.append(c)
return ”.join(stack[::-1])
Step by Step Implementation For Remove All Adjacent Duplicates In String
public String removeDuplicates(String S) { Stackstack = new Stack<>(); for (char c : S.toCharArray()) { if (!stack.empty() && stack.peek() == c) { stack.pop(); } else { stack.push(c); } } StringBuilder sb = new StringBuilder(); for (char c : stack) { sb.append(c); } return sb.toString(); }
class Solution: def removeDuplicates(self, S: str) -> str: # Base case if len(S) == 0: return S # Recursive case else: # If the first two characters are the same, # we can remove them and make a recursive call if S[0] == S[1]: return self.removeDuplicates(S[2:]) # If the first two characters are not the same, # we keep the first character and make a recursive call # on the rest of the string else: return S[0] + self.removeDuplicates(S[1:])
var removeDuplicates = function(s) { // create a stack to store characters let stack = []; // loop through string for (let i = 0; i < s.length; i++) { // get current character let c = s.charAt(i); // if stack is empty or character at top of stack is not equal to current character, push current character to stack if (stack.length === 0 || stack[stack.length - 1] !== c) { stack.push(c); } else { // else, pop character from stack stack.pop(); } } // return stack as string return stack.join(""); };
One possible solution to this problem is to use a stack data structure to keep track of the characters in the string. We can iterate through the string, and if the character we are currently looking at is not the same as the top element of the stack, we can push it onto the stack. If the character is the same as the top element of the stack, we can pop the top element off the stack. We can continue doing this until we have iterated through the entire string. The characters remaining in the stack will be the characters that are not adjacent duplicates.
public class Solution { public string RemoveDuplicates(string s) { // create a stack to store the characters in the string Stackstack = new Stack (); // loop through each character in the string foreach (char c in s) { // if the stack is empty or the top character of the stack is not equal to the current character if (stack.Count == 0 || stack.Peek() != c) { // push the current character onto the stack stack.Push(c); } else { // if the top character of the stack is equal to the current character // pop the top character off the stack stack.Pop(); } } // return the remaining characters in the stack as a string return new string(stack.ToArray()); } }