Remove all adjacent duplicates in string using stack

Here given code implementation process.

import java.util.Stack;
/*
    Java program for
    Remove all adjacent duplicates in string using stack
*/
public class Duplicates
{
	public void removeAdjacentDup(String text)
	{
		int n = text.length();
		// Create an empty tracker
		Stack < Character > tracker = new Stack < Character > ();
		// Auxiliary resultant variable
		String result = "";
		boolean status = false;
		int i = 0;
		// Collect all adjacent unique elements
		while (i < n)
		{
			if (tracker.isEmpty())
			{
				// When tracker is empty
				tracker.push(text.charAt(i));
				i++;
			}
			else if (tracker.peek() != text.charAt(i))
			{
				if (status)
				{
					// When need to remove tracker top element
					tracker.pop();
					// Indicates there is no back duplicates
					status = false;
				}
				else
				{
					// Add unique adjacent
					tracker.push(text.charAt(i));
					i++;
				}
			}
			else
			{
				// When top of tracker element is equal to current element
				status = true;
				i++;
			}
		}
		if (status == true && tracker.isEmpty() == false)
		{
			// Remove last duplicates
			tracker.pop();
		}
		// This is collects resultant value
		while (tracker.isEmpty() == false)
		{
			result = tracker.peek() + result;
			tracker.pop();
		}
		// Display given text
		System.out.print("\n Given : " + text);
		// Display calculated result
		System.out.print("\n Result : " + result);
	}
	public static void main(String[] args)
	{
		Duplicates task = new Duplicates();
		// Test
		/*
		    Example A
		    
		    xyxxyzyy
		    ────────
		    xyxxyzyy   
		      --      ->remove adjacent xx
		    xyyzyy     
		     --       ->remove adjacent yy
		    xzyy
		      --      ->remove adjacent yy
		    ----------------------------------
		    xz   <-- Result
		*/
		task.removeAdjacentDup("xyxxyzyy");
		/*
		    Example B

		    abccebbec
		    ─────────
		    abccebbec   
		      --      ->remove adjacent cc
		    abebbec     
		       --     ->remove adjacent bb
		    abeec
		      --      ->remove adjacent ee
		    ----------------------------------
		    abc   <-- Result
		*/
		task.removeAdjacentDup("abccebbec");
		/*
		    Example C

		    abcccb
		    ─────────
		    abcccb   
		      ---      ->remove adjacent ccc
		    abb     
		     --     ->remove adjacent bb
		    ----------------------------------
		    a   <-- Result
		*/
		task.removeAdjacentDup("abcccb");
	}
}

Output

 Given : xyxxyzyy
 Result : xz
 Given : abccebbec
 Result : abc
 Given : abcccb
 Result : a

// Include header file
#include <iostream>
#include <stack>
#include <string>

