Question

Execute your program like this: C:\> java Lab4 10000ints.txt 172822words.txt
Be sure to put the ints filename before the words filename. The starter file will be expecting them in that order.
Lab#4's main method is completely written. Do not modify main. Just fill in the methods. Main will load a large arrays of int, and then load a large array of Strings. As usual the read loops for each file will be calling a resize method as needed. Once the arrays are loaded, each array will be tested for the presence of duplicates via calls to indexOfFirstDuplicate(). Do not do any trim operation.
Here are the rules:
       In your methods that look for the first occurrence of a duplicate in each array, you must sort the arrays before looking for the dupe. Do not search the array for the dupe until it is sorted. We require this because an unsorted array would require a quadratic algorithm (N squared via nested loops). If you sort you array first you will only incur an O(n*Log2n) cost for the sort with an additional O(n) for the search. This is the best that can be done without using a technology such as hashing which you will use for your next lab.

Inside your method to find the dupe you must sort the array first.

Do not define/use any new type or data structure that we have not covered yet.

Your traversal of the array looking for the dupe should require no more than one pass.

Be as efficient as you can without breaking rule #2.

Given 10,000ints.txt & 172,822words.txt

Program given to start with
/* Lab4.java  Reads two files into two arrays then checks both arrays for dupes */

import java.io.*;
import java.util.*;

public class Lab4
{
        static final int INITIAL_CAPACITY = 10;
        static final int NOT_FOUND = -1; // indexOfFirstDupe returns this value if no dupes found
        public static void main (String[] args) throws Exception
        {
                // ALWAYS TEST FIRST TO VERIFY USER PUT REQUIRED INPUT FILE NAME ON THE COMMAND LINE
                if (args.length < 1 )
                {
                        System.out.println("\nusage: C:\\> java Lab4 <numbers file> <words filename>\n\n"); // i.e. C:\> java Lab4 10000ints.txt 172822words.txt
                        System.exit(0);
                }

                String[] wordList = new String[INITIAL_CAPACITY];
                int[] intList  =  new int[INITIAL_CAPACITY];
                int wordCount = 0, intCount=0;

                Scanner intFile = new Scanner( new File(args[0]) );
                BufferedReader wordFile = new BufferedReader( new FileReader(args[1]) );

                // P R O C E S S   I N T   F I L E 
                while ( intFile.hasNextInt() ) // i.e. while there are more ints in the file
                {       if ( intCount == intList.length ) 
                                intList = upSizeArr( intList );
                        intList[intCount++] = intFile.nextInt();
                } //END WHILE intFile
                intFile.close(); 
                System.out.format( "%s loaded into intList array. size=%d, count=%d\n",args[0],intList.length,intCount );
                int dupeIndex = indexOfFirstDupe( intList, intCount );
                if ( dupeIndex == NOT_FOUND )
                        System.out.format("No duplicate values found in intList\n");
                else
                        System.out.format("First duplicate value in intList found at index %d\n",dupeIndex);


                // P R O C E S S   S T R I N G    F I L E
                while ( wordFile.ready() ) // i.e. while there is another line (word) in the file
                {       if ( wordCount == wordList.length ) 
                                wordList = upSizeArr( wordList );
                        wordList[wordCount++] = wordFile.readLine();
                } //END WHILE wordFile
                wordFile.close(); 
                System.out.format( "%s loaded into word array. size=%d, count=%d\n",args[1],wordList.length,wordCount );
                dupeIndex = indexOfFirstDupe( wordList, wordCount );
                if ( dupeIndex == NOT_FOUND )
                        System.out.format("No duplicate values found in wordList\n");
                else
                        System.out.format("First duplicate value in wordList found at index %d\n",dupeIndex);

        } // END MAIN

        //##################################################################################################
        // FYI. Methods that don't say private are by default, private.

        // copy/adapt your working code from lab3 || project3
        static String[] upSizeArr( String[] fullArr )
        {
                /* Y O U R  C O D E   H E R E */
                return null; // just to make it compile

        }
        // copy/adapt your working code from lab3 || project3
        static int[] upSizeArr( int[] fullArr )
        {
                /* Y O U R  C O D E   H E R E */
                return null; // just to make it compile
        }

        // use Arrays.sort() before scanning for dupe
        static int indexOfFirstDupe( int[] arr, int count )
        {               
                /* Y O U R  C O D E   H E R E */
                return NOT_FOUND; // just to make it compile
        }

