Question

You must implement the following methods using Java's Stack Object.

/**
   * Computes the factorial of n
   * @param n-integer value greater or equal to 0
   * @return n!
   */
   public static int factorial( int n ) { }

/**
   * Computes the nth term of the Fibonacci sequence
   * @param n -nth term to find
   * @return -the nth term
   */
   public static int fibonacci( int n ) {}

   /**
   * Find the min value using the comparable interface of the elements found in theStack
   * @param theStack - the stack of objects to search
   * @return the min value
   */
   public static <T extends Comparable< T> > T min( Stack< T > theStack ) {}

Answer 1

        
    /**
     * Computes the factorial of n
     * 
     * @param n-integer value greater or equal to 0
     * @return n!
     */
    public static int factorial(int n) {
        Stack<Integer> aux = new Stack<>();
        
        while(n >= 1) {
            aux.push(n--);
        }
        
        int value = 1;
        while(! aux.isEmpty()) {
            value *= aux.pop();
        }
        
        return value;
    }

    /**
     * Computes the nth term of the Fibonacci sequence
     * 
     * @param n -nth term to find
     * @return -the nth term
     */
    public static int fibonacci(int n) {
        Stack<Integer> aux = new Stack<>();
        aux.push(0);
        aux.push(1);
        
        int secondLast = 0;
        for(int i=2; i<n; i++) {
            int last = aux.peek();
            aux.push(last + secondLast);
            secondLast = last;
        }

        return aux.pop() + aux.pop();
    }

    /**
     * Find the min value using the comparable interface of the elements found in
     * theStack
     * 
     * @param theStack - the stack of objects to search
     * @return the min value
     */
    public static <T extends Comparable<T>> T min(Stack<T> theStack) {
        if(theStack.isEmpty()) {
            return null;
        }
        T minEle = theStack.peek();
        Stack<T> aux = new Stack<>();
        while(!theStack.isEmpty()) {
            T tmp = theStack.pop();
            if(tmp.compareTo(minEle) < 0) {
                minEle = tmp;
            }
            aux.push(tmp);
        }
        
        // restore/
        while(!aux.isEmpty()) {
            theStack.push(aux.pop());
        }
        
        return minEle;
    }