import java.util.Scanner;
import java.io.File;
import java.io.IOException;
import java.util.*;



public class Assign1Soln
{

    // Read a sequence of integers from a file into an array.
    // The first integer of the file tells the number n of integers in the
    // sequence.  The remaining n integers in the file are the sequence.
    // Each integer in the file is separated from the next by one
    // or more white-space characters (spaces or newlines).
    // The method returns an array that is allocated to have size n
    // and holds the n-integer sequence.  If there is an IO exception,
    // which can happen if the file doesn't exist or doesn't adhere
    // to the formatting requirements, the method prints an error message
    // and halts the program with status 1.
    public static int[] readIn(String fName) {
       int[] res = {};
       try {
           Scanner scan = new Scanner(new File(fName));
           int size;
           size = scan.nextInt();
           res = new int[size];
           // loop through numbers in input file and sum them
           for(int i=0; i<size; i++) {
               res[i] = scan.nextInt();
           }
       } catch (IOException E) {
           System.out.println("readIn: IOException!!");
           System.exit(1);
       }
       return res;
    }
	
	
    // Menu option X.  SOLVED PROBLEM:  Print out elements A[0..size]
    // Precondition:  0 < size <= A.length;
    // Postcondition:  A[0], A[1], ..., A[size-1] have been printed
    //   to one line of output, each followed by a space.  The line
    //   is followed by a newline.
    public static void printArr(int A[], int size)
    {

        int counter = 0;  

        while (counter < size)
        {
            System.out.print(A[counter] + " ");  
            counter++;   
        }

        System.out.println();  // The newline we're supposed to put at the
                               //  end of the output
    }

    // Menu option 3.  Use a for loop to print out the contents of 
    // an array
    // Print out A[0] through A[size-1] using a for loop.

    // Precondition:  0 < size <= A.length;
    // Postcondition:  A[0], A[1], ..., A[size-1] have been printed
    //   to one line of output, each followed by a space.  The line
    //   is followed by a newline.
    public static void printArrFor(int A[], int size)
    {
        for (int counter = 0; counter < size; counter++)
            System.out.print(A[counter] + " ");  

        System.out.println();
    }

    //  Menu option 4.  Use a do-while loop to print out the contents of 
    //   an array 
    // Print out A[0] through A[size-1] using a do-while loop.

    // Precondition:  0 < size <= A.length
    // Postcondition:  A[0], A[1], ..., A[size-1] have been printed
    //   to one line of output, each followed by a space.  The line
    //   is followed by a newline.
    public static void printArrDo (int A[], int size)
    {
        int counter = 0;
        do
        {
           System.out.print(A[counter] + " ");
           counter++;
        } while (counter < size);
        System.out.println();
    }

    // Menu option 5.  Find the maximum value in an array of integers.
    // Precondition:  0 < size <= A.length;
    // Postcondition:  The method has returned the maximum
    //   value that occurs in A[0..size-1]
    public static int arrayMax(int A[], int size)
    {
       int soFar = A[0];
       for (int counter = 1; counter < size; counter++)
           if (A[counter] > soFar) soFar = A[counter];
       return soFar;
    }

    // Menu option 6.  Find the sum of a section of an array.
    // precondition:  0 <= i <= j < A.length;
    // postcondition:  The sum of elements in A[i..j] has been returned
    public static int arraySectSum(int [] A, int i, int j)
    {
       int sum=0;
       for (int counter = i; counter<=j; counter++)
         sum = sum + A[counter];
       return sum;
    }

    // Menu option 7.  Swap 2 elements of an array. 
    // Preconditions:  0 <= i <= j < A.length
    // Postconditions:  the contents of A[i] and A[j] have been
    //  swapped
    public static void swap (int A[], int i, int j)
    {
       int temp = A[i];
       A[i] = A[j];
       A[j] = temp;
    }