using namespace std;
/*
    C++ program for
    Remove all adjacent duplicates in string using stack
*/
class Duplicates
{
	public: void removeAdjacentDup(string text)
	{
		int n = text.length();
		// Create an empty tracker
		stack < char > tracker;
		// Auxiliary resultant variable
		string result = "";
		bool status = false;
		int i = 0;
		// Collect all adjacent unique elements
		while (i < n)
		{
			if (tracker.empty())
			{
				// When tracker is empty
				tracker.push(text[i]);
				i++;
			}
			else if (tracker.top() != text[i])
			{
				if (status)
				{
					// When need to remove tracker top element
					tracker.pop();
					// Indicates there is no back duplicates
					status = false;
				}
				else
				{
					// Add unique adjacent
					tracker.push(text[i]);
					i++;
				}
			}
			else
			{
				// When top of tracker element is equal to current element
				status = true;
				i++;
			}
		}
		if (status == true && tracker.empty() == false)
		{
			// Remove last duplicates
			tracker.pop();
		}
		// This is collects resultant value
		while (tracker.empty() == false)
		{
			result = (tracker.top())  +  result;
			tracker.pop();
		}
		// Display given text
		cout << "\n Given : " << text;
		// Display calculated result
		cout << "\n Result : " << result;
	}
};
int main()
{
	Duplicates *task = new Duplicates();
	// Test
	/*
	    Example A
	    
	    xyxxyzyy
	    ────────
	    xyxxyzyy   
	      --      ->remove adjacent xx
	    xyyzyy     
	     --       ->remove adjacent yy
	    xzyy
	      --      ->remove adjacent yy
	    ----------------------------------
	    xz   <-- Result
	*/
	task->removeAdjacentDup("xyxxyzyy");
	/*
	    Example B
	    abccebbec
	    ─────────
	    abccebbec   
	      --      ->remove adjacent cc
	    abebbec     
	       --     ->remove adjacent bb
	    abeec
	      --      ->remove adjacent ee
	    ----------------------------------
	    abc   <-- Result
	*/
	task->removeAdjacentDup("abccebbec");
	/*
	    Example C
	    abcccb
	    ─────────
	    abcccb   
	      ---      ->remove adjacent ccc
	    abb     
	     --     ->remove adjacent bb
	    ----------------------------------
	    a   <-- Result
	*/
	task->removeAdjacentDup("abcccb");
	return 0;
}

Output

 Given : xyxxyzyy
 Result : xz
 Given : abccebbec
 Result : abc
 Given : abcccb
 Result : a

// Include namespace system
using System;
using System.Collections.Generic;
/*
    Csharp program for
    Remove all adjacent duplicates in string using stack
*/
public class Duplicates
{
	public void removeAdjacentDup(String text)
	{
		int n = text.Length;
		// Create an empty tracker
		Stack < char > tracker = new Stack < char > ();
		// Auxiliary resultant variable
		String result = "";
		Boolean status = false;
		int i = 0;
		// Collect all adjacent unique elements
		while (i < n)
		{
			if ((tracker.Count == 0))
			{
				// When tracker is empty
				tracker.Push(text[i]);
				i++;
			}
			else if (tracker.Peek() != text[i])
			{
				if (status)
				{
					// When need to remove tracker top element
					tracker.Pop();
					// Indicates there is no back duplicates
					status = false;
				}
				else
				{
					// Add unique adjacent
					tracker.Push(text[i]);
					i++;
				}
			}
			else
			{
				// When top of tracker element is equal to current element
				status = true;
				i++;
			}
		}
		if (status == true && (tracker.Count == 0) == false)
		{
			// Remove last duplicates
			tracker.Pop();
		}
		// This is collects resultant value
		while ((tracker.Count == 0) == false)
		{
			result = tracker.Peek() + result;
			tracker.Pop();
		}
		// Display given text
		Console.Write("\n Given : " + text);
		// Display calculated result
		Console.Write("\n Result : " + result);
	}
	public static void Main(String[] args)
	{
		Duplicates task = new Duplicates();
		// Test
		/*
		    Example A
		    
		    xyxxyzyy
		    ────────
		    xyxxyzyy   
		      --      ->remove adjacent xx
		    xyyzyy     
		     --       ->remove adjacent yy
		    xzyy
		      --      ->remove adjacent yy
		    ----------------------------------
		    xz   <-- Result
		*/
		task.removeAdjacentDup("xyxxyzyy");
		/*
		    Example B
		    abccebbec
		    ─────────
		    abccebbec   
		      --      ->remove adjacent cc
		    abebbec     
		       --     ->remove adjacent bb
		    abeec
		      --      ->remove adjacent ee
		    ----------------------------------
		    abc   <-- Result
		*/
		task.removeAdjacentDup("abccebbec");
		/*
		    Example C
		    abcccb
		    ─────────
		    abcccb   
		      ---      ->remove adjacent ccc
		    abb     
		     --     ->remove adjacent bb
		    ----------------------------------
		    a   <-- Result
		*/
		task.removeAdjacentDup("abcccb");
	}
}

