diff --git a/src/main/java/CollectionsHackerrank/CollectionsHackerrankProblems.java b/src/main/java/CollectionsHackerrank/CollectionsHackerrankProblems.java
index 6c2f4e1..a6b80ef 100644
--- a/src/main/java/CollectionsHackerrank/CollectionsHackerrankProblems.java
+++ b/src/main/java/CollectionsHackerrank/CollectionsHackerrankProblems.java
@@ -3,15 +3,33 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Queue;
+import java.util.*;
 
 public class CollectionsHackerrankProblems {
-    public class CollectionsHackerrankPractice {
+    public static void main(String[] args) {
+    // You can test your methods here
+        testMethods();
+}
 
-        public static void main(String[] args) {
 
-            // You can test your methods here
+    public static void testMethods() {
+                List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
 
-        }
+                System.out.println("Remove duplicates:");
+                System.out.println(removeDuplicates(numbers));
+
+                System.out.println("\nCount frequency:");
+                System.out.println(countFrequency(Arrays.asList(1, 2, 2, 3, 3, 3)));
+
+                System.out.println("\nFirst unique:");
+                System.out.println(firstUnique(Arrays.asList(4, 5, 1, 2, 0, 4)));
+
+                System.out.println("\nTwo Sum:");
+                System.out.println(twoSum(Arrays.asList(2, 7, 11, 15), 9));
+
+                System.out.println("\nUnique words:");
+                System.out.println(countUniqueWords(Arrays.asList("apple", "banana", "apple", "orange")));
+            }
 
         /*
         Problem 1
@@ -24,8 +42,8 @@ public static void main(String[] args) {
         public static List<Integer> removeDuplicates(List<Integer> numbers) {
 
             // TODO: Implement this method
-
-            return null;
+            Set<Integer> set = new LinkedHashSet<>(numbers);
+            return new ArrayList<>(set);
         }
 
         /*
@@ -39,8 +57,12 @@ public static List<Integer> removeDuplicates(List<Integer> numbers) {
         public static Map<Integer, Integer> countFrequency(List<Integer> numbers) {
 
             // TODO: Implement this method
+            Map<Integer, Integer> map = new HashMap<>();
+            for (Integer num : numbers) {
+                map.put(num, map.getOrDefault(num, 0) + 1);
+            }
 
-            return null;
+            return map;
         }
 
         /*
@@ -54,6 +76,13 @@ public static Map<Integer, Integer> countFrequency(List<Integer> numbers) {
         public static Integer firstUnique(List<Integer> numbers) {
 
             // TODO: Implement this method
+            Map<Integer, Integer> freqMap = countFrequency(numbers);
+
+            for (Integer num : numbers) {
+                if (freqMap.get(num) == 1) {
+                    return num;
+                }
+            }
 
             return null;
         }
@@ -71,7 +100,16 @@ public static Integer firstUnique(List<Integer> numbers) {
         public static boolean twoSum(List<Integer> numbers, int target) {
 
             // TODO: Implement this method
+            Set<Integer> seen = new HashSet<>();
 
+            for (Integer num : numbers) {
+                int complement = target - num;
+
+                if (seen.contains(complement)) {
+                    return true;
+                }
+                seen.add(num);
+            }
             return false;
         }
 
@@ -86,8 +124,9 @@ public static boolean twoSum(List<Integer> numbers, int target) {
         public static int countUniqueWords(List<String> words) {
 
             // TODO: Implement this method
+            Set<String> set = new HashSet<>(words);
 
-            return 0;
+            return set.size();
         }
 
         /*
@@ -101,8 +140,17 @@ public static int countUniqueWords(List<String> words) {
         public static Queue<Integer> reverseQueue(Queue<Integer> queue) {
 
             // TODO: Implement this method
+            Stack<Integer> stack = new Stack<>();
 
-            return null;
+            while (!queue.isEmpty()) {
+                stack.push(queue.poll());
+            }
+
+            while (!stack.isEmpty()) {
+                queue.offer(stack.pop());
+            }
+
+            return queue;
         }
 
         /*
@@ -120,7 +168,20 @@ public static boolean isBalanced(String expression) {
 
             // TODO: Implement this method
 
-            return false;
+            Stack<Character> stack = new Stack<>();
+
+            for (char ch : expression.toCharArray()) {
+                if (ch == '(') {
+                    stack.push(ch);
+                } else if (ch == ')') {
+                    if (stack.isEmpty()) {
+                        return false;
+                    }
+                    stack.pop();
+                }
+            }
+
+            return stack.isEmpty();
         }
 
         /*
@@ -134,8 +195,19 @@ public static boolean isBalanced(String expression) {
         public static Integer mostFrequent(List<Integer> numbers) {
 
             // TODO: Implement this method
+            Map<Integer, Integer> freqMap = countFrequency(numbers);
 
-            return null;
+            int maxCount = 0;
+            Integer mostFrequentNum = null;
+
+            for (Map.Entry<Integer, Integer> entry : freqMap.entrySet()) {
+                if (entry.getValue() > maxCount) {
+                    maxCount = entry.getValue();
+                    mostFrequentNum = entry.getKey();
+                }
+            }
+
+            return mostFrequentNum;
         }
 
         /*
@@ -154,8 +226,20 @@ public static Integer mostFrequent(List<Integer> numbers) {
         public static Map<Integer, List<String>> groupByLength(List<String> words) {
 
             // TODO: Implement this method
+            Map<Integer, List<String>> map = new HashMap<>();
+
+            for (String word : words) {
+                int length = word.length();
+
+                if (!map.containsKey(length)) {
+                    map.put(length, new ArrayList<>());
+                }
+
+                map.get(length).add(word);
+            }
+
+            return map;
 
-            return null;
         }
 
         /*
@@ -172,7 +256,22 @@ public static int maxSlidingWindowSum(List<Integer> numbers, int k) {
 
             // TODO: Implement this method
 
-            return 0;
+            int windowSum = 0;
+
+            for (int i = 0; i < k; i++) {
+                windowSum += numbers.get(i);
+            }
+
+            int maxSum = windowSum;
+
+            for (int i = k; i < numbers.size(); i++) {
+                windowSum += numbers.get(i);
+                windowSum -= numbers.get(i - k);
+                maxSum = Math.max(maxSum, windowSum);
+            }
+
+            return maxSum;
         }
+
     }
-}
+
diff --git a/src/main/java/Iterable/Examples/ForEachLoopDemo.java b/src/main/java/Iterable/Examples/ForEachLoopDemo.java
index a6d2198..9a2c540 100644
--- a/src/main/java/Iterable/Examples/ForEachLoopDemo.java
+++ b/src/main/java/Iterable/Examples/ForEachLoopDemo.java
@@ -17,12 +17,17 @@ public static void main(String[] args) {
 
         // TODO:
         // Use a for-each loop to print each student name
-
+        for (String student : students){
+            System.out.println(student);
+        }
 
         System.out.println("\nPrinting students in uppercase:");
 
         // TODO:
         // Use a for-each loop to print each name in uppercase
+        for (String student : students){
+            System.out.println(student.toUpperCase());
+        }
 
 
         System.out.println("\nCount the number of students:");
@@ -31,6 +36,10 @@ public static void main(String[] args) {
 
         // TODO:
         // Use a for-each loop to count how many students are in the list
+        for (String student : students){
+            count++;
+        }
+
 
         System.out.println("Total students: " + count);
     }
diff --git a/src/main/java/Iterable/Examples/IteratorDemo.java b/src/main/java/Iterable/Examples/IteratorDemo.java
index b09fca7..a5a6e5e 100644
--- a/src/main/java/Iterable/Examples/IteratorDemo.java
+++ b/src/main/java/Iterable/Examples/IteratorDemo.java
@@ -26,7 +26,10 @@ public static void main(String[] args) {
         // TODO:
         // Use iterator.hasNext() and iterator.next()
         // Print each number
-
+        while (iterator.hasNext()){
+            Integer num = iterator.next();
+            System.out.println(num);
+        }
 
         System.out.println("\nRemoving odd numbers using Iterator");
 
@@ -35,6 +38,13 @@ public static void main(String[] args) {
         // TODO:
         // Use iterator to remove odd numbers
         // Remember: use iterator.remove()
+        while (iterator.hasNext()){
+            Integer num = iterator.next();
+
+            if (num % 2 != 0){
+                iterator.remove();
+            }
+        }
 
 
         System.out.println("\nUpdated list:");
diff --git a/src/main/java/Iterable/Practice/IterableWarmups.java b/src/main/java/Iterable/Practice/IterableWarmups.java
index 9e9de94..f2efd33 100644
--- a/src/main/java/Iterable/Practice/IterableWarmups.java
+++ b/src/main/java/Iterable/Practice/IterableWarmups.java
@@ -30,6 +30,9 @@ public static int sum(Iterable<Integer> numbers) {
 
         // TODO:
         // Use a for-each loop to calculate the sum
+        for (Integer num : numbers) {
+            total += num;
+        }
 
         return total;
     }
@@ -46,39 +49,56 @@ public static int countEven(Iterable<Integer> numbers) {
         // TODO:
         // Loop through numbers
         // Increment count if number is even
+        for (Integer num : numbers) {
+            if (num % 2 == 0) {
+                count++;
+            }
+        }
+            return count;
+        }
 
-        return count;
-    }
 
 
     /*
     PROBLEM 3
     Return the maximum value
      */
-    public static int findMax(Iterable<Integer> numbers) {
+        public static int findMax (Iterable < Integer > numbers) {
 
-        int max = Integer.MIN_VALUE;
+            int max = Integer.MIN_VALUE;
 
-        // TODO:
-        // Loop through numbers
-        // Update max if current number is larger
+            // TODO:
+            // Loop through numbers
+            // Update max if current number is larger
+            for (Integer num : numbers) {
+                if (num > max) {
+                    max = num;
+                }
+            }
 
-        return max;
-    }
+            return max;
+        }
 
 
     /*
     PROBLEM 4 (BONUS)
     Count how many times a word appears
      */
-    public static int countMatches(Iterable<String> words, String target) {
+        public static int countMatches (Iterable < String > words, String target){
 
-        int count = 0;
+            int count = 0;
 
-        // TODO:
-        // Loop through words
-        // Compare each word to target
+            // TODO:
+            // Loop through words
+            // Compare each word to target
+            for (String word : words) {
+                if (word.equals(target)) {
+                    count++;
+                }
+            }
 
-        return count;
+            return count;
+        }
     }
-}
+
+
diff --git a/src/main/java/Lists/ArrayLists/ArrayListProblems.java b/src/main/java/Lists/ArrayLists/ArrayListProblems.java
index baf4dfa..8990d47 100644
--- a/src/main/java/Lists/ArrayLists/ArrayListProblems.java
+++ b/src/main/java/Lists/ArrayLists/ArrayListProblems.java
@@ -34,8 +34,13 @@ public static void main(String[] args) {
     public static int sum(List<Integer> nums) {
 
         // TODO: Implement this method
+        int total = 0;
 
-        return 0;
+        for (Integer num : nums) {
+            total += num;
+        }
+
+        return total;
     }
 
     /*
@@ -49,8 +54,15 @@ public static int sum(List<Integer> nums) {
     public static int countEvens(List<Integer> nums) {
 
         // TODO: Implement this method
+        int count = 0;
+
+        for (Integer num : nums){
+            if(num % 2 == 0){
+                count++;
+            }
+        }
 
-        return 0;
+        return count;
     }
 
     /*
@@ -67,6 +79,16 @@ public static int countEvens(List<Integer> nums) {
     public static boolean hasDuplicate(List<Integer> nums) {
 
         // TODO: Implement this method
+        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;
+                }
+
+            }
+        }
+
 
         return false;
     }
@@ -82,8 +104,15 @@ public static boolean hasDuplicate(List<Integer> nums) {
     public static int findMax(List<Integer> nums) {
 
         // TODO: Implement this method
+        int max = Integer.MIN_VALUE;
 
-        return 0;
+        for (Integer num : nums) {
+            if (num > max) {
+                max = num;
+            }
+        }
+
+        return max;
     }
 
     /*
@@ -100,6 +129,13 @@ public static List<Integer> reverse(List<Integer> nums) {
 
         // TODO: Implement this method
 
-        return null;
+        List<Integer> reversed = new ArrayList<>();
+
+        for (int i = nums.size() - 1; i >= 0; i--) {
+            reversed.add(nums.get(i));
+        }
+
+
+        return reversed;
     }
 }
diff --git a/src/main/java/Lists/LinkedLists/LinkedListProblems.java b/src/main/java/Lists/LinkedLists/LinkedListProblems.java
index 178a2ba..b4f9de7 100644
--- a/src/main/java/Lists/LinkedLists/LinkedListProblems.java
+++ b/src/main/java/Lists/LinkedLists/LinkedListProblems.java
@@ -38,6 +38,8 @@ public static void main(String[] args) {
     public static void addToFront(LinkedList<Integer> list, int value) {
 
         // TODO: Implement this method
+        list.addFirst(value);
+
 
     }
 
@@ -52,6 +54,7 @@ public static void addToFront(LinkedList<Integer> list, int value) {
     public static void addToEnd(LinkedList<Integer> list, int value) {
 
         // TODO: Implement this method
+        list.addLast(value);
 
     }
 
@@ -66,6 +69,7 @@ public static void addToEnd(LinkedList<Integer> list, int value) {
     public static void removeFirstElement(LinkedList<Integer> list) {
 
         // TODO: Implement this method
+        list.removeFirst();
 
     }
 
@@ -80,6 +84,7 @@ public static void removeFirstElement(LinkedList<Integer> list) {
     public static void removeLastElement(LinkedList<Integer> list) {
 
         // TODO: Implement this method
+        list.removeLast();
 
     }
 
@@ -95,7 +100,7 @@ public static int getFirstElement(LinkedList<Integer> list) {
 
         // TODO: Implement this method
 
-        return 0;
+        return list.getFirst();
     }
 
     /*
@@ -110,6 +115,7 @@ 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..893d0b4 100644
--- a/src/main/java/Maps/HashMap/HashMapProblems.java
+++ b/src/main/java/Maps/HashMap/HashMapProblems.java
@@ -35,6 +35,7 @@ public static void main(String[] args) {
     public static void addItem(Map<String, Integer> map, String item, int quantity) {
 
         // TODO: Implement this method
+        map.put(item, quantity);
 
     }
 
@@ -50,7 +51,8 @@ public static int getQuantity(Map<String, Integer> map, String item) {
 
         // TODO: Implement this method
 
-        return 0;
+
+        return map.get(item);
     }
 
     /*
@@ -64,6 +66,7 @@ public static int getQuantity(Map<String, Integer> map, String item) {
     public static void updateQuantity(Map<String, Integer> map, String item, int newQuantity) {
 
         // TODO: Implement this method
+        map.put(item, newQuantity);
 
     }
 
@@ -78,6 +81,7 @@ public static void updateQuantity(Map<String, Integer> map, String item, int new
     public static void removeItem(Map<String, Integer> map, String item) {
 
         // TODO: Implement this method
+        map.remove(item);
 
     }
 
@@ -92,7 +96,14 @@ public static void removeItem(Map<String, Integer> map, String item) {
     public static Map<Integer, Integer> countFrequency(List<Integer> numbers) {
 
         // TODO: Implement this method
+        Map<Integer, Integer> frequent = new HashMap<>();
+
+        for (Integer num : numbers) {
+            frequent.put(num, frequent.getOrDefault(num, 0) + 1);
+        }
+
+
+        return frequent;
 
-        return null;
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/Maps/LinkedHashMap/LinkedHashMapProblems.java b/src/main/java/Maps/LinkedHashMap/LinkedHashMapProblems.java
index e8bbdc2..b7f0cf9 100644
--- a/src/main/java/Maps/LinkedHashMap/LinkedHashMapProblems.java
+++ b/src/main/java/Maps/LinkedHashMap/LinkedHashMapProblems.java
@@ -33,6 +33,7 @@ public static void main(String[] args) {
     public static void addStudent(Map<String, Integer> map, String name, int grade) {
 
         // TODO: Implement this method
+        map.put(name, grade);
 
     }
 
@@ -47,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) {
 
         // TODO: Implement this method
+        map.put(name, newGrade);
+
 
     }
 
@@ -61,6 +64,7 @@ public static void updateGrade(Map<String, Integer> map, String name, int newGra
     public static void removeStudent(Map<String, Integer> map, String name) {
 
         // TODO: Implement this method
+        map.remove(name);
 
     }
 
@@ -75,6 +79,9 @@ public static void removeStudent(Map<String, Integer> map, String name) {
     public static String getFirstInserted(Map<String, Integer> map) {
 
         // TODO: Implement this method
+        for (String key : map.keySet()){
+            return key;
+        }
 
         return null;
     }
@@ -91,7 +98,21 @@ public static String getFirstInserted(Map<String, Integer> map) {
     public static Map<String, Integer> wordFrequency(List<String> words) {
 
         // TODO: Implement this method
+        Map<String, Integer> frequency = new LinkedHashMap<>();
 
-        return null;
+        for (String word : words) {
+
+            if (frequency.containsKey(word)) {
+                frequency.put(word, frequency.get(word) + 1);
+            } else {
+                frequency.put(word, 1);
+            }
+
+        }
+
+        return frequency;
     }
-}
+
+
+    }
+
diff --git a/src/main/java/Maps/TreeMap/TreeMapProblems.java b/src/main/java/Maps/TreeMap/TreeMapProblems.java
index b101d2e..0181242 100644
--- a/src/main/java/Maps/TreeMap/TreeMapProblems.java
+++ b/src/main/java/Maps/TreeMap/TreeMapProblems.java
@@ -31,6 +31,7 @@ public static void main(String[] args) {
     public static void addPlayer(TreeMap<Integer, String> map, int rank, String name) {
 
         // TODO: Implement this method
+        map.put(rank,name);
 
     }
 
@@ -46,7 +47,7 @@ public static String getTopPlayer(TreeMap<Integer, String> map) {
 
         // TODO: Implement this method
 
-        return null;
+        return map.get(map.firstKey());
     }
 
     /*
@@ -61,7 +62,7 @@ public static String getLowestPlayer(TreeMap<Integer, String> map) {
 
         // TODO: Implement this method
 
-        return null;
+        return map.get(map.lastKey());
     }
 
     /*
@@ -75,6 +76,7 @@ public static String getLowestPlayer(TreeMap<Integer, String> map) {
     public static void removePlayer(TreeMap<Integer, String> map, int rank) {
 
         // TODO: Implement this method
+        map.remove(rank);
 
     }
 
@@ -90,6 +92,6 @@ public static Integer getNextRank(TreeMap<Integer, String> map, int rank) {
 
         // TODO: Implement this method
 
-        return null;
+        return map.higherKey(rank);
     }
 }
diff --git a/src/main/java/Queues/ArrayDeque/ArrayDequeProblems.java b/src/main/java/Queues/ArrayDeque/ArrayDequeProblems.java
index dac03cf..748bdd8 100644
--- a/src/main/java/Queues/ArrayDeque/ArrayDequeProblems.java
+++ b/src/main/java/Queues/ArrayDeque/ArrayDequeProblems.java
@@ -31,6 +31,7 @@ public static void main(String[] args) {
     public static void addToFront(ArrayDeque<Integer> deque, int value) {
 
         // TODO: Implement this method
+        deque.addFirst(value);
 
     }
 
@@ -45,6 +46,7 @@ public static void addToFront(ArrayDeque<Integer> deque, int value) {
     public static void addToBack(ArrayDeque<Integer> deque, int value) {
 
         // TODO: Implement this method
+        deque.addLast(value);
 
     }
 
@@ -59,6 +61,7 @@ public static void addToBack(ArrayDeque<Integer> deque, int value) {
     public static void removeFront(ArrayDeque<Integer> deque) {
 
         // TODO: Implement this method
+        deque.removeFirst();
 
     }
 
@@ -73,6 +76,7 @@ public static void removeFront(ArrayDeque<Integer> deque) {
     public static void removeBack(ArrayDeque<Integer> deque) {
 
         // TODO: Implement this method
+        deque.removeLast();
 
     }
 
@@ -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..3339e95 100644
--- a/src/main/java/Queues/Deque/DequeProblems.java
+++ b/src/main/java/Queues/Deque/DequeProblems.java
@@ -6,6 +6,29 @@ public class DequeProblems {
     public static void main(String[] args) {
 
         // You can test your methods here
+        Deque<Integer> deque = new java.util.ArrayDeque<>();
+
+        // Test adding
+        addFront(deque, 10);
+        addFront(deque, 5);
+        addBack(deque, 20);
+
+        System.out.println("After adding: " + deque);
+
+        // Test peeking
+        System.out.println("Peek Front: " + peekFront(deque));
+
+        System.out.println("Peek Back: " + peekBack(deque));
+
+        // Test removing
+        System.out.println("Removed Front: " + removeFront(deque));
+
+        System.out.println("After removing front: " + deque);
+
+        System.out.println("Removed Back: " + removeBack(deque));
+
+        System.out.println("Final deque: " + deque);
+
 
     }
 
@@ -20,6 +43,7 @@ public static void main(String[] args) {
     public static void addFront(Deque<Integer> deque, int value) {
 
         // TODO: Implement this method
+        deque.addFirst(value);
 
     }
 
@@ -34,6 +58,7 @@ public static void addFront(Deque<Integer> deque, int value) {
     public static void addBack(Deque<Integer> deque, int value) {
 
         // TODO: Implement this method
+        deque.addLast(value);
 
     }
 
@@ -49,7 +74,7 @@ public static Integer removeFront(Deque<Integer> deque) {
 
         // TODO: Implement this method
 
-        return null;
+        return deque.removeFirst();
     }
 
     /*
@@ -64,7 +89,7 @@ public static Integer removeBack(Deque<Integer> deque) {
 
         // TODO: Implement this method
 
-        return null;
+        return deque.removeLast();
     }
 
     /*
@@ -79,7 +104,7 @@ public static Integer peekFront(Deque<Integer> deque) {
 
         // TODO: Implement this method
 
-        return null;
+        return deque.peekFirst();
     }
 
     /*
@@ -94,7 +119,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..2cbfcce 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;
 
@@ -7,6 +8,21 @@ public class HashSetProblems {
     public static void main(String[] args) {
 
         // You can test your methods here
+        Set<String> fruits = new HashSet<>();
+
+        addElement(fruits, "apple");
+        addElement(fruits, "banana");
+        addElement(fruits, "apple"); // duplicate
+
+        System.out.println("Set: " + fruits);
+
+        System.out.println("Contains banana: " + containsValue(fruits, "banana"));
+
+        removeValue(fruits, "apple");
+        System.out.println("After removing apple: " + fruits);
+
+        System.out.println("Unique count: " + getUniqueCount(fruits));
+
 
     }
 
@@ -21,6 +37,7 @@ public static void main(String[] args) {
     public static void addElement(Set<String> set, String value) {
 
         // TODO: Implement this method
+        set.add(value);
 
     }
 
@@ -36,7 +53,7 @@ public static boolean containsValue(Set<String> set, String value) {
 
         // TODO: Implement this method
 
-        return false;
+        return set.contains(value);
     }
 
     /*
@@ -50,6 +67,7 @@ public static boolean containsValue(Set<String> set, String value) {
     public static void removeValue(Set<String> set, String value) {
 
         // TODO: Implement this method
+        set.remove(value);
 
     }
 
@@ -65,7 +83,7 @@ public static int getUniqueCount(Set<String> set) {
 
         // TODO: Implement this method
 
-        return 0;
+        return set.size();
     }
 
     /*
@@ -80,6 +98,6 @@ public static Set<Integer> getUniqueValues(List<Integer> numbers) {
 
         // TODO: Implement this method
 
-        return null;
+        return new HashSet<>(numbers);
     }
 }