    // Menu option 8.  Reverse a section of an array.
    // preconditions:  0 <= i <= j < A.length;
    // postconditions:  The order of elements in A[i..j] has been reversed
    //
    // Hint:  You should make calls to 'swap' from within the method.
    public static void arrSectReverse (int [] A, int i, int j)
    {
        int counter1 = i;
        int counter2 = j;
        while (counter1 < counter2)
          swap(A, counter1++, counter2--);
        return;
    }

    // Menu option 9.  Concatinate 2 arrays.
    // Preconditions:  0 < size1 <= A1.length; 0 < size2 <= A2.length
    // Postcondition:  An array of length size1 + size2 has been allocated,
    //   Its contents are the concatenation A1[0..size1-1]A2[0..size2-1],
    //   and a reference to this array has been returned
    public static int [] concatArrs(int [] A1, int size1, int[] A2, int size2)
    {
        int size = size1 + size2;   //size of the new array
        int[] A = new int[size];  // Allocate new array A

        // copy A1 into first part
        for (int counter=0; counter<size1; counter++)  
          A[counter] = A1[counter];

        // copy A2 into second part
        for (int counter=0; counter<size2; counter++)  
         A[counter + size1] = A2[counter];
        return A;
    }

    // Menu option 10.  Interleave 2 arrays.
    // Preconditions:  0 < size1 <= A1.length; 0 < size2 <= A2.length
    // Postcondition:  An array of length size1 + size2 has been allocated,
    //   If size1 == size2, its contents are 
    //   (A1[0],A2[0],A1[1],A2[1], ..., A1[size1-1],A2[size1-1])
    //   If size1 < size2, its contents are 
    //     (A1[0],A2[0],A1[1],A2[1], ..., A1[size1-1],A2[size1-1], 
    //     A2[size1],A2[size1+1], ..., A2[size2-1])
    //   If size2 < size1, its contents are
    //     (A1[0],A2[0],A1[1],A2[1], ..., A1[size2-1],A2[size2-1], 
    //     A1[size2],A1[size2+1], ..., A1[size1-1])
    //   A reference to this array has been returned
    public static int [] interleave(int [] A1, int size1, int[] A2, int size2)
    {
        int[] A3 = new int[size1 + size2];
        int counter1 = 0;  // index into A1
        int counter2 = 0;  // index into A2
        int counter3 = 0;  // index into A3

        // While you haven't run off end of A1 or A2
        while (counter1 < size1 && counter2 < size2)
        {
           A3[counter3++] = A1[counter1++];
           A3[counter3++] = A2[counter2++];
        }

        // Copy any remaining elements from end of A1 ..
        while (counter1 < size1)
            A3[counter3++] = A1[counter1++];
        //
        // Copy any remaining elements from end of A2 ..
        while (counter2 < size2)
            A3[counter3++] = A2[counter2++];

        return A3;
    }

    // Menu option 11.  Merge 2 arrays
    // preconditions:  0 < size1 <= A1.length; 0 < size2 <= A2.length;
    //   A1[0..size1-1] is in sorted order
    //   A2[0..size2-1] is in sorted order
    // Postconditions:  An array of length size1 + size2 has been allocated,
    //   its contents are the elements of A1[0..size1-1] and A2[0..size2-1]
    //   in sorted order.  A reference to this array has been returned.
    public static int [] merge(int [] A1, int size1, int [] A2, int size2)
    {
        int[] A3 = new int[size1 + size2];

        int counter1 = 0;  // index into A1
        int counter2 = 0;  // index into A2
        int counter3 = 0;  // index into A3

        while (counter1 < size1 && counter2 < size2)
           if (A1[counter1] < A2[counter2])
               A3[counter3++] = A1[counter1++];
           else
               A3[counter3++] = A2[counter2++];

        // Copy any remaining elements from end of A1 ..
        while (counter1 < size1)
            A3[counter3++] = A1[counter1++];
       
        // Copy any remaining elements from end of A2 ..
        while (counter2 < size2)
            A3[counter3++] = A2[counter2++];
        
        return A3;
    }

