Question

Trying to make an autocomplete java program that given a prefix, find all strings in set that start with said prefix, in descending weight order. I created the classes Term.java, BinarySearchDeluxe.java, and Autocomplete.java posted below. I believe Term.java is correct, but where you see "//?" needs added code. I will also list before the code, the descriptions of said methods with "//?" to explain their purpose. DO NOT add more import packages or change the main methods as that is all that is needed and serve as guidance to what the class does.

BinarySearchDeluxe.java methods:

Comments regarding firstIndexOf():

Method: static int firstIndexOf(Key[] a, Key key, Comparator comparator)

Description: the index of the first key in a[] that equals search key, or -1 if no key exists

Comments regarding lastIndexOf():

Method: static int lastIndexOf(Key[] a, Key key, Comparator comparator)

Description: the index of the last key in a[] that equals search key, or -1 if no key exists

Autocomplete.java

Method: Autocomplete(Term[] terms) … Description: Initialize data structure from given array of terms

Method: Term[] allMatches(String prefix) … Description: All terms that start with given prefix, by descending order of weight

Method: int numberOfMatches(String prefix) … Description: number of terms that start with given prefix

Below is what I have so far:

---Term.java--- For reference to BinarySearchDeluxe and Autocomplete methods

//remember do not change import packages for any files, not necessary

import java.util.Arrays;
import java.util.Comparator;
public class Term implements Comparable<Term> {
  
private final String query;
private final long weight;
  
// constructor
public Term(String query)
{
if(query == null) // check if query is null
throw new NullPointerException();
this.query = query;
weight = 0; // assign weight to 0
}
  
// constructor
public Term(String query, long weight) {
if(query == null) // check if query is null
throw new NullPointerException();
else if(weight < 0) // check if weight is negative
throw new IllegalArgumentException();
this.query = query;
this.weight = weight;
}
// return comparator that compares the terms by weight in descending order
public static Comparator<Term> byReverseWeightOrder() {
return new ReverseWeightOrder();
}
  
// class that compares 2 terms by weight in descending order
private static class ReverseWeightOrder implements Comparator<Term> {
  
public int compare(Term v, Term w) {
if(v.weight > w.weight)
return -1;
else if(v.weight < w.weight)
return 1;
else
return 0;
}
}
  
// return comparator that compares the query string in lexicographic order using only the first r characters
public static Comparator<Term> byPrefixOrder(int r) {
if(r < 0) // check that r >= 0
throw new IllegalArgumentException();
return new PrefixOrder(r);
}
  
// class that compares 2 terms by query using the first r characters in lexicographic order
private static class PrefixOrder implements Comparator<Term> {
  
private int r;
  
PrefixOrder(int r) {
this.r = r;
}
  
public int compare(Term v, Term w) {
return(v.query.substring(0,r).compareTo(w.query.substring(0,r)));
}
}
// return comparator that compares the query string in lexicographic order
public int compareTo(Term that) {
return(query.compareTo(that.query));
}
  
// return string representation of Term
public String toString() {
return weight + "\t" + query;
}
  
public static void main(String[] args) {
  
String filename = args[0];
int k = Integer.parseInt(args[1]);
In in = new In(filename);
int N = in.readInt();
Term[] terms = new Term[N];
for (int i = 0; i < N; i++) {
long weight = in.readLong();
in.readChar();
String query = in.readLine();
terms[i] = new Term(query.trim(), weight);
}
System.out.printf("Top %d by lexicographic order:\n", k);
Arrays.sort(terms);
for (int i = 0; i < k; i++) {
System.out.println(terms[i]);
}
System.out.printf("Top %d by reverse-weight order:\n", k);
Arrays.sort(terms, Term.byReverseWeightOrder());
for (int i = 0; i < k; i++) {
System.out.println(terms[i]);
}
}
}

---BinarySearchDeluxe.java---

import java.util.Arrays;
import java.util.Comparator;

// Implements binary search for clients that may want to know the index of
// either the first or last key in a (sorted) collection of keys.
public class BinarySearchDeluxe {
// The index of the first key in a[] that equals the search key,
// or -1 if no such key.
public static <Key> int firstIndexOf(Key[] a, Key key,
Comparator<Key> comparator) {
//? <-- Symbol for needs code
}

// The index of the last key in a[] that equals the search key,
// or -1 if no such key.
public static <Key> int lastIndexOf(Key[] a, Key key,
Comparator<Key> comparator) {
//?
}

// Test client. no changes needed
public static void main(String[] args) {
String filename = args[0];
String prefix = args[1];
In in = new In(filename);
int N = in.readInt();
Term[] terms = new Term[N];
for (int i = 0; i < N; i++) {
long weight = in.readLong();
in.readChar();
String query = in.readLine();
terms[i] = new Term(query.trim(), weight);
}
Arrays.sort(terms);
Term term = new Term(prefix);
Comparator<Term> prefixOrder = Term.byPrefixOrder(prefix.length());
int i = BinarySearchDeluxe.firstIndexOf(terms, term, prefixOrder);
int j = BinarySearchDeluxe.lastIndexOf(terms, term, prefixOrder);
int count = i == -1 && j == -1 ? 0 : j - i + 1;
System.out.println(count);
}
}

