// Program that demonstrates stack and queue operations
//  and solving an interesting stack/queue problem (sum).
import java.util.*;

public class StackQueue {
   public static void main(String[] args) {
      Queue<Integer> queue = makeQueueOf(3, 6);
      System.out.println("queue: " + queue);
      System.out.println("sum: " + sum(queue));
      System.out.println("queue: " + queue);
      System.out.println();
      
      Stack<Integer> stack = makeStackOf(3, 6);
      System.out.println("stack: " + stack);
      System.out.println("sum: " + sum(stack));
      System.out.println("stack: " + stack);
   }

   
   // returns a queue containing the first size multiples of base
   // pre: size >= 0
   public static Queue<Integer> makeQueueOf(int base, int size) {
      Queue<Integer> queue = new LinkedList<Integer>();
      for (int i = base; i <= base * size; i += base) {
         queue.add(i);
      }
      return queue;
   }
   
   // returns a stack containing the first size multiples of base
   // pre: size >= 0   
   public static Stack<Integer> makeStackOf(int base, int size) {
      Stack<Integer> stack = new Stack<Integer>();
      for (int i = base; i <= base * size; i += base) {
         stack.push(i);
      }
      return stack;
   }
   
   // moves all values from stack to queue in order
   // pre stack != null, queue != null
   // post: stack is empty
   public static void stackToQueue(Stack<Integer> stack, Queue<Integer> queue) {
      while (!stack.isEmpty()) {
         queue.add(stack.pop());
      }
   }
   
   // moves all values from queue to stack in order
   // pre: queue != null, stack != null
   // post: queue is empty   
   public static void queueToStack(Queue<Integer> queue, Stack<Integer> stack) {
      while (!queue.isEmpty()) {
         stack.push(queue.remove());
      }
   } 
   
   // reverses a stack
   public static void reverseStack(Stack<Integer> stack) {
      Queue<Integer> q = new LinkedList<Integer>();
      stackToQueue(stack, q);
      queueToStack(q, stack);
   }
   
   // returns the sum of the values in queue
   // pre: queue != null
   public static int sum(Queue<Integer> queue) {
      int sum = 0;
      int size = queue.size();
      for (int i = 0; i < size; i++) {
         int num = queue.remove();
         sum += num;
         queue.add(num);
      }
      
      return sum;
   }
   
   // returns the sume of the values in stack
   // pre: stack != null
   public static int sum(Stack<Integer> stack) {
      Queue<Integer> queue = new LinkedList<Integer>();
      int sum = 0;
      int size = stack.size();
      for (int i = 0; i < size; i++) {
         int num = stack.pop();
         sum += num;
         queue.add(num);
      }
      queueToStack(queue, stack);
      stackToQueue(stack, queue);
      queueToStack(queue, stack);
      
      return sum;   
   }
}