    // Menu option 12.  Print out the ordered pairs.
    // preconditions:  0 < size <= A.length and the elements of A[0..size-1]
    //  are distinct (no two are the same)
    // postconditions:  All ordered pairs from A[0..size-1] of the form 
    //   (A[i],A[j]) have been printed out, one per line, enclosed in 
    //    parentheses, separated by commas.  No other characters should
    //    appear on the line.  The number of pairs printed 
    //    has been counted and this count has been returned.
    public static int orderedPairs(int [] A, int size)
    {
        int count = 0; //  Variable to hold the count of pairs
        for (int i=0; i<size; i++){
          for (int j=0; j<size; j++){
              System.out.println("(" + A[i] + "," + A[j] + ")");
              count++;
          }
        }
        return count;
    }
 
    // Menu option 13.  Print out the ordered triples.
    // preconditions: 0 < size <= A.length and the elements of A[0..size-1]
    //   are all distinct
    // postconditions: All ordered triples from A[0..size-1] of the form 
    //   (A[i],A[j],A[k]) have been printed out, one per line, enclosed 
    //   in parentheses, separated by commas.  No other characters should
    //   appear on the line.  The number of these triples 
    //   has been counted and this count has been returned.
    public static int orderedTriples(int [] A, int size)
    {
        int count = 0;  //  Variable to hold the count of triples
        for (int i=0; i<size; i++){
          for (int j=0; j<size; j++){
              for (int k=0; k<size; k++){
                  System.out.println("(" + A[i] + "," + A[j] + "," + A[k] + ")");
                  count++;
                }
            }
        }
        return count;
    }

    // Menu option 14.  Print out the ordered pairs.
    // preconditions:  0 < size <= A.length and the elements of A[0..size-1]
    //   are all distinct
    // postconditions:  All ordered pairs from A[0..size-1] of the form 
    //   (A[i],A[j]), where A[i] != A[j] have been printed out, one per 
    //   line, enclosed in parentheses, separated by commas.  No other
    //   characters should appear on the line.  The number of pairs 
    //   printed out has been counted and the count has been returned.
    public static int orderedPairsNoRepeats(int [] A, int size)
    {
        int count = 0; //  Variable to hold the count of pairs
        for (int i=0; i<size; i++){
          for (int j=0; j<size; j++){
            if (i!=j){
              System.out.println("(" + A[i] + "," + A[j] + ")");
              count++;
            }
          }
        }
        return count;
    }
 
    // Menu option 15.  Print out the ordered triples.
    // preconditions: 0 < size <= A.length and the elements of A[0..size-1]
    //    are distinct
    // postconditions: All ordered triples from A[0..size-1] of the form 
    // (A[i],A[j],A[k]), where no two of A[i], A[j], A[k] are equal, have 
    //   been printed out, one per line, enclosed in parentheses, separated
    //   by commas.  No other characters should appear on the line.
    //   The number of triples printed has been counted and the count 
    //   has been returned 
    public static int orderedTriplesNoRepeats(int [] A, int size)
    {
        int count = 0;  // Variable to hold the count of triples
        for (int i=0; i<size; i++){
          for (int j=0; j<size; j++)
            if (i!=j) {
              for (int k=0; k<size; k++)
                if (i!=k && j!=k) {
                  System.out.println("(" + A[i] + "," + A[j] + "," + A[k] + ")");
                  count++;
                }
            }
        }
        return count;
    }

    // Menu option 16.  Print out the subsets of size 2.
    // preconditions: 0 < size <= A.length and the elements of A[0..size-1]
    //    are distinct
    // postconditions:  All subsets of size two of A[0..size-1] have been 
    //   printed out once, one per line, enclosed in curly braces, separated
    //   by commas.  No other characters should appear on the line.
    //   The order in which they must appear as {A[i],A[j]} 
    //   between the curly braces is dictated by i < j.  The count of the 
    //   number of subsets printed has been returned.
    public static int twoSubsets(int [] A, int size)
    {
        int count = 0;  // Variable to hold the count of number of subsets
        for (int i=0; i<size; i++){
          for (int j=i+1; j<size; j++){
            System.out.println("{" + A[i] + "," + A[j] + "}");
            count++;
          }
        }
        return count;
    }

