diff --git a/src/Main.java b/src/Main.java
index 036c766..57b84f8 100644
--- a/src/Main.java
+++ b/src/Main.java
@@ -6,7 +6,7 @@
 public class Main {
 
   // The time complexity is:
-  // YOUR ANSWER HERE
+  // O(n^2) where n is the number of times the loop runs (x)
   public static void timesTable(int x) {
     for(int i = 1; i <= x; i++) {
         for(int j = 1; j <= x; j++) {
@@ -17,7 +17,7 @@ public static void timesTable(int x) {
   }
 
   // The time complexity is:
-  // YOUR ANSWER HERE
+  // O(n)
   public static void printLetters(String word) {
     char[] letters = word.toCharArray();
 
@@ -27,7 +27,7 @@ public static void printLetters(String word) {
   }
 
   // The time complexity is:
-  // YOUR ANSWER HERE
+  // O(n^2) where n is the number of passwords in the String[]
   public static boolean isBanned(String password) {
     String[] bannedPasswords = {"password", "hello", "qwerty"};
     boolean banned = false;
@@ -41,7 +41,7 @@ public static boolean isBanned(String password) {
 
 
   // The time complexity is:
-  // YOUR ANSWER HERE
+  // O(n) where n is the number of items in the int[]
   public static int computeProduct(int[] nums) {
     int total = 1;
     for(int num : nums) {
@@ -51,7 +51,8 @@ public static int computeProduct(int[] nums) {
   }
 
   // The time complexity is:
-  // YOUR ANSWER HERE
+  // O(n) where n is the number of items in array nums 
+  // (which is passed to the  (n) function computeProduct)
   public static void describeProduct(int[] nums) {
     System.out.println("About to compute the product of the array...");
     int product = computeProduct(nums);
@@ -60,7 +61,7 @@ public static void describeProduct(int[] nums) {
 
 
   // The time complexity is:
-  // YOUR ANSWER HERE
+  // O(n) where n is the number of times the for loop will run
   public static int computeFactorial(int n) {
     int result = 1;
     for(int i = 1; i <= n; i++) {
@@ -71,17 +72,18 @@ public static int computeFactorial(int n) {
 
   // Assume that the largest number is no bigger than the length
   // of the array
+  // O(n^2) (O(n)*O(n)) where n is the length of the nums array
   public static void computeAllFactorials(int[] nums) {
-    for(int num : nums) {
-        int result = computeFactorial(num);
-        System.out.println("The factorial of " + num + " is " + result);
+    for(int num : nums) { //O(n)
+        int result = computeFactorial(num); //O(n)
+        System.out.println("The factorial of " + num + " is " + result); //(1)
     }
   }
 
 
   // assume that each String is bounded by a constant length
   // The time complexity is:
-  // YOUR ANSWER HERE
+  // O(n) because it is a list it has to go through every item
   public static void checkIfContainedArrayList(ArrayList<String> arr, String target) {
     if (arr.contains(target)) {
         System.out.println(target + " is present in the list");
@@ -94,7 +96,7 @@ public static void checkIfContainedArrayList(ArrayList<String> arr, String targe
   // assume n = wordsA.length = wordsB.length
   // assume that each String is bounded by a constant length
   // The time complexity is:
-  // YOUR ANSWER HERE
+  // O(n^2) each loop will operate O(n) times, so O(n)*O(n)=O(n^2)
   public static boolean containsOverlap(String[] wordsA, String[] wordsB) {
     for(String wordA : wordsA) {
         for(String wordB : wordsB) {
@@ -108,7 +110,7 @@ public static boolean containsOverlap(String[] wordsA, String[] wordsB) {
 
   // assume that each String is bounded by a constant length
   // The time complexity is:
-  // YOUR ANSWER HERE
+  // O(n) each loop will run O(n) times O(N)+O(n)=O(n)
   public static boolean containsOverlap2(String[] wordsA, String[] wordsB) {
     Set<String> wordsSet = new HashSet<>();
     for(String word : wordsA) {
@@ -125,7 +127,7 @@ public static boolean containsOverlap2(String[] wordsA, String[] wordsB) {
   }
 
   // The time complexity is:
-  // YOUR ANSWER HERE
+  // O(n) where n is the number of characters in the array
   public static void printCharacters(char[] chars) {
     for (int i = 0; i < chars.length; i++) {
       char character = chars[i];
@@ -133,14 +135,14 @@ public static void printCharacters(char[] chars) {
     }
   }
   // The time complexity is:
-  // YOUR ANSWER HERE
+  // O(1) 
   public static double computeAverage(double a, double b) {
     return (a + b) / 2.0;
   }
 
   // assume that each String is bounded by a constant length
   // The time complexity is:
-  // YOUR ANSWER HERE
+  // O(1) because contains for a hashset is O(1) and there is not a loop
   public static void checkIfContainedHashSet(HashSet<String> set, String target)
   {
     if (set.contains(target)) {
@@ -156,7 +158,7 @@ public static void checkIfContainedHashSet(HashSet<String> set, String target)
   // Otherwise, it returns "Person not found"
   // assume that each String is bounded by a constant length
   // What is the time complexity of this method?
-  // YOUR ANSWER HERE
+  // O(n) where n is the number of items in the names array
   public static String emailLookup(String[] names, String[] emails, String queryName) {
     for(int i = 0; i < names.length; i++) {
       if (names[i].equals(queryName)) {
@@ -172,15 +174,19 @@ public static String emailLookup(String[] names, String[] emails, String queryNa
   // Write this method to efficiently return the corresponding email or "Person not found" if appropriate
   // assume that each String is bounded by a constant length
   // What is the time complexity of your solution?
-  // YOUR ANSWER HERE
+  // O(1) becuase .get and .contains are both O(1) operations for a hashmap
   public static String emailLookupEfficient(HashMap<String, String> namesToEmails, String queryName) {
-    return null;
+    if (namesToEmails.containsKey(queryName)) {
+      return namesToEmails.get(queryName);
+    }
+
+    return "Person not found";
   }
 
   // What is the time complexity of this method?
   // assume that each String is bounded by a constant length
   // (assume the set and list have the same number of elements)
-  // YOUR ANSWER HERE
+  // O(n^2) where the loop is O(n) for each item in the wordSet and the wordList.contains is O(n)
   public static boolean hasCommon(HashSet<String> wordSet, ArrayList<String> wordList) {
     for(String word : wordSet) {
       if(wordList.contains(word)) {
@@ -193,8 +199,15 @@ public static boolean hasCommon(HashSet<String> wordSet, ArrayList<String> wordL
   // Do not change the datatype of wordSet or wordList.
   // assume that each String is bounded by a constant length
   // What is the time complexity of your new solution?
-  // YOUR ANSWER HERE
+  // O(n) since .contains for hashSet is complexity O(1)*O(n)for the for each loop
+  // where n is the number of items in the loop
   public static boolean hasCommonEfficient(HashSet<String> wordSet, ArrayList<String> wordList) {
+    for(String word : wordList) {
+      if(wordSet.contains(word)) {
+        return true;
+      }
+    }
+
     return false;
   }
 
@@ -203,14 +216,14 @@ public static boolean hasCommonEfficient(HashSet<String> wordSet, ArrayList<Stri
   // The prices will be updated frequently throughout the day, and you need to efficiently update
   // and access the current price for each stock. The order of the ticker symbols is not important.
   // What would be a good choice of data structure?
-  // YOUR ANSWER HERE
+  // HashMap because the values do not need to be in order, we need to save a key/value pair, and HashMaps are slightly faster to add/get
 
   // Suppose you are building a music player application where users can create playlists.
   // Songs can be added to the end of the playlist in the order the user chooses, and the user can
   // skip to the next or previous song. Most operations involve adding songs and accessing them by
   // their position in the playlist.
   // What would be a good choice of data structure?
-  // YOUR ANSWER HERE
+  // ArrayList because we can access the items by index, items can be added or removed from the list, and we don't need to define how long the list will be at the start
 
   // Suppose you are developing a search feature that keeps track of the user's
   // recent search queries. You want to store the queries in the order they were made,
@@ -218,5 +231,5 @@ public static boolean hasCommonEfficient(HashSet<String> wordSet, ArrayList<Stri
   // relatively small, and it is more important to preserve the order of the searches than
   // to optimize for fast lookups or deletions.
   // What would be a good choice of data structure?
-  // YOUR ANSWER HERE
+  // TreeSet because the order IS important, but it has quick adds/removes and will be a small list
 }
\ No newline at end of file