src/main/java/chat/UMessageServerConnection.java

@@ -131,7 +131,7 @@ public class UMessageServerConnection extends Thread {
                     String cmd = line.split(" ")[1];
                     final String[] lineParts = line.split(":");
                     switch (cmd) {
-                        case "PART":
+                        case "QUIT":
                             SwingUtilities.invokeLater(new Runnable() {
                                 @Override
                                 public void run() {

src/main/java/chat/uMessage.java

@@ -19,10 +19,16 @@ import java.util.function.Supplier;
 public class uMessage {
     private static final int N = 3;
     private static final String CORPUS = "corpus/eggs.txt";
+    // Use .binarySearchTreeConstructor(); if you want to test things since it is an implementation we provide and is guaranteed to work
+    // Other examples:
+    // .trieConstructor(NGram.class);
+    // .trieConstructor(AlphabeticString.class);
+    // .hashtableConstructor(NGramTester.avlTreeConstructor());
+    // .hashtableConstructor(NGramTester.binarySearchTreeConstructor());
     private static final Supplier<Dictionary<NGram, Dictionary<AlphabeticString, Integer>>> NEW_OUTER = NGramTester
-            .trieConstructor(NGram.class);
+            .binarySearchTreeConstructor();
     private static final Supplier<Dictionary<AlphabeticString, Integer>> NEW_INNER = NGramTester
-            .trieConstructor(AlphabeticString.class);
+            .binarySearchTreeConstructor();
 
     /*
      *

src/main/java/datastructures/dictionaries/ChainingHashTable.java

@@ -9,23 +9,24 @@ import java.util.Iterator;
 import java.util.function.Supplier;
 
 /**
- * 1. You must implement a generic chaining hashtable. You may not
- * restrict the size of the input domain (i.e., it must accept
- * any key) or the number of inputs (i.e., it must grow as necessary).
- * 3. Your HashTable should rehash as appropriate (use load factor as
- * shown in class!).
- * 5. HashTable should be able to resize its capacity to prime numbers for more
- * than 200,000 elements. After more than 200,000 elements, it should
- * continue to resize using some other mechanism.
- * 6. We suggest you hard code some prime numbers. You can use this
- * list: http://primes.utm.edu/lists/small/100000.txt
- * NOTE: Do NOT copy the whole list!
- * 7. When implementing your iterator, you should NOT copy every item to another
- * dictionary/list and return that dictionary/list's iterator.
+ * - You must implement a generic chaining hashtable. You may not
+ *   restrict the size of the input domain (i.e., it must accept
+ *   any key) or the number of inputs (i.e., it must grow as necessary).
+ *
+ * - ChainingHashTable should rehash as appropriate (use load factor as shown in lecture!).
+ *
+ * - ChainingHashTable must resize its capacity into prime numbers via given PRIME_SIZES list.
+ *   Past this, it should continue to resize using some other mechanism (primes not necessary).
+ *
+ * - When implementing your iterator, you should NOT copy every item to another
+ *   dictionary/list and return that dictionary/list's iterator.
  */
 public class ChainingHashTable<K, V> extends DeletelessDictionary<K, V> {
     private Supplier<Dictionary<K, V>> newChain;
 
+    static final int[] PRIME_SIZES =
+            {11, 23, 47, 97, 193, 389, 773, 1549, 3089, 6173, 12347, 24697, 49393, 98779, 197573, 395147};
+
     public ChainingHashTable(Supplier<Dictionary<K, V>> newChain) {
         this.newChain = newChain;
     }
@@ -44,4 +45,13 @@ public class ChainingHashTable<K, V> extends DeletelessDictionary<K, V> {
     public Iterator<Item<K, V>> iterator() {
         throw new NotYetImplementedException();
     }
+
+    /**
+     * Temporary fix so that you can debug on IntelliJ properly despite a broken iterator
+     * Remove to see proper String representation (inherited from Dictionary)
+     */
+    @Override
+    public String toString() {
+        return "ChainingHashTable String representation goes here.";
+    }
 }

src/main/java/p2/clients/NGramTester.java

@@ -36,7 +36,7 @@ public class NGramTester {
 
     public static void main(String[] args) {
         try {
-            WordSuggestor suggestions = new WordSuggestor("eggs.txt", 2, -1,
+            WordSuggestor suggestions = new WordSuggestor("corpus/eggs.txt", 2, -1,
                     NGramTester.trieConstructor(NGram.class),
                     NGramTester.trieConstructor(AlphabeticString.class));
             System.out.println(suggestions);

src/main/java/p2/sorts/TopKSort.java

@@ -9,9 +9,7 @@ public class TopKSort {
         sort(array, k, (x, y) -> x.compareTo(y));
     }
 
-    /**
-     * Behaviour is undefined when k > array.length
-     */
+
     public static <E> void sort(E[] array, int k, Comparator<E> comparator) {
         throw new NotYetImplementedException();
     }

src/main/java/p2/wordsuggestor/NGramToNextChoicesMap.java

@@ -7,6 +7,8 @@ import cse332.misc.LargeValueFirstItemComparator;
 import cse332.sorts.InsertionSort;
 import cse332.types.AlphabeticString;
 import cse332.types.NGram;
+import p2.sorts.QuickSort;
+import p2.sorts.TopKSort;
 
 import java.util.Comparator;
 import java.util.Iterator;
@@ -73,10 +75,16 @@ public class NGramToNextChoicesMap {
 
         Comparator<Item<String, Integer>> comp = new LargeValueFirstItemComparator<String, Integer>();
         if (k < 0) {
-            InsertionSort.sort(afterNGrams, comp);
+            QuickSort.sort(afterNGrams, comp);
         } else {
-            // You must fix this line toward the end of the project
-            throw new NotYetImplementedException();
+            Comparator<Item<String, Integer>> revComp = (o1, o2) -> comp.compare(o2, o1);
+            TopKSort.sort(afterNGrams, k, revComp);
+            int cutoff = Math.min(k, afterNGrams.length);
+            for (int i = 0; i < cutoff / 2; i++) {
+                Item<String, Integer> temp = afterNGrams[i];
+                afterNGrams[i] = afterNGrams[cutoff - i - 1];
+                afterNGrams[cutoff - i - 1] = temp;
+            }
         }
 
         String[] nextWords = new String[k < 0 ? afterNGrams.length : k];

src/test/java/ckpt2/AVLTreeTests.java → src/test/java/provided/AVLTreeTests.java

-package ckpt2;
+package provided;
 
 import cse332.datastructures.containers.Item;
 import cse332.datastructures.trees.BinarySearchTree.BSTNode;

src/test/java/ckpt2/ChainingHashTableTests.java → src/test/java/provided/ChainingHashTableTests.java

-package ckpt2;
+package provided;
 
 import cse332.datastructures.containers.Item;
+import cse332.datastructures.trees.BinarySearchTree;
 import cse332.interfaces.misc.Dictionary;
 import datastructures.dictionaries.ChainingHashTable;
 import datastructures.dictionaries.MoveToFrontList;
@@ -25,8 +26,11 @@ public class ChainingHashTableTests {
 	@Test()
     @Timeout(value = 3000, unit = TimeUnit.MILLISECONDS)
 	public void test_insertFind_manyElements_correctStructure() {
-		ChainingHashTable<String, Integer> list = new ChainingHashTable<>(MoveToFrontList::new);
-
+		/*
+			Replace BinarySearchTree with your own Dictionary implementations like MoveToFrontList or AVLTree
+			to test them as chains for the ChainingHashTable (highly recommended to find potential bugs)
+		* */
+		ChainingHashTable<String, Integer> list = new ChainingHashTable<>(BinarySearchTree::new);
 		int n = 1000;
 
 		// Add them

src/test/java/ckpt1/CircularArrayComparatorTests.java → src/test/java/provided/CircularArrayComparatorTests.java

-package ckpt1;
+package provided;
 
 import datastructures.worklists.CircularArrayFIFOQueue;
 import org.junit.jupiter.api.Test;

src/test/java/ckpt2/CircularArrayHashCodeTests.java → src/test/java/provided/CircularArrayHashCodeTests.java

-package ckpt2;
+package provided;
 
 import datastructures.worklists.CircularArrayFIFOQueue;
 import org.junit.jupiter.api.Test;

src/test/java/ckpt2/HashTrieMapTests.java → src/test/java/provided/HashTrieMapTests.java

-package ckpt2;
+package provided;
 
 import cse332.types.AlphabeticString;
 import datastructures.dictionaries.HashTrieMap;

src/test/java/provided/HashTrieSetTests.java

+package provided;
+
+
+import cse332.types.AlphabeticString;
+import datastructures.dictionaries.HashTrieSet;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.jupiter.api.Assertions.*;
+public class HashTrieSetTests {
+
+    /**
+     * Test to check if HashTrieSet has been copied over from P1
+     * */
+    @Test()
+    @Timeout(value = 3000, unit = TimeUnit.MILLISECONDS)
+    public void test_isHashTrieSetAvailable() {
+        HashTrieSet<Character, AlphabeticString> STUDENT = new HashTrieSet<>(AlphabeticString.class);
+        String[] words = {"dog", "doggy", "doge", "dragon", "cat", "draggin"};
+        String[] invalid = {"d", "cataract", "", "do"};
+
+        for (String word: words) {
+            STUDENT.add(a(word));
+        }
+
+        assertEquals(6, STUDENT.size());
+
+        for (String word: words) {
+            assertTrue(STUDENT.contains(a(word)));
+        }
+
+        for (String invalid_word: invalid) {
+            assertFalse(STUDENT.contains(a(invalid_word)));
+        }
+    }
+
+    private static AlphabeticString a(String s) {
+        return new AlphabeticString(s);
+    }
+}

src/test/java/ckpt2/HeapSortTests.java → src/test/java/provided/HeapSortTests.java

-package ckpt2;
+package provided;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;

src/test/java/ckpt1/MinFourHeapComparableTests.java → src/test/java/provided/MinFourHeapComparableTests.java

-package ckpt1;
+package provided;
 
 import cse332.interfaces.worklists.PriorityWorkList;
 import cse332.interfaces.worklists.WorkList;

src/test/java/ckpt2/MinFourHeapTests.java → src/test/java/provided/MinFourHeapTests.java

-package ckpt2;
-
+package provided;
 
 import cse332.interfaces.worklists.PriorityWorkList;
 import cse332.interfaces.worklists.WorkList;

src/test/java/ckpt1/MoveToFrontListTests.java → src/test/java/provided/MoveToFrontListTests.java

-package ckpt1;
+package provided;
 
 import cse332.datastructures.containers.Item;
 import datastructures.dictionaries.MoveToFrontList;

src/test/java/ckpt2/QuickSortTests.java → src/test/java/provided/QuickSortTests.java

-package ckpt2;
+package provided;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;

src/test/java/ckpt2/TopKSortTests.java → src/test/java/provided/TopKSortTests.java

-package ckpt2;
+package provided;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;