Output

 Given : xyxxyzyy
 Result : xz
 Given : abccebbec
 Result : abc
 Given : abcccb
 Result : a

package main
import "fmt"
/*
    Go program for
    Remove all adjacent duplicates in string using stack
*/

func removeAdjacentDup(text string) {
	var n int = len(text)
	// Create an empty tracker
	var tracker = make([] byte, 0)
	// Auxiliary resultant variable
	var result string = ""
	var status bool = false
	var i int = 0
	// Collect all adjacent unique elements
	for (i < n) {
		if len(tracker) == 0 {
			// When tracker is empty
			tracker = append(tracker, text[i])
			i++
		} else if tracker[len(tracker) - 1] != text[i] {
			if status {
				// When need to remove tracker top element
				tracker = tracker[: len(tracker) - 1]
				// Indicates there is no back duplicates
				status = false
			} else {
				// Add unique adjacent
				tracker = append(tracker, text[i])
				i++
			}
		} else {
			// When top of tracker element is equal to current element
			status = true
			i++
		}
	}
	if status == true && len(tracker) > 0 {
		// Remove last duplicates
		tracker = tracker[: len(tracker) - 1]
	}
	// This is collects resultant value
	for (len(tracker) > 0 ) {
		result = string(int(tracker[len(tracker) - 1])) + result
		tracker = tracker[: len(tracker) - 1]
	}
	// Display given text
	fmt.Print("\n Given : ", text)
	// Display calculated result
	fmt.Print("\n Result : ", result)
}
func main() {

	// Test
	/*
	    Example A
	    
	    xyxxyzyy
	    ────────
	    xyxxyzyy   
	      --      ->remove adjacent xx
	    xyyzyy     
	     --       ->remove adjacent yy
	    xzyy
	      --      ->remove adjacent yy
	    ----------------------------------
	    xz   <-- Result
	*/
	removeAdjacentDup("xyxxyzyy")
	/*
	    Example B
	    abccebbec
	    ─────────
	    abccebbec   
	      --      ->remove adjacent cc
	    abebbec     
	       --     ->remove adjacent bb
	    abeec
	      --      ->remove adjacent ee
	    ----------------------------------
	    abc   <-- Result
	*/
	removeAdjacentDup("abccebbec")
	/*
	    Example C
	    abcccb
	    ─────────
	    abcccb   
	      ---      ->remove adjacent ccc
	    abb     
	     --     ->remove adjacent bb
	    ----------------------------------
	    a   <-- Result
	*/
	removeAdjacentDup("abcccb")
}

Output

 Given : xyxxyzyy
 Result : xz
 Given : abccebbec
 Result : abc
 Given : abcccb
 Result : a

<?php
/*
    Php program for
    Remove all adjacent duplicates in string using stack
*/
class Duplicates
{
	public	function removeAdjacentDup($text)
	{
		$n = strlen($text);
		// Create an empty tracker
		$tracker = array();
		// Auxiliary resultant variable
		$result = "";
		$status = false;
		$i = 0;
		// Collect all adjacent unique elements
		while ($i < $n)
		{
			if (empty($tracker))
			{
				// When tracker is empty
				array_push($tracker, $text[$i]);
				$i++;
			}
			else if (end($tracker) != $text[$i])
			{
				if ($status)
				{
					// When need to remove tracker top element
					array_pop($tracker);
					// Indicates there is no back duplicates
					$status = false;
				}
				else
				{
					// Add unique adjacent
					array_push($tracker, $text[$i]);
					$i++;
				}
			}
			else
			{
				// When top of tracker element is equal to current element
				$status = true;
				$i++;
			}
		}
		if ($status == true && !empty($tracker))
		{
			// Remove last duplicates
			array_pop($tracker);
		}
		// This is collects resultant value
		while (empty($tracker) == false)
		{
			$result = strval(end($tracker)).$result;
			array_pop($tracker);
		}
		// Display given text
		echo("\n Given : ".$text);
		// Display calculated result
		echo("\n Result : ".$result);
	}
}

