message

IntegerDuplicateDeleter.java

@@ -1,6 +1,55 @@
- 
+import org.omg.PortableInterceptor.INACTIVE;
 
+import java.util.Arrays;
 
 public class IntegerDuplicateDeleter extends DuplicateDeleter<Integer>{
 
-}
+
+    public IntegerDuplicateDeleter(Integer[] array) {
+         super(array);
+     }
+
+
+     public Integer[] removeDuplicates(int maxNumberOfDuplications) {
+         Integer[] newArr = Arrays.copyOf(this.array, this.array.length);
+         int counter = 0;
+
+         for (int x = 0; x < array.length; x++) {
+             if (countOccurence(array[x]) < maxNumberOfDuplications) {
+                 newArr[counter] = array[x];
+                 counter++;
+                 }
+         }
+
+         Integer[] answer = Arrays.copyOf(newArr, counter);
+         return  answer;
+     }
+
+
+     public Integer[] removeDuplicatesExactly(int exactNumberOfDuplications) {
+         Integer[] newArr = Arrays.copyOf(this.array, this.array.length);
+         int counter = 0;
+
+         for (int x = 0; x < array.length; x++) {
+             if (countOccurence(array[x]) < exactNumberOfDuplications || countOccurence(array[x]) > exactNumberOfDuplications) {
+                 newArr[counter] = array[x];
+                 counter++;
+             }
+         }
+
+         Integer[] answer = Arrays.copyOf(newArr, counter);
+         return answer;
+     }
+
+
+     public int countOccurence(Integer value) {
+        int count = 0;
+         for (int x = 0; x < array.length; x++) {
+
+             if (array[x] == value) {
+                 count++;
+             }
+         }
+         return count;
+     }
+ }

IntegerDuplicateDeleterTest.java

@@ -1,78 +1,77 @@
- 
 
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
 
-import java.util.Arrays;
+ import org.junit.Assert;
+ import org.junit.Before;
+ import org.junit.Test;
 
-/**
- * Created by leon on 1/25/18.
- * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
- */
-public class IntegerDuplicateDeleterTest {
+ import java.util.Arrays;
 
-    @Test
-    public void testRemoveDuplicatesExactly_whenThereIsOnlyOneElement() {
-        Integer[] intArray = new Integer[]{0};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
+ /**
+  * Created by leon on 1/25/18.
+  * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
+  */
+ public class IntegerDuplicateDeleterTest {
 
-        Integer[] expected = new Integer[]{0};
-        Integer[] actual = deleter.removeDuplicatesExactly(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
+     @Test
+     public void testRemoveDuplicatesExactly_whenThereIsOnlyOneElement() {
+         Integer[] intArray = new Integer[]{0};
+         DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
 
-    @Test
-    public void testRemoveDuplicatesExactly_whenThereIsOnlyOneElementAndRemoveDumplicationIs1() {
-        Integer[] intArray = new Integer[]{9};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
+         Integer[] expected = new Integer[]{0};
+         Integer[] actual = deleter.removeDuplicatesExactly(2);
+         Assert.assertArrayEquals(expected, actual);
+     }
 
-        Integer[] expected = new Integer[]{};
-        Integer[] actual = deleter.removeDuplicatesExactly(1);
-        Assert.assertArrayEquals(expected, actual);
-    }
+     @Test
+     public void testRemoveDuplicatesExactly_whenThereIsOnlyOneElementAndRemoveDumplicationIs1() {
+         Integer[] intArray = new Integer[]{9};
+         DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
 
-    @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[]{};
+         Integer[] actual = deleter.removeDuplicatesExactly(1);
+         Assert.assertArrayEquals(expected, actual);
+     }
 
-        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_withNoElementsWithExactDumplication() {
+         Integer[] intArray = new Integer[]{51, 4, 4, 4, 28, 38, 38, 38, 38, 38};
+         DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
 
-    @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[]{51, 4, 4, 4, 28, 38, 38, 38, 38, 38};
+         Integer[] actual = deleter.removeDuplicatesExactly(2);
+         Assert.assertArrayEquals(expected, actual);
+     }
 
-        Integer[] expected = new Integer[]{1, 3, 3, 3};
-        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);
 
-    @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, 3, 3, 3};
+         Integer[] actual = deleter.removeDuplicatesExactly(2);
+         Assert.assertArrayEquals(expected, actual);
+     }
 
-        Integer[] expected = new Integer[]{1, 2, 2, 4, 4, 6};
-        Integer[] actual = deleter.removeDuplicatesExactly(3);
-        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 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);
+     }
 
 
 