    // Menu option 17.  Print out the subsets of size 3
    // preconditions: 0 < size <= A.length and the elements of A[0..size-1]
    //    are distinct
    // postconditions:  All subsets of size 3 of elements have been printed
    //   out once, one per line, enclosed in curly braces, separated by
    //   commas, and counted.  The order in which they must appear as 
    //   {A[i], A[j], A[k]} in the curly braces is dictated by i < j < k.  
    //   The count of the number of subsets printed has been returned.
    public static int threeSubsets(int [] A, int size)
    {
        int count = 0;  // Variable to hold the count of number of subsets
        for (int i=0; i<size; i++){
          for (int j=i+1; j<size; j++){
            for (int k=j+1; k<size; k++){
              System.out.println("{" + A[i] + "," + A[j] + "," + A[k] + "}");
              count++;
            }
          }
        }
        return count;
    }
    // Menu option 18. Create a 2-D array.
    // precondition:  dimension >= 1
    // postcondition:  A 2-d dimension x dimension array has been
    //   allocated.  For each row i from 0 to dimension-1, 
    //   column j from 0 to dimension -1, the element in row i,
    //   column j has been filled in with the product i*j
    //   A reference to this array has been returned
    public static int [] [] multTable(int dimension)
    {
        int[][] A = new int[dimension][dimension];
        for (int i=0; i<dimension; i++)
          for (int j=0; j<dimension; j++)
            A[i][j]=i*j;
        return A;
    }