function main()
{
	$task = new Duplicates();
	// Test
	/*
	    Example A
	    
	    xyxxyzyy
	    ────────
	    xyxxyzyy   
	      --      ->remove adjacent xx
	    xyyzyy     
	     --       ->remove adjacent yy
	    xzyy
	      --      ->remove adjacent yy
	    ----------------------------------
	    xz   <-- Result
	*/
	$task->removeAdjacentDup("xyxxyzyy");
	/*
	    Example B
	    abccebbec
	    ─────────
	    abccebbec   
	      --      ->remove adjacent cc
	    abebbec     
	       --     ->remove adjacent bb
	    abeec
	      --      ->remove adjacent ee
	    ----------------------------------
	    abc   <-- Result
	*/
	$task->removeAdjacentDup("abccebbec");
	/*
	    Example C
	    abcccb
	    ─────────
	    abcccb   
	      ---      ->remove adjacent ccc
	    abb     
	     --     ->remove adjacent bb
	    ----------------------------------
	    a   <-- Result
	*/
	$task->removeAdjacentDup("abcccb");
}
main();

Output

 Given : xyxxyzyy
 Result : xz
 Given : abccebbec
 Result : abc
 Given : abcccb
 Result : a

/*
    Node JS program for
    Remove all adjacent duplicates in string using stack
*/
class Duplicates
{
	removeAdjacentDup(text)
	{
		var n = text.length;
		// Create an empty tracker
		var tracker = [];
		// Auxiliary resultant variable
		var result = "";
		var status = false;
		var i = 0;
		// Collect all adjacent unique elements
		while (i < n)
		{
			if ((tracker.length == 0))
			{
				// When tracker is empty
				tracker.push(text.charAt(i));
				i++;
			}
			else if (tracker[tracker.length - 1] != 
                     text.charAt(i))
			{
				if (status)
				{
					// When need to remove tracker top element
					tracker.pop();
					// Indicates there is no back duplicates
					status = false;
				}
				else
				{
					// Add unique adjacent
					tracker.push(text.charAt(i));
					i++;
				}
			}
			else
			{
				// When top of tracker element is equal to current element
				status = true;
				i++;
			}
		}
		if (status == true && (tracker.length == 0) == false)
		{
			// Remove last duplicates
			tracker.pop();
		}
		// This is collects resultant value
		while ((tracker.length == 0) == false)
		{
			result = tracker[tracker.length - 1] + result;
			tracker.pop();
		}
		// Display given text
		process.stdout.write("\n Given : " + text);
		// Display calculated result
		process.stdout.write("\n Result : " + result);
	}
}

function main()
{
	var task = new Duplicates();
	// Test
	/*
	    Example A
	    
	    xyxxyzyy
	    ────────
	    xyxxyzyy   
	      --      ->remove adjacent xx
	    xyyzyy     
	     --       ->remove adjacent yy
	    xzyy
	      --      ->remove adjacent yy
	    ----------------------------------
	    xz   <-- Result
	*/
	task.removeAdjacentDup("xyxxyzyy");
	/*
	    Example B
	    abccebbec
	    ─────────
	    abccebbec   
	      --      ->remove adjacent cc
	    abebbec     
	       --     ->remove adjacent bb
	    abeec
	      --      ->remove adjacent ee
	    ----------------------------------
	    abc   <-- Result
	*/
	task.removeAdjacentDup("abccebbec");
	/*
	    Example C
	    abcccb
	    ─────────
	    abcccb   
	      ---      ->remove adjacent ccc
	    abb     
	     --     ->remove adjacent bb
	    ----------------------------------
	    a   <-- Result
	*/
	task.removeAdjacentDup("abcccb");
}
main();