        // use Array.sort() before scanning for dupe
        static int indexOfFirstDupe( String[] arr, int count )
        {               /* Y O U R  C O D E   H E R E */
                return NOT_FOUND; // just to make it compile
        }

} // END CLASS LAB#4

Answer 1

output:

intput Files:

1).10000ints.txt :

8
2
3
3
4
5
1
6
9
3
5
14

2). 172822words.txt​

ashd
sfdhjf
fnjgf
yreuir
cnjcnxc
ndjnhh
vfjfjvnjc
njchbdnhc
ashj
dbhfgyur
hjdjkgfj
jhruyj
fbdhbcnnc
mjfdjfjd
jfjhgru
zzhmfdh
fjkdf
dhsjs
fng

Program:

import java.io.*;
import java.util.*;

public class Lab4
{
static final int INITIAL_CAPACITY = 10;
static final int NOT_FOUND = -1; // indexOfFirstDupe returns this value if no dupes found
public static void main (String[] args) throws Exception
{
// ALWAYS TEST FIRST TO VERIFY USER PUT REQUIRED INPUT FILE NAME ON THE COMMAND LINE
if (args.length < 1 )
{
System.out.println("\nusage: C:\\> java Lab4 <numbers file> <words filename>\n\n"); // i.e. C:\> java Lab4 10000ints.txt 172822words.txt
System.exit(0);
}

String[] wordList = new String[INITIAL_CAPACITY];
int[] intList = new int[INITIAL_CAPACITY];
int wordCount = 0, intCount=0;

Scanner intFile = new Scanner( new File(args[0]) );
BufferedReader wordFile = new BufferedReader( new FileReader(args[1]) );

// P R O C E S S I N T F I L E
while ( intFile.hasNextInt() ) // i.e. while there are more ints in the file
{ if ( intCount == intList.length &&intCount>0 )
intList = upSizeArr( intList );
intList[intCount++] = intFile.nextInt();
} //END WHILE intFile
intFile.close();
System.out.format( "%s loaded into intList array. size=%d, count=%d\n",args[0],intList.length,intCount );
int dupeIndex = indexOfFirstDupe( intList, intCount );
if ( dupeIndex == NOT_FOUND )
System.out.format("No duplicate values found in intList\n");
else
System.out.format("First duplicate value in intList found at index %d\n",dupeIndex);

// P R O C E S S S T R I N G F I L E
while ( wordFile.ready() ) // i.e. while there is another line (word) in the file
{ if ( wordCount == wordList.length &&wordCount > 0 )
wordList = upSizeArr( wordList );
wordList[wordCount++] = wordFile.readLine();
} //END WHILE wordFile
wordFile.close();
System.out.format( "%s loaded into word array. size=%d, count=%d\n",args[1],wordList.length,wordCount );
dupeIndex = indexOfFirstDupe( wordList, wordCount );
if ( dupeIndex == NOT_FOUND )
System.out.format("No duplicate values found in wordList\n");
else
System.out.format("First duplicate value in wordList found at index %d\n",dupeIndex);

} // END MAIN

//##################################################################################################
// FYI. Methods that don't say private are by default, private.

// copy/adapt your working code from lab3 || project3
static String[] upSizeArr( String[] fullArr )
{
/* Y O U R C O D E H E R E */
String arr[]=new String[fullArr.length+5];
for(int i=0;i<fullArr.length;i++)
arr[i]=fullArr[i];
return arr; // just to make it compile

}
// copy/adapt your working code from lab3 || project3
static int[] upSizeArr( int[] fullArr )
{
/* Y O U R C O D E H E R E */
int arr[]=new int[fullArr.length+5];
for(int i=0;i<fullArr.length;i++)
arr[i]=fullArr[i];
return arr; // just to make it compile
}

// use Arrays.sort() before scanning for dupe
static int indexOfFirstDupe( int[] arr, int count )
{   
Arrays.sort(arr);              
int t;
/* Y O U R C O D E H E R E */
for(int i=0;i<count;i++)
{
t=arr[i];
for(int j=i+1;j<count;j++)
{
if(t==arr[j])
return j;
}
}
return NOT_FOUND; // just to make it compile
}

// use Array.sort() before scanning for dupe
static int indexOfFirstDupe( String[] arr, int count )
{   
//Arrays.sort(arr);// it is Arrays. sort() not for strings
  
String t;
/* Y O U R C O D E H E R E */
for(int i=0;i<count;i++)
{
t=arr[i];
for(int j=i+1;j<count;j++)
{
if(t.equals(arr[j]))
return j;
}
}
return NOT_FOUND; // just to make it compile
}

} // END CLASS LAB#4