---Autocomplete.java---

import java.util.Arrays;
import java.util.Comparator;

// A data type that provides autocomplete functionality for a given set of
// string and weights, using Term and BinarySearchDeluxe.
public class Autocomplete {
private Term[] terms;

// Initialize the data structure from the given array of terms.
public Autocomplete(Term[] terms) {
//?
}

// All terms that start with the given prefix, in descending order of
// weight.
public Term[] allMatches(String prefix) {
//?
}

// The number of terms that start with the given prefix.
public int numberOfMatches(String prefix) {
//?
}

// no changes needed
public static void main(String[] args) throws IOException{
String filename = args[0];
In in = new In(filename);
int N = in.readInt();
Term[] terms = new Term[N];
for (int i = 0; i < N; i++) {
long weight = in.readLong();
in.readChar();
String query = in.readLine();
terms[i] = new Term(query.trim(), weight);
}
int k = Integer.parseInt(args[1]);
Autocomplete autocomplete = new Autocomplete(terms);
while (StdIn.hasNextLine()) {
String prefix = StdIn.readLine();
Term[] results = autocomplete.allMatches(prefix);
for (int i = 0; i < Math.min(k, results.length); i++) {
System.out.println(results[i]);
}
}
}
}

Answer 1

// Term.java

import java.util.Arrays;
import java.util.Comparator;

public class Term implements Comparable<Term> {
  
   private final String query;
   private final long weight;
  
   // constructor
   public Term(String query)
   {
       if(query == null) // check if query is null
           throw new NullPointerException();
      
       this.query = query;
       weight = 0;   // assign weight to 0
   }
  
   // constructor
   public Term(String query, long weight) {
       if(query == null) // check if query is null
           throw new NullPointerException();
       else if(weight < 0) // check if weight is negative
           throw new IllegalArgumentException();
       this.query = query;
       this.weight = weight;  
   }

   // return comparator that compares the terms by weight in descending order
   public static Comparator<Term> byReverseWeightOrder() {
       return new ReverseWeightOrder();
   }
  
   // class that compares 2 terms by weight in descending order
   private static class ReverseWeightOrder implements Comparator<Term> {
  
       public int compare(Term v, Term w) {
           if(v.weight > w.weight)
               return -1;
           else if(v.weight < w.weight)
               return 1;
           else
               return 0;
       }  
   }
  
   // return comparator that compares the query string in lexicographic order using only the first r characters
   public static Comparator<Term> byPrefixOrder(int r) {
       if(r < 0) // check that r >= 0
           throw new IllegalArgumentException();
       return new PrefixOrder(r);
   }
  
   // class that compares 2 terms by query using the first r characters in lexicographic order
   private static class PrefixOrder implements Comparator<Term> {
      
       private int r;
      
       PrefixOrder(int r) {
           this.r = r;
       }
      
       public int compare(Term v, Term w) {
           return(v.query.substring(0,r).compareTo(w.query.substring(0,r)));
       }
   }

   // return comparator that compares the query string in lexicographic order
   public int compareTo(Term that) {
       return(query.compareTo(that.query));
   }
  
   // return string representation of Term
   public String toString() {
       return weight + "\t" + query;
   }
  
   public static void main(String[] args) {
      
      
       String fname = args[0];
       int c = Integer.parseInt(args[1]);
       In in = new In(fname);
       int N = in.readInt();
       Term[] terms = new Term[N];
       for (int i = 0; i < N; i++) {
       long weight = in.readLong();
       in.readChar();
       String query = in.readLine();
       terms[i] = new Term(query.trim(), weight);
       }
       System.out.printf("Top %d by lexicographic order:\n", c);
       Arrays.sort(terms);
       for (int i = 0; i < c; i++) {
       System.out.println(terms[i]);
       }
       System.out.printf("Top %d by reverse-weight order:\n", c);
       Arrays.sort(terms, Term.byReverseWeightOrder());
       for (int i = 0; i < c; i++) {
       System.out.println(terms[i]);
       }
   }
}

//end of Term.java

// BinarySearchDeluxe.java

import java.util.Arrays;
import java.util.Comparator;

// Implements binary search for clients that may want to know the index of
// either the first or last key in a (sorted) collection of keys.

public class BinarySearchDeluxe {
  