@@ -82,108 +81,113 @@ public class IntegerDuplicateDeleterTest {
 
 
 
-    @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_whenThereIsOnlyOneElement() {
+         Integer[] intArray = new Integer[]{5};
+         DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
 
-    @Test
-    public void testRemoveDuplicates_whenThereIsOnlyOneElementAndRemoveDumplicationIs1() {
-        Integer[] intArray = new Integer[]{3};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
+         Integer[] expected = new Integer[]{5};
+         Integer[] actual = deleter.removeDuplicates(2);
+         Assert.assertArrayEquals(expected, actual);
+     }
 
-        Integer[] expected = new Integer[]{};
-        Integer[] actual = deleter.removeDuplicatesExactly(1);
-        Assert.assertArrayEquals(expected, actual);
-    }
+     @Test
+     public void testRemoveDuplicates_whenThereIsOnlyOneElementAndRemoveDumplicationIs1() {
+         Integer[] intArray = new Integer[]{3};
+         DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
 
-    @Test
-    public void testRemoveDuplicates_whenThereIsMoreThanOneElement() {
-        Integer[] intArray = new Integer[]{4, 1, 2};
-        DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
+         Integer[] expected = new Integer[]{};
+         Integer[] actual = deleter.removeDuplicatesExactly(1);
+         Assert.assertArrayEquals(expected, actual);
+     }
 
-        Integer[] expected = new Integer[]{4, 1, 2};
-        Integer[] actual = deleter.removeDuplicates(2);
-        Assert.assertArrayEquals(expected, actual);
-    }
+     @Test
+     public void testRemoveDuplicates_whenThereIsMoreThanOneElement() {
+         Integer[] intArray = new Integer[]{4, 1, 2};
+         DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(intArray);
 
-    @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[]{4, 1, 2};
+         Integer[] actual = deleter.removeDuplicates(2);
+         Assert.assertArrayEquals(expected, actual);
+     }
 
-        Integer[] expected = new Integer[]{1};
-        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);
 
-    @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);
-    }
+         Integer[] expected = new Integer[]{1};
+         Integer[] actual = deleter.removeDuplicates(2);
+         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_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 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);
+     @Test
+     public void testRemoveDuplicatesExactlyIdempotence() {
+         Integer[] input = {11, 3, 3, 3, 4, 4, 4, 4};
+         Integer[] expected = {11, 4, 4, 4, 4};
 
-        Integer[] actual1 = deleter.removeDuplicatesExactly(3);
-        Integer[] actual2 = deleter.removeDuplicatesExactly(3);
-        Integer[] actual3 = deleter.removeDuplicatesExactly(3);
+         DuplicateDeleter<Integer> deleter = new IntegerDuplicateDeleter(input);
 
-        Assert.assertArrayEquals(expected, actual1);
-        Assert.assertArrayEquals(expected, actual2);
-        Assert.assertArrayEquals(expected, actual3);
-    }
+         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);
+     @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);
+     }
+
+
+
+     }
 
-        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);
-    }
-}

StringDuplicateDeleter.java

@@ -1,6 +1,60 @@
- 
+ import java.util.*;
 
 public final class StringDuplicateDeleter extends DuplicateDeleter<String> {
 
+    public StringDuplicateDeleter(String[] array) {
+        super(array);
+
+    }
+
+     @Override
+    public String[] removeDuplicates(int maxNumberOfDuplications) {
+         String[] newArr = Arrays.copyOf(array, array.length);
+         int counter = 0;
+
+         for (int x = 0; x < array.length; x++) {
+             if (countOccurence(array[x]) < maxNumberOfDuplications) {
+                 newArr[counter] = array[x];
+                 counter++;
+             }
+         }
+
+         String[] answer = Arrays.copyOf(newArr, counter);
+         return  answer;
+     }
+
+    //@Override
+    public String[] removeDuplicatesExactly(int exactNumberOfDuplications) {
+        String[] newArr = Arrays.copyOf(array, array.length);
+        int counter = 0;
+
+        for (int x = 0; x < array.length; x++) {
+            if (countOccurence(array[x]) < exactNumberOfDuplications || countOccurence(array[x]) > exactNumberOfDuplications) {
+                newArr[counter] = array[x];
+                counter++;
+            }
+        }
+
+        String[] answer = Arrays.copyOf(newArr, counter);
+        return answer;
+    }
+
+
+
+    public Integer countOccurence(String value) {
+        int count = 0;
+        for (int x = 0; x < array.length; x++) {
+
+            if (array[x] == value) {
+                count++;
+            }
+        }
+        return count;
+    }
+    }
+
+
+
+
+
 
-}