Question

I have a java project that I need help trying to finish. I have most of it completed but the issue I am running into is adding numbers with different lengths.

Project requirements:

.

Use a Stack ADT with the implementation of your choice (Array or Link), it should not make a

difference

2.Read two “integer” numbers from the user. Hint: You don’t need to use an int type when you read, it may be easier to parse the input as a string

and convert to int as you push to the stack

3. Ask user for the maximum length of the digits if necessary (depends on your structure’s boundedness).

4. Use the algorithm discussed in class to simulate the addition of the two numbers

a. Push digits of number1 in stack 1

b. Push digits of number2 in stack 2

c. Numbers may or may not be of the same length. Also number2 may be longer or shorter. You should be able to handle all cases.

d. Rough algorithm below:

Repeat as long as there is something to pop

•Pop digits and add

(including the carry over if one exists)

•Place result in output stack, one digit only, so if sum is 14, place the 4 in the output stack and

• “Carry over” if necessary , in the example above, carry over the 1 and use it in the next addition

e. Display result of sum

f. Handle having numbers of different digit lengths – so if you are popping elements from number stacks of different sizes, your checks should take that into account

CODE:

package AddStack;

public class ArrayStack<T> implements BoundedStackInterface<T> {

   private int top;
   private T[] stack;
   private static final int DEFCAP = 100;  
  
   public ArrayStack() {
       this(DEFCAP);
   }
  
   public ArrayStack(int capacity) {
       stack = (T[]) new Object[capacity];
       top = -1;
   }
  
   @Override
   public T pop() throws StackUnderflowException {
       // TODO Auto-generated method stub
       T element;
       if (isEmpty())
           throw new StackUnderflowException("Pop attempted on an empty stack");
       else {
           element = stack[top];
           stack[top] = null;
           top--;
           return element;
       }

   }

   @Override
   public T peek() throws StackUnderflowException {
      
   if(isEmpty()) {
       throw new StackUnderflowException("no elements in stack");
       }
  
   return stack[top];
  
   }

   @Override
   public boolean isEmpty() {
       // TODO Auto-generated method stub
       return (top == -1);
   }

   @Override
   public int size() {
       return top;
   }

   @Override
   public void push(T element) throws StackOverflowException {
       // TODO Auto-generated method stub
      
       if (isFull())
           throw new StackOverflowException("Push attempted on a full stack");
       else {
          
           top++;
           stack[top] = element;
          
       }
      
   }

   @Override
   public boolean isFull() {
       // TODO Auto-generated method stub
       return (top == stack.length-1);
   }
  
   public T inspect(int loc) {
  
   if(loc > size()) {
   return null;
   }
  
   return stack[loc];
  
   }
  
  
   public int capacity() {
  
   return stack.length;
   }

}

package AddStack;
import java.io.IOException;
import java.util.Scanner;

public class AddMain {

   static Scanner sc;

   public static void main(String[] args) throws IOException, StackUnderflowException {

       sc = new Scanner(System.in);
       System.out.print("\tEnter an option (1) to Add, (2) Quit ");
       String input = sc.nextLine();

       while (!input.equals("2")) {

           if (input.equals("1")) {

               ArrayStack<Integer> sum = new ArrayStack<Integer>();
               System.out.print("\tEnter integer. Enter -1 to stop: ");
               input = sc.nextLine();

               while (!input.equals("-1")) {
                   ArrayStack<Integer> number = new ArrayStack<Integer>();
                   for (int i = 0; i < input.length(); i++) {
                       number.push(Integer.parseInt(String.valueOf(input.charAt(i))));
                  
                   }
              
                   sum = add(sum, number);
                   System.out.print("\tEnter integer. Enter -1 to stop. => ");
                   input = sc.nextLine();
               }

               String result = "";
               while (!sum.isEmpty()) {
                   result = sum.peek() + result;
                   sum.pop();
               }

               System.out.println("The sum is: " + result);

           } else {
               System.out.println("Invalid option " + input);
           }

           System.out.print("\tEnter an option (1) to add, (2) to Quit ");
           input = sc.nextLine();
       }

   }

   public static ArrayStack<Integer> add(ArrayStack<Integer> first, ArrayStack<Integer> second) throws StackUnderflowException {

       ArrayStack<Integer> sum = new ArrayStack<Integer>();
       int firstInteger;
       int secondInteger;
       int carryOver = 0;
       while (!first.isEmpty() && !second.isEmpty()) {

           firstInteger = (int) first.peek();
           first.pop();

           secondInteger = (int) second.peek();
           second.pop();

           int total = firstInteger + secondInteger + carryOver;
           if (total >= 10) {
               total -= 10;
               carryOver = 1;
           } else {
               carryOver = 0;
           }
           sum.push(total);
       }
       if (first.isEmpty() && second.isEmpty()) {

           if (carryOver > 0) {
               sum.push(carryOver);
               carryOver = 0;
           }
       } else if (first.isEmpty()) {

           while (!second.isEmpty()) {

               sum.push((int) second.peek() + carryOver);
               second.pop();
               carryOver = 0;
           }
       } else {

           while (!first.isEmpty()) {
               sum.push((int) first.peek() + carryOver);
               first.peek();
               carryOver = 0;
           }
       }

       ArrayStack<Integer> realSum = new ArrayStack<Integer>();
       while (!sum.isEmpty()) {
           realSum.push((Integer) sum.peek());
           sum.pop();
       }
       return realSum;
   }

}

Answer 1

Hope this is what you need help with. Updated code for adding two stack values:

while (!first.isEmpty() && !second.isEmpty()) {

firstInteger = (int) first.peek();
first.pop();

secondInteger = (int) second.peek();
second.pop();

int total = firstInteger + secondInteger + carryOver;
if (total%10) {
//total -= 10;
//carryOver = 1;
              carryOver=total/10;
               total=total%10;
} else {
carryOver = 0;
}
sum.push(total);
}