CC-15 : Remove consecutive duplicates from array.

Description:

Given an input integer array, return consecutive duplicate integers from the same.

Test cases and expected outputs:

Input Parameters	Expected outputs
Original array : 1,2,2,1,4,7,2,1	Cons Dups removed : 4,7,2,1
Original array : 8,3,2,3,3,1,1,4	Cons Dups removed : 8,3,2,4

Pseudocode:

Initialize a Deque based stack for processing purposes.

For each integer in input array:

If stack size is not zero and top element of stack is same as current element of array, remove top element of stack.

Else add current element of array to stack.

Convert the stack to array and reverse elements of array to get output array in same order as input array with consecutive duplicates removed.

Code:

public int[] removeConsequtiveDuplicates(int[] arr) throws Exception{
	Deque<Integer> stack=new LinkedList<Integer>();
	int i;
	for (int idx=0; idx< arr.length;idx++) {
		i=arr[idx];
		if ((stack.size()!=0)&&(stack.peekFirst()==i)){
			stack.pollFirst();
		}else {
			stack.offerFirst(i);
		}
	}
	Integer[] retVal1=stack.toArray(new Integer[0]);
	int[] retVal2=new int[retVal1.length];
	for (int idx=0; idx< retVal1.length;idx++) {
		retVal2[retVal1.length-idx-1]=retVal1[idx];
	}
	return retVal2;	
}

Click here to download and run code and test cases !

Below fully running code can be copied and run on Eclipse or other Java IDEs. Refer the classname in code below. If the class name below is "A", save the code below to a file named A.java before running it. Be sure to try your own test cases to enhance your understanding ! You can also tweak the code to optimize or add enhancements and custom features.

import java.util.Deque;
import java.util.LinkedList;

public class StackRemoveConsequtiveDuplicates {
	
public int[] removeConsequtiveDuplicates(int[] arr) throws Exception{
	Deque<Integer> stack=new LinkedList<Integer>();
	int i;
	for (int idx=0; idx< arr.length;idx++) {
		i=arr[idx];
		if ((stack.size()!=0)&&(stack.peekFirst()==i)){
			stack.pollFirst();
		}else {
			stack.offerFirst(i);
		}
	}
	Integer[] retVal1=stack.toArray(new Integer[0]);
	int[] retVal2=new int[retVal1.length];
	for (int idx=0; idx< retVal1.length;idx++) {
		retVal2[retVal1.length-idx-1]=retVal1[idx];
	}
	return retVal2;	
}

public static void printArraySummary(int[] intArray, String label) throws Exception {
   	// Case 1: The input Array is null !!
	if (intArray == null) { System.out.println("\n\n Input Array was null !! \n"); return; }
	// Case 2: Print input Array by index (first to last)
	System.out.println();
	System.out.println("************************************************************************");
	System.out.print(label+" : ");
	int arrayIndex=0;
	for (arrayIndex=0; arrayIndex < intArray.length; arrayIndex++) {
			System.out.print(intArray[arrayIndex]);
			if (arrayIndex < intArray.length-1) {System.out.print(",");}
	} 
	System.out.println();
	System.out.println(" ************************************************************************");
		System.out.println();
		Thread.sleep(2000);
		return;
}
 	
public static void main(String[] args) {
	/**********************
 	Test cases given below
	 *********************/
	try {
	int[] retVal;
	StackRemoveConsequtiveDuplicates remove=new StackRemoveConsequtiveDuplicates();
	int[] arr= {1,2,2,1,4, 7, 2, 1};
	printArraySummary(arr, "Original array");
	retVal=remove.removeConsequtiveDuplicates(arr);
	printArraySummary(retVal, "Cons Dups removed");
	
	int[] arr1= {8, 3, 2, 3, 3, 1, 1, 4};
	printArraySummary(arr1, "Original array");
	retVal=remove.removeConsequtiveDuplicates(arr1);
	printArraySummary(retVal, "Cons Dups removed");
	
	
	}catch (Exception exception) {
	System.out.print("Exception: "+ exception);
	exception.printStackTrace();
	}
		
}
	
}