diff --git a/src/main/java/CollectionsHackerrank/CollectionsHackerrankProblems.java b/src/main/java/CollectionsHackerrank/CollectionsHackerrankProblems.java
index 6c2f4e1..c586451 100644
--- a/src/main/java/CollectionsHackerrank/CollectionsHackerrankProblems.java
+++ b/src/main/java/CollectionsHackerrank/CollectionsHackerrankProblems.java
@@ -1,8 +1,6 @@
 package CollectionsHackerrank;
 
-import java.util.List;
-import java.util.Map;
-import java.util.Queue;
+import java.util.*;
 
 public class CollectionsHackerrankProblems {
     public class CollectionsHackerrankPractice {
@@ -23,9 +21,15 @@ public static void main(String[] args) {
         */
         public static List<Integer> removeDuplicates(List<Integer> numbers) {
 
+            if (numbers == null || numbers.isEmpty()) {
+                return new ArrayList<>();
+            }
+
+            LinkedHashSet<Integer> uniqueNumbers = new LinkedHashSet<>(numbers);
+
             // TODO: Implement this method
 
-            return null;
+            return new ArrayList<>(uniqueNumbers);
         }
 
         /*
@@ -37,10 +41,18 @@ public static List<Integer> removeDuplicates(List<Integer> numbers) {
         Output: {1=1, 2=2, 3=3}
         */
         public static Map<Integer, Integer> countFrequency(List<Integer> numbers) {
+            if (numbers == null || numbers.isEmpty()) {
+                return new HashMap<>();
+            }
 
             // TODO: Implement this method
 
-            return null;
+            Map<Integer, Integer> frequencyMap = new HashMap<>();
+            for (int number : numbers) {
+                frequencyMap.put(number, frequencyMap.getOrDefault(number, 0) + 1);
+            }
+
+            return frequencyMap;
         }
 
         /*
@@ -53,6 +65,19 @@ public static Map<Integer, Integer> countFrequency(List<Integer> numbers) {
         */
         public static Integer firstUnique(List<Integer> numbers) {
 
+            if (numbers == null || numbers.isEmpty()) {
+                return null;
+            }
+            Map<Integer, Integer> frequencyMap = new HashMap<>();
+            for (int number : numbers) {
+                frequencyMap.put(number, frequencyMap.getOrDefault(number, 0) + 1);
+            }
+            for (int number : numbers) {
+                if (frequencyMap.get(number) == 1) {
+                    return number;
+                }
+            }
+
             // TODO: Implement this method
 
             return null;
@@ -69,11 +94,26 @@ public static Integer firstUnique(List<Integer> numbers) {
         Output: true
         */
         public static boolean twoSum(List<Integer> numbers, int target) {
+            if (numbers == null || numbers.isEmpty()) {
 
-            // TODO: Implement this method
+                // TODO: Implement this method
+
+                return false;
+            }
+            HashSet<Integer> seenNumbers = new HashSet<>();
+            for (int number : numbers) {
+                int complement = target - number;
 
+                if (seenNumbers.contains(complement)) {
+                    return true;
+                }
+
+                seenNumbers.add(number);
+            }
             return false;
         }
+    }
+
 
         /*
         Problem 5
@@ -84,10 +124,14 @@ public static boolean twoSum(List<Integer> numbers, int target) {
         Output: 3
         */
         public static int countUniqueWords(List<String> words) {
+            if (words == null || words.isEmpty()) {
+                return 0;
+            }
+            HashSet<String> uniqueWords = new HashSet<>(words);
 
             // TODO: Implement this method
 
-            return 0;
+            return uniqueWords.size();
         }
 
         /*
@@ -99,10 +143,22 @@ public static int countUniqueWords(List<String> words) {
         Output: [4,3,2,1]
         */
         public static Queue<Integer> reverseQueue(Queue<Integer> queue) {
+            if (queue == null || queue.isEmpty()) {
+                return queue;
+            }
+            Stack<Integer> stack = new Stack<>();
+            while (!queue.isEmpty()) {
+
+                stack.push(queue.poll());
+            }
+
+            while (!stack.isEmpty()) {
+                queue.offer(stack.pop());
+            }
 
             // TODO: Implement this method
 
-            return null;
+            return queue;
         }
 
         /*
@@ -117,10 +173,30 @@ public static Queue<Integer> reverseQueue(Queue<Integer> queue) {
         Output: false
         */
         public static boolean isBalanced(String expression) {
+            if (expression == null || expression.isEmpty()) {
+                return true;
+            }
+
+            Stack<Character> stack = new Stack<>();
+            for (char c : expression.toCharArray()) {
+                if (c == '(' || c == '{' || c == ']') {
+                        stack.push(c);
+                    } else if (c == ')' || c == '}' || c == ']') {
+                        if (stack.isEmpty()) {
+                            return false;
+
+                    }
+                        char top = stack.pop();
+                        if ((c == ')' && top != '(') || (c == '}' && top != '{') || (c == ']' &&
+                                top != ']')) {
+                            return false;
+                        }
+                }
+            }
 
             // TODO: Implement this method
 
-            return false;
+            return stack.isEmpty();
         }
 
         /*
@@ -133,9 +209,32 @@ public static boolean isBalanced(String expression) {
         */
         public static Integer mostFrequent(List<Integer> numbers) {
 
+            Map<Integer, Integer> frequecyMap = new HashMap<>();
+            for (Integer number : numbers) {
+
+                frequecyMap.put(number, frequecyMap.getOrDefault(number, 0) + 1);
+
+            }
+
+            int mostFrequentNumber = 0;
+            int maxFrequency = 0;
+            boolean first = true;
+            for (Map.Entry<Integer, Integer> entry : frequecyMap.entrySet()) {
+                if (first) {
+                    mostFrequentNumber = entry.getKey();
+                    maxFrequency = entry.getValue();
+                    first = false;
+                } else if (entry.getValue() > maxFrequency) {
+                    mostFrequentNumber = entry.getKey();
+                    maxFrequency = entry.getValue();
+
+                }
+            }
+
+
             // TODO: Implement this method
 
-            return null;
+            return mostFrequentNumber;
         }
 
         /*
@@ -152,10 +251,20 @@ public static Integer mostFrequent(List<Integer> numbers) {
         }
         */
         public static Map<Integer, List<String>> groupByLength(List<String> words) {
+            Map<Integer, List<String>> lengthMap = new HashMap<>();
+
+            for (String word : words) {
+                int length = word.length();
+                if (!lengthMap.containsKey(length)) {
+                    lengthMap.put(length, new ArrayList<>());
+                }
+
+                lengthMap.get(length).add(word);
+            }
 
             // TODO: Implement this method
 
-            return null;
+            return lengthMap;
         }
 
         /*
@@ -170,9 +279,24 @@ public static Map<Integer, List<String>> groupByLength(List<String> words) {
         */
         public static int maxSlidingWindowSum(List<Integer> numbers, int k) {
 
+            int max_sum = Integer.MIN_VALUE;
+            int current_window_sum = 0;
+
+            for (int i = 0; i < k; i++) {
+                current_window_sum += numbers.get(i);
+            }
+                max_sum = current_window_sum;
+
+                for (int i = k; i < numbers.size(); i++) {
+                    current_window_sum += numbers.get(i) - numbers.get(i - k);
+
+                    max_sum = Math.max(max_sum, current_window_sum);
+                }
+
+
             // TODO: Implement this method
 
-            return 0;
+            return max_sum;
         }
     }
-}
+
diff --git a/src/main/java/Iterable/Practice/IterableWarmups.java b/src/main/java/Iterable/Practice/IterableWarmups.java
index 9e9de94..ee867ba 100644
--- a/src/main/java/Iterable/Practice/IterableWarmups.java
+++ b/src/main/java/Iterable/Practice/IterableWarmups.java
@@ -1,6 +1,7 @@
 package Iterable.Practice;
 
 import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
 
 public class IterableWarmups {
@@ -27,6 +28,10 @@ public static void main(String[] args) {
     public static int sum(Iterable<Integer> numbers) {
 
         int total = 0;
+        Iterator<Integer> iterator = numbers.iterator();
+        while (iterator.hasNext()) {
+            total += iterator.next();
+        }
 
         // TODO:
         // Use a for-each loop to calculate the sum
@@ -43,6 +48,14 @@ public static int countEven(Iterable<Integer> numbers) {
 
         int count = 0;
 
+        Iterator<Integer> iterator = numbers.iterator();
+        while (iterator.hasNext()) {
+            int number = iterator.next();
+            if (number % 2 == 0) {
+                count++;
+            }
+        }
+
         // TODO:
         // Loop through numbers
         // Increment count if number is even
@@ -58,6 +71,13 @@ public static int countEven(Iterable<Integer> numbers) {
     public static int findMax(Iterable<Integer> numbers) {
 
         int max = Integer.MIN_VALUE;
+        Iterator<Integer> iterator = numbers.iterator();
+        while (iterator.hasNext()) {
+            int number = iterator.next();
+            if (number > max) {
+                max = number;
+            }
+        }
 
         // TODO:
         // Loop through numbers
@@ -75,10 +95,21 @@ public static int countMatches(Iterable<String> words, String target) {
 
         int count = 0;
 
-        // TODO:
-        // Loop through words
-        // Compare each word to target
-
-        return count;
-    }
-}
+        if (target == null) {
+            return 0;
+        }
+        Iterator<String> iterator = words.iterator();
+        while (iterator.hasNext()) {
+            String word = iterator.next();
+            if (target.equals(word)) {
+                count++;
+            }
+
+        }
+                // TODO:
+                // Loop through words
+                // Compare each word to target
+
+                return count;
+            }
+        }
diff --git a/src/main/java/Lists/ArrayLists/ArrayListProblems.java b/src/main/java/Lists/ArrayLists/ArrayListProblems.java
index baf4dfa..b4f4c9e 100644
--- a/src/main/java/Lists/ArrayLists/ArrayListProblems.java
+++ b/src/main/java/Lists/ArrayLists/ArrayListProblems.java
@@ -32,10 +32,14 @@ public static void main(String[] args) {
     Output: 6
     */
     public static int sum(List<Integer> nums) {
+        int sum = 0;
+        for (int num : nums) {
+            sum += num;
+        }
 
         // TODO: Implement this method
 
-        return 0;
+        return sum;
     }
 
     /*
@@ -48,9 +52,16 @@ public static int sum(List<Integer> nums) {
     */
     public static int countEvens(List<Integer> nums) {
 
+        int count = 0;
+        for (int num : nums) {
+            if (num % 2 == 0) {
+                count++;
+            }
+        }
+
         // TODO: Implement this method
 
-        return 0;
+        return count;
     }
 
     /*
@@ -66,6 +77,15 @@ public static int countEvens(List<Integer> nums) {
     */
     public static boolean hasDuplicate(List<Integer> nums) {
 
+        for (int i = 0; i < nums.size(); i++) {
+            for (int j = i + 1; j < nums.size(); j++) {
+                if (nums.get(i).equals(nums.get(j))) {
+
+                    return true;
+                }
+            }
+        }
+
         // TODO: Implement this method
 
         return false;
@@ -81,9 +101,19 @@ public static boolean hasDuplicate(List<Integer> nums) {
     */
     public static int findMax(List<Integer> nums) {
 
+        if (nums.isEmpty()) {
+            return 0;
+        }
+        int max = nums.get(0);
+        for (int i = 1; i < nums.size(); i++) {
+            if (nums.get(i) > max) {
+                max = nums.get(i);
+            }
+        }
+
         // TODO: Implement this method
 
-        return 0;
+        return max;
     }
 
     /*
@@ -98,8 +128,14 @@ public static int findMax(List<Integer> nums) {
     */
     public static List<Integer> reverse(List<Integer> nums) {
 
+        List<Integer> reversedList = new ArrayList<>();
+        for (int i = nums.size() - 1; i >= 0; i--) {
+
+            reversedList.add(nums.get(i));
+        }
+
         // TODO: Implement this method
 
-        return null;
+        return reversedList;
     }
 }
diff --git a/src/main/java/Lists/LinkedLists/LinkedListProblems.java b/src/main/java/Lists/LinkedLists/LinkedListProblems.java
index 178a2ba..744d280 100644
--- a/src/main/java/Lists/LinkedLists/LinkedListProblems.java
+++ b/src/main/java/Lists/LinkedLists/LinkedListProblems.java
@@ -36,6 +36,7 @@ public static void main(String[] args) {
     Output: [5,10,20,30]
     */
     public static void addToFront(LinkedList<Integer> list, int value) {
+        list.addFirst(value);
 
         // TODO: Implement this method
 
@@ -51,6 +52,8 @@ public static void addToFront(LinkedList<Integer> list, int value) {
     */
     public static void addToEnd(LinkedList<Integer> list, int value) {
 
+        list.addLast(value);
+
         // TODO: Implement this method
 
     }
@@ -65,6 +68,8 @@ public static void addToEnd(LinkedList<Integer> list, int value) {
     */
     public static void removeFirstElement(LinkedList<Integer> list) {
 
+        list.removeFirst();
+
         // TODO: Implement this method
 
     }
@@ -79,6 +84,8 @@ public static void removeFirstElement(LinkedList<Integer> list) {
     */
     public static void removeLastElement(LinkedList<Integer> list) {
 
+        list.removeLast();
+
         // TODO: Implement this method
 
     }
@@ -93,9 +100,10 @@ public static void removeLastElement(LinkedList<Integer> list) {
     */
     public static int getFirstElement(LinkedList<Integer> list) {
 
+        return list.getFirst();
+
         // TODO: Implement this method
 
-        return 0;
     }
 
     /*
@@ -110,6 +118,6 @@ public static int getLastElement(LinkedList<Integer> list) {
 
         // TODO: Implement this method
 
-        return 0;
+        return list.getLast();
     }
 }
diff --git a/src/main/java/Maps/HashMap/HashMapProblems.java b/src/main/java/Maps/HashMap/HashMapProblems.java
index 04b5567..d637cb0 100644
--- a/src/main/java/Maps/HashMap/HashMapProblems.java
+++ b/src/main/java/Maps/HashMap/HashMapProblems.java
@@ -34,6 +34,8 @@ public static void main(String[] args) {
     */
     public static void addItem(Map<String, Integer> map, String item, int quantity) {
 
+        map.put(item,quantity);
+
         // TODO: Implement this method
 
     }
@@ -50,7 +52,7 @@ public static int getQuantity(Map<String, Integer> map, String item) {
 
         // TODO: Implement this method
 
-        return 0;
+        return map.getOrDefault(item, 0);
     }
 
     /*
@@ -63,6 +65,8 @@ public static int getQuantity(Map<String, Integer> map, String item) {
     */
     public static void updateQuantity(Map<String, Integer> map, String item, int newQuantity) {
 
+        map.put(item, newQuantity);
+
         // TODO: Implement this method
 
     }
@@ -77,6 +81,8 @@ public static void updateQuantity(Map<String, Integer> map, String item, int new
     */
     public static void removeItem(Map<String, Integer> map, String item) {
 
+        map.remove(item);
+
         // TODO: Implement this method
 
     }
@@ -91,8 +97,13 @@ public static void removeItem(Map<String, Integer> map, String item) {
     */
     public static Map<Integer, Integer> countFrequency(List<Integer> numbers) {
 
+        Map<Integer, Integer> frequencyMap = new HashMap<>();
+        for (int number : numbers) {
+            frequencyMap.put(number, frequencyMap.getOrDefault(number, 0) + 1);
+        }
+
         // TODO: Implement this method
 
-        return null;
+        return frequencyMap;
     }
 }
diff --git a/src/main/java/Maps/LinkedHashMap/LinkedHashMapProblems.java b/src/main/java/Maps/LinkedHashMap/LinkedHashMapProblems.java
index e8bbdc2..391ecb6 100644
--- a/src/main/java/Maps/LinkedHashMap/LinkedHashMapProblems.java
+++ b/src/main/java/Maps/LinkedHashMap/LinkedHashMapProblems.java
@@ -32,6 +32,8 @@ public static void main(String[] args) {
     */
     public static void addStudent(Map<String, Integer> map, String name, int grade) {
 
+        map.put(name, grade);
+
         // TODO: Implement this method
 
     }
@@ -46,6 +48,8 @@ public static void addStudent(Map<String, Integer> map, String name, int grade)
     */
     public static void updateGrade(Map<String, Integer> map, String name, int newGrade) {
 
+        map.put(name, newGrade);
+
         // TODO: Implement this method
 
     }
@@ -60,6 +64,8 @@ public static void updateGrade(Map<String, Integer> map, String name, int newGra
     */
     public static void removeStudent(Map<String, Integer> map, String name) {
 
+        map.remove(name);
+
         // TODO: Implement this method
 
     }
@@ -73,10 +79,14 @@ public static void removeStudent(Map<String, Integer> map, String name) {
     Output: "Jordan"
     */
     public static String getFirstInserted(Map<String, Integer> map) {
+        if (map.isEmpty()) {
 
-        // TODO: Implement this method
+            // TODO: Implement this method
 
-        return null;
+            return null;
+        }
+
+        return map.keySet().iterator().next();
     }
 
     /*
@@ -90,8 +100,14 @@ public static String getFirstInserted(Map<String, Integer> map) {
     */
     public static Map<String, Integer> wordFrequency(List<String> words) {
 
+        Map<String, Integer> frequencyMap = new LinkedHashMap<>();
+
+        for (String word : words) {
+            frequencyMap.put(word, frequencyMap.getOrDefault(word, 0) + 1);
+        }
+
         // TODO: Implement this method
 
-        return null;
+        return frequencyMap;
     }
 }
diff --git a/src/main/java/Maps/TreeMap/TreeMapProblems.java b/src/main/java/Maps/TreeMap/TreeMapProblems.java
index b101d2e..dab5c28 100644
--- a/src/main/java/Maps/TreeMap/TreeMapProblems.java
+++ b/src/main/java/Maps/TreeMap/TreeMapProblems.java
@@ -30,6 +30,8 @@ public static void main(String[] args) {
     */
     public static void addPlayer(TreeMap<Integer, String> map, int rank, String name) {
 
+        map.put(rank, name);
+
         // TODO: Implement this method
 
     }
@@ -44,9 +46,15 @@ Return the player with the highest ranking (smallest key).
     */
     public static String getTopPlayer(TreeMap<Integer, String> map) {
 
-        // TODO: Implement this method
+        if (map.isEmpty()) {
+
+
+            // TODO: Implement this method
+
+            return null;
+        }
 
-        return null;
+        return map.firstEntry().getValue();
     }
 
     /*
@@ -61,7 +69,12 @@ public static String getLowestPlayer(TreeMap<Integer, String> map) {
 
         // TODO: Implement this method
 
-        return null;
+        if (map.isEmpty()) {
+
+            return null;
+        }
+
+        return map.lastEntry().getValue();
     }
 
     /*
@@ -74,6 +87,8 @@ public static String getLowestPlayer(TreeMap<Integer, String> map) {
     */
     public static void removePlayer(TreeMap<Integer, String> map, int rank) {
 
+        map.remove(rank);
+
         // TODO: Implement this method
 
     }
@@ -88,8 +103,10 @@ public static void removePlayer(TreeMap<Integer, String> map, int rank) {
     */
     public static Integer getNextRank(TreeMap<Integer, String> map, int rank) {
 
+        Integer nextRank = map.higherKey(rank);
+
         // TODO: Implement this method
 
-        return null;
+        return nextRank;
     }
 }
diff --git a/src/main/java/Queues/ArrayDeque/ArrayDequeProblems.java b/src/main/java/Queues/ArrayDeque/ArrayDequeProblems.java
index dac03cf..94cc7bb 100644
--- a/src/main/java/Queues/ArrayDeque/ArrayDequeProblems.java
+++ b/src/main/java/Queues/ArrayDeque/ArrayDequeProblems.java
@@ -29,6 +29,7 @@ public static void main(String[] args) {
     Output: [5]
     */
     public static void addToFront(ArrayDeque<Integer> deque, int value) {
+        deque.addFirst(value);
 
         // TODO: Implement this method
 
@@ -43,6 +44,7 @@ public static void addToFront(ArrayDeque<Integer> deque, int value) {
     Output: [5,10]
     */
     public static void addToBack(ArrayDeque<Integer> deque, int value) {
+        deque.addLast(value);
 
         // TODO: Implement this method
 
@@ -57,6 +59,7 @@ public static void addToBack(ArrayDeque<Integer> deque, int value) {
     Output: [10,20]
     */
     public static void removeFront(ArrayDeque<Integer> deque) {
+        deque.removeFirst();
 
         // TODO: Implement this method
 
@@ -71,6 +74,7 @@ public static void removeFront(ArrayDeque<Integer> deque) {
     Output: [5,10]
     */
     public static void removeBack(ArrayDeque<Integer> deque) {
+        deque.removeLast();
 
         // TODO: Implement this method
 
@@ -88,7 +92,7 @@ public static Integer peekFront(ArrayDeque<Integer> deque) {
 
         // TODO: Implement this method
 
-        return null;
+        return deque.peekFirst();
     }
 
     /*
@@ -103,6 +107,6 @@ public static Integer peekBack(ArrayDeque<Integer> deque) {
 
         // TODO: Implement this method
 
-        return null;
+        return deque.peekLast();
     }
 }
diff --git a/src/main/java/Queues/Deque/DequeProblems.java b/src/main/java/Queues/Deque/DequeProblems.java
index 7ef0c06..b78ffe0 100644
--- a/src/main/java/Queues/Deque/DequeProblems.java
+++ b/src/main/java/Queues/Deque/DequeProblems.java
@@ -18,6 +18,7 @@ public static void main(String[] args) {
     Output: [5]
     */
     public static void addFront(Deque<Integer> deque, int value) {
+        deque.addFirst(value);
 
         // TODO: Implement this method
 
@@ -32,6 +33,7 @@ public static void addFront(Deque<Integer> deque, int value) {
     Output: [5,10]
     */
     public static void addBack(Deque<Integer> deque, int value) {
+        deque.addLast(value);
 
         // TODO: Implement this method
 
@@ -49,7 +51,7 @@ public static Integer removeFront(Deque<Integer> deque) {
 
         // TODO: Implement this method
 
-        return null;
+        return deque.removeFirst();
     }
 
     /*
@@ -64,7 +66,7 @@ public static Integer removeBack(Deque<Integer> deque) {
 
         // TODO: Implement this method
 
-        return null;
+        return deque.removeLast();
     }
 
     /*
@@ -79,7 +81,7 @@ public static Integer peekFront(Deque<Integer> deque) {
 
         // TODO: Implement this method
 
-        return null;
+        return deque.peekFirst();
     }
 
     /*
@@ -94,7 +96,7 @@ public static Integer peekBack(Deque<Integer> deque) {
 
         // TODO: Implement this method
 
-        return null;
+        return deque.peekLast();
     }
 
 }
diff --git a/src/main/java/Sets/HashSet/HashSetProblems.java b/src/main/java/Sets/HashSet/HashSetProblems.java
index a36c570..1bc5172 100644
--- a/src/main/java/Sets/HashSet/HashSetProblems.java
+++ b/src/main/java/Sets/HashSet/HashSetProblems.java
@@ -1,5 +1,6 @@
 package Sets.HashSet;
 
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
@@ -20,6 +21,8 @@ public static void main(String[] args) {
     */
     public static void addElement(Set<String> set, String value) {
 
+        set.add(value);
+
         // TODO: Implement this method
 
     }
@@ -36,7 +39,7 @@ public static boolean containsValue(Set<String> set, String value) {
 
         // TODO: Implement this method
 
-        return false;
+        return set.contains(value);
     }
 
     /*
@@ -48,6 +51,7 @@ public static boolean containsValue(Set<String> set, String value) {
     Output: value removed
     */
     public static void removeValue(Set<String> set, String value) {
+        set.remove(value);
 
         // TODO: Implement this method
 
@@ -65,7 +69,7 @@ public static int getUniqueCount(Set<String> set) {
 
         // TODO: Implement this method
 
-        return 0;
+        return set.size();
     }
 
     /*
@@ -77,9 +81,14 @@ public static int getUniqueCount(Set<String> set) {
     Output: {1,2,3}
     */
     public static Set<Integer> getUniqueValues(List<Integer> numbers) {
+        Set<Integer> uniqueValues = new HashSet<>();
+
+        for (Integer number : numbers) {
+            uniqueValues.add(number);
+        }
 
         // TODO: Implement this method
 
-        return null;
+        return uniqueValues;
     }
 }