From 3637aab1b3663f10f906a0d071589056316bf2c3 Mon Sep 17 00:00:00 2001
From: Kibret Tecle <kibrettecle@zipcoders-MacBook-Pro-2.local>
Date: Sun, 11 Feb 2018 17:37:48 -0500
Subject: [PATCH 1/2] complete DuplicateDeleter Lab

---
 .../looplabs/DuplicateDeleter.java            |   4 +
 .../looplabs/IntegerDuplicateDeleter.java     | 105 +++++++++++++++++-
 .../looplabs/StringDuplicateDeleter.java      |  97 ++++++++++++++++
 .../looplabs/IntegerDuplicateDeleterTest.java |   2 +-
 .../looplabs/StringDuplicateDeleterTest.java  |   1 +
 5 files changed, 207 insertions(+), 2 deletions(-)

diff --git a/src/main/java/com/zipcodewilmington/looplabs/DuplicateDeleter.java b/src/main/java/com/zipcodewilmington/looplabs/DuplicateDeleter.java
index c176838..d29171b 100644
--- a/src/main/java/com/zipcodewilmington/looplabs/DuplicateDeleter.java
+++ b/src/main/java/com/zipcodewilmington/looplabs/DuplicateDeleter.java
@@ -6,10 +6,14 @@
 public abstract class DuplicateDeleter<T> implements DuplicateDeleterInterface<T> {
     protected final T[] array;
 
+
     public DuplicateDeleter(T[] intArray) {
         this.array = intArray;
     }
 
     abstract public T[] removeDuplicates(int maxNumberOfDuplications);
+    {
+
+    }
     abstract public T[] removeDuplicatesExactly(int exactNumberOfDuplications);
 }
\ No newline at end of file
diff --git a/src/main/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleter.java b/src/main/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleter.java
index ee550c5..3a8f760 100644
--- a/src/main/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleter.java
+++ b/src/main/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleter.java
@@ -1,8 +1,111 @@
 package com.zipcodewilmington.looplabs;
 
