Revert "convert to bluej"

This reverts commit e1b8167c8641fe4703ccb39809da56504afd631b.

DuplicateDeleter.java

- 
-
-/**
- * Created by leon on 1/25/18.
- */
-public abstract class DuplicateDeleter<T> {
-    protected T[] array;
-
-    public DuplicateDeleter(T[] array) {
-        this.array = array;
-    }
-
-    /**
-     *  Removes all values in the array which occur n or more times
-     *
-     *  DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter();
-     *  Integer[] array = new Integer[]{1,1,1,23,23,56,57,58};
-     *  deleter.removeDuplicateExactly(array, 2); // => {56, 57, 58}
-     *
-     * @param maxNumberOfDuplications
-     * @return
-     */
-    abstract public T[] removeDuplicates(int maxNumberOfDuplications);
-
-    /**
-     *  Removes all the values in the array which occurs exactly n times
-     *
-     *  DuplicateDeleter<Integer> = new IntegerDuplicateDeleter();
-     *  Integer[] array = new Integer[]{1,1,1,23,23,56,57,58};
-     *  deleter.removeDuplicateExactly(array, 2); // => {1, 1, 1, 56, 57, 58}
-     *
-     * @param exactNumberOfDuplications
-     * @return
-     */
-    abstract public T[] removeDuplicatesExactly(int exactNumberOfDuplications);
-}

IntegerDuplicateDeleter.java

- 
-
-
-public class IntegerDuplicateDeleter extends DuplicateDeleter<Integer>{
-
-}

IntegerDuplicateDeleterTest.java

