import java.util.*;

public class A1
{
    
    /**
        This method constructs an array of integers of a given size,
        with random elements ranging uniformly from 0 up to but not including 
        a given integer value.  It assumes that the size is nonnegative.
        @param size the given size
        @param r a Random object to generate the array elements.
        @param bound the given integer value  
        @return the constructed array
     */
       
    public static int[] buildRandomArray(int size, Random r, int bound)   {
      int[] a = new int[size];        
      for (int i=0; i<size; i++)
          a[i] = r.nextInt(bound);
      return a;                                                           }
     
    
    /**
        This method constructs a sorted array of integers of a given size,
        with consecutive elements differing by an increment varying randomly
        and uniformly from 0 up to but not including a given maximum increment.
        It assumes that the size is positive.
        @param size the given size
        @param r a Random object to generate the array increments.
        @param maxIncrement the given maximum increment 
        @return the sorted array
     */
    
    public static int[] buildRandomSortedArray(int size, Random r, 
                                                int maxIncrement)         {
      int[] a = new int[size];
      a[0] = r.nextInt(maxIncrement);
      for (int i=1; i<size; i++)
          a[i] = a[i-1] + r.nextInt(maxIncrement);
      return a;                                                           }
        

    /**
        This method uses a DuplicateTester object to determine whether 
        an array of integers is sorted.
        @param a the array to be tested
        @param d the DuplicateTester object
        @return <code>true</code> if the array is sorted, 
                and <code>false</code> otherwise
    */
    
    public static boolean hasDuplicates(int[] a, DuplicateTester d)       {
      if (d.isSorted(a))                                    {
          System.out.print("testing sorted array -- ");
          return d.hasDuplicatesSorted(a);                  }
      else                                                  {
          System.out.print("testing unsorted array -- ");
          return d.hasDuplicatesUnsorted(a);                }             }
          
    
    /**
        A test program for the Duplicate Tester class
     */
    
    public static void main(String args[])                  {
      DuplicateTester dt = new DuplicateTester();
      Random r = new Random(1);
      int[] a;
      a = buildRandomArray(1,r,100);
      System.out.println(" " + hasDuplicates(a,dt));      
      a = buildRandomArray(25,r,100);
      System.out.println(" " + hasDuplicates(a,dt));      
      a = buildRandomArray(25,r,1000);
      System.out.println(" " + hasDuplicates(a,dt));      
      a = buildRandomArray(25,r,10000);
      System.out.println(" " + hasDuplicates(a,dt));        
      a = buildRandomSortedArray(1,r,10);
      System.out.println(" " + hasDuplicates(a,dt));      
      a = buildRandomSortedArray(25,r,100);
      System.out.println(" " + hasDuplicates(a,dt));      
      a = buildRandomSortedArray(250,r,100);
      System.out.println(" " + hasDuplicates(a,dt));      
      a = buildRandomSortedArray(2500,r,100);
      System.out.println(" " + hasDuplicates(a,dt));        }
    
}