+import java.util.Arrays;
+
 /**
  * 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> {
-}
+
+    public IntegerDuplicateDeleter(Integer[] intArray) {
+        super(intArray);
+    }
+    Integer[] myCopyOfArray = Arrays.copyOf(this.array, this.array.length);
+
+    @Override
+    public Integer[] removeDuplicates(int maxNumberOfDuplications) {
+        Integer[] toBeRemoved = new Integer[0];
+        int toBeRemovedIndex = 0;
+        for (int s : myCopyOfArray) {
+            if (checkExistence(toBeRemoved, s)) {
+                continue;
+            } else if (getNumberOfOccurrences(myCopyOfArray, s) >= maxNumberOfDuplications) {
+                toBeRemoved = Arrays.copyOf(toBeRemoved, toBeRemoved.length + 1);
+                toBeRemoved[toBeRemovedIndex] = s;
+                toBeRemovedIndex++;
+            }
+
+        }
+        int resultIndex = 0;
+        Integer[] resultArray = Arrays.copyOf(myCopyOfArray, myCopyOfArray.length);
+
+        for (int r = 0; r < toBeRemoved.length; r++) {
+            resultArray = deleter(resultArray, toBeRemoved[r]);
+            }
+            return resultArray;
+        }
+
+
+        @Override
+        public Integer[] removeDuplicatesExactly(int exactNumberOfDuplications) {
+            Integer[] toBeRemoved = new Integer[0];
+            int toBeRemovedIndex = 0;
+            for (int s : myCopyOfArray) {
+                if (checkExistence(toBeRemoved, s)) {
+                    continue;
+                } else if (getNumberOfOccurrences(myCopyOfArray, s) == exactNumberOfDuplications) {
+                    toBeRemoved = Arrays.copyOf(toBeRemoved, toBeRemoved.length + 1);
+                    toBeRemoved[toBeRemovedIndex] = s;
+                    toBeRemovedIndex++;
+                }
+
+            }
+            int resultIndex = 0;
+            Integer[] resultArray = Arrays.copyOf(myCopyOfArray, myCopyOfArray.length);
+
+            for (int r = 0; r < toBeRemoved.length; r++) {
+                resultArray = deleter(resultArray, toBeRemoved[r]);
+                System.out.println(resultArray);
+            }
+            return resultArray;
+        }
+
+        public static int getNumberOfOccurrences(Integer[] array, Integer value) {
+
+                int counter = 0;
+                for(int i=0;i<array.length;i++){
+                        if(array[i]==value){
+                                counter++;
+                        }
+                }
+                return counter;
+        }
+        public static Integer[] deleter(Integer[] array, Integer valueToRemove) {
+                int counter =getNumberOfOccurrences(array, valueToRemove);
+                Integer[] valuesToKeep = new Integer[array.length];
+                for(int i=0;i<array.length;i++){
+                        if(!valueToRemove.equals(array[i]))
+                        {
+                                valuesToKeep[i]=array[i];
+
+                        }
+                }
+
+                //Resizing the valuesToKeep array by getting rid of the null values.
+                Integer[] resultArray = new Integer[array.length-counter];
+                int resultArrayIndex=0;
+
+                for(Integer element: valuesToKeep){
+
+                        if(element!=null){
+                                resultArray[resultArrayIndex]=element;
+                                resultArrayIndex++;
+                        }
+
+
+                }
+
+                return resultArray;
+        }
+
+        public static boolean checkExistence(Integer[] array, Integer checkElement){
+                for(Integer element: array){
+                        if(checkElement.equals(element)){
+                                return true;
+                        }
+                }
+                return false;
+        }
+
+}
\ No newline at end of file
diff --git a/src/main/java/com/zipcodewilmington/looplabs/StringDuplicateDeleter.java b/src/main/java/com/zipcodewilmington/looplabs/StringDuplicateDeleter.java
index 4818fe3..2f2cda0 100644
--- a/src/main/java/com/zipcodewilmington/looplabs/StringDuplicateDeleter.java
+++ b/src/main/java/com/zipcodewilmington/looplabs/StringDuplicateDeleter.java
@@ -1,8 +1,105 @@
 package com.zipcodewilmington.looplabs;
 
+import java.util.Arrays;
+
 /**
  * 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> {
+
+    public StringDuplicateDeleter(String[] stringArray) {
+        super(stringArray);
+    }
+         String[] myCopyOfArray = Arrays.copyOf(this.array,this.array.length);
+
+    @Override
+    public String[] removeDuplicates(int maxNumberOfDuplications) {
+        String[] toBeRemoved = new String[0];
+        int toBeRemovedIndex = 0;
+        for (String s : myCopyOfArray) {
+            if (checkExistence(toBeRemoved,s)) {
+                continue;
+            } else if (getNumberOfOccurrences(myCopyOfArray, s)>= maxNumberOfDuplications) {
+                toBeRemoved = Arrays.copyOf(toBeRemoved, toBeRemoved.length+1);
+                toBeRemoved[toBeRemovedIndex] = s;
+                toBeRemovedIndex++;
+            }
+
+        }
+
+        String[] resultArray = Arrays.copyOf(myCopyOfArray, myCopyOfArray.length);
+        for (int r = 0; r < toBeRemoved.length; r++) {
+            resultArray = deleter(resultArray, toBeRemoved[r]);
+        }
+        return resultArray;
+    }
+    @Override
+    public String[] removeDuplicatesExactly(int exactNumberOfDuplications) {
+        String[] toBeRemoved = new String[0];
+        int toBeRemovedIndex = 0;
+        for (String s : myCopyOfArray) {
+            if (checkExistence(toBeRemoved,s)) {
+                continue;
+            } else if (getNumberOfOccurrences(myCopyOfArray, s) == exactNumberOfDuplications) {
+                toBeRemoved = Arrays.copyOf(toBeRemoved, toBeRemoved.length+1);
+                toBeRemoved[toBeRemovedIndex] = s;
+                toBeRemovedIndex++;
+            }
+
+        }
+
+        String[] resultArray = Arrays.copyOf(myCopyOfArray, myCopyOfArray.length);
+        for (int r = 0; r < toBeRemoved.length; r++) {
+                resultArray= deleter(resultArray, toBeRemoved[r]);
+        }
+        return resultArray;
+    }
+
+    public static int getNumberOfOccurrences(String[] array, String value) {
+
+              int counter = 0;
+               for(int i=0;i<array.length;i++){
+                       if(array[i].equalsIgnoreCase(value)){
+                              counter++;
+                          }
+                  }
+              return counter;
+    }
+    public static String[] deleter(String[] array, String valueToRemove) {
+        int counter =getNumberOfOccurrences(array, valueToRemove);
+        String[] valuesToKeep = new String[array.length];
+        for(int i=0;i<array.length;i++){
+            if(!(array[i].equals(valueToRemove)))
+            {
+                valuesToKeep[i]=array[i];
+
+            }
+        }
+        String[] resultArray = new String[array.length-counter];
+        int resultArrayIndex=0;
+
+        for( String element: valuesToKeep){
+
+            if(element!=null){
+                resultArray[resultArrayIndex]=element;
+                resultArrayIndex++;
+            }
+
+
+        }
+
+        return resultArray;
+    }
+
+    public static boolean checkExistence(String[] array, String checkElement){
+        for(int a=0;a<array.length;a++){
+            if(checkElement.equals(array[a])){
+                return true;
+            }
+        }
+        return false;
+    }
+
+
 }
diff --git a/src/test/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleterTest.java b/src/test/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleterTest.java
index 3388c27..eb9f5ed 100644
--- a/src/test/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleterTest.java
+++ b/src/test/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleterTest.java
@@ -8,7 +8,7 @@
 /**
  * Created by leon on 1/25/18.
  * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
- */
+  */
 public class IntegerDuplicateDeleterTest {
 
     private static Integer[] intArray;
diff --git a/src/test/java/com/zipcodewilmington/looplabs/StringDuplicateDeleterTest.java b/src/test/java/com/zipcodewilmington/looplabs/StringDuplicateDeleterTest.java
index e9225cf..39222da 100644
--- a/src/test/java/com/zipcodewilmington/looplabs/StringDuplicateDeleterTest.java
+++ b/src/test/java/com/zipcodewilmington/looplabs/StringDuplicateDeleterTest.java
@@ -24,6 +24,7 @@ public void setup() {
     @Test
     public void testRemoveDuplicatesExactly1() {
         String[] expected = new String[]{"aba", "aba", "bba", "bba", "bba", "bba", "bbb", "bbb"};
+        //                               "aba", "aba", "bba", "bba", "bba", "bba", "bbb", "bbb"
         String[] actual = deleter.removeDuplicatesExactly(1);
         TestUtils.assertArrayEquality(expected, actual);
     }

From 4d106c3638cde28784c8f664f240eded8596ba72 Mon Sep 17 00:00:00 2001
From: Kibret Tecle <kibrettecle@zipcoders-MacBook-Pro-5.local>
Date: Sun, 18 Feb 2018 19:25:55 -0500
Subject: [PATCH 2/2] Refactored and cleaned up

---
 .../looplabs/IntegerDuplicateDeleter.java     | 126 +++++++-----------
 .../looplabs/StringDuplicateDeleter.java      |  83 +++---------
 .../looplabs/IntegerDuplicateDeleterTest.java |   2 +-
 .../looplabs/StringDuplicateDeleterTest.java  |   1 -
 4 files changed, 67 insertions(+), 145 deletions(-)

diff --git a/src/main/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleter.java b/src/main/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleter.java
index 3a8f760..b31d681 100644
--- a/src/main/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleter.java
+++ b/src/main/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleter.java
@@ -4,6 +4,7 @@
 
 /**
  * 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> {
@@ -11,101 +12,66 @@ public final class IntegerDuplicateDeleter extends DuplicateDeleter<Integer> {
     public IntegerDuplicateDeleter(Integer[] intArray) {
         super(intArray);
     }
+
     Integer[] myCopyOfArray = Arrays.copyOf(this.array, this.array.length);
 
+    /**
+     *
+     * @param maxNumberOfDuplications
+     * @return returns an array with integers occuring less than the maxNumberOfDuplications
+     */
     @Override
     public Integer[] removeDuplicates(int maxNumberOfDuplications) {
-        Integer[] toBeRemoved = new Integer[0];
-        int toBeRemovedIndex = 0;
+        Integer[] outPut = new Integer[0];
+        int outPutIndex = 0;
         for (int s : myCopyOfArray) {
-            if (checkExistence(toBeRemoved, s)) {
-                continue;
-            } else if (getNumberOfOccurrences(myCopyOfArray, s) >= maxNumberOfDuplications) {
-                toBeRemoved = Arrays.copyOf(toBeRemoved, toBeRemoved.length + 1);
-                toBeRemoved[toBeRemovedIndex] = s;
-                toBeRemovedIndex++;
-            }
-
-        }
-        int resultIndex = 0;
-        Integer[] resultArray = Arrays.copyOf(myCopyOfArray, myCopyOfArray.length);
 
-        for (int r = 0; r < toBeRemoved.length; r++) {
-            resultArray = deleter(resultArray, toBeRemoved[r]);
+            if (getNumberOfOccurrences(myCopyOfArray, s) < maxNumberOfDuplications) {
+                outPut = Arrays.copyOf(outPut, outPut.length + 1);
+                outPut[outPutIndex] = s;
+                outPutIndex++;
             }
-            return resultArray;
         }
+        return outPut;
+    }
 
+    /**
+     *
+     * @param exactNumberOfDuplications
+     * @return returns an array of Integers not the exactNumberOfDuplications
+     */
 
-        @Override
-        public Integer[] removeDuplicatesExactly(int exactNumberOfDuplications) {
-            Integer[] toBeRemoved = new Integer[0];
-            int toBeRemovedIndex = 0;
-            for (int s : myCopyOfArray) {
-                if (checkExistence(toBeRemoved, s)) {
-                    continue;
-                } else if (getNumberOfOccurrences(myCopyOfArray, s) == exactNumberOfDuplications) {
-                    toBeRemoved = Arrays.copyOf(toBeRemoved, toBeRemoved.length + 1);
-                    toBeRemoved[toBeRemovedIndex] = s;
-                    toBeRemovedIndex++;
-                }
-
-            }
-            int resultIndex = 0;
-            Integer[] resultArray = Arrays.copyOf(myCopyOfArray, myCopyOfArray.length);
+    @Override
+    public Integer[] removeDuplicatesExactly(int exactNumberOfDuplications) {
+        Integer[] outPut = new Integer[0];
+        int outPutIndex = 0;
+        for (int s : myCopyOfArray) {
 
-            for (int r = 0; r < toBeRemoved.length; r++) {
-                resultArray = deleter(resultArray, toBeRemoved[r]);
-                System.out.println(resultArray);
+            if (getNumberOfOccurrences(myCopyOfArray, s) != exactNumberOfDuplications) {
+                outPut = Arrays.copyOf(outPut, outPut.length + 1);
+                outPut[outPutIndex] = s;
+                outPutIndex++;
             }
-            return resultArray;
-        }
-
-        public static int getNumberOfOccurrences(Integer[] array, Integer value) {
-
-                int counter = 0;
-                for(int i=0;i<array.length;i++){
-                        if(array[i]==value){
-                                counter++;
-                        }
-                }
-                return counter;
         }
-        public static Integer[] deleter(Integer[] array, Integer valueToRemove) {
-                int counter =getNumberOfOccurrences(array, valueToRemove);
-                Integer[] valuesToKeep = new Integer[array.length];
-                for(int i=0;i<array.length;i++){
-                        if(!valueToRemove.equals(array[i]))
-                        {
-                                valuesToKeep[i]=array[i];
-
-                        }
-                }
-
-                //Resizing the valuesToKeep array by getting rid of the null values.
-                Integer[] resultArray = new Integer[array.length-counter];
-                int resultArrayIndex=0;
-
-                for(Integer element: valuesToKeep){
-
-                        if(element!=null){
-                                resultArray[resultArrayIndex]=element;
-                                resultArrayIndex++;
-                        }
-
 
-                }
-
-                return resultArray;
-        }
+        return outPut;
+    }
 
-        public static boolean checkExistence(Integer[] array, Integer checkElement){
-                for(Integer element: array){
-                        if(checkElement.equals(element)){
-                                return true;
-                        }
-                }
-                return false;
+    /**
+     *
+     * @param array an array of Integers
+     * @param value  the value to which the number of occurence in the array is to be determined
+     * @return the number of times a value occurs in the array
+     */
+    public static int getNumberOfOccurrences(Integer[] array, Integer value) {
+
+        int counter = 0;
+        for (int i = 0; i < array.length; i++) {
+            if (array[i] == value) {
+                counter++;
+            }
         }
+        return counter;
+    }
 
 }
\ No newline at end of file
diff --git a/src/main/java/com/zipcodewilmington/looplabs/StringDuplicateDeleter.java b/src/main/java/com/zipcodewilmington/looplabs/StringDuplicateDeleter.java
index 2f2cda0..b8e67dd 100644
--- a/src/main/java/com/zipcodewilmington/looplabs/StringDuplicateDeleter.java
+++ b/src/main/java/com/zipcodewilmington/looplabs/StringDuplicateDeleter.java
@@ -13,47 +13,39 @@ public StringDuplicateDeleter(String[] stringArray) {
     }
          String[] myCopyOfArray = Arrays.copyOf(this.array,this.array.length);
 
+    /**
+     *
+     * @param maxNumberOfDuplications
+     * @return
+     */
     @Override
     public String[] removeDuplicates(int maxNumberOfDuplications) {
-        String[] toBeRemoved = new String[0];
-        int toBeRemovedIndex = 0;
+        String[] outPut = new String[0];
+        int outPutIndex = 0;
         for (String s : myCopyOfArray) {
-            if (checkExistence(toBeRemoved,s)) {
-                continue;
-            } else if (getNumberOfOccurrences(myCopyOfArray, s)>= maxNumberOfDuplications) {
-                toBeRemoved = Arrays.copyOf(toBeRemoved, toBeRemoved.length+1);
-                toBeRemoved[toBeRemovedIndex] = s;
-                toBeRemovedIndex++;
-            }
 
+           if(getNumberOfOccurrences(myCopyOfArray, s)< maxNumberOfDuplications) {
+                outPut = Arrays.copyOf(outPut, outPut.length+1);
+                outPut[outPutIndex] = s;
+                outPutIndex++;
+            }
         }
 
-        String[] resultArray = Arrays.copyOf(myCopyOfArray, myCopyOfArray.length);
-        for (int r = 0; r < toBeRemoved.length; r++) {
-            resultArray = deleter(resultArray, toBeRemoved[r]);
-        }
-        return resultArray;
+        return outPut;
     }
     @Override
     public String[] removeDuplicatesExactly(int exactNumberOfDuplications) {
-        String[] toBeRemoved = new String[0];
-        int toBeRemovedIndex = 0;
+        String[] outPut = new String[0];
+        int outPutIndex = 0;
         for (String s : myCopyOfArray) {
-            if (checkExistence(toBeRemoved,s)) {
-                continue;
-            } else if (getNumberOfOccurrences(myCopyOfArray, s) == exactNumberOfDuplications) {
-                toBeRemoved = Arrays.copyOf(toBeRemoved, toBeRemoved.length+1);
-                toBeRemoved[toBeRemovedIndex] = s;
-                toBeRemovedIndex++;
+            if (getNumberOfOccurrences(myCopyOfArray, s) != exactNumberOfDuplications) {
+                outPut = Arrays.copyOf(outPut, outPut.length+1);
+                outPut[outPutIndex] = s;
+                outPutIndex++;
             }
 
         }
-
-        String[] resultArray = Arrays.copyOf(myCopyOfArray, myCopyOfArray.length);
-        for (int r = 0; r < toBeRemoved.length; r++) {
-                resultArray= deleter(resultArray, toBeRemoved[r]);
-        }
-        return resultArray;
+        return outPut;
     }
 
     public static int getNumberOfOccurrences(String[] array, String value) {
@@ -66,40 +58,5 @@ public static int getNumberOfOccurrences(String[] array, String value) {
                   }
               return counter;
     }
-    public static String[] deleter(String[] array, String valueToRemove) {
-        int counter =getNumberOfOccurrences(array, valueToRemove);
-        String[] valuesToKeep = new String[array.length];
-        for(int i=0;i<array.length;i++){
-            if(!(array[i].equals(valueToRemove)))
-            {
-                valuesToKeep[i]=array[i];
-
-            }
-        }
-        String[] resultArray = new String[array.length-counter];
-        int resultArrayIndex=0;
-
-        for( String element: valuesToKeep){
-
-            if(element!=null){
-                resultArray[resultArrayIndex]=element;
-                resultArrayIndex++;
-            }
-
-
-        }
-
-        return resultArray;
-    }
-
-    public static boolean checkExistence(String[] array, String checkElement){
-        for(int a=0;a<array.length;a++){
-            if(checkElement.equals(array[a])){
-                return true;
-            }
-        }
-        return false;
-    }
-
 
 }
diff --git a/src/test/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleterTest.java b/src/test/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleterTest.java
index eb9f5ed..3388c27 100644
--- a/src/test/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleterTest.java
+++ b/src/test/java/com/zipcodewilmington/looplabs/IntegerDuplicateDeleterTest.java
@@ -8,7 +8,7 @@
 /**
  * Created by leon on 1/25/18.
  * @ATTENTION_TO_STUDENTS You are forbidden from modifying this class.
-  */
+ */
 public class IntegerDuplicateDeleterTest {
 
     private static Integer[] intArray;
diff --git a/src/test/java/com/zipcodewilmington/looplabs/StringDuplicateDeleterTest.java b/src/test/java/com/zipcodewilmington/looplabs/StringDuplicateDeleterTest.java
index 39222da..e9225cf 100644
--- a/src/test/java/com/zipcodewilmington/looplabs/StringDuplicateDeleterTest.java
+++ b/src/test/java/com/zipcodewilmington/looplabs/StringDuplicateDeleterTest.java
@@ -24,7 +24,6 @@ public void setup() {
     @Test
     public void testRemoveDuplicatesExactly1() {
         String[] expected = new String[]{"aba", "aba", "bba", "bba", "bba", "bba", "bbb", "bbb"};
-        //                               "aba", "aba", "bba", "bba", "bba", "bba", "bbb", "bbb"
         String[] actual = deleter.removeDuplicatesExactly(1);
         TestUtils.assertArrayEquality(expected, actual);
     }