Output

 Given : xyxxyzyy
 Result : xz
 Given : abccebbec
 Result : abc
 Given : abcccb
 Result : a

#    Python 3 program for
#    Remove all adjacent duplicates in string using stack
class Duplicates :
	def removeAdjacentDup(self, text) :
		n = len(text)
		#  Create an empty tracker
		tracker = []
		#  Auxiliary resultant variable
		result = ""
		status = False
		i = 0
		#  Collect all adjacent unique elements
		while (i < n) :
			if ((len(tracker) == 0)) :
				#  When tracker is empty
				tracker.append(text[i])
				i += 1
			elif (tracker[-1] != text[i]) :
				if (status) :
					#  When need to remove tracker top element
					tracker.pop()
					#  Indicates there is no back duplicates
					status = False
				else :
					#  Add unique adjacent
					tracker.append(text[i])
					i += 1
				
			else :
				#  When top of tracker element is equal to current element
				status = True
				i += 1
			
		
		if (status == True and len(tracker) != 0) :
			#  Remove last duplicates
			tracker.pop()
		
		#  This is collects resultant value
		while ((len(tracker) == 0) == False) :
			result = str(tracker[-1]) + result
			tracker.pop()
		
		#  Display given text
		print("\n Given : ", text, end = "")
		#  Display calculated result
		print("\n Result : ", result, end = "")
	

def main() :
	task = Duplicates()
	#  Test
	#    Example A
	#    xyxxyzyy
	#    ────────
	#    xyxxyzyy   
	#      --      ->remove adjacent xx
	#    xyyzyy     
	#     --       ->remove adjacent yy
	#    xzyy
	#      --      ->remove adjacent yy
	#    ----------------------------------
	#    xz   <-- Result
	task.removeAdjacentDup("xyxxyzyy")
	#    Example B
	#    abccebbec
	#    ─────────
	#    abccebbec   
	#      --      ->remove adjacent cc
	#    abebbec     
	#       --     ->remove adjacent bb
	#    abeec
	#      --      ->remove adjacent ee
	#    ----------------------------------
	#    abc   <-- Result
	task.removeAdjacentDup("abccebbec")
	#    Example C
	#    abcccb
	#    ─────────
	#    abcccb   
	#      ---      ->remove adjacent ccc
	#    abb     
	#     --     ->remove adjacent bb
	#    ----------------------------------
	#    a   <-- Result
	task.removeAdjacentDup("abcccb")

if __name__ == "__main__": main()

Output

 Given :  xyxxyzyy
 Result :  xz
 Given :  abccebbec
 Result :  abc
 Given :  abcccb
 Result :  a

#    Ruby program for
#    Remove all adjacent duplicates in string using stack
class Duplicates 
	def removeAdjacentDup(text) 
		n = text.length
		#  Create an empty tracker
		tracker = []
		#  Auxiliary resultant variable
		result = ""
		status = false
		i = 0
		#  Collect all adjacent unique elements
		while (i < n) 
			if ((tracker.length == 0)) 
				#  When tracker is empty
				tracker.push(text[i])
				i += 1
			elsif (tracker.last != text[i]) 
				if (status) 
					#  When need to remove tracker top element
					tracker.pop()
					#  Indicates there is no back duplicates
					status = false
				else
 
					#  Add unique adjacent
					tracker.push(text[i])
					i += 1
				end

			else
 
				#  When top of tracker element is equal to current element
				status = true
				i += 1
			end

		end

		if (status == true && (tracker.length != 0)) 
			#  Remove last duplicates
			tracker.pop()
		end

		#  This is collects resultant value
		while ((tracker.length != 0) ) 
			result = tracker.last.to_s + result
			tracker.pop()
		end

		#  Display given text
		print("\n Given : ", text)
		#  Display calculated result
		print("\n Result : ", result)
	end

end