- 
-
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.util.Arrays;
-
-/**
- * Created by leon on 1/25/18.
- * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
- */
-public class IntegerDuplicateDeleterTest {
-
-    @Test
-    public void testRemoveDuplicatesExactly_whenThereIsOnlyOneElement() {
-        Integer[] intArray = new Integer[]{0};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
-
-        Integer[] expected = new Integer[]{0};
-        Integer[] actual = deleter.removeDuplicatesExactly(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicatesExactly_whenThereIsOnlyOneElementAndRemoveDumplicationIs1() {
-        Integer[] intArray = new Integer[]{9};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
-
-        Integer[] expected = new Integer[]{};
-        Integer[] actual = deleter.removeDuplicatesExactly(1);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicatesExactly_withNoElementsWithExactDumplication() {
-        Integer[] intArray = new Integer[]{51, 4, 4, 4, 28, 38, 38, 38, 38, 38};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
-
-        Integer[] expected = new Integer[]{51, 4, 4, 4, 28, 38, 38, 38, 38, 38};
-        Integer[] actual = deleter.removeDuplicatesExactly(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicatesExactly_withMoreThanOneElement() {
-        Integer[] intArray = new Integer[]{5, 5, 1, 2, 2, 3, 3, 3};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
-
-        Integer[] expected = new Integer[]{1, 3, 3, 3};
-        Integer[] actual = deleter.removeDuplicatesExactly(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicatesExactly_withOccuranceAtTheBeginningAndEnd() {
-        Integer[] intArray = new Integer[]{0, 0, 0, 1, 2, 2, 4, 4, 5, 5, 5, 6, 9, 9, 9};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
-
-        Integer[] expected = new Integer[]{1, 2, 2, 4, 4, 6};
-        Integer[] actual = deleter.removeDuplicatesExactly(3);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-
-    @Test
-    public void testRemoveDuplicatesExactly_withOccuranceInTheMiddle() {
-        Integer[] intArray = new Integer[]{0, 0, 0, 1, 2, 2, 4, 4, 5, 5, 5, 6, 9, 9, 9};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
-
-        Integer[] expected = new Integer[]{0, 0, 0, 1, 5, 5, 5, 6, 9, 9, 9};
-        Integer[] actual = deleter.removeDuplicatesExactly(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-
-
-
-
-
-
-
-
-
-    @Test
-    public void testRemoveDuplicates_whenThereIsOnlyOneElement() {
-        Integer[] intArray = new Integer[]{5};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
-
-        Integer[] expected = new Integer[]{5};
-        Integer[] actual = deleter.removeDuplicates(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicates_whenThereIsOnlyOneElementAndRemoveDumplicationIs1() {
-        Integer[] intArray = new Integer[]{3};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
-
-        Integer[] expected = new Integer[]{};
-        Integer[] actual = deleter.removeDuplicatesExactly(1);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicates_whenThereIsMoreThanOneElement() {
-        Integer[] intArray = new Integer[]{4, 1, 2};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
-
-        Integer[] expected = new Integer[]{4, 1, 2};
-        Integer[] actual = deleter.removeDuplicates(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicates_whenThereIsMoreThanOneElementWithOccurance() {
-        Integer[] intArray = new Integer[]{4, 4, 1, 2, 2, 2};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
-
-        Integer[] expected = new Integer[]{1};
-        Integer[] actual = deleter.removeDuplicates(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicates_removesNothing() {
-        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
-        Integer[] expected = new Integer[]{};
-        Integer[] actual = deleter.removeDuplicates(0);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicates_withOccuranceInTheMiddle() {
-        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
-        Integer[] expected = new Integer[]{2};
-        Integer[] actual = deleter.removeDuplicates(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-
-    @Test
-    public void testRemoveDuplicates_withOccuranceAtTheBeginningAndEnd() {
-        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
-        Integer[] expected = new Integer[]{1, 1, 2, 4, 4};
-        Integer[] actual = deleter.removeDuplicates(3);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-
-
-
-
-    @Test
-    public void testRemoveDuplicatesExactlyIdempotence() {
-        Integer[] input = {11, 3, 3, 3, 4, 4, 4, 4};
-        Integer[] expected = {11, 4, 4, 4, 4};
-
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(input);
-
-        Integer[] actual1 = deleter.removeDuplicatesExactly(3);
-        Integer[] actual2 = deleter.removeDuplicatesExactly(3);
-        Integer[] actual3 = deleter.removeDuplicatesExactly(3);
-
-        Assert.assertArrayEquals(expected, actual1);
-        Assert.assertArrayEquals(expected, actual2);
-        Assert.assertArrayEquals(expected, actual3);
-    }
-
-
-    @Test
-    public void testRemoveDuplicatesIdempotence() {
-        Integer[] input = {1, 2, 2, 2, 3, 4, 4};
-        Integer[] expected = {1, 3};
-
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(input);
-
-        Integer[] actual1 = deleter.removeDuplicates(2);
-        Integer[] actual2 = deleter.removeDuplicates(2);
-        Integer[] actual3 = deleter.removeDuplicates(2);
-
-        Assert.assertArrayEquals(expected, actual1);
-        Assert.assertArrayEquals(expected, actual2);
-        Assert.assertArrayEquals(expected, actual3);
-    }
-}

README.md

 
-# Delete Duplicates
+# Delete Duplicates 
 * **Objective**
 	* To write methods which remove duplicate elements from an array.
 * **Purpose**
 
     ```
     // : Given
-    Integer[] array = new Integer[]{1, 1, 1, 23, 23, 56, 57, 58};
+    Integer[] array = new Integer[]{1,1,1,23,23,56,57,58};
     DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
-
+    
     // : When
     Integer[] actual = deleter.removeDuplicateExactly(3);
-
+    
     // : Then
-		Integer[] expected = new Integer[]{23, 23, 56, 57, 58};
-    assertArrayEquals(expected, actual);
+    System.out.println(Arrays.toString(actual));
     ```
 
+* Sample Output
 
+    ```
+    [23,23,56,57,58]
+    ```
+    
+    
+    
 
 ### Example 2
 * Sample Script
 
     ```
     // : Given
-    Integer[] array = new Integer[]{1, 1, 1, 23, 23, 56, 57, 58};
+    Integer[] array = new Integer[]{1,1,1,23,23,56,57,58};
     DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
-
+    
     // : When
     Integer[] actual = deleter.removeDuplicateExactly(1);
-
+    
     // : Then
-		Integer[] expected = {1, 1, 1, 23, 23};
-    assertArrayEquals(expected, actual);
+    System.out.println(Arrays.toString(actual));
     ```
 
+* Sample Output
 
+    ```
+    [1,1,1,23,23]
+    ```
+    
+    
+    
 
 ### Example 3
 * Sample Script
     // : Given
     Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
     DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
-
+    
     // : When
     Integer[] actual = deleter.removeDuplicateExactly(3);
-
+    
     // : Then
-		Integer[] expected = {1, 1, 2, 4, 4, 5, 5, 5, 5};
-    assertArrayEquals(expected, actual);
+    System.out.println(Arrays.toString(actual));
+    ```
+
+* Sample Output
+
     ```
+    [1, 1, 2, 4, 4, 5, 5, 5, 5]
+    ```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
     // : Given
     Integer[] array = new Integer[]{1,1,1,23,23,56,57,58};
     DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
-
+    
     // : When
     Integer[] actual = deleter.removeDuplicateExactly(1);
-
+    
     // : Then
-		Integer[] expected = {};
-    assertArrayEquals(expected, actual);
+    System.out.println(Arrays.toString(actual));
+    ```
+
+
+
+* Sample Output
+
+    ```
+    []
     ```
 
 
+
+
 ### Example 2
 * Sample Script
 
     // : Given
     Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
     DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
-
+    
     // : When
     Integer[] actual = deleter.removeDuplicates(2);
-
+    
     // : Then
-		Integer[] expected = {2};
-    assertArrayEquals(expected, actual);
+    System.out.println(Arrays.toString(actual));
     ```
 
 
+
+* Sample Output
+
+    ```
+    [2]
+    ```
+
+
+
 ### Example 3
 * Sample Script
 
     // : Given
     Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
     DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
-
+    
     // : When
     Integer[] actual = deleter.removeDuplicates(3);
-
+    
     // : Then
-		Integer[] expected = {1, 1, 2, 4, 4};
-    assertArrayEquals(expected, actual);
+    System.out.println(Arrays.toString(actual));
     ```
 
 
 
+* Sample Output
 
-
+    ```
+    [1,1,2,4,4]
+    ```
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
 <br><br><br><br>
 ## Idempotence
 
     deleter.removeDuplicates(0);
     deleter.removeDuplicates(1);
     deleter.removeDuplicates(2);
-
+    
     // : When
     Integer[] actual = deleter.removeDuplicates(3);
-
+    
     // : Then
-		Integer[] expected = {1, 1, 2, 4, 4};
-    assertArrayEquals(expected, actual);
+    System.out.println(Arrays.toString(actual));
     ```
 
 
+
+* Sample Output
+
+    ```
+    [1,1,2,4,4]
+    ```
+    
+
 ### Example 2
 * Sample Script
 
     ```
     // : Given
-    Integer[] array = new Integer[]{1, 1, 1, 23, 23, 56, 57, 58};
+    Integer[] array = new Integer[]{1,1,1,23,23,56,57,58};
     DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
-
-		deleter.removeDuplicates(0);
+    deleter.removeDuplicates(0);
     deleter.removeDuplicates(1);
     deleter.removeDuplicates(2);
-
+    
     // : When
     Integer[] actual = deleter.removeDuplicatesExactly(3);
-
+    
     // : Then
-		Integer[] expected = {23, 23, 56, 57, 58};
-    assertArrayEquals(expected, actual);
+    System.out.println(Arrays.toString(actual));
+    ```
+
+
+
+* Sample Output
+
+    ```
+    [23,23,56,57,58]
     ```

StringDuplicateDeleter.java

- 
-
-public final class StringDuplicateDeleter extends DuplicateDeleter<String> {
-
-
-}

StringDuplicateDeleterTest.java

- 
-
-
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.util.Arrays;
-
-/**
- * Created by leon on 1/28/18.
- * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
- */
-public class StringDuplicateDeleterTest {
-    @Test
-    public void testRemoveDuplicatesExactly_whenThereIsOnlyOneElement() {
-        String[] array = new String[]{"a"};
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(array);
-
-        String[] expected = new String[]{"a"};
-        String[] actual = deleter.removeDuplicatesExactly(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicatesExactly_whenThereIsOnlyOneElementAndRemoveDumplicationIs1() {
-        String[] array = new String[]{"b"};
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(array);
-
-        String[] expected = new String[]{};
-        String[] actual = deleter.removeDuplicatesExactly(1);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicatesExactly_withNoElementsToRemove() {
-        String[] array = new String[]{"aa", "b", "d"};
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(array);
-
-        String[] expected = new String[]{"aa", "b", "d"};
-        String[] actual = deleter.removeDuplicatesExactly(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicatesExactly_withMoreThanOneElementToRemove() {
-        String[] array = new String[]{"cat", "cat", "dog", "dog", "fox"};
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(array);
-
-        String[] expected = new String[]{"fox"};
-        String[] actual = deleter.removeDuplicatesExactly(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicatesExactly_withOccuranceAtTheBeginningAndEnd() {
-        String[] array = new String[]{"cat", "cat", "cat", "deer", "deer", "dog", "fox", "fox", "goat", "goat", "goat"};
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(array);
-
-        String[] expected = new String[]{"deer", "deer", "dog", "fox", "fox"};
-        String[] actual = deleter.removeDuplicatesExactly(3);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-
-    @Test
-    public void testRemoveDuplicatesExactly_withOccuranceInTheMiddle() {
-        String[] array = new String[]{"cat", "cat", "cat", "deer", "deer", "dog", "fox", "fox", "goat", "goat", "goat"};
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(array);
-
-        String[] expected = new String[]{"cat", "cat", "cat", "dog", "goat", "goat", "goat"};
-        String[] actual = deleter.removeDuplicatesExactly(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-
-
-
-
-
-
-
-
-
-    @Test
-    public void testRemoveDuplicates_withOneElement() {
-        String[] array = new String[]{"Droolius Caesar"};
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(array);
-
-        String[] expected = new String[]{"Droolius Caesar"};
-        String[] actual = deleter.removeDuplicates(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicates_withOneElementToRemove() {
-        String[] array = new String[]{"Chewbarka"};
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(array);
-
-        String[] expected = new String[]{};
-        String[] actual = deleter.removeDuplicatesExactly(1);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicates_withNoElementToRemove() {
-        String[] array = new String[]{"a", "a", "b", "c", "c", "c", "d"};
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(array);
-
-        String[] expected = new String[]{"a", "a", "b", "c", "c", "c", "d"};
-        String[] actual = deleter.removeDuplicates(4);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicates_whenThereIsMoreThanOneElementWithOccurance() {
-        String[] array = new String[]{"a", "a", "b", "c", "c", "c", "d"};
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(array);
-
-        String[] expected = new String[]{"b", "d"};
-        String[] actual = deleter.removeDuplicates(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-    @Test
-    public void testRemoveDuplicates_withOccuranceInTheMiddle() {
-        String[] array = new String[]{"aba", "baa", "baa", "bbb", "bbb", "bbb", "cat", "cat", "dog"};
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(array);
-        String[] expected = new String[]{"aba", "dog"};
-        String[] actual = deleter.removeDuplicates(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-
-    @Test
-    public void testRemoveDuplicates_withOccuranceAtTheBeginningAndEnd() {
-        String[] array = new String[]{"aba", "aba", "aba", "bab", "aaa", "bba", "bba", "bbb", "bbb", "bbb"};
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(array);
-        String[] expected = new String[]{"bab", "aaa", "bba", "bba"};
-        String[] actual = deleter.removeDuplicates(3);
-        Assert.assertArrayEquals(expected, actual);
-    }
-
-
-
-
-
-    @Test
-    public void testRemoveDuplicatesExactlyIdempotence() {
-        String[] input = {"aa", "b", "b", "b", "c", "c", "t", "t", "t"};
-        String[] expected = {"aa", "c", "c"};
-
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
-
-        String[] actual1 = deleter.removeDuplicatesExactly(3);
-        String[] actual2 = deleter.removeDuplicatesExactly(3);
-        String[] actual3 = deleter.removeDuplicatesExactly(3);
-
-        Assert.assertArrayEquals(expected, actual1);
-        Assert.assertArrayEquals(expected, actual2);
-        Assert.assertArrayEquals(expected, actual3);
-    }
-
-
-    @Test
-    public void testRemoveDuplicatesIdempotence() {
-        String[] input = {"aa", "b", "b", "b", "c", "c", "t", "t"};
-        String[] expected = {"aa"};
-
-        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
-
-        String[] actual1 = deleter.removeDuplicates(2);
-        String[] actual2 = deleter.removeDuplicates(2);
-        String[] actual3 = deleter.removeDuplicates(2);
-
-        Assert.assertArrayEquals(expected, actual1);
-        Assert.assertArrayEquals(expected, actual2);
-        Assert.assertArrayEquals(expected, actual3);
-    }
-}

package.bluej

-#BlueJ package file
-dependency1.from=StringDuplicateDeleterTest
-dependency1.to=StringDuplicateDeleter
-dependency1.type=UsesDependency
-dependency2.from=StringDuplicateDeleterTest
-dependency2.to=TestUtils
-dependency2.type=UsesDependency
-dependency3.from=StringDuplicateDeleterTest
-dependency3.to=RandomNumberFactory
-dependency3.type=UsesDependency
-dependency4.from=IntegerDuplicateDeleterTest
-dependency4.to=IntegerDuplicateDeleter
-dependency4.type=UsesDependency
-dependency5.from=IntegerDuplicateDeleterTest
-dependency5.to=TestUtils
-dependency5.type=UsesDependency
-dependency6.from=IntegerDuplicateDeleterTest
-dependency6.to=RandomNumberFactory
-dependency6.type=UsesDependency
-editor.fx.0.height=722
-editor.fx.0.width=988
-editor.fx.0.x=425
-editor.fx.0.y=176
-objectbench.height=189
-objectbench.width=1211
-package.divider.horizontal=0.6
-package.divider.vertical=0.6979969183359014
-package.editor.height=446
-package.editor.width=1109
-package.editor.x=142
-package.editor.y=61
-package.frame.height=707
-package.frame.width=1235
-package.numDependencies=6
-package.numTargets=8
-package.showExtends=true
-package.showUses=true
-project.charset=UTF-8
-readme.height=58
-readme.name=@README
-readme.width=47
-readme.x=10
-readme.y=10
-target1.height=50
-target1.name=TestUtils
-target1.showInterface=false
-target1.type=ClassTarget
-target1.width=80
-target1.x=750
-target1.y=210
-target2.association=StringDuplicateDeleterTest
-target2.height=50
-target2.name=StringDuplicateDeleter
-target2.showInterface=false
-target2.type=ClassTarget
-target2.width=170
-target2.x=90
-target2.y=40
-target3.height=50
-target3.name=RandomNumberFactory
-target3.showInterface=false
-target3.type=ClassTarget
-target3.width=170
-target3.x=230
-target3.y=130
-target4.height=50
-target4.name=DuplicateDeleterInterface
-target4.showInterface=false
-target4.type=InterfaceTarget
-target4.width=210
-target4.x=480
-target4.y=30
-target5.association=IntegerDuplicateDeleterTest
-target5.height=50
-target5.name=IntegerDuplicateDeleter
-target5.showInterface=false
-target5.type=ClassTarget
-target5.width=170
-target5.x=40
-target5.y=220
-target6.height=50
-target6.name=StringDuplicateDeleterTest
-target6.showInterface=false
-target6.type=UnitTestTargetJunit4
-target6.width=170
-target6.x=120
-target6.y=10
-target7.height=50
-target7.name=IntegerDuplicateDeleterTest
-target7.showInterface=false
-target7.type=UnitTestTargetJunit4
-target7.width=170
-target7.x=70
-target7.y=190
-target8.height=50
-target8.name=DuplicateDeleter
-target8.showInterface=false
-target8.type=AbstractTarget
-target8.width=160
-target8.x=450
-target8.y=120

src/main/java/com/zipcodewilmington/looplabs/DuplicateDeleter.java

+package com.zipcodewilmington.looplabs;
+
+/**
+ * Created by leon on 1/25/18.
+ */
+public abstract class DuplicateDeleter<T> implements DuplicateDeleterInterface<T> {
+    protected T[] array;
+
+    public DuplicateDeleter(T[] intArray) {
+        this.array = intArray;
+    }
+
+    abstract public T[] removeDuplicates(int maxNumberOfDuplications);
+    abstract public T[] removeDuplicatesExactly(int exactNumberOfDuplications);
+}

src/main/java/com/zipcodewilmington/looplabs/DuplicateDeleterInterface.java

+package com.zipcodewilmington.looplabs;
+
+/**
+ * Created by leon on 1/28/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+ */
+public interface DuplicateDeleterInterface<T> {
+    T[] removeDuplicates(int maxNumberOfDuplications);
+    T[] removeDuplicatesExactly(int exactNumberOfDuplications);
+}

src/main/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleter.java

+package com.zipcodewilmington.looplabs;
+
+/**
+ * Created by leon on 1/29/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying the signature of this class.
+ */
+public final class IntegerDuplicateDeleter extends DuplicateDeleter<Integer> {
+}

src/main/java/com/zipcodewilmington/looplabs/RandomNumberFactory.java

+package com.zipcodewilmington.looplabs;
+
+import java.util.Random;
+
+/**
+ * @author leon.hunter
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+ */
+public final class RandomNumberFactory {
+    private static volatile Random random = new Random();
+
+    private RandomNumberFactory() {
+    }
+    /**
+     * @param min
+     * @param max
+     * @return a random character between the specified min and max character range
+     */
+    public static Character createCharacter(char min, char max) {
+        return (char) createInteger((int) min, (int) max).intValue();
+    }
+
+    /**
+     * @param min
+     * @param max
+     * @return a random float between the specified minimum and maximum numeric range
+     */
+    public static synchronized Float createFloat(float min, float max) {
+        return random.nextFloat() * (max - min) + min;
+    }
+
+    /**
+     * @param min
+     * @param max
+     * @return a random integer between the specified minimum and maximum numeric range
+     */
+    public static Integer createInteger(Integer min, Integer max) {
+        return createFloat(min, max).intValue();
+    }
+
+    /**
+     * @param min
+     * @param max
+     * @return an array the specified length containing integers in the specified range
+     */
+    public static Integer[] createIntegers(int min, int max, int length) {
+        Integer[] integers = new Integer[length];
+        for(int i=0; i<length; i++) {
+            integers[i] = createInteger(min, max);
+        }
+        return integers;
+    }
+
+    /**
+     * @param min
+     * @param max
+     * @return a random string of the specified length containing characters in the specified range
+     */
+    public static String createString(char min, char max, int length) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < length; i++) {
+            sb.append(createCharacter(min, max));
+        }
+        return sb.toString();
+    }
+
+
+    /**
+     * @param min
+     * @param max
+     * @return an array containing arrays of specified length containing characters in the specified range
+     */
+    public static String[] createStrings(char min, char max, int stringLength, int arrayLength) {
+        String[] array = new String[arrayLength];
+        for(int i=0; i<arrayLength; i++) {
+            array[i] = createString(min, max, stringLength);
+        }
+        return array;
+    }
+}

src/main/java/com/zipcodewilmington/looplabs/StringDuplicateDeleter.java

+package com.zipcodewilmington.looplabs;
+
+/**
+ * Created by leon on 1/28/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying the signature of this class.
+ */
+public final class StringDuplicateDeleter extends DuplicateDeleter<String> {
+}

src/test/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleterTest.java

+package com.zipcodewilmington.looplabs;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * Created by leon on 1/25/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+ */
+public class IntegerDuplicateDeleterTest {
+
+    private static Integer[] intArray;
+    private static DuplicateDeleter<Integer> deleter;
+
+    @Before
+    public void setup() {
+        this.intArray = new Integer[]{0, 0, 0, 1, 2, 2, 4, 4, 5, 5, 5, 6, 9, 9, 9};
+        this.deleter = new IntegerDuplicateDeleter(intArray);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactlyExactly() {
+        Integer[] expected = new Integer[]{1, 2, 2, 4, 4, 6};
+        Integer[] actual = deleter.removeDuplicatesExactly(3);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly1() {
+        Integer[] expected = new Integer[]{0, 0, 0, 1, 5, 5, 5, 6, 9, 9, 9};
+        Integer[] actual = deleter.removeDuplicatesExactly(2);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+
+    @Test
+    public void testRemoveDuplicatesExactly2() {
+        Integer[] expected = new Integer[]{0, 0, 0, 2, 2, 4, 4, 5, 5, 5, 9, 9, 9};
+        Integer[] actual = deleter.removeDuplicatesExactly(1);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly3() {
+        Integer[] expected = new Integer[]{1, 2, 2, 4, 4, 6};
+        deleter.removeDuplicates(3);
+        deleter.removeDuplicatesExactly(2);
+        deleter.removeDuplicatesExactly(1);
+
+        Integer[] actual = deleter.removeDuplicatesExactly(3);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    @Test
+    public void testRemoveDuplicates0() {
+        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
+        Integer[] expected = new Integer[]{};
+        Integer[] actual = deleter.removeDuplicates(0);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicates1() {
+        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
+        Integer[] expected = new Integer[]{};
+        Integer[] actual = deleter.removeDuplicates(1);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicates2() {
+        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
+        Integer[] expected = new Integer[]{2};
+        Integer[] actual = deleter.removeDuplicates(2);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicates3() {
+        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
+        Integer[] expected = new Integer[]{1,1,2,4,4};
+        Integer[] actual = deleter.removeDuplicates(3);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicates4() {
+        Integer[] array = new Integer[]{0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 5, 5};
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(array);
+        Integer[] expected = new Integer[]{0,0,0,1,1,2,3,3,3,4,4};
+        Integer[] actual = deleter.removeDuplicates(4);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    @Test
+    public void testRemoveDuplicatesExactlyIdempotence() {
+        Integer[] input = RandomNumberFactory.createIntegers(0,50,150);
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(input);
+        Integer[] expected = deleter.removeDuplicatesExactly(5);
+
+        for (int i = 0; i < input.length; i++) {
+            deleter.removeDuplicatesExactly(i);
+        }
+
+        Integer[] actual = deleter.removeDuplicatesExactly(5);
+
+        Arrays.sort(input);
+        System.out.println("Input:\n\t" + Arrays.toString(input));
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesIdempotence() {
+        Integer[] input = RandomNumberFactory.createIntegers(0,50,150);
+        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(input);
+        Integer[] expected = deleter.removeDuplicates(5);
+
+        for (int i = 0; i < input.length; i++) {
+            deleter.removeDuplicates(i);
+        }
+
+        Integer[] actual = deleter.removeDuplicates(5);
+
+        Arrays.sort(input);
+        System.out.println("Input:\n\t" + Arrays.toString(input));
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+}

src/test/java/com/zipcodewilmington/looplabs/StringDuplicateDeleterTest.java

+package com.zipcodewilmington.looplabs;
+
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * Created by leon on 1/28/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+ */
+public class StringDuplicateDeleterTest {
+    private static String[] stringArray;
+    private static volatile DuplicateDeleter<String> deleter;
+
+    @Before
+    public void setup() {
+        this.stringArray = new String[]{"aba", "aba", "baa", "bab", "bba", "bba", "bba", "bba", "bbb", "bbb"};
+        this.deleter = new StringDuplicateDeleter(stringArray);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly1() {
+        String[] expected = new String[]{"aba", "aba", "bba", "bba", "bba", "bba", "bbb", "bbb"};
+        String[] actual = deleter.removeDuplicatesExactly(1);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly2() {
+        String[] expected = new String[]{"baa", "bab", "bba", "bba", "bba", "bba"};
+        String[] actual = deleter.removeDuplicatesExactly(2);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly3() {
+        String[] expected = new String[]{"aba", "aba", "baa", "bab", "bba", "bba", "bba", "bba", "bbb", "bbb"};
+        String[] actual = deleter.removeDuplicatesExactly(3);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly4() {
+        String[] expected = new String[]{"aba", "aba", "baa", "bab", "bbb", "bbb"};
+        String[] actual = deleter.removeDuplicatesExactly(4);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesExactly5() {
+        String[] input = new String[]{"aa", "aa", "aa", "aa", "aa", "ab", "ba", "ba", "ba", "ba", "bb", "bb", "bb", "bb", "bb"};
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = new String[]{"ab", "ba", "ba", "ba", "ba"};
+        String[] actual = deleter.removeDuplicatesExactly(5);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    @Test
+    public void testRemoveDuplicates0() {
+        String[] input = new String[]{"aa", "aa", "aa", "aa", "aa", "ab", "ba", "ba", "ba", "ba", "bb", "bb", "bb", "bb", "bb"};
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = new String[]{};
+        String[] actual = deleter.removeDuplicates(0);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+
+    @Test
+    public void testRemoveDuplicates1() {
+        String[] input = new String[]{"aa", "aa", "aa", "aa", "aa", "ab", "ba", "ba", "ba", "ba", "bb", "bb", "bb", "bb", "bb"};
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = new String[]{};
+        String[] actual = deleter.removeDuplicates(1);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicates2() {
+        String[] input = new String[]{"aa", "aa", "aa", "aa", "aa", "ab", "ba", "ba", "ba", "ba", "bb", "bb", "bb", "bb", "bb"};
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = new String[]{"ab"};
+        String[] actual = deleter.removeDuplicates(2);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+    @Test
+    public void testRemoveDuplicates3() {
+        String[] input = new String[]{"aa", "aa", "aa", "aa", "aa", "ab", "ba", "ba", "ba", "ba", "bb", "bb", "bb", "bb", "bb"};
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = new String[]{"ab"};
+        String[] actual = deleter.removeDuplicates(3);
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    @Test
+    public void testRemoveDuplicatesExactlyIdempotence() {
+        String[] input = RandomNumberFactory.createStrings('a', 'c', 2, 15);
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = deleter.removeDuplicatesExactly(5);
+
+        for (int i = 0; i < input.length; i++) {
+            deleter.removeDuplicatesExactly(i);
+        }
+
+        String[] actual = deleter.removeDuplicatesExactly(5);
+
+        Arrays.sort(input);
+        System.out.println("Input:\n\t" + Arrays.toString(input));
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+
+    @Test
+    public void testRemoveDuplicatesIdempotence() {
+        String[] input = RandomNumberFactory.createStrings('a', 'c', 2, 15);
+        DuplicateDeleter<String> deleter = new StringDuplicateDeleter(input);
+        String[] expected = deleter.removeDuplicates(5);
+
+        for (int i = 0; i < input.length; i++) {
+            deleter.removeDuplicates(i);
+        }
+
+        String[] actual = deleter.removeDuplicates(5);
+
+        Arrays.sort(input);
+        System.out.println("Input:\n\t" + Arrays.toString(input));
+        TestUtils.assertArrayEquality(expected, actual);
+    }
+
+}

src/test/java/com/zipcodewilmington/looplabs/TestSuite.java

+package com.zipcodewilmington.looplabs;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * Created by leon on 1/28/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+ */
+@RunWith(Suite.class)
+
+@Suite.SuiteClasses({
+        IntegerDuplicateDeleterTest.class,
+        StringDuplicateDeleterTest.class
+})
+public class TestSuite {
+}

src/test/java/com/zipcodewilmington/looplabs/TestUtils.java

+package com.zipcodewilmington.looplabs;
+
+import org.junit.Assert;
+
+import java.util.Arrays;
+
+/**
+ * Created by leon on 1/28/18.
+ * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+ */
+public class TestUtils {
+    public synchronized static <T, E> void assertArrayEquality(T[] expected, E[] actual) {
+        Arrays.sort(expected);
+        Arrays.sort(actual);
+        String expectedString = Arrays.toString(expected);
+        String actualString = Arrays.toString(actual);
+        boolean equality = expectedString.equals(actualString);
+
+        System.out.println("\n\nExpected:\n\t" + expectedString);
+        System.out.println("\nActual:\n\t" + actualString);
+        System.out.println("\nEquivalence:\n\t" + equality);
+
+        Assert.assertEquals(expectedString, actualString);
+        Assert.assertEquals(expected, actual);
+    }
+}