Question

1 Create a ThreeSum array method. in java and add comments, please

a - Call for sizes from 1000 to max size incrementing by 1000. Show execution time and result.

b- method ( Consistency analysis of the ThreeSum method. )For a given size repeat the computation a number of time. Show all results.

c- Analysis with repeats and increasing sizes.

Answer 1

Answer:

Note: For the three sum method it is not specified whether sum value must be 0 or any other value and also it is not specified the which type of integer values need to be stored in the array.

So, the below program is designed in such a way that sum value and range of values to be inserted into array are left to user. So, the user will be prompted for the values, depending the user choice, the program will compute the values of analysis.

Program code screen shot:

Sample Output:

Note: If need to perform the repeat operation on same size but with different array values, the place the arrayValues = generateRandomValues(miniRange, maxRange, size);

in the for loop while performing the repeat analysis.

Program Code to Copy:

// ThreeSum.java
import java.util.Scanner;

public class ThreeSum
{
   // Define the variables as static
   static int miniRange, maxRange, size, sum = 0;
   static long startTime, endTime, elapsedTime;
   static int startRange = 1000;
   static int endRange = 0;
   static Scanner input = new Scanner(System.in);
   static int numTimes = 0;
   static int arrayValues[] = null;

   // define a static method to generate random values
   // of the given range and size
   public static int[] generateRandomValues(int min, int max, int size)
   {
       // initialize the array
       int arrayVals[] = new int[size];

       // loop to populate the array
       for (int i = 0; i < size; i++)
       {
           // generate random number and populate
           arrayVals[i] = (int) (Math.random() * max) + min;
       }

       // return the new array
       return arrayVals;
   }

   // define a static method to compute the threeSum and
   // return the count of how many sum of the three values
   // have been equivalent to the given sum
   public static int threeSumMethod(int array[], int sum)
   {
       // store the length of the array
       int arrayLength = array.length;

       // initialize the counter
       int count = 0;

       // loop to go through all the elements
       for (int i = 0; i < arrayLength; i++)
       {
           // loop to go through i+1 to rest of the elements
           for (int j = i + 1; j < arrayLength; j++)
           {
               // loop to go through (i+1)+1 = j + 1
               // to rest of the elements
               for (int k = j + 1; k < arrayLength; k++)
               {
                   // condition to check the sum of the array
                   // values at i, j and k are equivalent to
                   // sum
                   if (array[i] + array[j] + array[k] == sum)
                   {
                       // increment the count
                       count++;
                   }
               }
           }
       }

       // return the count value
       return count;
   }

   // define a static method to do the analysis on the three sum
   // on the given array
   public static void computeAnalysis_EachSize(int[] array, int sum)
   {
       // get the start time
       long startTime = System.currentTimeMillis();

       // call the threeSumMethod
       int value = threeSumMethod(array, sum);

       // get the end time
       long endTime = System.currentTimeMillis();

       // compute the elapsed time
       long elapsedTime = endTime - startTime;

       // display the size of array, time taken and count value
       System.out.printf("%8d %15d %18d\n", array.length, elapsedTime, +value);
   }

   // define a static method to compute the repetitions analysis
   public static void computeRepetitions(int arrayLength, int sum,
           int numTimes)
   {
       // initialize the array
       arrayValues = new int[arrayLength];

       // generate the random values
       arrayValues = generateRandomValues(miniRange, maxRange, size);

       // compute the three sum analysis for numTimes
       for (int i = 0; i < numTimes; i++)
       {
           computeAnalysis_EachSize(arrayValues, sum);
       }
   }

   // define a static method to compute the analysis on different
   // sizes of array
   public static void computeAnalysis()
   {
       // loop the array from startingRange 1000 to maximumRange
       // by incrementing the iteration value by 1000
       for (int i = startRange; i <= endRange; i = i + 1000)
       {
           // set the size value with i
           size = i;

           // initialize the array
           arrayValues = new int[size];

           // generate the random numbers
           arrayValues = generateRandomValues(miniRange, maxRange, size);

           // call the computeAnalysis_EachSize() to analyze the
           // ThreeSum method on given array size and sum value
           computeAnalysis_EachSize(arrayValues, sum);
       }
   }

   // define a static method to compute repeats and compute the
   // analysis
   public static void repeatsComputeAnalysis(int numberTimes)
   {
       for (int i = startRange; i <= endRange; i = i + 1000)
       {
           // set the size value with i
           size = i;

           // initialize the array
           arrayValues = new int[size];

           // generate the random numbers
           arrayValues = generateRandomValues(miniRange, maxRange, size);

           // call the cmputeRepetitions()
           computeRepetitions(size, sum, numberTimes);
           System.out.println();
       }
   }

   // define a static method to retrieve values from the user
   // while performing the Analysis for different array sizes
   public static void getComputeAnalysisValues()
   {
       // prompt and read the maximum range of array size to be looped
       System.out.print("Enter the maximum range to execute the loop: ");
       endRange = input.nextInt();

       // prompt and read the maximum and minimum range of the values
       // to be store din array
       System.out.println(
               "\nEnter elements range to be inserted into the array: ");
       System.out.print("\tMinimum value: ");
       miniRange = input.nextInt();
       System.out.print("\tMaximum value: ");
       maxRange = input.nextInt();

       // prompt and read the sum value to be checked in three sum method
       System.out.print("Enter the sum value: ");
       sum = input.nextInt();
   }

   // define a static method to retrieve values from the user
   // while performing analysis of repetitions
   public static void getRepeatAnalysisValues()
   {
       // prompt for the size of array
       System.out.print("\nEnter the size of array: ");
       size = input.nextInt();

       // prompt for number of times to be repeated
       System.out.print("Number of times to repeat the loop: ");
       numTimes = input.nextInt();

       // prompt and read the sum value to be checked in three sum method
       System.out.print("Enter the sum value: ");
       sum = input.nextInt();
   }

   // main method of execution
   public static void main(String args[])
   {
       // steps to perform the part a
       System.out.println("\t\t-----------Part a -----------\n");

       // get the information to perform the analysis of three sum
       // of different sizes
       getComputeAnalysisValues();

       // display the header
       System.out.println("\nSize of Array \t Time Taken \t Count Value");

       // call the method computeAnalysis()
       computeAnalysis();

       // steps to perform the part b
       System.out.println("\n\t\t-----------Part b -----------");

       // get the information to perform the repetitions of three sum
       // on single size
       getRepeatAnalysisValues();

       // display the header
       System.out.println("\nSize of Array \t Time Taken \t Count Value");

       // call the method computeRepetitions()
       computeRepetitions(size, sum, numTimes);

       // steps to perform the part c
       System.out.println("\n\t\t-----------Part c -----------\n");

       // get the information to perform the analysis of three sum
       // of different sizes
       getComputeAnalysisValues();

       // prompt for number of times to be repeated for each size
       // of array
       System.out.print("Number of times to repeat the loop: ");
       numTimes = input.nextInt();

       // display the header
       System.out.println("\nSize of Array \t Time Taken \t Count Value");

       // call the method repeatsComputeAnalysis()
       repeatsComputeAnalysis(numTimes);
   }
}