def main() 
	task = Duplicates.new()
	#  Test
	#    Example A
	#    xyxxyzyy
	#    ────────
	#    xyxxyzyy   
	#      --      ->remove adjacent xx
	#    xyyzyy     
	#     --       ->remove adjacent yy
	#    xzyy
	#      --      ->remove adjacent yy
	#    ----------------------------------
	#    xz   <-- Result
	task.removeAdjacentDup("xyxxyzyy")
	#    Example B
	#    abccebbec
	#    ─────────
	#    abccebbec   
	#      --      ->remove adjacent cc
	#    abebbec     
	#       --     ->remove adjacent bb
	#    abeec
	#      --      ->remove adjacent ee
	#    ----------------------------------
	#    abc   <-- Result
	task.removeAdjacentDup("abccebbec")
	#    Example C
	#    abcccb
	#    ─────────
	#    abcccb   
	#      ---      ->remove adjacent ccc
	#    abb     
	#     --     ->remove adjacent bb
	#    ----------------------------------
	#    a   <-- Result
	task.removeAdjacentDup("abcccb")
end

main()

Output

 Given : xyxxyzyy
 Result : xz
 Given : abccebbec
 Result : abc
 Given : abcccb
 Result : a

import scala.collection.mutable._;
/*
    Scala program for
    Remove all adjacent duplicates in string using stack
*/
class Duplicates()
{
	def removeAdjacentDup(text: String): Unit = {
		var n: Int = text.length();
		// Create an empty tracker
		var tracker: Stack[Character] = new Stack[Character]();
		// Auxiliary resultant variable
		var result: String = "";
		var status: Boolean = false;
		var i: Int = 0;
		// Collect all adjacent unique elements
		while (i < n)
		{
			if (tracker.isEmpty)
			{
				// When tracker is empty
				tracker.push(text.charAt(i));
				i += 1;
			}
			else if (tracker.top != text.charAt(i).toInt)
			{
				if (status)
				{
					// When need to remove tracker top element
					tracker.pop;
					// Indicates there is no back duplicates
					status = false;
				}
				else
				{
					// Add unique adjacent
					tracker.push(text.charAt(i));
					i += 1;
				}
			}
			else
			{
				// When top of tracker element is equal to current element
				status = true;
				i += 1;
			}
		}
		if (status == true && tracker.isEmpty == false)
		{
			// Remove last duplicates
			tracker.pop;
		}
		// This is collects resultant value
		while (tracker.isEmpty == false)
		{
			result = tracker.top.toString() + result;
			tracker.pop;
		}
		// Display given text
		print("\n Given : " + text);
		// Display calculated result
		print("\n Result : " + result);
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: Duplicates = new Duplicates();
		// Test
		/*
		    Example A
		    
		    xyxxyzyy
		    ────────
		    xyxxyzyy   
		      --      ->remove adjacent xx
		    xyyzyy     
		     --       ->remove adjacent yy
		    xzyy
		      --      ->remove adjacent yy
		    ----------------------------------
		    xz   <-- Result
		*/
		task.removeAdjacentDup("xyxxyzyy");
		/*
		    Example B
		    abccebbec
		    ─────────
		    abccebbec   
		      --      ->remove adjacent cc
		    abebbec     
		       --     ->remove adjacent bb
		    abeec
		      --      ->remove adjacent ee
		    ----------------------------------
		    abc   <-- Result
		*/
		task.removeAdjacentDup("abccebbec");
		/*
		    Example C
		    abcccb
		    ─────────
		    abcccb   
		      ---      ->remove adjacent ccc
		    abb     
		     --     ->remove adjacent bb
		    ----------------------------------
		    a   <-- Result
		*/
		task.removeAdjacentDup("abcccb");
	}
}

Output

 Given : xyxxyzyy
 Result : xz
 Given : abccebbec
 Result : abc
 Given : abcccb
 Result : a

