(a) i goes from 1 to n and for each i, j goes from 1 to n. Hence total number of steps = n*n. Hence, complexity is O(n2)

(b) The number of steps is 1 + 2 + 3 + ... + n = n*(n+1)/2 = O(n2)

(c) i = 1, 2, 4, 8, .. , [log2(n)], where [.] = GIF and j = 1, 2, .., n. Hence number of steps, in the worst case are log2(n)*n, i.e. the complexity is O(n*log2(n))

(d) i = 1, 2, ..., [log2(n)] and j = 1,2, .., i. Number of steps is 1 + 2 + 4 + 8 + .. + log2(n). Hence complexity is O(log2(n)2)
-----------------------------------------------------------------------------------------------------------------------------
import java.util.List;
import java.util.ArrayList;

public class listRem {

   static void deletePositions(List<Character> L1, List<Integer> L2) {
       int eleRe = 0;
       for (Integer L : L2) {
           if (L > L1.size()) {
               continue;
           } else {
               L1.remove(L - 1 - eleRe);
               eleRe++;
           }
       }

   }

   public static void main(String[] args) {
       List<Character> al = new ArrayList<>();
       List<Integer> al1 = new ArrayList<>();
       al.add('A');
       al.add('B');
       al.add('C');
       al.add('D');
       al.add('E');
       al1.add(2);
       al1.add(4);
       al1.add(8);

       deletePositions(al, al1);

       System.out.println("Modified ArrayList : " + al);
   }
}
----------------------------------------------------------------------------------------------
// We will need 2 Queues to implement a Stack...
import java.util.*;

class GfG {

    static class StackQ<T> {
        // Two inbuilt queues
        Queue<T> queue1 = new LinkedList<>();
        Queue<T> queue2 = new LinkedList<>();

        // To maintain current number of
        // elements
        static int current_size;

        StackQ()
        {
            // initialise the current size to 0
            current_size = 0;
        }

        void push(T x)
        {
            current_size++;

            // Push x first in empty q2
            queue2.add(x);

            // Push all the remaining
            // elements in q1 to q2.
            while (!this.queue1.isEmpty()) {
                queue2.add(queue1.peek());
                queue1.remove();
            }

            // swap the names of two queues
            Queue<T> q = queue1;
            queue1 = queue2;
            queue2 = q;
        }

        void pop()
        {
            // if no elements are there in q1
            if (this.queue1.isEmpty())
                return;
            queue1.remove();
            current_size--;
        }

        T topEl()
        {
            if (this.queue1.isEmpty())
                return null;
            return this.queue1.peek();
        }

        int size()
        {
            return current_size;
        }
    }

    // driver code to test the class
    public static void main(String[] args)
    {
        StackQ<Integer> myStack = new StackQ<>();
        myStack.push(1);
        myStack.push(2);
        myStack.push(3);

        System.out.println("current size: " + myStack.size());
        System.out.println("The Stack Elements are:-");
        System.out.println(myStack.topEl());
        myStack.pop();
        System.out.println(myStack.topEl());
        myStack.pop();
        System.out.println(myStack.topEl());

        System.out.println("current size: " + myStack.size());
    }
}
--------------------------------------------------------------------------------
a)Recursive program for finding Binomial Coefficient in JAVA:

import java.util.*;
public class SolutionA {
public static void main(String args[])
{
   Scanner sc=new Scanner(System.in);
   int n=sc.nextInt();
   int k=sc.nextInt();
   sc.close();
   System.out.println(binomialCoefficientRecursive(n,k));

}
public static long binomialCoefficientRecursive(int n, int k)
{ if(k==0 || k==n)
   return 1;
return binomialCoefficientRecursive(n-1,k-1)+binomialCoefficientRecursive(n-1,k);


}
}

1) The computation is too long for C(40,20) and C(50,25), but it is working fine for C(30,15) with normal computational time.

b)Iterative program for finding Binomial Coefficient in JAVA:

import java.util.Scanner;
public class SolutionB {
   static long a=1,l=1,x;
public static void main(String args[])
{
   Scanner sc=new Scanner(System.in);
   int n=sc.nextInt();
   int k=sc.nextInt();
   sc.close();
   System.out.println(binomialCoefficientIterative(n,k));

}
public static long binomialCoefficientIterative(int n, int k)
{

   for(int i=k;i>=1;i--)
   {
   a=a*n;
   n=n-1;
   l=l*i;

   }
   x=a/l;
   return x;

}
}

The recursive code is effectively working fine for all the inputs whereas the iterative code is working fine for smaller inputs only.