Using Stack To Remove Trailing Zeros From The Sum Of Two Numbers

Share Your Love

In this post, We are going to discuss the program, Given two numbers A and B, the challenge is to use a stack to eliminate the trailing zeros from the sum of the two numbers.

Example:

Input: A = 124, B = 186
Output: 31
Explanation: Sum of A and B is 310. Removing the trailing zeros modifies the sum to 31.

Input: A=130246, B= 450164
Output : 58041

Approach: The string and stack data structures can be used to address the given problem. To address the problem, follow the instructions below:

  • Calculate A + B and store it in a variable, say N.
  • Initialize a stack < char >, say S, to store the digits of N.
  • Convert the integer N to string and then push the characters into the stack S.
  • Iterate while S is not empty(), If the top element of the stack is ‘0’, then pop it out of the stack.
  • Otherwise, break. Initialize a string, say res, to store the resultant string.
  • Iterate while S is not empty(), and push all the characters in res and, then pop the top element.
  • Reverse the string res and print the res as the answer.

Below is the implementation of the above approach In C++14:

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to remove trailing
// zeros from the sum of two numbers
string removeTrailing(int A, int B)
{
	// Stores the sum of A and B
	int N = A + B;

	// Stores the digits
	stack<int> s;

	// Stores the equivalent
	// string of integer N
	string strsum = to_string(N);

	// Traverse the string
	for (int i = 0; i < strsum.length(); i++) {

		// Push the digit at i
		// in the stack
		s.push(strsum[i]);
	}

	// While top element is '0'
	while (s.top() == '0')

		// Pop the top element
		s.pop();

	// Stores the resultant number
	// without trailing 0's
	string res = "";

	// While s is not empty
	while (!s.empty()) {

		// Append top element of S in res
		res = res + char(s.top());

		// Pop the top element of S
		s.pop();
	}

	// Reverse the string res
	reverse(res.begin(), res.end());

	return res;
}

// Driver Code
int main()
{
	// Input
	int A = 130246, B = 450164;

	// Function Call
	cout << removeTrailing(A, B);
	return 0;
}

Below is the implementation of the above approach In Java:

// Java program for the above approach
import java.io.*;
import java.util.*;

class GFG{

// Function to remove trailing
// zeros from the sum of two numbers
static String removeTrailing(int A, int B)
{
	
	// Stores the sum of A and B
	int N = A + B;

	// Stores the digits
	Stack<Character> s = new Stack<Character>();

	// Stores the equivalent
	// string of integer N
	String strsum = Integer.toString(N);

	// Traverse the string
	for(int i = 0; i < strsum.length(); i++) 
	{
		
		// Push the digit at i
		// in the stack
		s.push(strsum.charAt(i));
	}

	// While top element is '0'
	while (s.peek() == '0')
	{
		
		// Pop the top element
		s.pop();
	}

	// Stores the resultant number
	// without trailing 0's
	String res = "";

	// While s is not empty
	while (s.empty() == false) 
	{
		
		// Append top element of S in res
		res = res + (char)s.peek();

		// Pop the top element of S
		s.pop();
	}

	StringBuilder str = new StringBuilder();
	str.append(res);

	// Reverse the string res
	str.reverse();

	return str.toString();
}

// Driver Code
public static void main (String[] args) 
{
	
	// Input
	int A = 130246, B = 450164;

	// Function Call
	System.out.println(removeTrailing(A, B));
}
}

// This code is contributed by Dharanendra.L.V.

Below is the implementation of the above approach In Python3:

# Python 3 program for the above approach

# Function to remove trailing
# zeros from the sum of two numbers
def removeTrailing(A, B):

	# Stores the sum of A and B
	N = A + B

	# Stores the digits
	s = []

	# Stores the equivalent
	# string of integer N
	strsum = str(N)

	# Traverse the string
	for i in range(len(strsum)):

		# Push the digit at i
		# in the stack
		s.append(strsum[i])

	# While top element is '0'
	while (s[-1] == '0'):

		# Pop the top element
		s.pop()

	# Stores the resultant number
	# without trailing 0's
	res = ""

	# While s is not empty
	while (len(s) != 0):

		# Append top element of S in res
		res = res + (s[-1])

		# Pop the top element of S
		s.pop()

	# Reverse the string res
	res = list(res)
	res.reverse()
	res = ''.join(res)

	return res


# Driver Code
if __name__ == "__main__":

	# Input
	A = 130246
	B = 450164

	# Function Call
	print(removeTrailing(A, B))

	# This code is contributed by ukasp.

Below is the implementation of the above approach In JavaScript:

<script>

		// Javascript program for the above approach

		// Function to remove trailing
		// zeros from the sum of two numbers
		function removeTrailing(A, B) {

			// Stores the sum of A and B
			let N = A + B;

			// Stores the digits
			let s = new Array();

			// Stores the equivalent
			// string of integer N
			let strsum = N.toString();

			// Traverse the string
			for (let i = 0; i < strsum.length; i++) {

				// Push the digit at i
				// in the stack
				s.push(strsum.charAt(i));
			}

			// While top element is '0'
			while (s[s.length-1] === '0') {

				// Pop the top element
				s.pop();
			}
		
			// Stores the resultant number
			// without trailing 0's
			let res = "";

			// While s is not empty
			while (s.length != 0) {

				// Append top element of S in res
				res = res.concat(s[s.length-1]);

				// Pop the top element of S
				s.pop();
			}

			let str = "";
			str = str.concat(res)

			// Reverse the string res
			str = str.split("").reverse().join("");

			return str.toString();
		}

		// Driver Code

		// Input
		let A = 130246, B = 450164;

		// Function Call
		document.write(removeTrailing(A, B));

		// This code is contributed by Hritik
		
	</script>

Below is the implementation of the above approach In C#:

// C# program for the above approach
using System;
using System.Collections.Generic;

class GFG{
	
// Function to remove trailing
// zeros from the sum of two numbers
static string removeTrailing(int A, int B)
{
	
	// Stores the sum of A and B
	int N = A + B;

	// Stores the digits
	Stack<char> s = new Stack<char>();

	// Stores the equivalent
	// string of integer N
	string strsum = N.ToString();

	// Traverse the string
	for(int i = 0; i < strsum.Length; i++)
	{
		
		// Push the digit at i
		// in the stack
		s.Push(strsum[i]);
	}

	// While top element is '0'
	while (s.Peek() == '0')
	{
		
		// Pop the top element
		s.Pop();
	}

	// Stores the resultant number
	// without trailing 0's
	string res = "";

	// While s is not empty
	while (s.Count != 0)
	{
		
		// Append top element of S in res
		res = res + (char)s.Peek();

		// Pop the top element of S
		s.Pop();
	}
	
	char[] str = res.ToCharArray();
	Array.Reverse(str);
	
	// Reverse the string res
	return new string( str);
}

// Driver Code
static public void Main()
{
	
	// Input
	int A = 130246, B = 450164;
	
	// Function Call
	Console.WriteLine(removeTrailing(A, B));
}
}

// This code is contributed by avanitrachhadiya2155

Output:

58041

Share Your Love
Avatar photo
Lingaraj Senapati

Hey There! I am Lingaraj Senapati, the Founder of lingarajtechhub.com My skills are Freelance, Web Developer & Designer, Corporate Trainer, Digital Marketer & Youtuber.

Articles: 355

Newsletter Updates

Enter your email address below to subscribe to our newsletter