import Foundation;
/*
    Swift 4 program for
    Remove all adjacent duplicates in string using stack
*/
struct Stack
{
	private
	var items: [Character] = []
	func peek()->Character
	{
		if (self.isEmpty()==false)
		{
			return items.first!
		}
		else
		{
			fatalError("This stack is empty.")
		}
	}
	func isEmpty()->Bool
	{
		return items.count == 0
	}
	mutating func pop()
	{
		items.removeFirst()
	}
	mutating func push(_ data: Character)
	{
		items.insert(data, at: 0)
	}
}
class Duplicates
{
	func removeAdjacentDup(_ data: String)
	{
      	let text = Array(data);
		let n: Int = text.count;
		// Create an empty tracker
		var tracker = Stack();
		// Auxiliary resultant variable
		var result: String = "";
		var status: Bool = false;
		var i: Int = 0;
		// Collect all adjacent unique elements
		while (i < n)
		{
			if (tracker.isEmpty())
			{
				// When tracker is empty
				tracker.push(text[i]);
				i += 1;
			}
			else if (!(tracker.peek() == text[i]))
			{
				if (status)
				{
					// When need to remove tracker top element
					tracker.pop();
					// Indicates there is no back duplicates
					status = false;
				}
				else
				{
					// Add unique adjacent
					tracker.push(text[i]);
					i += 1;
				}
			}
			else
			{
				// When top of tracker element is equal to current element
				status = true;
				i += 1;
			}
		}
		if (status == true && tracker.isEmpty() == false)
		{
			// Remove last duplicates
			tracker.pop();
		}
		// This is collects resultant value
		while (tracker.isEmpty() == false)
		{
			result = String(tracker.peek()) + result;
			tracker.pop();
		}
		// Display given text
		print("\n Given : ", data, terminator: "");
		// Display calculated result
		print("\n Result : ", result, terminator: "");
	}
}
func main()
{
	let task: Duplicates = Duplicates();
	// Test
	/*
	    Example A
	    
	    xyxxyzyy
	    ────────
	    xyxxyzyy   
	      --      ->remove adjacent xx
	    xyyzyy     
	     --       ->remove adjacent yy
	    xzyy
	      --      ->remove adjacent yy
	    ----------------------------------
	    xz   <-- Result
	*/
	task.removeAdjacentDup("xyxxyzyy");
	/*
	    Example B
	    abccebbec
	    ─────────
	    abccebbec   
	      --      ->remove adjacent cc
	    abebbec     
	       --     ->remove adjacent bb
	    abeec
	      --      ->remove adjacent ee
	    ----------------------------------
	    abc   <-- Result
	*/
	task.removeAdjacentDup("abccebbec");
	/*
	    Example C
	    abcccb
	    ─────────
	    abcccb   
	      ---      ->remove adjacent ccc
	    abb     
	     --     ->remove adjacent bb
	    ----------------------------------
	    a   <-- Result
	*/
	task.removeAdjacentDup("abcccb");
}
main();

Output

 Given :  xyxxyzyy
 Result :  xz
 Given :  abccebbec
 Result :  abc
 Given :  abcccb
 Result :  a

