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

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``