   // The index of the first key in a[] that equals the search key,
   // or -1 if no such key.
   public static <Key> int firstIndexOf(Key[] a, Key key,
   Comparator<Key> comparator) {
      
       // loop over the array a
       for(int i=0;i<a.length;i++)
       {
           // if ith element of a = key using comparator, return i
           if(comparator.compare(a[i], key) == 0)
               return i;
       }
      
       return -1; // key not found
   }
  
   // The index of the last key in a[] that equals the search key,
   // or -1 if no such key.
   public static <Key> int lastIndexOf(Key[] a, Key key,
   Comparator<Key> comparator) {
       int index = -1;
       // loop over the array a
       for(int i=0;i<a.length;i++)
       {
           // if ith element of a = key using comparator, set index to i
           if(comparator.compare(a[i],key) == 0)
               index = i;
       }
      
       return index; // return index
   }

   // Test client. no changes needed
   public static void main(String[] args) {
      
      
       String filename = args[0];
       String prefix = args[1];
       In in = new In(filename);
       int N = in.readInt();
       Term[] terms = new Term[N];
       for (int i = 0; i < N; i++) {
           long weight = in.readLong();
           in.readChar();
           String query = in.readLine();
           terms[i] = new Term(query.trim(), weight);
       }
       Arrays.sort(terms);
       Term term = new Term(prefix);
       Comparator<Term> prefixOrder = Term.byPrefixOrder(prefix.length());
       int i = BinarySearchDeluxe.firstIndexOf(terms, term, prefixOrder);
       int j = BinarySearchDeluxe.lastIndexOf(terms, term, prefixOrder);
       int count = i == -1 && j == -1 ? 0 : j - i + 1;
       System.out.println(count);
      
   }

}

//end of BinarySearchDeluxe.java

// Autocomplete.java

import java.util.Arrays;
import java.util.Comparator;

// A data type that provides autocomplete functionality for a given set of
// string and weights, using Term and BinarySearchDeluxe.

public class Autocomplete {

   private Term[] terms;

   // Initialize the data structure from the given array of terms.
   public Autocomplete(Term[] terms) {
       this.terms = terms;
   }

   // All terms that start with the given prefix, in descending order of
   // weight.
   public Term[] allMatches(String prefix) {
      
       Arrays.sort(terms); // sort the terms in lexicographic order
       Term term = new Term(prefix);
       // create a prefix order comparator using prefix length as argument
       Comparator<Term> prefixOrder = Term.byPrefixOrder(prefix.length());
       int firstIndex = BinarySearchDeluxe.firstIndexOf(terms, term, prefixOrder); // get the index of first occurrence of prefix in terms
       if(firstIndex == -1) // if term is not found
           return null; // return null
       else
       {
           // if at least one occurrence of term is found
           // get the index of last occurrence of prefix in terms
           int lastIndex = BinarySearchDeluxe.lastIndexOf(terms, term, prefixOrder);
           int length = lastIndex - firstIndex + 1; // get the number of terms
          
           // create output array of length
           Term[] matching = new Term[length];
          
           // loop to populate matching from terms
           for(int i=firstIndex;i<=lastIndex;i++)
           {
               matching[i] = terms[i];
           }
           Arrays.sort(matching,Term.byReverseWeightOrder()); // sort the matching array in descending order of weight
           return matching; // return the array
       }
   }

   // The number of terms that start with the given prefix.
   public int numberOfMatches(String prefix) {
       Arrays.sort(terms); // sort the terms in lexicographic order
       Term term = new Term(prefix);
       // create a prefix order comparator using prefix length as argument
       Comparator<Term> prefixOrder = Term.byPrefixOrder(prefix.length());
       int firstIndex = BinarySearchDeluxe.firstIndexOf(terms, term, prefixOrder); // get the index of first occurrence of prefix in terms
      
       if(firstIndex == -1) // if term is not found
           return 0;
       else
       {
           // get the index of last occurrence of prefix in terms
           int lastIndex = BinarySearchDeluxe.lastIndexOf(terms, term, prefixOrder);
           int length = lastIndex - firstIndex + 1; // get the number of terms
          
           return length; // return the length
       }
   }
  
   // no changes needed
   public static void main(String[] args) throws IOException{
      
       String filename = args[0];
       In in = new In(filename);
       int N = in.readInt();
       Term[] terms = new Term[N];
       for (int i = 0; i < N; i++) {
           long weight = in.readLong();
           in.readChar();
           String query = in.readLine();
           terms[i] = new Term(query.trim(), weight);
       }
       int k = Integer.parseInt(args[1]);
       Autocomplete autocomplete = new Autocomplete(terms);
       while (StdIn.hasNextLine()) {
           String prefix = StdIn.readLine();
           Term[] results = autocomplete.allMatches(prefix);
           for (int i = 0; i < Math.min(k, results.length); i++) {
               System.out.println(results[i]);
           }
       }
   }
}

//end of Autocomplete.java