import java.util.Stack;
/*
    Kotlin program for
    Remove all adjacent duplicates in string using stack
*/
class Duplicates
{
	fun removeAdjacentDup(text: String): Unit
	{
		val n: Int = text.length;
		// Create an empty tracker
		var tracker: Stack < Char > = Stack < Char > ();
		// Auxiliary resultant variable
		var result: String = "";
		var status: Boolean = false;
		var i: Int = 0;
		// Collect all adjacent unique elements
		while (i < n)
		{
			if (tracker.empty())
			{
				// When tracker is empty
				tracker.push(text.get(i));
				i += 1;
			}
			else if (tracker.peek() != text.get(i))
			{
				if (status)
				{
					// When need to remove tracker top element
					tracker.pop();
					// Indicates there is no back duplicates
					status = false;
				}
				else
				{
					// Add unique adjacent
					tracker.push(text.get(i));
					i += 1;
				}
			}
			else
			{
				// When top of tracker element is equal to current element
				status = true;
				i += 1;
			}
		}
		if (status == true && !tracker.empty() )
		{
			// Remove last duplicates
			tracker.pop();
		}
		// This is collects resultant value
		while (tracker.empty() == false)
		{
			result = tracker.peek().toString() + result;
			tracker.pop();
		}
		// Display given text
		print("\n Given : " + text);
		// Display calculated result
		print("\n Result : " + result);
	}
}
fun main(args: Array < String > ): Unit
{
	val task: Duplicates = Duplicates();
	// Test
	/*
	    Example A
	    
	    xyxxyzyy
	    ────────
	    xyxxyzyy   
	      --      ->remove adjacent xx
	    xyyzyy     
	     --       ->remove adjacent yy
	    xzyy
	      --      ->remove adjacent yy
	    ----------------------------------
	    xz   <-- Result
	*/
	task.removeAdjacentDup("xyxxyzyy");
	/*
	    Example B
	    abccebbec
	    ─────────
	    abccebbec   
	      --      ->remove adjacent cc
	    abebbec     
	       --     ->remove adjacent bb
	    abeec
	      --      ->remove adjacent ee
	    ----------------------------------
	    abc   <-- Result
	*/
	task.removeAdjacentDup("abccebbec");
	/*
	    Example C
	    abcccb
	    ─────────
	    abcccb   
	      ---      ->remove adjacent ccc
	    abb     
	     --     ->remove adjacent bb
	    ----------------------------------
	    a   <-- Result
	*/
	task.removeAdjacentDup("abcccb");
}

Output

 Given : xyxxyzyy
 Result : xz
 Given : abccebbec
 Result : abc
 Given : abcccb
 Result : a

« Previous Next »

Stack

Implementation stack using linked list

Infix to prefix conversion

Infix to postfix conversion

Prefix to infix conversion

Prefix to Postfix Conversion

Postfix to prefix conversion

Postfix To Infix Conversion

Evaluate postfix expression

Iterative postorder traversal

Reverse a linked list using stack

Reverse a string using stack

Print stack elements from Bottom to Top

Implement tower of hanoi using stack

Sort array using stack

Sort a stack using temporary two stack

Implement stack using array

Insert the element at the bottom side of stack

Delete middle element of a stack

Reverse each word in a string

Bubble sort using two stack

Reverse a number using stack

Reverse a queue using stack

Check balanced parentheses using Stack

Check if stack elements are pairwise consecutive

Print all internal nodes of a binary tree using stack

Print all paths from root node to leaf

Print all paths from leaf node to root

Print all Leaf nodes of a binary tree from left to right

Find the next greater element on right side

Generating all possible subsequences

Find longest length subsequence of given sum

Convert Ternary Expression to a Binary Tree Using Stack

Check if leaf traversal of two Binary Trees is same or not

Find all subsequences with given sum

Tracking present maximum element in a stack

Tracking present minimum element in a stack

Sort stack using another stack

Reverse stack using another stack

Delete all even elements from a stack

Remove all particular element from a stack

Stock Span Problem

Construct BST from given preorder traversal using stack

Check if two stacks are equal

Add two numbers represented by stack

Check if stack contains given array element present or not

Remove all duplicate adjacent characters from a string using stack

Check valid parentheses using stack

Length of the longest balanced parentheses in a string

Quicksort using stack

Remove the redundant parentheses from valid expression

Check redundant parentheses in an expression

Find minimum number from a ID sequence

Remove all adjacent duplicates in string using stack

Find leftmost smaller number in an array

Score of parentheses using stack

Check if expression contains extra brackets or not

Count of binary strings that does not contain Arc intersection

Find all distinct subsets of given sum

Find the nearest smaller numbers on left side in an array using stack

Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment

Name