    // Menu option 18.  Print the 2-D array.
    // preconditions:  0 < rows <= A.length.  For each row i from
    //   0 through rows-1, 0 < columns <= A[i].length
    // postcondition: print A for the number of rows and columns
    //   specified.  Put each row on a seperate line.  In each row,
    //   put a space between each element.
    public static void print2dArr(int [] [] A, int rows, int columns)
    {
        for (int i=0; i<rows; i++){
          for (int j=0; j<columns; j++)
            System.out.print(A[i][j] + " ");
          System.out.println();
        }
    }

    
    public static void main(String[] args)
    {
         // The following line creates a Scanner object called Input whose 
         // methods hand us inputs that the user types into the keyboard.   For 
         // instance, consider the following line of code that we can
         // now put in our program:
     
         // int i = Input.nextInt();

         // The line scans through zero or more spaces and newlines, followed by
         // an integer, and assigns the integer to i.
     
         // See pages 43-44, which includes a list of other methods, such 
         //  as nextDouble, that a scanner object has available.
        Scanner Input = new Scanner(System.in);

        int choice = -1; // Records the option number the user selected
                         //   from the menu
        int [] Array1;
        int arr1Size;
        int [] Array2;
        int arr2Size;
        int [] Array3;
        int arr3Size;
        System.out.println("The first element of the file should be the size n");
        System.out.println("The next n elements are the values that get filled");
        System.out.println("into the array\n\n");

        System.out.println("Name of file for Array1:  ");
        String filename = Input.next();
        System.out.print ("\n" + filename + "\n\n\n");
        Array1 = readIn(filename); 
        arr1Size = Array1.length;
        System.out.println("Name of file for Array2:  ");
        filename = Input.next();
        System.out.print ("\n" + filename + "\n\n\n");
        Array2 = readIn(filename); 
        arr2Size = Array2.length;
        do
        {
             System.out.println("\n ---------------------------------------");
             System.out.println("                MENU");
             System.out.println("0.  Exit");
             System.out.println("1.  Read a new set of values into Array1[]");
             System.out.println("2.  Read a new set of values into Array2[]");
             System.out.println("3.  printArrFor on Array1[]");
             System.out.println("4.  printArrDo on Array2[]");
             System.out.println("5.  'arrayMax' on Array1");
             System.out.println("6.  'arraySectSum' on Array1");
             System.out.println("7.  'swap' on Array1");
             System.out.println("8.  'arraySectReverse' on Array1");
             System.out.println("9.  'concatArrs' on Array1, Array2");
             System.out.println("10.  'interleaveArrs' on Array1, Array2");
             System.out.println("11.  'merge' on Array1, Array2");
             System.out.println("12.  'orderedPairs' on Array1");
             System.out.println("13.  'orderedTriples' on Array1");
             System.out.println("14.  'orderedPairsNoRepeats' on Array1");
             System.out.println("15.  'orderedTriplesNoRepeats' on Array1");
             System.out.println("16.  'twoSubsets' on Array1");
             System.out.println("17.  'threeSubsets' on Array1");
             System.out.println("18.  'multTable' and 'print2dArr'");
                          
             System.out.print("\n    Which? ");
             choice = Input.nextInt();
             System.out.println(choice);


             if (choice == 1){ 
               System.out.println("Name of file for Array1:  ");
               filename = Input.next();
               System.out.print ("\n" + filename + "\n\n\n");
               Array1 = readIn(filename); 
               arr1Size = Array1.length;
             }
             else if (choice == 2){
               System.out.println("Name of file for Array2:  ");
               filename = Input.next();
               System.out.print ("\n" + filename + "\n\n\n");
               Array2 = readIn(filename); 
               arr2Size = Array2.length;
             }
             else if (choice == 3)  
                 printArrFor(Array1, arr1Size); //change to call to printArrFor
             else if (choice == 4) 
                 printArrDo(Array2, arr2Size); // change to call to printArrDo
             else if (choice == 5)
                 System.out.println(arrayMax(Array1, arr1Size));
             else if (choice == 6){
                 System.out.println("Enter start index");
                 int start = Input.nextInt();
                 System.out.println("Enter end index");
                 int end = Input.nextInt();
                 System.out.println("Sum="+arraySectSum(Array1,start,end));
             }
             else if (choice == 7){
                 System.out.println("Enter first index");
                 int start = Input.nextInt();
                 System.out.println("Enter second index");
                 int end = Input.nextInt();
                 swap(Array1, start, end);
             }
             else if (choice == 8){
                 System.out.println("Enter start index");
                 int start = Input.nextInt();
                 System.out.println("Enter end index");
                 int end = Input.nextInt();
                 arrSectReverse(Array1,start,end);
             }
             else if (choice == 9)
                 printArrFor(concatArrs(Array1,arr1Size,Array2,arr2Size),arr1Size+arr2Size);
             else if (choice == 10)
                 printArrFor(interleave(Array1,arr1Size,Array2,arr2Size),arr1Size+arr2Size);
             else if (choice == 11)
                 printArrFor(merge(Array1,arr1Size,Array2,arr2Size),arr1Size+arr2Size);
             else if (choice == 12){
                 int count = orderedPairs(Array1, arr1Size);
                 System.out.println("Count="+count);
             }
             else if (choice == 13){
                 int count = orderedTriples(Array1, arr1Size);
                 System.out.println("Count="+count);
             }
             else if (choice == 14){
                 int count = orderedPairsNoRepeats(Array1, arr1Size);
                 System.out.println("Count="+count);
             }
             else if (choice == 15){
                 int count = orderedTriplesNoRepeats(Array1, arr1Size);
                 System.out.println("Count="+count);
             }
             else if (choice == 16){
                 int count = twoSubsets(Array1, arr1Size);
                 System.out.println("Count="+count);
             }
             else if (choice == 17){
                 int count = threeSubsets(Array1, arr1Size);
                 System.out.println("Count="+count);
             }
             else if (choice == 18){
                 System.out.println("Enter size");
                 int size = Input.nextInt();
                 int [][] table = multTable(size);
                 System.out.println("Enter rows");
                 int rows = Input.nextInt();
                 System.out.println("Enter columns");
                 int col = Input.nextInt();
                 print2dArr(table,rows,col);
             }
        } while (choice != 0);
    }
}