diff --git a/Concurrency/Building H2O.java b/Concurrency/Building H2O.java
index 2d2dee57..04fda0bc 100644
--- a/Concurrency/Building H2O.java	
+++ b/Concurrency/Building H2O.java	
@@ -1,26 +1,24 @@
 class H2O {
-  
-  private final Semaphore hydrogenSemaphore;
-  private final Semaphore oxygenSemaphore;
+    
+    private Semaphore hydrogenSemaphore;
+    private Semaphore oxygenSemaphore;
 
-  public H2O() {
-    this.hydrogenSemaphore = new Semaphore(2);
-    this.oxygenSemaphore = new Semaphore(0);
-  }
+    public H2O() {
+        this.hydrogenSemaphore = new Semaphore(2);
+        this.oxygenSemaphore = new Semaphore(0);
+    }
 
-  public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
+    public void hydrogen(Runnable releaseHydrogen) throws InterruptedException {
+		hydrogenSemaphore.acquire();
+        // releaseHydrogen.run() outputs "H". Do not change or remove this line.
+        releaseHydrogen.run();
+        this.oxygenSemaphore.release();
+    }
 
-    this.hydrogenSemaphore.acquire();
-    // releaseHydrogen.run() outputs "H". Do not change or remove this line.
-    releaseHydrogen.run();
-    this.oxygenSemaphore.release();
-  }
-
-  public void oxygen(Runnable releaseOxygen) throws InterruptedException {
-
-    this.oxygenSemaphore.acquire(2);
-    // releaseOxygen.run() outputs "O". Do not change or remove this line.
-    releaseOxygen.run();
-    this.hydrogenSemaphore.release(2);
-  }
+    public void oxygen(Runnable releaseOxygen) throws InterruptedException {
+        this.oxygenSemaphore.acquire(2);
+        // releaseOxygen.run() outputs "O". Do not change or remove this line.
+		releaseOxygen.run();
+        this.hydrogenSemaphore.release(2);
+    }
 }
diff --git a/Concurrency/Fizz Buzz Multithreaded.java b/Concurrency/Fizz Buzz Multithreaded.java
index 2e213c7c..b749ba25 100644
--- a/Concurrency/Fizz Buzz Multithreaded.java	
+++ b/Concurrency/Fizz Buzz Multithreaded.java	
@@ -1,77 +1,71 @@
 class FizzBuzz {
-  private int n;
-  private int count;
-  private Semaphore fizz;
-  private Semaphore buzz;
-  private Semaphore fizzBuzz;
-  private Semaphore number;
+    private int n;
+    private final Semaphore fizzSemaphore;
+    private final Semaphore buzzSemaphore;
+    private final Semaphore fizzBuzzSemaphore;
+    private final Semaphore numSemaphore;
 
-  public FizzBuzz(int n) {
-    this.n = n;
-    this.count = 1;
-    this.fizz = new Semaphore(0);
-    this.buzz = new Semaphore(0);
-    this.fizzBuzz = new Semaphore(0);
-    this.number = new Semaphore(1);
-  }
+    public FizzBuzz(int n) {
+        this.n = n;
+        this.fizzSemaphore = new Semaphore(0);
+        this.buzzSemaphore = new Semaphore(0);
+        this.fizzBuzzSemaphore = new Semaphore(0);
+        this.numSemaphore = new Semaphore(1);
+    }
 
-  // printFizz.run() outputs "fizz".
-  public void fizz(Runnable printFizz) throws InterruptedException {
-    while (this.count <= this.n) {
-      if (this.count % 3 == 0 && this.count % 5 != 0) {
-        this.fizz.acquire();
-        printFizz.run();
-        this.count++;
-        releaseLock(this.count);
-      }
+    // printFizz.run() outputs "fizz".
+    public void fizz(Runnable printFizz) throws InterruptedException {
+        for (int i = 1; i <= n; i++) {
+            if (i % 3 == 0 && i % 5 != 0) {
+                fizzSemaphore.acquire();
+                printFizz.run();
+                releaseLock(i + 1);
+            }
+        }
     }
-  }
 
-  // printBuzz.run() outputs "buzz".
-  public void buzz(Runnable printBuzz) throws InterruptedException {
-    while (this.count <= this.n) {
-      if (this.count % 3 != 0 && this.count % 5 == 0) {
-        this.buzz.acquire();
-        printBuzz.run();
-        this.count++;
-        releaseLock(this.count);
-      }
+    // printBuzz.run() outputs "buzz".
+    public void buzz(Runnable printBuzz) throws InterruptedException {
+        for (int i = 1; i <= n; i++) {
+            if (i % 3 != 0 && i % 5 == 0) {
+                buzzSemaphore.acquire();
+                printBuzz.run();
+                releaseLock(i + 1);
+            }
+        }
     }
-  }
 
-  // printFizzBuzz.run() outputs "fizzbuzz".
-  public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException {
-    while (this.count <= this.n) {
-      if (this.count % 3 == 0 && this.count % 5 == 0) {
-        this.fizzBuzz.acquire();
-        printFizzBuzz.run();
-        this.count++;
-        releaseLock(this.count);
-      }
+    // printFizzBuzz.run() outputs "fizzbuzz".
+    public void fizzbuzz(Runnable printFizzBuzz) throws InterruptedException {
+        for (int i = 1; i <= n; i++) {
+            if (i % 3 == 0 && i % 5 == 0) {
+                fizzBuzzSemaphore.acquire();
+                printFizzBuzz.run();
+                releaseLock(i + 1);
+            }
+        }
     }
-  }
 
-  // printNumber.accept(x) outputs "x", where x is an integer.
-  public void number(IntConsumer printNumber) throws InterruptedException {
-    while (this.count <= this.n) {
-      if (this.count % 3 != 0 && this.count % 5 != 0) {
-        this.number.acquire();
-        printNumber.accept(this.count);
-        this.count++;
-        releaseLock(this.count);
-      }
+    // printNumber.accept(x) outputs "x", where x is an integer.
+    public void number(IntConsumer printNumber) throws InterruptedException {
+        for (int i = 1; i <= n; i++) {
+            if (i % 3 != 0 && i % 5 != 0) {
+                numSemaphore.acquire();
+                printNumber.accept(i);
+                releaseLock(i + 1);
+            }
+        }
     }
-  }
-  
-  private void releaseLock(int n) {
-    if (n % 15 == 0) {
-      this.fizzBuzz.release();
-    } else if (n % 3 == 0) {
-      this.fizz.release();
-    } else if (n % 5 == 0) {
-      this.buzz.release();
-    } else {
-      this.number.release();
+    
+    private void releaseLock(int num) {
+        if (num % 3 == 0 && num % 5 == 0) {
+            fizzBuzzSemaphore.release();
+        } else if (num % 3 == 0 && num % 5 != 0) {
+            fizzSemaphore.release();
+        } else if (num % 3 != 0 && num % 5 == 0) {
+            buzzSemaphore.release();
+        } else {
+            numSemaphore.release();
+        }
     }
-  }
 }
diff --git a/Concurrency/Print FooBar Alternately.java b/Concurrency/Print FooBar Alternately.java
index f19a774f..94fa19cc 100644
--- a/Concurrency/Print FooBar Alternately.java	
+++ b/Concurrency/Print FooBar Alternately.java	
@@ -1,32 +1,33 @@
 class FooBar {
-  private int n;
-
-  private Semaphore fooSemaphore = new Semaphore(1);
-  private Semaphore barSemaphore = new Semaphore(0);
-
-  public FooBar(int n) {
-    this.n = n;
-  }
-
-  public void foo(Runnable printFoo) throws InterruptedException {
-
-    for (int i = 0; i < n; i++) {
-
-      // printFoo.run() outputs "foo". Do not change or remove this line.
-      fooSemaphore.acquire();
-      printFoo.run();
-      barSemaphore.release();
+    private int n;
+    
+    private final Semaphore fooMutex;
+    private final Semaphore barMutex;
+
+    public FooBar(int n) {
+        this.n = n;
+        this.fooMutex = new Semaphore(1);
+        this.barMutex = new Semaphore(0);
     }
-  }
-
-  public void bar(Runnable printBar) throws InterruptedException {
 
-    for (int i = 0; i < n; i++) {
+    public void foo(Runnable printFoo) throws InterruptedException {
+        
+        for (int i = 0; i < n; i++) {
+            
+        	// printFoo.run() outputs "foo". Do not change or remove this line.
+            this.fooMutex.acquire();
+        	printFoo.run();
+            this.barMutex.release();
+        }
+    }
 
-      // printBar.run() outputs "bar". Do not change or remove this line.
-      barSemaphore.acquire();
-      printBar.run();
-      fooSemaphore.release();
+    public void bar(Runnable printBar) throws InterruptedException {
+        
+        for (int i = 0; i < n; i++) {
+            this.barMutex.acquire();
+            // printBar.run() outputs "bar". Do not change or remove this line.
+        	printBar.run();
+            this.fooMutex.release();
+        }
     }
-  }
 }
diff --git a/Concurrency/Print Zero Even Odd.java b/Concurrency/Print Zero Even Odd.java
index 35b3a599..784b7fd7 100644
--- a/Concurrency/Print Zero Even Odd.java	
+++ b/Concurrency/Print Zero Even Odd.java	
@@ -1,42 +1,43 @@
 class ZeroEvenOdd {
-  private int n;
-  private int flag = 0;
-
-  public ZeroEvenOdd(int n) {
-    this.n = n;
-  }
+    private int n;
+    
+    private final Semaphore zeroMutex;
+    private final Semaphore oddMutex;
+    private final Semaphore evenMutex;
+    
+    public ZeroEvenOdd(int n) {
+        this.n = n;
+        this.zeroMutex = new Semaphore(1);
+        this.oddMutex = new Semaphore(0);
+        this.evenMutex = new Semaphore(0);
+    }
 
-  // printNumber.accept(x) outputs "x", where x is an integer.
-  public synchronized void zero(IntConsumer printNumber) throws InterruptedException {
-    for (int i = 0; i < n; i++) {
-      while (flag != 0) {
-        this.wait();
-      }
-      printNumber.accept(0);
-      flag = i % 2 == 0 ? 1 : 2;
-      this.notifyAll();
+    // printNumber.accept(x) outputs "x", where x is an integer.
+    public void zero(IntConsumer printNumber) throws InterruptedException {
+        for (int i = 0; i < n; i++) {
+            this.zeroMutex.acquire();
+            printNumber.accept(0);
+            if (i % 2 == 0) {
+                this.oddMutex.release();
+            } else {
+                this.evenMutex.release();
+            }
+        }
     }
-  }
 
-  public synchronized void even(IntConsumer printNumber) throws InterruptedException {
-    for (int i = 2; i <= n; i += 2) {
-      while (flag != 2) {
-        this.wait();
-      }
-      printNumber.accept(i);
-      flag = 0;
-      this.notifyAll();
+    public void even(IntConsumer printNumber) throws InterruptedException {
+        for (int i = 2; i <= n; i += 2) {
+            this.evenMutex.acquire();
+            printNumber.accept(i);
+            this.zeroMutex.release();
+        }
     }
-  }
 
-  public synchronized void odd(IntConsumer printNumber) throws InterruptedException {
-    for (int i = 1; i <= n; i += 2) {
-      while (flag != 1) {
-        this.wait();
-      }
-      printNumber.accept(i);
-      flag = 0;
-      this.notifyAll();
+    public void odd(IntConsumer printNumber) throws InterruptedException {
+        for (int i = 1; i <= n; i += 2) {
+            this.oddMutex.acquire();
+            printNumber.accept(i);
+            this.zeroMutex.release();
+        } 
     }
-  }
 }
diff --git a/Concurrency/README.md b/Concurrency/README.md
new file mode 100644
index 00000000..8bc6ef63
--- /dev/null
+++ b/Concurrency/README.md
@@ -0,0 +1,11 @@
+# Concurrency LeetCode Java Solutions 
+S.no | Coding Problem 
+--- | --- 
+1 | [Building H2O](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Building%20H2O.java)
+2 | [Design Bounded Blocking Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Design%20Bounded%20Blocking%20Queue.java)
+3 | [Fizz Buzz Multithreaded](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Fizz%20Buzz%20Multithreaded.java)
+4 | [Print FooBar Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Print%20FooBar%20Alternately.java)
+5 | [Print Zero Even Odd](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Print%20Zero%20Even%20Odd.java)
+6 | [Print in Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Print%20in%20Order.java)
+7 | [The Dining Philosophers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/The%20Dining%20Philosophers.java)
+8 | [Traffic Light Controlled Intersection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Concurrency/Traffic%20Light%20Controlled%20Intersection.java)
diff --git a/Concurrency/Web Crawler Multithreaded.java b/Concurrency/Web Crawler Multithreaded.java
new file mode 100644
index 00000000..bb48616c
--- /dev/null
+++ b/Concurrency/Web Crawler Multithreaded.java	
@@ -0,0 +1,108 @@
+/**
+ * // This is the HtmlParser's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * interface HtmlParser {
+ *     public List<String> getUrls(String url) {}
+ * }
+ */
+import java.net.URI;
+import java.net.URISyntaxException;
+
+
+class Solution {
+    public List<String> crawl(String startUrl, HtmlParser htmlParser) {
+        ResultRecord resultRecord = new ResultRecord();
+        CrawlTask task = new CrawlTask(
+            startUrl, htmlParser, resultRecord, UrlUtil.parseHostname(startUrl));
+        try {
+            task.start();
+            task.join();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        return resultRecord.getResultList();
+    }
+}
+
+class CrawlTask extends Thread {
+    
+    private final String url;
+    private final HtmlParser htmlParser;
+    private final ResultRecord resultRecord;
+    private final String parentHost;
+    
+    public CrawlTask(String url, 
+                     HtmlParser htmlParser, 
+                     ResultRecord resultRecord,
+                     String parentHost) {
+        this.url = url;
+        this.htmlParser = htmlParser;
+        this.resultRecord = resultRecord;
+        this.parentHost = parentHost;
+    }
+    
+    public void run() {
+        String hostname = UrlUtil.parseHostname(url);
+        if (!hostname.equals(parentHost)) {
+            return;
+        }
+        if (resultRecord.addIfNotExists(url)) {
+            List<String> childUrls = htmlParser.getUrls(url);
+            List<CrawlTask> tasks = new ArrayList<>();
+            for (String childUrl : childUrls) {
+                tasks.add(new CrawlTask(
+                    childUrl, htmlParser, resultRecord, parentHost));
+            }
+            try {
+                for (CrawlTask task : tasks) {
+                    task.start();
+                }
+                for (CrawlTask task : tasks) {
+                    task.join();
+                }
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+
+class UrlUtil {
+    
+    public static String parseHostname(String url) {
+        try {
+            URI uri = new URI(url);
+            return uri.getHost();
+        } catch(URISyntaxException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+}
+
+class ResultRecord {
+
+    private Set<String> urls;
+    private Semaphore mutex;
+    
+    public ResultRecord() {
+        this.urls = new HashSet<>();
+        this.mutex = new Semaphore(1);
+    }
+    
+    public boolean addIfNotExists(String url) {
+        try {
+            this.mutex.acquire();
+            boolean added = this.urls.add(url);
+            this.mutex.release();
+            return added;
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        return false;
+    } 
+    
+    public List<String> getResultList() {
+        return new ArrayList<>(urls);
+    }
+}
diff --git a/Easy/Account Balance After Rounded Purchase.java b/Easy/Account Balance After Rounded Purchase.java
new file mode 100644
index 00000000..3342d18d
--- /dev/null
+++ b/Easy/Account Balance After Rounded Purchase.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public int accountBalanceAfterPurchase(int purchaseAmount) {
+        if (purchaseAmount % 10 >= 5) {
+            purchaseAmount += 10 - purchaseAmount % 10;
+        } else {
+            purchaseAmount -= purchaseAmount % 10;
+        }
+        return 100 - purchaseAmount;
+    }
+}
diff --git a/Easy/Add to Array-Form of Integer.java b/Easy/Add to Array-Form of Integer.java
index 1ef362dd..64cbbb31 100644
--- a/Easy/Add to Array-Form of Integer.java	
+++ b/Easy/Add to Array-Form of Integer.java	
@@ -1,15 +1,22 @@
 class Solution {
-  public List<Integer> addToArrayForm(int[] num, int k) {
-    int carry = 0;
-    int idx = num.length - 1;
-    List<Integer> result = new ArrayList<>();
-    while (idx >= 0 || carry > 0 || k > 0) {
-      int temp = k % 10 + carry + (idx >= 0 ? num[idx--] : 0);
-      result.add(temp % 10);
-      carry = temp / 10;
-      k /= 10;
+    public List<Integer> addToArrayForm(int[] num, int k) {
+        List<Integer> result = new ArrayList<>();
+        int idx = num.length - 1;
+        int carry = 0;
+        while (idx >= 0 || k > 0 || carry > 0) {
+            if (idx >= 0 && k > 0) {
+                carry += num[idx--] + k % 10;
+                k /= 10;
+            } else if (idx >= 0 && k == 0) {
+                carry += num[idx--];
+            } else if (idx < 0 && k > 0) {
+                carry += k % 10;
+                k /= 10;
+            }
+            result.add(carry % 10);
+            carry /= 10;
+        }
+        Collections.reverse(result);
+        return result;
     }
-    Collections.reverse(result);
-    return result;
-  }
 }
diff --git a/Easy/Adjacent Increasing Subarrays Detection I.java b/Easy/Adjacent Increasing Subarrays Detection I.java
new file mode 100644
index 00000000..5be82de7
--- /dev/null
+++ b/Easy/Adjacent Increasing Subarrays Detection I.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public boolean hasIncreasingSubarrays(List<Integer> nums, int k) {
+        int n = nums.size();
+        for (int i = 0; i <= n - 2 * k; i++) {
+            if (isStrictlyIncreasing(nums, i, k) && isStrictlyIncreasing(nums, i + k, k)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean isStrictlyIncreasing(List<Integer> nums, int idx, int k) {
+        for (int start = idx; start < idx + k - 1; start++) {
+            if (nums.get(start) >= nums.get(start + 1)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/Easy/Alternating Digit Sum.java b/Easy/Alternating Digit Sum.java
new file mode 100644
index 00000000..4505e2e3
--- /dev/null
+++ b/Easy/Alternating Digit Sum.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int alternateDigitSum(int n) {
+        int firstHalf = 0;
+        int secondHalf = 0;
+        int count = 0;
+        while (n > 0) {
+            secondHalf += n % 10;
+            n /= 10;
+            count++;
+            if (n > 0) {
+                firstHalf += n % 10;
+                n /= 10;
+                count++;
+            }
+        }
+        return count % 2 == 0 ? (firstHalf + -1 * secondHalf) : (secondHalf + -1 * firstHalf);
+    }
+}
diff --git a/Easy/Alternating Groups I.java b/Easy/Alternating Groups I.java
new file mode 100644
index 00000000..9730d5ea
--- /dev/null
+++ b/Easy/Alternating Groups I.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int numberOfAlternatingGroups(int[] colors) {
+        int count = 0;
+        int n = colors.length;
+        for (int i = 0; i < n - 2; i++) {
+            if (colors[i + 1]  != colors[i] && colors[i + 1] != colors[i + 2]) {
+                count++;
+            }
+        }
+        if (colors[n - 2] != colors[n - 1] && colors[n - 2] == colors[0]) {
+            count++;
+        }
+        if (colors[n - 1] != colors[0] && colors[n - 1] == colors[1]) {
+            count++;
+        }
+        return count;
+    }
+}
diff --git a/Easy/Ant on the Boundary.java b/Easy/Ant on the Boundary.java
new file mode 100644
index 00000000..25e95d0a
--- /dev/null
+++ b/Easy/Ant on the Boundary.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int returnToBoundaryCount(int[] nums) {
+        int currPosition = 0;
+        int count = 0;
+        for (int num : nums) {
+            currPosition += num;
+            if (currPosition == 0) {
+                count++;
+            }
+        }
+        return count;
+    }
+}
diff --git a/Easy/Apple Redistribution into Boxes.java b/Easy/Apple Redistribution into Boxes.java
new file mode 100644
index 00000000..d84bd8a8
--- /dev/null
+++ b/Easy/Apple Redistribution into Boxes.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int minimumBoxes(int[] apple, int[] capacity) {
+        int totalApples = 0;
+        for (int count : apple) {
+            totalApples  += count;
+        }
+        Arrays.sort(capacity);
+        int idx = capacity.length - 1;
+        int currCapacity = capacity[idx--];
+        while (totalApples > 0) {
+            int applesDeleted = Math.min(currCapacity, totalApples);
+            totalApples -= applesDeleted;
+            currCapacity -= applesDeleted;
+            if (currCapacity == 0 && totalApples > 0) {
+                currCapacity = capacity[idx--];
+            }
+        }
+        return capacity.length - idx - 1;
+    }
+}
diff --git a/Easy/Apply Operations to an Array.java b/Easy/Apply Operations to an Array.java
index b0a663a2..3b2bca86 100644
--- a/Easy/Apply Operations to an Array.java	
+++ b/Easy/Apply Operations to an Array.java	
@@ -1,21 +1,20 @@
 class Solution {
     public int[] applyOperations(int[] nums) {
-        for (int i = 0; i < nums.length - 1; i++) {
+        int n = nums.length;
+        for (int i = 0; i < n - 1; i++) {
             if (nums[i] == nums[i + 1]) {
                 nums[i] *= 2;
                 nums[i + 1] = 0;
             }
         }
-        int startIdx = 0;
-        int endIdx = 0;
-        while (endIdx < nums.length) {
-            if (nums[endIdx] != 0) {
-                nums[startIdx++] = nums[endIdx];
+        int start = 0;
+        for (int i = 0; i < n; i++) {
+            if (nums[i] != 0) {
+                nums[start++] = nums[i];
             }
-            endIdx++;
         }
-        while (startIdx < nums.length) {
-            nums[startIdx++] = 0;
+        while (start < n) {
+            nums[start++] = 0;
         }
         return nums;
     }
diff --git a/Easy/Assign Cookies.java b/Easy/Assign Cookies.java
index 6ff366ad..32b09bf6 100644
--- a/Easy/Assign Cookies.java	
+++ b/Easy/Assign Cookies.java	
@@ -1,15 +1,13 @@
 class Solution {
-  public int findContentChildren(int[] g, int[] s) {
-    Arrays.sort(g);
-    Arrays.sort(s);
-    int gIdx = 0;
-    int sIdx = 0;
-    while (sIdx < s.length && gIdx < g.length) {
-      if (s[sIdx] >= g[gIdx]) {
-        gIdx++;
-      }
-      sIdx++;
+    public int findContentChildren(int[] greed, int[] cookieSize) {
+        Arrays.sort(greed);
+        Arrays.sort(cookieSize);
+        int idx = 0;
+        for (int i = 0; i < cookieSize.length && idx < greed.length; i++) {
+            if (cookieSize[i] >= greed[idx]) {
+                idx++;
+            }
+        }
+        return idx;
     }
-    return gIdx;
-  }
 }
diff --git a/Easy/Average Salary Excluding the Minimum and Maximum Salary.java b/Easy/Average Salary Excluding the Minimum and Maximum Salary.java
index 08d8663e..1d4d872c 100644
--- a/Easy/Average Salary Excluding the Minimum and Maximum Salary.java	
+++ b/Easy/Average Salary Excluding the Minimum and Maximum Salary.java	
@@ -1,15 +1,13 @@
 class Solution {
-  public double average(int[] salary) {
-    int minSalary = salary[0];
-    int maxSalary = salary[0];
-    int n = salary.length;
-    int sum = 0;
-    for (int i = 0; i < n; i++) {
-      sum += salary[i];
-      minSalary = Math.min(minSalary, salary[i]);
-      maxSalary = Math.max(maxSalary, salary[i]);
+    public double average(int[] salary) {
+        int minSalary = salary[0];
+        int maxSalary = salary[0];
+        double totalSalary = 0;
+        for (int s : salary) {
+            minSalary = Math.min(minSalary, s);
+            maxSalary = Math.max(maxSalary, s);
+            totalSalary += s;
+        }
+        return (totalSalary - minSalary - maxSalary) / (salary.length - 2);
     }
-    sum -= (maxSalary + minSalary);
-    return ((double) sum) / (n - 2);
-  }
 }
diff --git a/Easy/Backspace String Compare.java b/Easy/Backspace String Compare.java
index 170f9f69..91ef6593 100644
--- a/Easy/Backspace String Compare.java	
+++ b/Easy/Backspace String Compare.java	
@@ -1,23 +1,23 @@
 class Solution {
-  public boolean backspaceCompare(String s, String t) {
-    return formBackSpaceString(s).equals(formBackSpaceString(t));
-  }
-  
-  private String formBackSpaceString(String s) {
-    Stack<Character> stack = new Stack<>();
-    for (char c : s.toCharArray()) {
-      if (c == '#') {
-        if (!stack.isEmpty()) {
-          stack.pop();
-        }
-      } else {
-        stack.push(c);
-      }
+    public boolean backspaceCompare(String s, String t) {
+        return buildBackspaceString(s).equals(buildBackspaceString(t));
     }
-    StringBuilder sb = new StringBuilder();
-    while (!stack.isEmpty()) {
-      sb.append(stack.pop());
+
+    private static String buildBackspaceString(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (c == '#') {
+                if (!stack.isEmpty()) {
+                    stack.pop();
+                }
+            } else {
+                stack.push(c);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for (char c : stack) {
+            sb.append(c);
+        }
+        return sb.toString();
     }
-    return sb.toString();
-  }
 }
diff --git a/Easy/Base 7.java b/Easy/Base 7.java
index 210d6c39..8da9a029 100644
--- a/Easy/Base 7.java	
+++ b/Easy/Base 7.java	
@@ -1,16 +1,15 @@
 class Solution {
-  public String convertToBase7(int num) {
-    StringBuilder sb = new StringBuilder();
-    char sign = num < 0 ? '-' : ' ';
-    num = Math.abs(num);
-    while (num > 0) {
-      sb.append(num % 7);
-      num /= 7;
+    public String convertToBase7(int num) {
+        StringBuilder sb = new StringBuilder();
+        boolean isNegative = num < 0;
+        num = Math.abs(num);
+        while (num > 0) {
+            sb.append(num % 7);
+            num /= 7;
+        }
+        if (isNegative) {
+            sb.append('-');
+        }
+        return sb.isEmpty() ? "0" : sb.reverse().toString();
     }
-    String representation = sb.length() == 0 ? "0" : sb.reverse().toString();
-    if (sign == '-') {
-      return sign + representation;
-    }
-    return representation;
-  }
 }
diff --git a/Easy/Buddy Strings.java b/Easy/Buddy Strings.java
index e153e52d..f34ecf35 100644
--- a/Easy/Buddy Strings.java	
+++ b/Easy/Buddy Strings.java	
@@ -1,36 +1,32 @@
 class Solution {
-  public boolean buddyStrings(String s, String goal) {
-    if (s.length() != goal.length()) {
-      return false;
-    }
-    if (s.equals(goal)) {
-      Set<Character> set = new HashSet<>();
-      for (char c : s.toCharArray()) {
-        if (set.contains(c)) {
-          return true;
-        }
-        set.add(c);
-      }
-      return false;
-    }
-    char[] mismatch = {'-', '-'};
-    for (int i = 0; i < s.length(); i++) {
-      if (s.charAt(i) != goal.charAt(i)) {
-        if (mismatch[0] == '|') {
-          return false;
+    
+    private static final int SWAP_DONE_IDX = Integer.MIN_VALUE;
+    
+    public boolean buddyStrings(String s, String goal) {
+        if (s.length() != goal.length()) {
+            return false;
         }
-        if (mismatch[0] == '-') {
-          mismatch[0] = s.charAt(i);
-          mismatch[1] = goal.charAt(i);
-        } else {
-          if (goal.charAt(i) == mismatch[0] && s.charAt(i) == mismatch[1]) {
-            mismatch[0] = '|';
-            continue;
-          }
-          return false;
+        int swapIdx = -1;
+        Set<Character> set = new HashSet<>();
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == goal.charAt(i)) {
+                set.add(s.charAt(i));
+                continue;
+            }
+            if (s.charAt(i) != goal.charAt(i)) {
+                if (swapIdx == SWAP_DONE_IDX) {
+                    return false;
+                }
+                if (swapIdx == -1) {
+                    swapIdx = i;
+                    continue;
+                } 
+                if (!(s.charAt(swapIdx) == goal.charAt(i) && s.charAt(i) == goal.charAt(swapIdx))) {
+                    return false;
+                }
+                swapIdx = SWAP_DONE_IDX;
+            }
         }
-      }
+        return (swapIdx != -1 && swapIdx == SWAP_DONE_IDX) || (swapIdx == -1 && set.size() < s.length());
     }
-    return mismatch[0] == '|';
-  }
 }
diff --git a/Easy/Build an Array With Stack Operations.java b/Easy/Build an Array With Stack Operations.java
deleted file mode 100644
index c3a57156..00000000
--- a/Easy/Build an Array With Stack Operations.java	
+++ /dev/null
@@ -1,20 +0,0 @@
-class Solution {
-  public List<String> buildArray(int[] target, int n) {
-    List<String> ans = new ArrayList<>();
-    final String PUSH = "Push";
-    final String POP = "Pop";
-    int idx = 0;
-    int curr = 1;
-    while (idx < target.length) {
-      ans.add(PUSH);
-      if (target[idx] == curr) {
-        idx++;
-      }
-      else {
-        ans.add(POP);
-      }
-      curr++;
-    }
-    return ans;
-  }
-}
diff --git a/Easy/Button with Longest Push Time.java b/Easy/Button with Longest Push Time.java
new file mode 100644
index 00000000..650bb1e4
--- /dev/null
+++ b/Easy/Button with Longest Push Time.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int buttonWithLongestTime(int[][] events) {
+        int maxTime = 0;
+        int resultIdx = 0;
+        int prevTime = 0;
+        for (int i = 0; i < events.length; i++) {
+            int timePressed = events[i][1] - prevTime;
+            if (timePressed > maxTime) {
+                maxTime = timePressed;
+                resultIdx = events[i][0];
+            } else if (timePressed == maxTime && resultIdx > events[i][0]) {
+                resultIdx = events[i][0];
+            }
+            prevTime = events[i][1];
+        }
+        return resultIdx;
+    }
+}
diff --git a/Easy/Buy Two Chocolates.java b/Easy/Buy Two Chocolates.java
new file mode 100644
index 00000000..fac6699e
--- /dev/null
+++ b/Easy/Buy Two Chocolates.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int buyChoco(int[] prices, int money) {
+        int cheapestChocolate = Math.min(prices[0], prices[1]);
+        int secondCheapestChocolate = Math.max(prices[0], prices[1]);
+        for (int i = 2; i < prices.length; i++) {
+            if (prices[i] < cheapestChocolate) {
+                secondCheapestChocolate = cheapestChocolate;
+                cheapestChocolate = prices[i];
+            } else if (prices[i] < secondCheapestChocolate) {
+                secondCheapestChocolate = prices[i];
+            }
+        }
+        int totalCost = cheapestChocolate + secondCheapestChocolate;
+        return totalCost <= money ? (money - totalCost) : money;
+    }
+}
diff --git a/Easy/Calculate Delayed Arrival Time.java b/Easy/Calculate Delayed Arrival Time.java
new file mode 100644
index 00000000..47367e00
--- /dev/null
+++ b/Easy/Calculate Delayed Arrival Time.java	
@@ -0,0 +1,6 @@
+class Solution {
+    public int findDelayedArrivalTime(int arrivalTime, int delayedTime) {
+        int newTime = arrivalTime + delayedTime;
+        return newTime - (newTime >= 24 ? 24 : 0);
+    }
+}
diff --git a/Easy/Can Make Arithmetic Progression From Sequence.java b/Easy/Can Make Arithmetic Progression From Sequence.java
index edc5b0db..fbd09e98 100644
--- a/Easy/Can Make Arithmetic Progression From Sequence.java	
+++ b/Easy/Can Make Arithmetic Progression From Sequence.java	
@@ -1,12 +1,12 @@
 class Solution {
-  public boolean canMakeArithmeticProgression(int[] arr) {
-    Arrays.sort(arr);
-    int diff = arr[1] - arr[0];
-    for (int i = 2; i < arr.length; i++) {
-      if (arr[i] - arr[i - 1] != diff) {
-        return false;
-      }
+    public boolean canMakeArithmeticProgression(int[] arr) {
+        Arrays.sort(arr);
+        int diff = arr[1] - arr[0];
+        for (int i = 2; i < arr.length; i++) {
+            if (arr[i] - arr[i - 1] != diff) {
+                return false;
+            }
+        }
+        return true;
     }
-    return true;
-  }
 }
diff --git a/Easy/Can Place Flowers.java b/Easy/Can Place Flowers.java
index c5b9df5d..eb2a21fb 100644
--- a/Easy/Can Place Flowers.java	
+++ b/Easy/Can Place Flowers.java	
@@ -1,19 +1,19 @@
 class Solution {
-  public boolean canPlaceFlowers(int[] flowerbed, int n) {
-    for (int i = 0; i < flowerbed.length && n > 0; i++) {
-      if (flowerbed[i] == 0) {
-        if (i == 0 && (flowerbed.length == 1 || flowerbed[i + 1] == 0)) {
-          flowerbed[i] = 1;
-          n--;
-        } else if (i == flowerbed.length - 1 && flowerbed[i - 1] == 0) {
-          flowerbed[i] = 1;
-          n--;
-        } else if (i + 1 < flowerbed.length && flowerbed[i + 1] == 0 && i - 1 >= 0 && flowerbed[i - 1] == 0) {
-          flowerbed[i] = 1;
-          n--;
+    public boolean canPlaceFlowers(int[] flowerbed, int n) {
+        for (int i = 0; i < flowerbed.length && n > 0; i++) {
+            if (canPlaceCheck(i, flowerbed)) {
+                flowerbed[i] = 1;
+                n--;
+            } 
         }
-      }
+        return n == 0;
+    }
+    
+    private boolean canPlaceCheck(int i, int[] flowerbed) {
+        return flowerbed[i] == 0 && (
+            (i == 0 && (i + 1 == flowerbed.length || flowerbed[i + 1] == 0)) || 
+            (i == flowerbed.length - 1 && (i - 1 == -1 || flowerbed[i - 1] == 0)) || 
+            (i != 0 && i != flowerbed.length - 1 && flowerbed[i - 1] == 0 && flowerbed[i + 1] == 0)
+        );
     }
-    return n == 0;
-  }
 }
diff --git a/Easy/Categorize Box According to Criteria.java b/Easy/Categorize Box According to Criteria.java
new file mode 100644
index 00000000..0c817a0a
--- /dev/null
+++ b/Easy/Categorize Box According to Criteria.java	
@@ -0,0 +1,23 @@
+class Solution {
+    
+    private static final int BULKY_DIMENSION_THRESHOLD = 1000_0;
+    private static final int BULKY_VOLUME_THRESHOLD = 1000_000_000;
+    private static final int HEAVY_MASS_THRESHOLD = 100;
+    
+    public String categorizeBox(int length, int width, int height, int mass) {
+        long volume = ((long) length) * width * height;
+        boolean isBulky = length >= BULKY_DIMENSION_THRESHOLD || 
+            width >= BULKY_DIMENSION_THRESHOLD || 
+            height >= BULKY_DIMENSION_THRESHOLD || 
+            mass >= BULKY_DIMENSION_THRESHOLD ||
+            volume >= BULKY_VOLUME_THRESHOLD;
+        boolean isHeavy = mass >= HEAVY_MASS_THRESHOLD;
+        if (isBulky && isHeavy) {
+            return "Both";
+        }
+        if (!(isBulky || isHeavy)) {
+            return "Neither";
+        }
+        return isBulky ? "Bulky" : "Heavy";
+    }
+}
diff --git a/Easy/Check If It Is a Straight Line.java b/Easy/Check If It Is a Straight Line.java
index 174053a3..407ed220 100644
--- a/Easy/Check If It Is a Straight Line.java	
+++ b/Easy/Check If It Is a Straight Line.java	
@@ -1,16 +1,21 @@
-class Solution {
-  public boolean checkStraightLine(int[][] coordinates) {
-    int xOne = coordinates[1][0]; 
-    int yOne = coordinates[1][1];
-    int dx = xOne - coordinates[0][0];
-    int dy = yOne - coordinates[0][1];
-    for (int[] coordinate : coordinates) {
-      int x = coordinate[0];
-      int y = coordinate[1];
-      if (dx * (y - yOne) != dy * (x - xOne)) {
-        return false;
-      }
+class Solution {    
+    public boolean checkStraightLine(int[][] coordinates) {
+        int deltaY = getYDiff(coordinates[1], coordinates[0]);
+        int deltaX = getXDiff(coordinates[1], coordinates[0]);
+        for (int i = 2; i < coordinates.length; i++) {
+            if (deltaY * getXDiff(coordinates[i], coordinates[0]) != deltaX * getYDiff(coordinates[i], coordinates[0])) {
+                return false;
+            }
+        }
+        return true;
     }
-    return true;
-  }
+    
+    private int getYDiff(int[] a, int[] b) {
+        return a[1] - b[1];
+    }
+
+    private int getXDiff(int[] a, int[] b) {
+        return a[0] - b[0];
+    }
+
 }
diff --git a/Easy/Check If Two String Arrays are Equivalent.java b/Easy/Check If Two String Arrays are Equivalent.java
index 70a73e1a..880301c2 100644
--- a/Easy/Check If Two String Arrays are Equivalent.java	
+++ b/Easy/Check If Two String Arrays are Equivalent.java	
@@ -1,27 +1,24 @@
 class Solution {
-  public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
-    int wordIdxOne = 0;
-    int wordIdxTwo = 0;
-    int idxOne = 0;
-    int idxTwo = 0;
-    while (wordIdxOne < word1.length && wordIdxTwo < word2.length) {
-      if (idxOne == word1[wordIdxOne].length() || idxTwo == word2[wordIdxTwo].length()) {
-        if (idxOne == word1[wordIdxOne].length()) {
-          wordIdxOne++;
-          idxOne = 0;
+    public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
+        int idxOne = 0;
+        int idxTwo = 0;
+        int wordIdxOne = 0;
+        int wordIdxTwo = 0;
+        while (idxOne < word1.length && idxTwo < word2.length) {
+            if (word1[idxOne].charAt(wordIdxOne) != word2[idxTwo].charAt(wordIdxTwo)) {
+                return false;
+            }
+            wordIdxOne++;
+            wordIdxTwo++;
+            if (wordIdxOne == word1[idxOne].length()) {
+                wordIdxOne = 0;
+                idxOne++;
+            }
+            if (wordIdxTwo == word2[idxTwo].length()) {
+                wordIdxTwo = 0;
+                idxTwo++;
+            }
         }
-        if (idxTwo == word2[wordIdxTwo].length()) {
-          wordIdxTwo++;
-          idxTwo = 0;
-        }
-      } else {
-        if (word1[wordIdxOne].charAt(idxOne) != word2[wordIdxTwo].charAt(idxTwo)) {
-          return false;
-        }
-        idxOne++;
-        idxTwo++;
-      }
+        return idxOne == word1.length && idxTwo == word2.length;
     }
-    return wordIdxOne == word1.length && wordIdxTwo == word2.length;
-  }
 }
diff --git a/Easy/Check If a Number Is Majority Element in a Sorted Array.java b/Easy/Check If a Number Is Majority Element in a Sorted Array.java
index 5913a03a..6491d715 100644
--- a/Easy/Check If a Number Is Majority Element in a Sorted Array.java	
+++ b/Easy/Check If a Number Is Majority Element in a Sorted Array.java	
@@ -1,38 +1,38 @@
 class Solution {
-  
-  private static enum DIRECTION {
-    LEFT, RIGHT;
-  }
-  
-  public boolean isMajorityElement(int[] nums, int target) {
-    int rightIdx = getIndex(nums, target, DIRECTION.RIGHT);
-    int leftIdx = getIndex(nums, target, DIRECTION.LEFT);
-    if (leftIdx == -1 || rightIdx == -1) {
-      return false;
+    
+    private static enum Direction {
+        LEFT, RIGHT;
     }
-    int occurrences = rightIdx - leftIdx + 1;
-    return occurrences > nums.length / 2;
-  }
-  
-  private int getIndex(int[] nums, int target, DIRECTION direction) {
-    int resultIdx = -1;
-    int left = 0;
-    int right = nums.length - 1;
-    while (left <= right) {
-      int mid = (left + right) / 2;
-      if (nums[mid] == target) {
-        resultIdx = mid;
-        if (direction == DIRECTION.LEFT) {
-          right = mid - 1;
-        } else {
-          left = mid + 1;
+    
+    public boolean isMajorityElement(int[] nums, int target) {
+        int firstIndex = findIndex(nums, target, Direction.LEFT);
+        if (firstIndex == -1) {
+            return false;
         }
-      } else if (nums[mid] > target) {
-        right = mid - 1;
-      } else {
-        left = mid + 1;
-      }
+        int lastIndex = findIndex(nums, target, Direction.RIGHT);
+        int occurrences = lastIndex - firstIndex + 1;
+        return occurrences > nums.length / 2;
+    }
+
+    private int findIndex(int[] nums, int target, Direction direction) {
+        int idx = -1;
+        int start = 0;
+        int end = nums.length - 1;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            if (nums[mid] == target) {
+                idx = mid;
+                if (direction == Direction.LEFT) {
+                    end = mid - 1;
+                } else {
+                    start = mid + 1;
+                }
+            } else if (nums[mid] > target) {
+                end = mid - 1;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return idx;
     }
-    return resultIdx;
-  }
 }
diff --git a/Easy/Check if Array is Good.java b/Easy/Check if Array is Good.java
new file mode 100644
index 00000000..f0b86ddc
--- /dev/null
+++ b/Easy/Check if Array is Good.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public boolean isGood(int[] nums) {
+        if (nums.length <= 1) {
+            return false;
+        }
+        int n = nums.length - 1;
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        for (int i = 1; i <= n; i++) {
+            if (!map.containsKey(i)) {
+                return false;
+            }
+            if (map.get(i) > 1 && i != n) {
+                return false;
+            }
+            if (i == n && map.get(i) != 2) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/Easy/Check if Bitwise OR Has Trailing Zeros.java b/Easy/Check if Bitwise OR Has Trailing Zeros.java
new file mode 100644
index 00000000..b1aedc22
--- /dev/null
+++ b/Easy/Check if Bitwise OR Has Trailing Zeros.java	
@@ -0,0 +1,7 @@
+class Solution {
+    public boolean hasTrailingZeros(int[] nums) {
+        return Arrays.stream(nums)
+                .filter(num -> Integer.numberOfTrailingZeros(num) > 0)
+                .count() >= 2;
+    }
+}
diff --git a/Easy/Check if Grid Satisfies Conditions.java b/Easy/Check if Grid Satisfies Conditions.java
new file mode 100644
index 00000000..93891460
--- /dev/null
+++ b/Easy/Check if Grid Satisfies Conditions.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public boolean satisfiesConditions(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (i + 1 < rows && grid[i][j] != grid[i + 1][j]) {
+                    return false;
+                }
+                if (j + 1 < cols && grid[i][j] == grid[i][j + 1]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
diff --git a/Easy/Check if One String Swap Can Make Strings Equal.java b/Easy/Check if One String Swap Can Make Strings Equal.java
index 3f26dac9..fca6fc9d 100644
--- a/Easy/Check if One String Swap Can Make Strings Equal.java	
+++ b/Easy/Check if One String Swap Can Make Strings Equal.java	
@@ -1,16 +1,21 @@
 class Solution {
-  public boolean areAlmostEqual(String s1, String s2) {
-    int mismatchIdx = -1;
-    for (int i = 0; i < s1.length(); i++) {
-      if (s1.charAt(i) != s2.charAt(i)) {
-        if (mismatchIdx != -1) {
-          return s1.charAt(mismatchIdx) == s2.charAt(i) && 
-            s1.charAt(i) == s2.charAt(mismatchIdx) && 
-            s1.substring(i + 1).equals(s2.substring(i + 1));
+    public boolean areAlmostEqual(String s1, String s2) {
+        int swapIdx = -1;
+        boolean swapped = false;
+        for (int i = 0; i < s1.length(); i++) {
+            if (s1.charAt(i) != s2.charAt(i)) {
+                if (swapped) {
+                    return false;
+                }
+                if (swapIdx != -1) {
+                    if (!(s1.charAt(swapIdx) == s2.charAt(i) && s1.charAt(i) == s2.charAt(swapIdx))) {
+                        return false;
+                    }
+                    swapped = true;
+                } 
+                swapIdx = i;
+            }
         }
-        mismatchIdx = i;
-      }
+        return swapIdx == -1 || (swapIdx != -1 && swapped);
     }
-    return mismatchIdx == -1;
-  }
 }
diff --git a/Easy/Check if Strings Can be Made Equal With Operations I.java b/Easy/Check if Strings Can be Made Equal With Operations I.java
new file mode 100644
index 00000000..cc99065a
--- /dev/null
+++ b/Easy/Check if Strings Can be Made Equal With Operations I.java	
@@ -0,0 +1,9 @@
+class Solution {
+    public boolean canBeEqual(String s1, String s2) {
+        boolean firstSwap = (s1.charAt(0) == s2.charAt(0) && s1.charAt(2) == s2.charAt(2)) || 
+            (s1.charAt(2) == s2.charAt(0) && s1.charAt(0) == s2.charAt(2));
+        boolean secondSwap = (s1.charAt(1) == s2.charAt(1) && s1.charAt(3) == s2.charAt(3)) || 
+            (s1.charAt(1) == s2.charAt(3) && s1.charAt(3) == s2.charAt(1));
+        return firstSwap && secondSwap;
+    }
+}
diff --git a/Easy/Check if The Number is Fascinating.java b/Easy/Check if The Number is Fascinating.java
new file mode 100644
index 00000000..d5074568
--- /dev/null
+++ b/Easy/Check if The Number is Fascinating.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public boolean isFascinating(int n) {
+        return isFascinatingHelper(n + "" + 2 * n + "" + 3 * n);
+    }
+    
+    private boolean isFascinatingHelper(String s) {
+        return s.length() == 9 && s.chars()
+            .mapToObj(c -> (char)  c)
+            .filter(c -> c != '0')
+            .collect(Collectors.toSet())
+            .size() == 9;
+    }
+}
diff --git a/Easy/Check if a String Is an Acronym of Words.java b/Easy/Check if a String Is an Acronym of Words.java
new file mode 100644
index 00000000..5608783c
--- /dev/null
+++ b/Easy/Check if a String Is an Acronym of Words.java	
@@ -0,0 +1,9 @@
+class Solution {
+    public boolean isAcronym(List<String> words, String s) {
+        StringBuilder sb = new StringBuilder();
+        for (String word : words) {
+            sb.append(word.charAt(0));
+        }
+        return sb.toString().equals(s);
+    }
+}
diff --git a/Easy/Circular Sentence.java b/Easy/Circular Sentence.java
new file mode 100644
index 00000000..51b21134
--- /dev/null
+++ b/Easy/Circular Sentence.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public boolean isCircularSentence(String sentence) {
+        String[] words = sentence.split("\\s+");
+        int n = words.length;
+        for (int i = 0; i < n - 1; i++) {
+            char lastCharOfCurrentWord = words[i].charAt(words[i].length() - 1);
+            char firstCharOfNextWord = words[i + 1].charAt(0);
+            if (lastCharOfCurrentWord != firstCharOfNextWord) {
+                return false;
+            }
+        }
+        char lastCharOfLastWord = words[n - 1].charAt(words[n - 1].length() - 1);
+        char firstCharOfFirstWord = words[0].charAt(0);
+        return lastCharOfLastWord == firstCharOfFirstWord;
+    }
+}
diff --git a/Easy/Clear Digits.java b/Easy/Clear Digits.java
new file mode 100644
index 00000000..1d308863
--- /dev/null
+++ b/Easy/Clear Digits.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public String clearDigits(String s) {
+        StringBuilder sb = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            if (Character.isDigit(c)) {
+                if (!sb.isEmpty()) {
+                    sb.deleteCharAt(sb.length() - 1);
+                }
+            } else {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+}
diff --git a/Easy/Climbing Stairs.java b/Easy/Climbing Stairs.java
index f2ff9386..ad49acda 100644
--- a/Easy/Climbing Stairs.java	
+++ b/Easy/Climbing Stairs.java	
@@ -1,14 +1,19 @@
 class Solution {
-  public int climbStairs(int n) {
-    if (n == 1) {
-      return 1;
+    public int climbStairs(int n) {
+        Integer[] dp = new Integer[n + 1];
+        return climbStairs(dp, n);
     }
-    int[] dp = new int[n + 1];
-    dp[1] = 1;
-    dp[2] = 2;
-    for (int i = 3; i <= n; i++) {
-      dp[i] = dp[i - 1] + dp[i - 2];
+
+    private int climbStairs(Integer[] dp, int n) {
+        if (n == 1) {
+            return 1;
+        }
+        if (n == 2) {
+            return 2;
+        }
+        if (dp[n] != null) {
+            return dp[n];
+        }
+        return dp[n] = climbStairs(dp, n - 1) + climbStairs(dp, n - 2);
     }
-    return dp[n];
-  }
 }
diff --git a/Easy/Correct a Binary Tree.java b/Easy/Correct a Binary Tree.java
new file mode 100644
index 00000000..3ec5f055
--- /dev/null
+++ b/Easy/Correct a Binary Tree.java	
@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode correctBinaryTree(TreeNode root) {
+        Queue<Pair> queue = new LinkedList<>();
+        queue.add(new Pair(root, null));
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            Set<TreeNode> visited = new HashSet<>();
+            for (int i = 0; i < size; i++) {
+                Pair pair = queue.remove();
+                TreeNode node = pair.node();
+                TreeNode parent = pair.parent();
+                if (visited.contains(node.right)) {
+                    if (parent.left == node) {
+                        parent.left = null;
+                    } else {
+                        parent.right = null;
+                    }
+                    return root;
+                }
+                visited.add(node);
+                if (node.right != null) {
+                    queue.add(new Pair(node.right, node));
+                }
+                if (node.left != null) {
+                    queue.add(new Pair(node.left, node));
+                }
+            }
+        }
+        return root;
+    }
+
+    private static record Pair(TreeNode node, TreeNode parent) {}
+}
diff --git a/Easy/Count Distinct Numbers on Board.java b/Easy/Count Distinct Numbers on Board.java
new file mode 100644
index 00000000..42a7ad68
--- /dev/null
+++ b/Easy/Count Distinct Numbers on Board.java	
@@ -0,0 +1,5 @@
+class Solution {
+    public int distinctIntegers(int n) {
+        return Math.max(n - 1, 1);
+    }
+}
diff --git a/Easy/Count Elements With Maximum Frequency.java b/Easy/Count Elements With Maximum Frequency.java
new file mode 100644
index 00000000..0f023200
--- /dev/null
+++ b/Easy/Count Elements With Maximum Frequency.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxFrequencyElements(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int maxFrequency = 0;
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+            maxFrequency = Math.max(maxFrequency, map.get(num));
+        }
+        int count = 0;
+        for (int num : nums) {
+            if (map.get(num) == maxFrequency) {
+                count++;
+            }
+        }
+        return count;
+    }
+}
diff --git a/Easy/Count Negative Numbers in a Sorted Matrix.java b/Easy/Count Negative Numbers in a Sorted Matrix.java
index 96daf80b..af842b43 100644
--- a/Easy/Count Negative Numbers in a Sorted Matrix.java	
+++ b/Easy/Count Negative Numbers in a Sorted Matrix.java	
@@ -1,28 +1,26 @@
 class Solution {
-  public int countNegatives(int[][] grid) {
-    int total = 0;
-    int n = grid[0].length;
-    for (int[] gr : grid) {
-      int negInd = binarySearchHelper(gr, 0, n - 1);
-      if (negInd != -1) {
-        total += n - negInd;
-      }
+    public int countNegatives(int[][] grid) {
+        int count = 0;
+        for (int[] row : grid) {
+            int idx = findFirstNonNegativeIndex(row);
+            count += idx == -1 ? 0 : (row.length - idx);
+        }
+        return count;
     }
-    return total;
-  }
-  
-  private int binarySearchHelper(int[] arr, int start, int end) {
-    int idx = -1;
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (arr[mid] < 0) {
-        idx = idx == -1 ? mid : Math.min(idx, mid);
-        end = mid - 1;
-      }
-      if (arr[mid] >= 0) {
-        start = mid + 1;
-      }
+    
+    private int findFirstNonNegativeIndex(int[] row) {
+        int start = 0;
+        int end = row.length - 1;
+        int idx = -1;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            if (row[mid] < 0) {
+                idx = mid;
+                end = mid - 1;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return idx;
     }
-    return idx;
-  }
 }
diff --git a/Easy/Count Pairs Of Similar Strings.java b/Easy/Count Pairs Of Similar Strings.java
new file mode 100644
index 00000000..d9b1f7f9
--- /dev/null
+++ b/Easy/Count Pairs Of Similar Strings.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int similarPairs(String[] words) {
+        Map<String, Integer> map = new HashMap<>();
+        int pairCount = 0;
+        for (String word : words) {
+            String key = buildSortedCharString(word);
+            pairCount += map.getOrDefault(key, 0);
+            map.put(key, map.getOrDefault(key, 0) + 1);
+        }
+        return pairCount;
+    }
+    
+    private static String buildSortedCharString(String s) {
+        boolean[] exists = new boolean[26];
+        for (char c : s.toCharArray()) {
+            exists[c - 'a'] = true;
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 26; i++) {
+            if (exists[i]) {
+                sb.append((char) (97 + i));
+            }
+        }
+        return sb.toString();
+    }
+}
diff --git a/Easy/Count Pairs That Form a Complete Day I.java b/Easy/Count Pairs That Form a Complete Day I.java
new file mode 100644
index 00000000..785a5937
--- /dev/null
+++ b/Easy/Count Pairs That Form a Complete Day I.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int countCompleteDayPairs(int[] hours) {
+        int count = 0;
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int hour : hours) {
+            count += map.getOrDefault((24 - hour % 24) % 24, 0);
+            map.put(hour % 24, map.getOrDefault(hour % 24, 0) + 1);
+        }
+        return count;
+    }
+}
diff --git a/Easy/Count Pairs Whose Sum is Less than Target.java b/Easy/Count Pairs Whose Sum is Less than Target.java
new file mode 100644
index 00000000..90c31c23
--- /dev/null
+++ b/Easy/Count Pairs Whose Sum is Less than Target.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int countPairs(List<Integer> nums, int target) {
+        Collections.sort(nums);
+        int start = 0;
+        int end = nums.size() - 1;
+        int count = 0;
+        while (start < end) {
+            int sum = nums.get(start) + nums.get(end);
+            if (sum < target) {
+                count += end - start;
+                start++;
+            } else {
+                end--;
+            }
+        }
+        return count;
+    }
+}
diff --git a/Easy/Count Partitions with Even Sum Difference.java b/Easy/Count Partitions with Even Sum Difference.java
new file mode 100644
index 00000000..0390a5a1
--- /dev/null
+++ b/Easy/Count Partitions with Even Sum Difference.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int countPartitions(int[] nums) {
+        int n = nums.length;
+        int[] prefixSum = new int[n];
+        for (int i = 0; i < n; i++) {
+            prefixSum[i] = nums[i];
+            prefixSum[i] += i == 0 ? 0 : prefixSum[i - 1];
+        }
+        int partitions = 0;
+        for (int i = 0; i < n - 1; i++) {
+            int leftSum = prefixSum[i];
+            int rightSum = prefixSum[n - 1] - prefixSum[i];
+            partitions += (rightSum - leftSum) % 2 == 0 ? 1 : 0;
+        }
+        return partitions;
+    }
+}
diff --git a/Easy/Count Prefix and Suffix Pairs I.java b/Easy/Count Prefix and Suffix Pairs I.java
new file mode 100644
index 00000000..919d41d1
--- /dev/null
+++ b/Easy/Count Prefix and Suffix Pairs I.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int countPrefixSuffixPairs(String[] words) {
+        int count = 0;
+        for (int i = 0; i < words.length; i++) {
+            String target = words[i];
+            for (int j = i + 1; j < words.length; j++) {
+                if (words[j].startsWith(target) && words[j].endsWith(target)) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+}
diff --git a/Easy/Count Subarrays of Length Three With a Condition.java b/Easy/Count Subarrays of Length Three With a Condition.java
new file mode 100644
index 00000000..4694fb65
--- /dev/null
+++ b/Easy/Count Subarrays of Length Three With a Condition.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int countSubarrays(int[] nums) {
+        int count = 0;
+        for (int i = 0; i < nums.length - 2; i++) {
+            if (2 * (nums[i] + nums[i + 2]) == nums[i + 1]) {
+                count++;
+            }
+        }
+        return count;
+    }
+}
diff --git a/Easy/Count Substrings That Satisfy K-Constraint I.java b/Easy/Count Substrings That Satisfy K-Constraint I.java
new file mode 100644
index 00000000..9f44425d
--- /dev/null
+++ b/Easy/Count Substrings That Satisfy K-Constraint I.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int countKConstraintSubstrings(String s, int k) {
+        Map<Character, Integer> map = new HashMap<>();
+        int start = 0;
+        int end = 0;
+        int n = s.length();
+        int result = 0;
+        while (end < n) {
+            map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
+            end++;
+            while (start < end && map.getOrDefault('0', 0) > k && map.getOrDefault('1', 0) > k) {
+                map.put(s.charAt(start), map.get(s.charAt(start)) - 1);
+                start++;
+            }
+            if (map.getOrDefault('0', 0) <= k || map.getOrDefault('1', 0) <= k) {
+                result += end - start;
+            }
+        }
+        return result;
+    }
+}
diff --git a/Easy/Count Symmetric Integers.java b/Easy/Count Symmetric Integers.java
new file mode 100644
index 00000000..8ae9c320
--- /dev/null
+++ b/Easy/Count Symmetric Integers.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public int countSymmetricIntegers(int low, int high) {
+        int count = 0;
+        for (int i = low; i <= high; i++) {
+            if (isSymmetric(i)) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    private static boolean isSymmetric(int num) {
+        String s = String.valueOf(num);
+        int n = s.length();
+        if (n % 2 != 0) {
+            return false;
+        }
+        int sum = 0;
+        for (int i = 0; i < n / 2; i++) {
+            sum += Character.getNumericValue(s.charAt(i));
+        }
+        for (int i = n / 2; i < n; i++) {
+            sum -= Character.getNumericValue(s.charAt(i));
+        }
+        return sum == 0;
+    }
+}
diff --git a/Easy/Count Tested Devices After Test Operations.java b/Easy/Count Tested Devices After Test Operations.java
new file mode 100644
index 00000000..1f6cdb0f
--- /dev/null
+++ b/Easy/Count Tested Devices After Test Operations.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int countTestedDevices(int[] batteryPercentages) {
+        int count = 0;
+        int diff = 0;
+        for (int batteryPercentage : batteryPercentages) {
+            if (Math.max(0, batteryPercentage - diff) > 0) {
+                count++;
+                diff++;
+            }
+        }
+        return count;
+    }
+}
diff --git a/Easy/Count the Digits That Divide a Number.java b/Easy/Count the Digits That Divide a Number.java
new file mode 100644
index 00000000..085c312b
--- /dev/null
+++ b/Easy/Count the Digits That Divide a Number.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int countDigits(int num) {
+        int count = 0;
+        int copy = num;
+        while (num > 0) {
+            int digit = num % 10;
+            num /= 10;
+            if (digit != 0 && copy % digit == 0) {
+                count++;
+            }
+        }
+        return count;
+    }
+}
diff --git a/Easy/Count the Number of Special Characters I.java b/Easy/Count the Number of Special Characters I.java
new file mode 100644
index 00000000..44c9950f
--- /dev/null
+++ b/Easy/Count the Number of Special Characters I.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int numberOfSpecialChars(String word) {
+        boolean[] upperPresent = new boolean[26];
+        boolean[] lowerPresent = new boolean[26];
+        for (char c : word.toCharArray()) {
+            if (Character.isUpperCase(c)) {
+                upperPresent[c - 'A'] = true;
+            } else {
+                lowerPresent[c - 'a'] = true;
+            }
+        }
+        int count = 0;
+        for (int i = 0; i < 26; i++) {
+            if (upperPresent[i] && lowerPresent[i]) {
+                count++;
+            }
+        }
+        return count;
+    }
+}
diff --git a/Easy/Count the Number of Vowel Strings in Range.java b/Easy/Count the Number of Vowel Strings in Range.java
new file mode 100644
index 00000000..38eeb76e
--- /dev/null
+++ b/Easy/Count the Number of Vowel Strings in Range.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public int vowelStrings(String[] words, int left, int right) {
+        Set<Character> vowels = Set.of('a', 'e', 'i', 'o', 'u');
+        return (int) Arrays.stream(words)
+                .skip(left)
+                .limit(right - left + 1)
+                .filter(word -> vowels.contains(word.charAt(0)) && vowels.contains(word.charAt(word.length() - 1)))
+                .count();
+    }
+}
diff --git a/Easy/Counting Bits.java b/Easy/Counting Bits.java
index 4d948810..4b5c69fa 100644
--- a/Easy/Counting Bits.java	
+++ b/Easy/Counting Bits.java	
@@ -1,9 +1,9 @@
 class Solution {
-  public int[] countBits(int n) {
-    int[] numofOnes = new int[n + 1];
-    for (int i = 1; i <= n; i++) {
-      numofOnes[i] = numofOnes[i / 2] + i % 2;
+    public int[] countBits(int n) {
+        int[] result = new int[n + 1];
+        for (int i = 1; i <= n; i++) {
+            result[i] = result[i / 2] + i % 2;
+        }
+        return result;
     }
-    return numofOnes;
-  }
 }
diff --git a/Easy/Delete Greatest Value in Each Row.java b/Easy/Delete Greatest Value in Each Row.java
new file mode 100644
index 00000000..ca6794aa
--- /dev/null
+++ b/Easy/Delete Greatest Value in Each Row.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int deleteGreatestValue(int[][] grid) {
+        for (int[] g : grid) {
+            Arrays.sort(g);
+        }
+        int result = 0;
+        for (int i = grid[0].length - 1; i >= 0; i--) {
+            int maxValue = Integer.MIN_VALUE;
+            for (int[] g : grid) {
+                maxValue = Math.max(maxValue, g[i]);
+            }
+            result += maxValue;
+        }
+        return result;
+    }
+}
diff --git a/Easy/Design HashMap.java b/Easy/Design HashMap.java
index d59fe9e1..ff29c920 100644
--- a/Easy/Design HashMap.java	
+++ b/Easy/Design HashMap.java	
@@ -1,42 +1,40 @@
 class MyHashMap {
 
-  /** Initialize your data structure here. */
-  Integer[][] map;
-  int NUM_OF_BUCKETS = 1000;
-  int BUCKET_SIZE = 1000;
-  public MyHashMap() {
-    map = new Integer[NUM_OF_BUCKETS][BUCKET_SIZE];
-  }
+    private static final int BUCKET_COUNT = 1001;
 
-  /** value will always be non-negative. */
-  public void put(int key, int value) {
-    Integer[] bucket = getBucket(key);
-    int keyHash = getKeyHash(key);
-    bucket[keyHash] = value;
-  }
+    private static final int BUCKET_SIZE = 1001;
 
-  /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
-  public int get(int key) {
-    Integer[] bucket = getBucket(key);
-    int keyHash = getKeyHash(key);
-    return bucket[keyHash] == null ? -1 : bucket[keyHash];
-  }
+    private final Integer[][] map;
 
-  /** Removes the mapping of the specified value key if this map contains a mapping for the key */
-  public void remove(int key) {
-    Integer[] bucket = getBucket(key);
-    int keyHash = getKeyHash(key);
-    bucket[keyHash] = null;
-  }
-  
-  private Integer[] getBucket(int key) {
-    int bucketIdx = key / BUCKET_SIZE;
-    return map[bucketIdx];
-  }
-  
-  private Integer getKeyHash(int key) {
-    return key % BUCKET_SIZE;
-  }
+    public MyHashMap() {    
+        this.map = new Integer[BUCKET_COUNT][BUCKET_SIZE];
+    }
+    
+    public void put(int key, int value) {
+        Position position = getPosition(key);
+        map[position.bucket()][position.index()] = value;
+    }
+    
+    public int get(int key) {
+        Position position = getPosition(key);
+        Integer value = map[position.bucket()][position.index()];
+        return value == null ? -1 : value;
+    }
+    
+    public void remove(int key) {
+        Position position = getPosition(key);
+        map[position.bucket()][position.index()] = null;
+    }
+
+    private static Position getPosition(int key) {
+        int bucket = key / BUCKET_COUNT;
+        int index = key % BUCKET_SIZE;
+        return new Position(bucket, index);
+    }
+
+    private static record Position(int bucket, int index) {
+      
+    }
 }
 
 /**
diff --git a/Easy/Design Neighbor Sum Service.java b/Easy/Design Neighbor Sum Service.java
new file mode 100644
index 00000000..93446e53
--- /dev/null
+++ b/Easy/Design Neighbor Sum Service.java	
@@ -0,0 +1,50 @@
+class neighborSum {
+
+    private static final int[][] ADJACENT_DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+    private static final int[][] DIAGONAL_DIRS = {{1, -1}, {-1, 1}, {1, 1}, {-1, -1}};
+
+    private final int[][] grid;
+    private final int numRows;
+    private final int numCols;
+    private final Map<Integer, int[]> valueToCoordinateMap;
+
+    public neighborSum(int[][] grid) {
+        this.numRows = grid.length;
+        this.numCols = grid[0].length;
+        this.valueToCoordinateMap = new HashMap<>();
+        this.grid = new int[numRows][numCols];
+        for (int i = 0; i < numRows; i++) {
+            for (int j = 0; j < numCols; j++) {
+                this.grid[i][j] = grid[i][j];
+                this.valueToCoordinateMap.put(grid[i][j], new int[]{i, j});
+            }
+        }
+    }
+    
+    public int adjacentSum(int value) {
+        return calculateSum(valueToCoordinateMap.get(value), ADJACENT_DIRS);
+    }
+    
+    public int diagonalSum(int value) {
+        return calculateSum(valueToCoordinateMap.get(value), DIAGONAL_DIRS);
+    }
+
+    private int calculateSum(int[] coordinate, int[][] directions) {
+        int sum = 0;
+        for (int[] dir : directions) {
+            int newX = dir[0] + coordinate[0];
+            int newY = dir[1] + coordinate[1];
+            if (newX >= 0 && newX < numRows && newY >= 0 && newY < numCols) {
+                sum += grid[newX][newY];
+            }
+        }
+        return sum;
+    }
+}
+
+/**
+ * Your neighborSum object will be instantiated and called as such:
+ * neighborSum obj = new neighborSum(grid);
+ * int param_1 = obj.adjacentSum(value);
+ * int param_2 = obj.diagonalSum(value);
+ */
diff --git a/Easy/Destination City.java b/Easy/Destination City.java
index c9f08cbc..f6e330ab 100644
--- a/Easy/Destination City.java	
+++ b/Easy/Destination City.java	
@@ -1,17 +1,12 @@
 class Solution {
-  public String destCity(List<List<String>> paths) {
-    Set<String> outgoingPathCities = new HashSet<>();
-    Set<String> cities = new HashSet<>();
-    for (List<String> path : paths) {
-      outgoingPathCities.add(path.get(0));
-      cities.add(path.get(0));
-      cities.add(path.get(1));
+    public String destCity(List<List<String>> paths) {
+        Set<String> cities = new HashSet<>();
+        Set<String> outgoingCities = new HashSet<>();
+        for (List<String> path : paths) {
+            cities.addAll(path);
+            outgoingCities.add(path.get(0));
+        }
+        cities.removeAll(outgoingCities);
+        return cities.iterator().next();
     }
-    for (String city : cities) {
-      if (!outgoingPathCities.contains(city)) {
-        return city;
-      }
-    }
-    return "";
-  }
 }
diff --git a/Easy/Determine if String Halves Are Alike.java b/Easy/Determine if String Halves Are Alike.java
index 218ce0ed..f7c9a995 100644
--- a/Easy/Determine if String Halves Are Alike.java	
+++ b/Easy/Determine if String Halves Are Alike.java	
@@ -1,14 +1,20 @@
 class Solution {
-  private static final String VOWELS = "aeiouAEIOU";
-  public boolean halvesAreAlike(String s) {
-    return getVowelCount(s.substring(0, s.length() / 2)).equals(getVowelCount(s.substring(s.length() / 2)));
-  }
-  
-  private Long getVowelCount(String s) {
-    return s.chars().mapToObj(c -> (char) c).filter(Solution::isVowel).count();
-  }
-  
-  private static boolean isVowel(char c) {
-    return VOWELS.indexOf(c) != -1;
-  }
+
+    private static final Set<Character> VOWELS = Set.of(
+        'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'
+    );
+
+    public boolean halvesAreAlike(String s) {
+        int count = 0;
+        int n = s.length();
+        for (int i = 0; i < n / 2; i++) {
+            if (VOWELS.contains(s.charAt(i))) {
+                count++;
+            }
+            if (VOWELS.contains(s.charAt(i + n / 2))) {
+                count--;
+            }
+        }
+        return count == 0;
+    }
 }
diff --git a/Easy/Determine the Winner of a Bowling Game.java b/Easy/Determine the Winner of a Bowling Game.java
new file mode 100644
index 00000000..0b64db30
--- /dev/null
+++ b/Easy/Determine the Winner of a Bowling Game.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int isWinner(int[] player1, int[] player2) {
+        int score1 = 0;
+        int score2 = 0;
+        int tenIndex1 = -1;
+        int tenIndex2 = -1;
+        for (int i = 0; i < player1.length; i++) {
+            score1 += player1[i];
+            score2 += player2[i];
+            if (tenIndex1 != -1 && i - tenIndex1 <= 2) {
+                score1 += player1[i];
+            }
+            if (tenIndex2 != -1 && i - tenIndex2 <= 2) {
+                score2 += player2[i];
+            }
+            if (player1[i] == 10) {
+                tenIndex1 = i;
+            }
+            if (player2[i] == 10) {
+                tenIndex2 = i;
+            }
+        }
+        return score1 > score2 ? 1 : (score1 == score2 ? 0 : 2);
+    }
+}
diff --git a/Easy/Difference Between Element Sum and Digit Sum of an Array.java b/Easy/Difference Between Element Sum and Digit Sum of an Array.java
new file mode 100644
index 00000000..1aef4cbe
--- /dev/null
+++ b/Easy/Difference Between Element Sum and Digit Sum of an Array.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int differenceOfSum(int[] nums) {
+        int elementSum = 0;
+        int digitSum = 0;
+        for (int num : nums) {
+            elementSum += num;
+            digitSum += getDigitSum(num);
+        }
+        return Math.abs(elementSum - digitSum);
+    }
+    
+    private static int getDigitSum(int num) {
+        int sum = 0;
+        while (num > 0) {
+            sum += num % 10;
+            num /= 10;
+        }
+        return sum;
+    }
+}
diff --git a/Easy/Distribute Elements Into Two Arrays I.java b/Easy/Distribute Elements Into Two Arrays I.java
new file mode 100644
index 00000000..9b4bd7d1
--- /dev/null
+++ b/Easy/Distribute Elements Into Two Arrays I.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int[] resultArray(int[] nums) {
+        int start = 0;
+        int end = nums.length - 1;
+        int[] result = new int[nums.length];
+        result[start++] = nums[0];
+        result[end--] = nums[1];
+        for (int i = 2; i < nums.length; i++) {
+            if (result[start - 1] > result[end + 1]) {
+                result[start++] = nums[i];
+            } else {
+                result[end--] = nums[i];
+            }
+        }
+        int left = end + 1;
+        int right = nums.length - 1;
+        while (left < right) {
+            int temp = result[left];
+            result[left] = result[right];
+            result[right] = temp;
+            left++;
+            right--;
+        }
+        return result;
+    }
+}
diff --git a/Easy/Distribute Money to Maximum Children.java b/Easy/Distribute Money to Maximum Children.java
new file mode 100644
index 00000000..06dd063f
--- /dev/null
+++ b/Easy/Distribute Money to Maximum Children.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int distMoney(int money, int children) {
+        money -= children;
+        if (money < 0) {
+            return -1;
+        }
+        if (money / 7 == children && money % 7 == 0) {
+            return children;
+        }
+        if (money / 7 == children - 1 && money % 7 == 3) {
+            return children - 2;
+        }
+        return Math.min(children - 1, money / 7);
+    }
+}
diff --git a/Easy/Divide an Array Into Subarrays With Minimum Cost I.java b/Easy/Divide an Array Into Subarrays With Minimum Cost I.java
new file mode 100644
index 00000000..7b214fa7
--- /dev/null
+++ b/Easy/Divide an Array Into Subarrays With Minimum Cost I.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int minimumCost(int[] nums) {
+        int minOne = Integer.MAX_VALUE;
+        int minTwo = Integer.MAX_VALUE;
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] < minOne) {
+                minTwo = minOne;
+                minOne = nums[i];
+            } else if (nums[i] < minTwo) {
+                minTwo = nums[i];
+            }
+        }
+        return nums[0] + minOne + minTwo;
+    }
+}
diff --git a/Easy/Divisible and Non-divisible Sums Difference.java b/Easy/Divisible and Non-divisible Sums Difference.java
new file mode 100644
index 00000000..a9c53cc8
--- /dev/null
+++ b/Easy/Divisible and Non-divisible Sums Difference.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public int differenceOfSums(int n, int m) {
+        int num1 = n * (n + 1) / 2;
+        int num2 = n / m;
+        num2 = m * num2 * (num2 + 1) / 2;
+        return num1 - 2 * num2;
+    }
+}
diff --git a/Easy/Duplicate Zeros.java b/Easy/Duplicate Zeros.java
index 54a3592a..9f97be38 100644
--- a/Easy/Duplicate Zeros.java	
+++ b/Easy/Duplicate Zeros.java	
@@ -1,23 +1,23 @@
 class Solution {
-  public void duplicateZeros(int[] arr) {
-    int numOfZeros = 0;
-    for (int num : arr) {
-      numOfZeros += num == 0 ? 1 : 0;
+    public void duplicateZeros(int[] arr) {
+        int count = 0;
+        for (int i = 0; i < arr.length; i++) {
+            count += arr[i] == 0 ? 1 : 0;
+        }
+        int idxOne = arr.length - 1;
+        int idxTwo = arr.length + count - 1;
+        while (idxOne != idxTwo) {
+            insertAtEnd(arr, idxOne, idxTwo--);
+            if (arr[idxOne] == 0) {
+                insertAtEnd(arr, idxOne, idxTwo--);
+            }
+            idxOne--;
+        }
     }
-    int i = arr.length - 1;
-    int j = arr.length + numOfZeros - 1;
-    while (i != j) {
-      insert(arr, i, j--);
-      if (arr[i] == 0) {
-        insert(arr, i, j--);
-      }
-      i--;
+    
+    private void insertAtEnd(int[] arr, int idxOne, int idxTwo) {
+        if (idxTwo < arr.length) {
+            arr[idxTwo] = arr[idxOne];
+        }
     }
-  }
-  
-  private void insert(int[] arr, int i, int j) {
-    if (j < arr.length) {
-      arr[j] = arr[i];
-    }
-  }
 }
diff --git a/Easy/Faulty Keyboard.java b/Easy/Faulty Keyboard.java
new file mode 100644
index 00000000..500dc39b
--- /dev/null
+++ b/Easy/Faulty Keyboard.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public String finalString(String s) {
+        Deque<Character> deque = new ArrayDeque<>();
+        boolean flip = false;
+        for (char c : s.toCharArray()) {
+            if (c == 'i') {
+                flip = !flip;
+            } else {
+                if (flip) {
+                    deque.addFirst(c);
+                } else {
+                    deque.addLast(c);
+                }
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for (char c : deque){
+            sb.append(c);
+        }
+        return flip ? sb.reverse().toString() : sb.toString();
+    }
+}
diff --git a/Easy/Faulty Sensor.java b/Easy/Faulty Sensor.java
new file mode 100644
index 00000000..dabed6c0
--- /dev/null
+++ b/Easy/Faulty Sensor.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int badSensor(int[] sensor1, int[] sensor2) {
+        int idx = 0;
+        int n = sensor1.length;
+        while (idx < n && sensor1[idx] == sensor2[idx]) {
+            idx++;
+        }
+        while (idx + 1 < n && sensor1[idx] == sensor2[idx + 1] && sensor1[idx + 1] == sensor2[idx]) {
+            idx++;
+        }
+        return idx >= n - 1 ? -1 : sensor1[idx] == sensor2[idx + 1] ? 1 : 2;
+    }
+}
diff --git a/Easy/Final Array State After K Multiplication Operations I.java b/Easy/Final Array State After K Multiplication Operations I.java
new file mode 100644
index 00000000..da5670de
--- /dev/null
+++ b/Easy/Final Array State After K Multiplication Operations I.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int[] getFinalState(int[] nums, int k, int multiplier) {
+        int n = nums.length;
+        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt((int[] o) -> o[0])
+            .thenComparingInt(o -> o[1]));
+        for (int i = 0; i < n; i++) {
+            pq.add(new int[]{nums[i], i});
+        }
+        while (k-- > 0) {
+            int[] removed = pq.remove();
+            int value = removed[0];
+            int index = removed[1];
+            int newValue = value * multiplier;
+            pq.add(new int[]{newValue, index});
+        }
+        int[] result = new int[n];
+        while (!pq.isEmpty()) {
+            int[] removed = pq.remove();
+            int value = removed[0];
+            int index = removed[1];
+            result[index] = value;
+        }
+        return result;
+    }
+}
diff --git a/Easy/Find All Anagrams in a String.java b/Easy/Find All Anagrams in a String.java
deleted file mode 100644
index 8d79ab3b..00000000
--- a/Easy/Find All Anagrams in a String.java	
+++ /dev/null
@@ -1,39 +0,0 @@
-class Solution {
-    public static List<Integer> findAnagrams(String s, String p) {
-        List<Integer> indexes = new ArrayList<>();
-        Map<Character, Integer> pMap = new TreeMap<>();
-
-        for (char c : p.toCharArray()) {
-            pMap.put(c, pMap.getOrDefault(c, 0) + 1);
-        }
-
-        Map<Character, Integer> map = new TreeMap<>();
-
-        for (int i=0; i<p.length() && i<s.length(); i++) {
-            map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
-        }
-
-        int i = p.length();
-        while (i < s.length()) {
-            int ind = i - p.length();         
-            if (map.toString().equals(pMap.toString())) {
-                indexes.add(ind);
-            }
-            
-            map.put(s.charAt(ind), map.getOrDefault(s.charAt(ind), 0) - 1);
-            if (map.get(s.charAt(ind)) <= 0) {
-                map.remove(s.charAt(ind));
-            }
-
-            map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
-
-            i++;
-        }
-
-        if (map.toString().equals(pMap.toString())) {
-            indexes.add(i-p.length());
-        }
-
-        return indexes;
-    }
-}
diff --git a/Easy/Find Anagram Mappings.java b/Easy/Find Anagram Mappings.java
index 2a7c34e3..3650db78 100644
--- a/Easy/Find Anagram Mappings.java	
+++ b/Easy/Find Anagram Mappings.java	
@@ -1,12 +1,13 @@
 class Solution {
-  public int[] anagramMappings(int[] nums1, int[] nums2) {
-    Map<Integer, Integer> indexMapping = new HashMap<>();
-    for (int i = 0; i < nums2.length; i++) {
-      indexMapping.put(nums2[i], i);
+    public int[] anagramMappings(int[] nums1, int[] nums2) {
+        Map<Integer, Integer> indexMap = new HashMap<>();
+        for (int i = 0; i < nums2.length; i++) {
+            indexMap.putIfAbsent(nums2[i], i);
+        }
+        int[] result = new int[nums1.length];
+        for (int i = 0; i < nums1.length; i++) {
+            result[i] = indexMap.get(nums1[i]);
+        }
+        return result;
     }
-    for (int i = 0; i < nums1.length; i++) {
-      nums1[i] = indexMapping.get(nums1[i]);
-    }
-    return nums1;
-  }
 }
diff --git a/Easy/Find Champion I.java b/Easy/Find Champion I.java
new file mode 100644
index 00000000..4728f452
--- /dev/null
+++ b/Easy/Find Champion I.java	
@@ -0,0 +1,20 @@
+import java.util.Map.Entry;
+
+class Solution {
+    public int findChampion(int[][] grid) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 1) {
+                    map.put(i, map.getOrDefault(i, 0) + 1);
+                }
+            }
+        }
+        return map.entrySet()
+            .stream()
+            .filter(entry -> entry.getValue() == grid.length - 1)
+            .findFirst()
+            .map(Entry::getKey)
+            .orElse(-1);
+    }
+}
diff --git a/Easy/Find Closest Person.java b/Easy/Find Closest Person.java
new file mode 100644
index 00000000..0d178230
--- /dev/null
+++ b/Easy/Find Closest Person.java	
@@ -0,0 +1,7 @@
+class Solution {
+    public int findClosest(int x, int y, int z) {
+        int diffOne = Math.abs(x - z);
+        int diffTwo = Math.abs(y - z);
+        return diffOne == diffTwo ? 0 : (diffOne < diffTwo ? 1 : 2);
+    }
+}
diff --git a/Easy/Find Common Elements Between Two Arrays.java b/Easy/Find Common Elements Between Two Arrays.java
new file mode 100644
index 00000000..4a6041ba
--- /dev/null
+++ b/Easy/Find Common Elements Between Two Arrays.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int[] findIntersectionValues(int[] nums1, int[] nums2) {
+        Map<Integer, Integer> map1 = buildFrequencyMap(nums1);
+        Map<Integer, Integer> map2 = buildFrequencyMap(nums2);
+        int[] result = new int[2];
+        for (Integer key : map1.keySet()) {
+            if (map2.containsKey(key)) {
+                result[0] += map1.get(key);
+            }
+        }
+        for (Integer key : map2.keySet()) {
+            if (map1.containsKey(key)) {
+                result[1] += map2.get(key);
+            }
+        }
+        return result;
+    }
+    
+    private static Map<Integer, Integer> buildFrequencyMap(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        return map;
+    }
+}
diff --git a/Easy/Find First Palindromic String in the Array.java b/Easy/Find First Palindromic String in the Array.java
index ba990c09..e215ab8d 100644
--- a/Easy/Find First Palindromic String in the Array.java	
+++ b/Easy/Find First Palindromic String in the Array.java	
@@ -1,9 +1,8 @@
 class Solution {
-  public String firstPalindrome(String[] words) {
-    return Arrays.stream(words).filter(Solution::isPalindrome).findFirst().orElse("");
-  }
-  
-  public static boolean isPalindrome(String s) {
-    return new StringBuilder().append(s).reverse().toString().equals(s);
-  }
+    public String firstPalindrome(String[] words) {
+        return Arrays.stream(words)
+            .filter(word -> word.equals(new StringBuilder(word).reverse().toString()))
+            .findFirst()
+            .orElse("");
+    }
 }
diff --git a/Easy/Find Indices of Stable Mountains.java b/Easy/Find Indices of Stable Mountains.java
new file mode 100644
index 00000000..3e0fbd79
--- /dev/null
+++ b/Easy/Find Indices of Stable Mountains.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public List<Integer> stableMountains(int[] height, int threshold) {
+        List<Integer> result = new ArrayList<>();
+        for (int i = 1; i < height.length; i++) {
+            if (height[i - 1] > threshold) {
+                result.add(i);
+            }
+        }
+        return result;
+    }
+}
diff --git a/Easy/Find Maximum Number of String Pairs.java b/Easy/Find Maximum Number of String Pairs.java
new file mode 100644
index 00000000..f2673fbe
--- /dev/null
+++ b/Easy/Find Maximum Number of String Pairs.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int maximumNumberOfStringPairs(String[] words) {
+        Set<String> set = new HashSet<>();
+        int pairCount = 0;
+        for (String word : words) {
+            if (set.contains(new StringBuilder(word).reverse().toString())) {
+                pairCount++;
+            }
+            set.add(word);
+        }
+        return pairCount;
+    }
+}
diff --git a/Easy/Find Minimum Log Transportation Cost.java b/Easy/Find Minimum Log Transportation Cost.java
new file mode 100644
index 00000000..3820474e
--- /dev/null
+++ b/Easy/Find Minimum Log Transportation Cost.java	
@@ -0,0 +1,12 @@
+class Solution {
+    public long minCuttingCost(int n, int m, int k) {
+        long cost = 0;
+        if (n > k) {
+            cost += ((long) (n - k)) * (k);
+        }
+        if (m > k) {
+            cost += ((long) (m - k)) * (k);
+        }
+        return cost;
+    }
+}
diff --git a/Easy/Find Minimum Operations to Make All Elements Divisible by Three.java b/Easy/Find Minimum Operations to Make All Elements Divisible by Three.java
new file mode 100644
index 00000000..c8d6f59e
--- /dev/null
+++ b/Easy/Find Minimum Operations to Make All Elements Divisible by Three.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int minimumOperations(int[] nums) {
+        int count = 0;
+        for (int num : nums) {
+            if (num % 3 != 0) {
+                count++;
+            }
+        }
+        return count;
+    }
+}
diff --git a/Easy/Find Missing and Repeated Values.java b/Easy/Find Missing and Repeated Values.java
new file mode 100644
index 00000000..52cf256e
--- /dev/null
+++ b/Easy/Find Missing and Repeated Values.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int[] findMissingAndRepeatedValues(int[][] grid) {
+        int n = grid.length;
+        int[] frequency = new int[n * n + 1];
+        for (int[] row : grid) {
+            for (int num : row) {
+                frequency[num]++;
+            }
+        }
+        int[] result = new int[2];
+        for (int i = 1; i <= n * n; i++) {
+            if (frequency[i] == 0) {
+                result[1] = i;
+            }
+            if (frequency[i] == 2) {
+                result[0] = i;
+            }
+        }
+        return result;
+    }
+}
diff --git a/Easy/Find Mode in Binary Search Tree.java b/Easy/Find Mode in Binary Search Tree.java
index a803103b..2b1f2fa0 100644
--- a/Easy/Find Mode in Binary Search Tree.java	
+++ b/Easy/Find Mode in Binary Search Tree.java	
@@ -14,44 +14,53 @@
  * }
  */
 class Solution {
-  Integer prev = null;
-  int count = 1;
-  int max = 0;
-  public int[] findMode(TreeNode root) {
-    if (root == null) {
-      return new int[0];
+    public int[] findMode(TreeNode root) {
+        ResultWrapper resultWrapper = new ResultWrapper();
+        inorder(root, resultWrapper);
+        return resultWrapper.result.stream().mapToInt(Integer::intValue).toArray();
     }
-    List<Integer> list = new ArrayList<>();
-    traverse(root, list);
-    int[] ans = new int[list.size()];
-    for (int i = 0; i < list.size(); i++) {
-      ans[i] = list.get(i);
+
+    private void inorder(TreeNode node, ResultWrapper resultWrapper) {
+        if (node == null) {
+            return;
+        }
+        inorder(node.left, resultWrapper);
+        int val = node.val;
+        resultWrapper.recordStreak(val);
+        resultWrapper.updateResult(val);
+        inorder(node.right, resultWrapper);
     }
-    return ans;
-  }
-  
-  private void traverse(TreeNode root, List<Integer> list) {
-    if (root == null) {
-      return;
+
+    private static class ResultWrapper {
+        private int maxStreak;
+        private int currStreak;
+        private Integer curr;
+        private List<Integer> result;
+
+        public ResultWrapper() {
+            this.maxStreak = 0;
+            this.currStreak = 0;
+            this.curr = 0;
+            this.result = new ArrayList<>();
+        }
+
+        public void recordStreak(int num) {
+            if (num == curr) {
+                currStreak++;
+            } else {
+                currStreak = 1;
+                curr = num;
+            }
+        }
+
+        public void updateResult(int num) {
+            if (currStreak > maxStreak) {
+                result.clear();
+                maxStreak = currStreak;
+            }
+            if (currStreak == maxStreak) {
+                result.add(num);
+            }
+        }
     }
-    traverse(root.left, list);
-    if (prev != null) {
-      if (root.val == prev) {
-        count++;
-      }
-      else {
-        count = 1;
-      }
-    }
-    if (count > max) {
-      max = count;
-      list.clear();
-      list.add(root.val);
-    }
-    else if (count == max) {
-      list.add(root.val);
-    }
-    prev = root.val;
-    traverse(root.right, list);
-  }
 }
diff --git a/Easy/Find Smallest Letter Greater Than Target.java b/Easy/Find Smallest Letter Greater Than Target.java
index 62e6cf03..6cdfb73a 100644
--- a/Easy/Find Smallest Letter Greater Than Target.java	
+++ b/Easy/Find Smallest Letter Greater Than Target.java	
@@ -1,17 +1,17 @@
 class Solution {
-  public char nextGreatestLetter(char[] letters, char target) {
-    int start = 0;
-    int end = letters.length - 1;
-    int minIdx = Integer.MAX_VALUE;
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (letters[mid] > target) {
-        minIdx = mid;
-        end = mid - 1;
-      } else {
-        start = mid + 1;
-      }
+    public char nextGreatestLetter(char[] letters, char target) {
+        int start = 0;
+        int end = letters.length - 1;
+        int idx = -1;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            if (letters[mid] > target) {
+                idx = mid;
+                end = mid - 1;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return idx == -1 ? letters[0] : letters[idx];
     }
-    return minIdx == Integer.MAX_VALUE ? letters[0] : letters[minIdx];
-  }
 }
diff --git a/Easy/Find Words Containing Character.java b/Easy/Find Words Containing Character.java
new file mode 100644
index 00000000..ba268c41
--- /dev/null
+++ b/Easy/Find Words Containing Character.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public List<Integer> findWordsContaining(String[] words, char x) {
+        return IntStream.range(0, words.length)
+            .filter(i -> words[i].indexOf(x) != -1)
+            .boxed()
+            .collect(Collectors.toList());
+    }
+}
diff --git a/Easy/Find Words That Can Be Formed by Characters.java b/Easy/Find Words That Can Be Formed by Characters.java
index 1dce1552..23550740 100644
--- a/Easy/Find Words That Can Be Formed by Characters.java	
+++ b/Easy/Find Words That Can Be Formed by Characters.java	
@@ -1,27 +1,24 @@
 class Solution {
-  public int countCharacters(String[] words, String chars) {
-    Map<Character, Integer> frequency = getFrequencyMap(chars);
-    return Arrays.stream(words)
-      .filter(word -> canBeFormed(word, frequency))
-      .map(word -> word.length())
-      .reduce(0, Integer::sum);
-  }
-  
-  private boolean canBeFormed(String word, Map<Character, Integer> frequency) {
-    Map<Character, Integer> wordFrequency = getFrequencyMap(word);
-    for (Character key : wordFrequency.keySet()) {
-      if (frequency.getOrDefault(key, 0) < wordFrequency.get(key)) {
-        return false;
-      }
+    public int countCharacters(String[] words, String chars) {
+        Map<Character, Long> targetMap = buildFrequencyMap(chars);
+        return Arrays.stream(words)
+                .filter(word -> doesIntersect(buildFrequencyMap(word), targetMap))
+                .mapToInt(String::length)
+                .sum();
     }
-    return true;
-  }
-  
-  private Map<Character, Integer> getFrequencyMap(String s) {
-    Map<Character, Integer> frequency = new HashMap<>();
-    for (char c : s.toCharArray()) {
-      frequency.put(c, frequency.getOrDefault(c, 0) + 1);
+
+    private static boolean doesIntersect(Map<Character, Long> currMap, Map<Character, Long> targetMap) {
+        for (Character key : currMap.keySet()) {
+            if (targetMap.getOrDefault(key, 0L) < currMap.get(key)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static Map<Character, Long> buildFrequencyMap(String s) {
+        return s.chars()
+                .mapToObj(c -> (char) c)
+                .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()));
     }
-    return frequency;
-  }
 }
diff --git a/Easy/Find if Digit Game Can Be Won.java b/Easy/Find if Digit Game Can Be Won.java
new file mode 100644
index 00000000..22c76892
--- /dev/null
+++ b/Easy/Find if Digit Game Can Be Won.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public boolean canAliceWin(int[] nums) {
+        int singleDigitSum = 0;
+        int doubleDigitSum = 0;
+        for (int num : nums) {
+            if (String.valueOf(num).length() > 1) {
+                doubleDigitSum += num;
+            } else {
+                singleDigitSum += num;
+            }
+        }
+        return singleDigitSum > doubleDigitSum || doubleDigitSum > singleDigitSum;
+    }
+}
diff --git a/Easy/Find if Path Exists in Graph.java b/Easy/Find if Path Exists in Graph.java
index cfa38aaa..7a0c6a47 100644
--- a/Easy/Find if Path Exists in Graph.java	
+++ b/Easy/Find if Path Exists in Graph.java	
@@ -1,28 +1,26 @@
 class Solution {
-  public boolean validPath(int n, int[][] edges, int start, int end) {
-    Map<Integer, Set<Integer>> graph = new HashMap<>();
-    for (int[] edge : edges) {
-      graph.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
-      graph.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
-    }
-    Queue<Integer> queue = new LinkedList<>();
-    queue.add(start);
-    Set<Integer> visited = new HashSet<>();
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int removed = queue.remove();
-        if (removed == end) {
-          return true;
+    public boolean validPath(int n, int[][] edges, int source, int destination) {
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+            graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
         }
-        visited.add(removed);
-        for (Integer connection : graph.getOrDefault(removed, new HashSet<>())) {
-          if (!visited.contains(connection)) {
-            queue.add(connection);
-          }
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(source);
+        Set<Integer> visited = new HashSet<>();
+        visited.add(source);
+        while (!queue.isEmpty()) {
+            Integer removed = queue.remove();
+            if (removed == destination) {
+                return true;
+            }
+            for (Integer connection : graph.getOrDefault(removed, new ArrayList<>())) {
+                if (!visited.contains(connection)) {
+                    queue.add(connection);
+                    visited.add(connection);
+                }
+            }
         }
-      }
+        return false;
     }
-    return false;
-  }
 }
diff --git a/Easy/Find the Array Concatenation Value.java b/Easy/Find the Array Concatenation Value.java
new file mode 100644
index 00000000..974ca82b
--- /dev/null
+++ b/Easy/Find the Array Concatenation Value.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public long findTheArrayConcVal(int[] nums) {
+        long concatenatedValue = 0;
+        int start = 0;
+        int end = nums.length - 1;
+        while (start <= end) {
+            concatenatedValue += start == end ? nums[start] : Integer.parseInt(nums[start] + "" + nums[end]);
+            start++;
+            end--;
+        }
+        return concatenatedValue;
+    }
+}
diff --git a/Easy/Find the Child Who Has the Ball After K Seconds.java b/Easy/Find the Child Who Has the Ball After K Seconds.java
new file mode 100644
index 00000000..6a4c8193
--- /dev/null
+++ b/Easy/Find the Child Who Has the Ball After K Seconds.java	
@@ -0,0 +1,7 @@
+class Solution {
+    public int numberOfChild(int n, int k) {
+        int factor = k / (n - 1);
+        int remainder = k % (n - 1);
+        return factor % 2 == 0 ? remainder : n - 1 - remainder;
+    }
+}
diff --git a/Easy/Find the Distinct Difference Array.java b/Easy/Find the Distinct Difference Array.java
new file mode 100644
index 00000000..5578427f
--- /dev/null
+++ b/Easy/Find the Distinct Difference Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int[] distinctDifferenceArray(int[] nums) {
+        int[] rightToLeft = new int[nums.length];
+        Set<Integer> set = new HashSet<>();
+        for (int i = nums.length - 1; i >= 0; i--) {
+            set.add(nums[i]);
+            rightToLeft[i] = set.size();
+        }
+        int[] diff = new int[nums.length];
+        set.clear();
+        for (int i = 0; i < nums.length; i++) {
+            set.add(nums[i]);
+            diff[i] = set.size() - (i == nums.length - 1 ? 0 : rightToLeft[i + 1]);
+        }
+        return diff;
+    }
+}
diff --git a/Easy/Find the Highest Altitude.java b/Easy/Find the Highest Altitude.java
index a7df7bf1..aa7d12e5 100644
--- a/Easy/Find the Highest Altitude.java	
+++ b/Easy/Find the Highest Altitude.java	
@@ -1,11 +1,11 @@
 class Solution {
-  public int largestAltitude(int[] gain) {
-    int highestAltitude = 0;
-    int currAltitude = 0;
-    for (int i = 0; i < gain.length; i++) {
-      currAltitude += gain[i];
-      highestAltitude = Math.max(highestAltitude, currAltitude);
+    public int largestAltitude(int[] gain) {
+        int highestAltitude = 0;
+        int currAltitude = 0;
+        for (int i = 0; i < gain.length; i++) {
+            currAltitude = currAltitude + gain[i];
+            highestAltitude = Math.max(highestAltitude, currAltitude);
+        }
+        return highestAltitude;
     }
-    return highestAltitude;
-  }
 }
diff --git a/Easy/Find the Integer Added to Array I.java b/Easy/Find the Integer Added to Array I.java
new file mode 100644
index 00000000..c5d551e3
--- /dev/null
+++ b/Easy/Find the Integer Added to Array I.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int addedInteger(int[] nums1, int[] nums2) {
+        int minOne = nums1[0];
+        int minTwo = nums2[0];
+        for (int i = 0; i < nums1.length; i++) {
+            minOne = Math.min(minOne, nums1[i]);
+            minTwo = Math.min(minTwo, nums2[i]);
+        }
+        return minTwo - minOne;
+    }
+}
diff --git a/Easy/Find the K-or of an Array.java b/Easy/Find the K-or of an Array.java
new file mode 100644
index 00000000..48343d5e
--- /dev/null
+++ b/Easy/Find the K-or of an Array.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public int findKOr(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            List<Integer> setBits = getSetBits(num);
+            for (Integer setBit : setBits) {
+                map.put(setBit, map.getOrDefault(setBit, 0) + 1);
+            }
+        }
+        int result = 0;
+        for (int i = 0, p = 1; i < 32; i++, p *= 2) {
+            if (map.getOrDefault(i, 0) >= k) {
+                result += p;
+            }
+        }
+        return result;
+    }
+
+    private static List<Integer> getSetBits(int num) {
+        List<Integer> bits = new ArrayList<>();
+        int bit = 0;
+        while (num > 0) {
+            if (num % 2 == 1) {
+                bits.add(bit);
+            }
+            num = num / 2;
+            bit++;
+        }
+        return bits;
+    }
+}
diff --git a/Easy/Find the Longest Balanced Substring of a Binary String.java b/Easy/Find the Longest Balanced Substring of a Binary String.java
new file mode 100644
index 00000000..2b1d3f2a
--- /dev/null
+++ b/Easy/Find the Longest Balanced Substring of a Binary String.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int findTheLongestBalancedSubstring(String s) {
+        int maxLength = 0;
+        int idx = 0;
+        while (idx < s.length()) {
+            if (s.charAt(idx) != '0') {
+                idx++;
+                continue;
+            }
+            int zeroCount = 0;
+            while (idx < s.length() && s.charAt(idx) == '0') {
+                idx++;
+                zeroCount++;
+            }
+            int oneCount = 0;
+            while (idx < s.length() && s.charAt(idx) == '1') {
+                idx++;
+                oneCount++;
+            }
+            maxLength = Math.max(maxLength, 2 * Math.min(zeroCount, oneCount));
+                
+        }
+        return maxLength;
+    }
+}
diff --git a/Easy/Find the Losers of the Circular Game.java b/Easy/Find the Losers of the Circular Game.java
new file mode 100644
index 00000000..aaa8c059
--- /dev/null
+++ b/Easy/Find the Losers of the Circular Game.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int[] circularGameLosers(int n, int k) {
+        Set<Integer> set = new HashSet<>();
+        int player = 1;
+        int multiple = k;
+        while (set.add(player)) {
+            player = (player + k) % n;
+            player = player == 0 ? n : player;
+            k += multiple;
+        }
+        int[] result = new int[n - set.size()];
+        for (int i = 1, j = 0; i <= n; i++) {
+            if (!set.contains(i)) {
+                result[j++] = i;
+            }
+        }
+        return result;
+    }
+}
diff --git a/Easy/Find the Maximum Achievable Number.java b/Easy/Find the Maximum Achievable Number.java
new file mode 100644
index 00000000..841862be
--- /dev/null
+++ b/Easy/Find the Maximum Achievable Number.java	
@@ -0,0 +1,5 @@
+class Solution {
+    public int theMaximumAchievableX(int num, int t) {
+        return num + 2 * t;
+    }
+}
diff --git a/Easy/Find the Number of Good Pairs I.java b/Easy/Find the Number of Good Pairs I.java
new file mode 100644
index 00000000..143d6abd
--- /dev/null
+++ b/Easy/Find the Number of Good Pairs I.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int numberOfPairs(int[] nums1, int[] nums2, int k) {
+        int count = 0;
+        for (int i = 0; i < nums1.length; i++) {
+            for (int j = 0; j < nums2.length; j++) {
+                if (nums1[i] % (nums2[j] * k) == 0) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+}
diff --git a/Easy/Find the Number of Winning Players.java b/Easy/Find the Number of Winning Players.java
new file mode 100644
index 00000000..fd4ea2ba
--- /dev/null
+++ b/Easy/Find the Number of Winning Players.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int winningPlayerCount(int n, int[][] pick) {
+        Map<Integer, Map<Integer, Integer>> map = new HashMap<>();
+        Set<Integer> winners = new HashSet<>();
+        for (int[] p : pick) {
+            map.computeIfAbsent(p[0], k -> new HashMap<>());
+            map.get(p[0]).put(p[1], map.get(p[0]).getOrDefault(p[1], 0) + 1);
+            if (map.get(p[0]).get(p[1]) > p[0]) {
+                winners.add(p[0]);
+            }
+        }
+        return winners.size();
+    }
+}
diff --git a/Easy/Find the Original Typed String I.java b/Easy/Find the Original Typed String I.java
new file mode 100644
index 00000000..dd6a5177
--- /dev/null
+++ b/Easy/Find the Original Typed String I.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int possibleStringCount(String word) {
+        int idx = 0;
+        int result = 1;
+        while (idx < word.length()) {
+            int currIdx = idx;
+            char c = word.charAt(currIdx);
+            while (currIdx < word.length() && word.charAt(currIdx) == c) {
+                currIdx++;
+            }
+            int segement = currIdx - idx;
+            result += segement - 1;
+            idx = currIdx;
+        }
+        return result;
+    }
+}
diff --git a/Easy/Find the Peaks.java b/Easy/Find the Peaks.java
new file mode 100644
index 00000000..f6120cd5
--- /dev/null
+++ b/Easy/Find the Peaks.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public List<Integer> findPeaks(int[] mountain) {
+        List<Integer> result = new ArrayList<>();
+        for (int i = 1; i < mountain.length - 1; i++) {
+            if (mountain[i] > mountain[i - 1] && mountain[i] > mountain[i + 1]) {
+                result.add(i);
+            }
+        }
+        return result;
+    }
+}
diff --git a/Easy/Find the Pivot Integer.java b/Easy/Find the Pivot Integer.java
new file mode 100644
index 00000000..3cad5e0b
--- /dev/null
+++ b/Easy/Find the Pivot Integer.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int pivotInteger(int n) {
+        int[] leftToRightSum = new int[n];
+        int currSum = 0;
+        for (int i = 0; i < n; i++) {
+            currSum += i + 1;
+            leftToRightSum[i] = currSum;
+        }
+        int rightToLeftSum = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            rightToLeftSum += i + 1;
+            if (leftToRightSum[i] == rightToLeftSum) {
+                return i + 1;
+            }
+        }
+        return -1;
+    }
+}
diff --git a/Easy/Find the Power of K-Size Subarrays I.java b/Easy/Find the Power of K-Size Subarrays I.java
new file mode 100644
index 00000000..975c1a3a
--- /dev/null
+++ b/Easy/Find the Power of K-Size Subarrays I.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int[] resultsArray(int[] nums, int k) {
+        if (k == 1) {
+            return nums;
+        }
+        int n = nums.length;
+        int[] result = new int[n - k + 1];
+        Arrays.fill(result, -1);
+        int count = 1;
+        for (int i = 0; i < nums.length - 1; i++) {
+            count = (nums[i + 1] - nums[i] == 1) ? count + 1 : 1;
+            if (count >= k) {
+                result[i - k + 2] = nums[i + 1];
+            }
+        }
+        return result;
+    }
+}
diff --git a/Easy/Find the Sum of Encrypted Integers.java b/Easy/Find the Sum of Encrypted Integers.java
new file mode 100644
index 00000000..6cee31bc
--- /dev/null
+++ b/Easy/Find the Sum of Encrypted Integers.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int sumOfEncryptedInt(int[] nums) {
+        int sum = 0;
+        for (int num : nums) {
+            sum += getEncryptedSum(num);
+        }
+        return sum;
+    }
+    
+    private static int getEncryptedSum(int num) {
+        int count = 0;
+        int max = 0;
+        while (num > 0) {
+            int digit = num % 10;
+            num /= 10;
+            count++;
+            max = Math.max(digit, max);
+        }
+        return Integer.parseInt(String.join("", Collections.nCopies(count, String.valueOf(max))));
+    }
+}
diff --git a/Easy/Find the Width of Columns of a Grid.java b/Easy/Find the Width of Columns of a Grid.java
new file mode 100644
index 00000000..843813b9
--- /dev/null
+++ b/Easy/Find the Width of Columns of a Grid.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int[] findColumnWidth(int[][] grid) {
+        int[] result = new int[grid[0].length];
+        for (int i = 0; i < grid[0].length; i++) {
+            int maxLength = 0;
+            for (int j = 0; j < grid.length; j++) {
+                maxLength = Math.max(maxLength, String.valueOf(grid[j][i]).length());
+            }
+            result[i] = maxLength;
+        }
+        return result;
+    }
+}
diff --git a/Easy/Find the XOR of Numbers Which Appear Twice.java b/Easy/Find the XOR of Numbers Which Appear Twice.java
new file mode 100644
index 00000000..baa845bc
--- /dev/null
+++ b/Easy/Find the XOR of Numbers Which Appear Twice.java	
@@ -0,0 +1,12 @@
+class Solution {
+    public int duplicateNumbersXOR(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        int xor = 0;
+        for (int num : nums) {
+            if (!set.add(num)) {
+                xor = xor ^ num;
+            }
+        }
+        return xor;
+    }
+}
diff --git a/Easy/Find the difference.java b/Easy/Find the difference.java
index 710a70d3..ca12be6d 100644
--- a/Easy/Find the difference.java	
+++ b/Easy/Find the difference.java	
@@ -1,15 +1,15 @@
 class Solution {
-  public char findTheDifference(String s, String t) {
-    int[] counter = new int[26];
-    for (char c : s.toCharArray()) {
-      counter[c - 'a']++;
+    public char findTheDifference(String s, String t) {
+        int[] frequency = new int[26];
+        for (char c : s.toCharArray()) {
+            frequency[c - 'a']++;
+        }
+        for (char c : t.toCharArray()) {
+            if (frequency[c - 'a'] == 0) {
+                return c;
+            }
+            frequency[c - 'a']--;
+        }
+        return ' ';
     }
-    for (char c : t.toCharArray()) {
-      if (counter[c - 'a'] == 0) {
-        return c;
-      }
-      counter[c - 'a']--;
-    }
-    return '-';
-  }
 }
diff --git a/Easy/Flip Game.java b/Easy/Flip Game.java
index 75a364a0..097acf18 100644
--- a/Easy/Flip Game.java	
+++ b/Easy/Flip Game.java	
@@ -1,11 +1,11 @@
 class Solution {
-  public List<String> generatePossibleNextMoves(String currentState) {
-    List<String> list = new ArrayList<>();
-    for (int i = 1; i < currentState.length(); i++) {
-      if (currentState.charAt(i) == '+' && currentState.charAt(i - 1) == '+') {
-        list.add(currentState.substring(0, i - 1) + "--" + currentState.substring(i + 1));
-      }
+    public List<String> generatePossibleNextMoves(String currentState) {
+        List<String> moves = new ArrayList<>();
+        for (int i = 0; i < currentState.length() - 1; i++) {
+            if (currentState.substring(i, i + 2).equals("++")) {
+                moves.add(currentState.substring(0, i) + "--" + currentState.substring(i + 2));
+            }
+        }
+        return moves;
     }
-    return list;
-  }
 }
diff --git a/Easy/Form Smallest Number From Two Digit Arrays.java b/Easy/Form Smallest Number From Two Digit Arrays.java
new file mode 100644
index 00000000..5ae6bd94
--- /dev/null
+++ b/Easy/Form Smallest Number From Two Digit Arrays.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int minNumber(int[] nums1, int[] nums2) {
+        int[] counter = new int[10];
+        int smallestOne = nums1[0];
+        int smallestTwo = nums2[0];
+        for (int num : nums1) {
+            counter[num]++;
+            smallestOne = Math.min(smallestOne, num);
+        }
+        for (int num : nums2) {
+            counter[num]++;
+            smallestTwo = Math.min(smallestTwo, num);
+        }
+        for (int i = 1; i < counter.length; i++) {
+            if (counter[i] == 2) {
+                return i;
+            }
+        }
+        return Math.min(smallestOne, smallestTwo) * 10 + Math.max(smallestOne, smallestTwo);
+    }
+}
diff --git a/Easy/Fruits Into Baskets II.java b/Easy/Fruits Into Baskets II.java
new file mode 100644
index 00000000..e0afa848
--- /dev/null
+++ b/Easy/Fruits Into Baskets II.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int numOfUnplacedFruits(int[] fruits, int[] baskets) {
+        int count = 0;
+        for (int fruit : fruits) {
+            int idx = -1;
+            for (int i = 0; i < baskets.length; i++) {
+                if (baskets[i] >= fruit) {
+                    idx = i;
+                    break;
+                }
+            }
+            if (idx == -1) {
+                count++;
+            } else {
+                baskets[idx] = -1;
+            }
+        }
+        return count;
+    }
+}
diff --git a/Easy/Furthest Point From Origin.java b/Easy/Furthest Point From Origin.java
new file mode 100644
index 00000000..d7abca92
--- /dev/null
+++ b/Easy/Furthest Point From Origin.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int furthestDistanceFromOrigin(String moves) {
+        int emptyCount = 0;
+        int direction = 0;
+        for (char c : moves.toCharArray()) {
+            if (c == '_') {
+                emptyCount++;
+            } else {
+                direction += c == 'L' ? -1 : 1;
+            }
+        }
+        return Math.abs(direction) + emptyCount;
+    }
+}
diff --git a/Easy/Greatest Common Divisor of Strings.java b/Easy/Greatest Common Divisor of Strings.java
index 263b6caa..f817725a 100644
--- a/Easy/Greatest Common Divisor of Strings.java	
+++ b/Easy/Greatest Common Divisor of Strings.java	
@@ -1,13 +1,13 @@
 class Solution {
-  public String gcdOfStrings(String str1, String str2) {
-    if (str1.length() < str2.length()) {  
-      return gcdOfStrings(str2, str1); 
-    } else if (!str1.startsWith(str2)) {
-      return "";
-    } else if (str2.isEmpty()) { 
-      return str1;
-    } else { 
-      return gcdOfStrings(str1.substring(str2.length()), str2); 
+    public String gcdOfStrings(String str1, String str2) {
+        if (!(str1 + str2).equals(str2 + str1)) {
+            return "";
+        }
+        int gcdLength = gcd(str1.length(), str2.length());
+        return str1.substring(0, gcdLength);
+    }
+    
+    private int gcd(int x, int y) {
+        return y == 0 ? x : gcd(y, x % y);
     }
-  }
 }
diff --git a/Easy/Harshad Number.java b/Easy/Harshad Number.java
new file mode 100644
index 00000000..c02c40bf
--- /dev/null
+++ b/Easy/Harshad Number.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int sumOfTheDigitsOfHarshadNumber(int x) {
+        int digitSum = getDigitSum(x);
+        return x % digitSum == 0 ? digitSum : -1;
+    }
+
+    private static int getDigitSum(int num) {
+        int sum = 0;
+        while (num > 0) {
+            sum += num % 10;
+            num /= 10;
+        }
+        return sum;
+    }
+}
diff --git a/Easy/Image Smoother.java b/Easy/Image Smoother.java
index 9f0d68f0..ede06daf 100644
--- a/Easy/Image Smoother.java	
+++ b/Easy/Image Smoother.java	
@@ -1,49 +1,27 @@
 class Solution {
-    public int[][] imageSmoother(int[][] M) {
-        
-        int[][] res = new int[M.length][M[0].length];
-        for (int i=0;i<M.length;i++) {
-            for (int j=0;j<M[0].length;j++) {
+
+    private static final int[][] DIRS = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}, {1, -1}, {-1, 1}, {1, 1}, {-1, -1}};
+
+    public int[][] imageSmoother(int[][] img) {
+        int rows = img.length;
+        int cols = img[0].length;
+        int[][] result = new int[rows][cols];
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                double sum = img[i][j];
                 int count = 1;
-                int sum = M[i][j];
-                
-                if(j-1 >= 0) {
-                    count++;
-                    sum += M[i][j-1];
-                }
-                if(j+1 < M[0].length) {
-                    count++;
-                    sum += M[i][j+1];
-                }
-                if(i-1 >= 0) {
-                    count++;
-                    sum += M[i-1][j];
-                }
-                if(i+1 < M.length) {
-                    count++;
-                    sum += M[i+1][j];
-                }
-                if(i+1 < M.length && j+1 < M[0].length) {
-                    count++;
-                    sum += M[i+1][j+1];
-                }
-                if(i+1 < M.length && j-1 >= 0) {
-                    count++;
-                    sum += M[i+1][j-1];
-                }
-                if(i-1 >= 0 && j-1 >= 0) {
-                    count++;
-                    sum += M[i-1][j-1];
-                }
-                if(i-1 >= 0 && j+1 < M[0].length) {
-                    count++;
-                    sum += M[i-1][j+1];
-                }
-                
-                res[i][j] = (int)Math.floor(sum/count);
+                for (int[] dir : DIRS) {
+                    int row = i + dir[0];
+                    int col = j + dir[1];
+                    if (row >= 0 && row < rows && col >= 0 && col < cols) {
+                        sum += img[row][col];
+                        count++;
+                    }
+                }
+                double smoothImage = sum / count;
+                result[i][j] = (int) smoothImage;
             }
         }
-        
-        return res;
+        return result;
     }
 }
diff --git a/Easy/Implement Queue using Stacks.java b/Easy/Implement Queue using Stacks.java
index c2a5254d..a84da8b6 100644
--- a/Easy/Implement Queue using Stacks.java	
+++ b/Easy/Implement Queue using Stacks.java	
@@ -1,46 +1,40 @@
 class MyQueue {
 
-  /** Initialize your data structure here. */
-  Stack<Integer> stack;
-  Stack<Integer> revStack;
-  public MyQueue() {
-    stack = new Stack<>();
-    revStack = new Stack<>();
-  }
+    private final Stack<Integer> first;
+    private final Stack<Integer> second;
 
-  /** Push element x to the back of queue. */
-  public void push(int x) {
-    stack.push(x);
-  }
-
-  /** Removes the element from in front of queue and returns that element. */
-  public int pop() {
-    while (!stack.isEmpty()) {
-      revStack.push(stack.pop());
+    public MyQueue() {
+        this.first = new Stack<>();
+        this.second = new Stack<>();
     }
-    int num = revStack.pop();
-    while (!revStack.isEmpty()) {
-      stack.push(revStack.pop());
+    
+    public void push(int x) {
+        first.push(x);
     }
-    return num;
-  }
-
-  /** Get the front element. */
-  public int peek() {
-    while (!stack.isEmpty()) {
-      revStack.push(stack.pop());
+    
+    public int pop() {
+        move(first, second);
+        int result = second.pop();
+        move(second, first);
+        return result;
     }
-    int num = revStack.peek();
-    while (!revStack.isEmpty()) {
-      stack.push(revStack.pop());
+    
+    public int peek() {
+        move(first, second);
+        int result = second.peek();
+        move(second, first);
+        return result;
+    }
+    
+    public boolean empty() {
+        return first.isEmpty();
     }
-    return num;
-  }
 
-  /** Returns whether the queue is empty. */
-  public boolean empty() {
-    return stack.isEmpty();
-  }
+    private void move(Stack<Integer> from, Stack<Integer> to) {
+        while (!from.isEmpty()) {
+            to.push(from.pop());
+        }
+    }
 }
 
 /**
diff --git a/Easy/Implement Stack using Queues.java b/Easy/Implement Stack using Queues.java
index 43c62339..d93ce3ae 100644
--- a/Easy/Implement Stack using Queues.java	
+++ b/Easy/Implement Stack using Queues.java	
@@ -1,52 +1,51 @@
 class MyStack {
-  
-  private Queue<Integer> primaryQueue;
-  private Queue<Integer> secondaryQueue;
-  
-  public MyStack() {
-    this.primaryQueue = new LinkedList<>();
-    this.secondaryQueue = new LinkedList<>();
-  }
+    
+    private final Queue<Integer> mainQueue;
+    private final Queue<Integer> backupQueue;
 
-  public void push(int x) {
-    this.primaryQueue.add(x);
-  }
-
-  public int pop() {
-    int result = moveFromPrimaryToSecondary();
-    moveFromSecondaryToPrimary(true);
-    return result;
-  }
-
-  public int top() {
-    int result = moveFromPrimaryToSecondary();
-    moveFromSecondaryToPrimary(false);
-    return result;
-  }
-  
-  public boolean empty() {
-    return this.primaryQueue.isEmpty();
-  }
-  
-  private int moveFromPrimaryToSecondary() {
-    int last = this.primaryQueue.peek();
-    while (!this.primaryQueue.isEmpty()) {
-      last = this.primaryQueue.peek();
-      this.secondaryQueue.add(this.primaryQueue.remove());
+    public MyStack() {
+        this.mainQueue = new LinkedList<>();
+        this.backupQueue = new LinkedList<>();
+    }
+    
+    public void push(int x) {
+        this.mainQueue.add(x);
+    }
+    
+    public int pop() {
+        int lastElement = moveToBackupQueue();
+        moveToMainQueue(true);
+        return lastElement;
+    }
+    
+    public int top() {
+        int lastElement = moveToBackupQueue();
+        moveToMainQueue(false);
+        return lastElement;
+    }
+    
+    public boolean empty() {
+        return this.mainQueue.isEmpty();
     }
-    return last;
-  }
-  
-  private void moveFromSecondaryToPrimary(boolean removeLast) {
-    while (this.secondaryQueue.size() > 1) {
-      this.primaryQueue.add(this.secondaryQueue.remove());
+    
+    private int moveToBackupQueue() {
+        int lastElement = this.mainQueue.peek();
+        while (!this.mainQueue.isEmpty()) {
+            lastElement = this.mainQueue.peek();
+            this.backupQueue.add(this.mainQueue.poll());
+        }
+        return lastElement;
     }
-    if (removeLast) {
-      this.secondaryQueue.remove();
-    } else {
-      this.primaryQueue.add(this.secondaryQueue.remove());
+    
+    private void moveToMainQueue(boolean removeLast) {
+        int sizeLimit = removeLast ? 1 : 0;
+        while (this.backupQueue.size() > sizeLimit) {
+            this.mainQueue.add(this.backupQueue.poll());
+        }
+        if (removeLast) {
+            this.backupQueue.remove();
+        }
     }
-  }
 }
 
 /**
diff --git a/Easy/Index Pairs of a String.java b/Easy/Index Pairs of a String.java
index 97d590ce..5fd32b1e 100644
--- a/Easy/Index Pairs of a String.java	
+++ b/Easy/Index Pairs of a String.java	
@@ -1,50 +1,14 @@
 class Solution {
-  public int[][] indexPairs(String text, String[] words) {
-    TrieNode root = new TrieNode('-');
-    for (String word : words) {
-      addWord(word, root);
-    }
-    List<int[]> list = new ArrayList<>();
-    for (int i = 0; i < text.length(); i++) {
-      int j = i;
-      TrieNode curr = root;
-      while (j < text.length() && curr.childrens.containsKey(text.charAt(j))) {
-        curr = curr.childrens.get(text.charAt(j));
-        if (curr.isWord) {
-          list.add(new int[]{i, j});
+    public int[][] indexPairs(String text, String[] words) {
+        List<int[]> pairs = new ArrayList<>();
+        for (String word : words) {
+            for (int i = 0; i < text.length() - word.length() + 1; i++) {
+                if (text.startsWith(word, i)) {
+                    pairs.add(new int[]{i, i + word.length() - 1});
+                }
+            }
         }
-        j++;
-      }
-    }
-    int[][] ans = new int[list.size()][2];
-    for (int i = 0; i < list.size(); i++) {
-      ans[i] = list.get(i);
+        pairs.sort(Comparator.comparingInt((int[] o) -> o[0]).thenComparingInt(o -> o[1]));
+        return pairs.toArray(new int[0][]);
     }
-    return ans;
-  }
-  
-  private void addWord(String s, TrieNode root) {
-    for (int i = 0; i < s.length(); i++) {
-      if (!root.childrens.containsKey(s.charAt(i))) {
-        root.childrens.put(s.charAt(i), new TrieNode(s.charAt(i)));
-      }
-      root = root.childrens.get(s.charAt(i));
-      if (i == s.length() - 1) {
-        root.isWord = true;
-      }
-    }
-  }
-}
-
-
-class TrieNode {
-  char c;
-  Map<Character, TrieNode> childrens;
-  boolean isWord;
-  
-  public TrieNode(char c) {
-    this.c = c;
-    childrens = new HashMap<>();
-    isWord = false;
-  }
 }
diff --git a/Easy/Intersection of Two Arrays.java b/Easy/Intersection of Two Arrays.java
index d05f4468..24a47d60 100644
--- a/Easy/Intersection of Two Arrays.java	
+++ b/Easy/Intersection of Two Arrays.java	
@@ -1,25 +1,8 @@
 class Solution {
-  public int[] intersection(int[] nums1, int[] nums2) {
-    boolean[][] found = new boolean[1001][2];
-    for (int num : nums1) {
-      found[num][0] = true;
+    public int[] intersection(int[] nums1, int[] nums2) {
+        Set<Integer> set1 = Arrays.stream(nums1).boxed().collect(Collectors.toSet());
+        Set<Integer> set2 = Arrays.stream(nums2).boxed().collect(Collectors.toSet());
+        set1.retainAll(set2);
+        return set1.stream().mapToInt(Integer::intValue).toArray();
     }
-    int count = 0;
-    for (int num : nums2) {
-      if (!found[num][1]) {
-        if (found[num][0]) {
-          count++;
-        }
-      }
-      found[num][1] = true;
-    }
-    int[] result = new int[count];
-    int idx = 0;
-    for (int i = 1; i <= 1000; i++) {
-      if (found[i][0] && found[i][1]) {
-        result[idx++] = i;
-      }
-    }
-    return result;
-  }
 }
diff --git a/Easy/Invert Binary Tree.java b/Easy/Invert Binary Tree.java
index f02950d0..d2c3c6ab 100644
--- a/Easy/Invert Binary Tree.java	
+++ b/Easy/Invert Binary Tree.java	
@@ -14,15 +14,13 @@
  * }
  */
 class Solution {
-  public TreeNode invertTree(TreeNode root) {
-    if (root == null) {
-      return root;
+    public TreeNode invertTree(TreeNode root) {
+        if (root == null) {
+            return null;
+        }
+        TreeNode leftNode = root.left;
+        root.left = invertTree(root.right);
+        root.right = invertTree(leftNode);
+        return root;
     }
-    TreeNode right = root.right;
-    root.right = root.left;
-    root.left = right;
-    invertTree(root.left);
-    invertTree(root.right);
-    return root;
-  }
 }
diff --git a/Easy/Is Subsequence.java b/Easy/Is Subsequence.java
index 90732379..2d67a698 100644
--- a/Easy/Is Subsequence.java	
+++ b/Easy/Is Subsequence.java	
@@ -1,11 +1,13 @@
 class Solution {
-  public boolean isSubsequence(String s, String t) {
-    int j = 0;
-    for (int i = 0; i < t.length() && j < s.length(); i++) {
-      if (s.charAt(j) == t.charAt(i)) {
-        j++;
-      }
+    public boolean isSubsequence(String s, String t) {
+        int sIdx = 0;
+        int tIdx = 0;
+        while (sIdx < s.length() && tIdx < t.length()) {
+            if (s.charAt(sIdx) == t.charAt(tIdx)) {
+                sIdx++;
+            }
+            tIdx++;
+        }
+        return sIdx == s.length();
     }
-    return j == s.length();
-  }
 }
diff --git a/Easy/Isomorphic Strings.java b/Easy/Isomorphic Strings.java
index 6b870650..b9813b64 100644
--- a/Easy/Isomorphic Strings.java	
+++ b/Easy/Isomorphic Strings.java	
@@ -1,12 +1,18 @@
 class Solution {
-  public boolean isIsomorphic(String s, String t) {
-    int[] position = new int[512];
-    for (int i = 0; i < s.length(); i++) {
-      if (position[s.charAt(i)] != position[t.charAt(i) + 256]) {
-        return false;
-      }
-      position[s.charAt(i)] = position[t.charAt(i) + 256] = i + 1;
+    public boolean isIsomorphic(String s, String t) {
+        return mapString(s).equals(mapString(t));
+    }
+
+    private static String mapString(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        int count = 0;
+        StringBuilder sb = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            if (!map.containsKey(c)) {
+                map.put(c, count++);
+            }
+            sb.append(map.get(c)).append("|");
+        }
+        return sb.toString();
     }
-    return true;
-  }
 }
diff --git a/Easy/K Items With the Maximum Sum.java b/Easy/K Items With the Maximum Sum.java
new file mode 100644
index 00000000..01d51965
--- /dev/null
+++ b/Easy/K Items With the Maximum Sum.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int kItemsWithMaximumSum(int numOnes, int numZeros, int numNegOnes, int k) {
+        int sum = 0;
+        sum += Math.min(numOnes, k) * 1;
+        k -= Math.min(numOnes, k);
+        sum += Math.min(numZeros, k) * 0;
+        k -= Math.min(numZeros, k);
+        sum += Math.min(numNegOnes, k) * -1;
+        return sum;
+    }
+}
diff --git a/Easy/Kids With the Greatest Number of Candies.java b/Easy/Kids With the Greatest Number of Candies.java
index 79789d90..67e2441d 100644
--- a/Easy/Kids With the Greatest Number of Candies.java	
+++ b/Easy/Kids With the Greatest Number of Candies.java	
@@ -1,13 +1,10 @@
 class Solution {
-  public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
-    int maxCandyCount = 0;
-    for (int candy : candies) {
-      maxCandyCount = Math.max(maxCandyCount, candy);
+    public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
+        final int maxCandy = Arrays.stream(candies)
+            .max()
+            .orElse(0);
+        return Arrays.stream(candies)
+            .mapToObj(candy -> candy + extraCandies >= maxCandy)
+            .collect(Collectors.toList());
     }
-    List<Boolean> result = new ArrayList<>();
-    for (int candy : candies) {
-      result.add((candy + extraCandies) >= maxCandyCount);
-    }
-    return result;
-  }
 }
diff --git a/Easy/Kth Largest Element in a Stream.java b/Easy/Kth Largest Element in a Stream.java
index 30bbc6f6..4b1868f3 100644
--- a/Easy/Kth Largest Element in a Stream.java	
+++ b/Easy/Kth Largest Element in a Stream.java	
@@ -1,25 +1,28 @@
 class KthLargest {
+    
+    private final PriorityQueue<Integer> pq;
+    private final int k;
 
-  private PriorityQueue<Integer> pq;
-  private int k;
-  public KthLargest(int k, int[] nums) {
-    this.k = k;
-    this.pq = new PriorityQueue<>();
-    for (int num : nums) {
-      pq.add(num);
-      if (pq.size() > k) {
-        pq.poll();
-      }
+    public KthLargest(int k, int[] nums) {
+        this.k = k;
+        this.pq = new PriorityQueue<>((a, b) -> a - b);
+        for (int num : nums) {
+            pq.add(num);
+            checkLength();
+        }
     }
-  }
-
-  public int add(int val) {
-    pq.add(val);
-    if (pq.size() > k) {
-      pq.poll();
+    
+    public int add(int val) {
+        pq.add(val);
+        checkLength();
+        return pq.peek();
+    }
+    
+    private void checkLength() {
+        if (pq.size() > k) {
+            pq.poll();
+        }
     }
-    return pq.peek();
-  }
 }
 
 /**
diff --git a/Easy/Largest Local Values in a Matrix.java b/Easy/Largest Local Values in a Matrix.java
new file mode 100644
index 00000000..570443a9
--- /dev/null
+++ b/Easy/Largest Local Values in a Matrix.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int[][] largestLocal(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        int[][] result = new int[rows - 2][cols - 2];
+        for (int i = 0; i < rows - 2; i++) {
+            for (int j = 0; j < cols - 2; j++) {
+                for (int k = i; k < i + 3; k++) {
+                    for (int l = j; l < j + 3; l++) {
+                        result[i][j] = Math.max(result[i][j], grid[k][l]);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
diff --git a/Easy/Largest Substring Between Two Equal Characters.java b/Easy/Largest Substring Between Two Equal Characters.java
index fa0d8495..24371003 100644
--- a/Easy/Largest Substring Between Two Equal Characters.java	
+++ b/Easy/Largest Substring Between Two Equal Characters.java	
@@ -1,12 +1,11 @@
 class Solution {
-  public int maxLengthBetweenEqualCharacters(String s) {
-    Map<Character, Integer> startIndex = new HashMap<>();
-    int largestSubstringLength = -1;
-    for (int i = 0; i < s.length(); i++) {
-      char c = s.charAt(i);
-      startIndex.putIfAbsent(c, i);
-      largestSubstringLength = Math.max(largestSubstringLength, i - startIndex.get(c) - 1);
+    public int maxLengthBetweenEqualCharacters(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        int maxLength = -1;
+        for (int i = 0; i < s.length(); i++) {
+            map.putIfAbsent(s.charAt(i), i);
+            maxLength = Math.max(maxLength, i - map.get(s.charAt(i)) - 1);
+        }
+        return maxLength;
     }
-    return largestSubstringLength;
-  }
 }
diff --git a/Easy/Last Stone Weight.java b/Easy/Last Stone Weight.java
index 08f390b1..afb35b41 100644
--- a/Easy/Last Stone Weight.java	
+++ b/Easy/Last Stone Weight.java	
@@ -1,16 +1,16 @@
 class Solution {
-  public int lastStoneWeight(int[] stones) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>((o1, o2) -> o2 - o1);
-    for (int stone : stones) {
-      pq.add(stone);
+    public int lastStoneWeight(int[] stones) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        for (int stone : stones) {
+            pq.add(stone);
+        }
+        while (pq.size() > 1) {
+            int stoneOne = pq.poll();
+            int stoneTwo = pq.poll();
+            if (stoneOne != stoneTwo) {
+                pq.add(stoneOne - stoneTwo);
+            }
+        }
+        return pq.isEmpty() ? 0 : pq.poll();
     }
-    while (pq.size() > 1) {
-      int firstStone = pq.poll();
-      int secondStone = pq.poll();
-      if (firstStone != secondStone) {
-        pq.add(firstStone - secondStone);
-      }
-    }
-    return pq.isEmpty() ? 0 : pq.poll();
-  }
 }
diff --git a/Easy/Last Visited Integers.java b/Easy/Last Visited Integers.java
new file mode 100644
index 00000000..e6a59e34
--- /dev/null
+++ b/Easy/Last Visited Integers.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public List<Integer> lastVisitedIntegers(List<String> words) {
+        List<Integer> result = new ArrayList<>();
+        List<Integer> numbers = new ArrayList<>();
+        int cursor = -1;
+        for (String word : words) {
+            if (word.equals("prev")) {
+                result.add(cursor == -1 ? -1 : numbers.get(cursor));
+                cursor = cursor == -1 ? -1 : (cursor - 1);
+            } else {
+                numbers.add(Integer.parseInt(word));
+                cursor = numbers.size() - 1;
+            }
+        }
+        return result;
+    }
+}
diff --git a/Easy/Leaf-Similar Trees.java b/Easy/Leaf-Similar Trees.java
index 38bb0ab9..082f6583 100644
--- a/Easy/Leaf-Similar Trees.java	
+++ b/Easy/Leaf-Similar Trees.java	
@@ -14,29 +14,29 @@
  * }
  */
 class Solution {
-  public boolean leafSimilar(TreeNode root1, TreeNode root2) {
-    return getLeaves(root1).equals(getLeaves(root2));
-  }   
-  
-  private List<Integer> getLeaves(TreeNode root) {
-    Stack<TreeNode> stack = new Stack<>();
-    List<Integer> leaves = new ArrayList<>();
-    while (root != null) {
-      stack.push(root);
-      root = root.left;
+    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
+        return getLeaves(root1).equals(getLeaves(root2));
     }
-    while (!stack.isEmpty()) {
-      TreeNode removed = stack.pop();
-      if (removed.left == null && removed.right == null) {
-        leaves.add(removed.val);
-      } else {
-        TreeNode rightNode = removed.right;
-        while (rightNode != null) {
-          stack.push(rightNode);
-          rightNode = rightNode.left;
+
+    private static List<Integer> getLeaves(TreeNode root) {
+        if (root == null) {
+            return new ArrayList<>();
         }
-      }
+        List<Integer> result = new ArrayList<>();
+        Stack<TreeNode> stack = new Stack<>();
+        stack.push(root);
+        while (!stack.isEmpty()) {
+            TreeNode removed = stack.pop();
+            if (removed.left == null && removed.right == null) {
+                result.add(removed.val);
+            }
+            if (removed.right != null) {
+                stack.push(removed.right);
+            }
+            if (removed.left != null) {
+                stack.push(removed.left);
+            }
+        }
+        return result;
     }
-    return leaves;
-  }
 }
diff --git a/Easy/Left and Right Sum Differences.java b/Easy/Left and Right Sum Differences.java
new file mode 100644
index 00000000..99a5338a
--- /dev/null
+++ b/Easy/Left and Right Sum Differences.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int[] leftRigthDifference(int[] nums) {
+        int n = nums.length;
+        int leftToRightSum = 0;
+        for (int i = 0; i < n; i++) {
+            leftToRightSum += nums[i];
+        }
+        int[] result = new int[n];
+        int rightToLeftSum = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            leftToRightSum -= nums[i];
+            result[i] = Math.abs(rightToLeftSum - leftToRightSum);
+            rightToLeftSum += nums[i];
+        }
+        return result;
+    }
+}
diff --git a/Easy/Longest Alternating Subarray.java b/Easy/Longest Alternating Subarray.java
new file mode 100644
index 00000000..65de425c
--- /dev/null
+++ b/Easy/Longest Alternating Subarray.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int alternatingSubarray(int[] nums) {
+        int start = 0;
+        int maxLength = -1;
+        int expectedDiff = 1;
+        for (int i = 1; i < nums.length;) {
+            if (nums[i] - nums[i - 1] != expectedDiff) {
+                if (nums[i] - nums[i - 1] != 1) {
+                    i++;
+                } 
+                start = i - 1;
+                expectedDiff = 1;
+                continue;
+            }
+            expectedDiff *= -1;
+            maxLength = Math.max(maxLength, i - start + 1);
+            i++;
+        }
+        return maxLength;
+    }
+}
diff --git a/Easy/Longest Even Odd Subarray With Threshold.java b/Easy/Longest Even Odd Subarray With Threshold.java
new file mode 100644
index 00000000..f3dcc239
--- /dev/null
+++ b/Easy/Longest Even Odd Subarray With Threshold.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public int longestAlternatingSubarray(int[] nums, int threshold) {
+        int maxLength = 0;
+        int start = 0;
+        boolean evenRequired = true;
+        int idx = 0;
+        while (idx < nums.length) {
+            if (nums[idx] > threshold) {
+                idx++;
+                start = idx;
+                evenRequired = true;
+                continue;
+            }
+            if (nums[idx] % 2 == 0 && !evenRequired) {
+                start = idx;
+                evenRequired = true;
+                continue;
+            }
+            if (nums[idx] % 2 != 0 && evenRequired) {
+                idx++;
+                start = idx;
+                evenRequired = true;
+                continue;
+            }
+            idx++;
+            maxLength = Math.max(maxLength, idx - start);
+            evenRequired = !evenRequired;
+        }
+        return maxLength;
+    }
+}
diff --git a/Easy/Longest Strictly Increasing or Strictly Decreasing Subarray.java b/Easy/Longest Strictly Increasing or Strictly Decreasing Subarray.java
new file mode 100644
index 00000000..c1ed1c36
--- /dev/null
+++ b/Easy/Longest Strictly Increasing or Strictly Decreasing Subarray.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int longestMonotonicSubarray(int[] nums) {
+        int max = 1;
+        int idx = 0;
+        int n = nums.length;
+        while (idx < n) {
+            if (idx == n - 1 || nums[idx + 1] == nums[idx]) {
+                idx++;
+                continue;
+            }
+            boolean increase = nums[idx + 1] > nums[idx];
+            int start = idx;
+            while (idx + 1 < n && (
+                (increase && nums[idx + 1] > nums[idx]) || 
+                (!increase && nums[idx + 1] < nums[idx]))) {
+                idx++;
+            }
+            max = Math.max(max, idx - start + 1);
+        }
+        return max;
+    }
+}
diff --git a/Easy/Make The String Great.java b/Easy/Make The String Great.java
index a7cb7882..32b4684a 100644
--- a/Easy/Make The String Great.java	
+++ b/Easy/Make The String Great.java	
@@ -1,18 +1,24 @@
 class Solution {
-  public String makeGood(String s) {
-    Stack<Character> stack = new Stack<>();
-    for (char c : s.toCharArray()) {
-      if (!stack.isEmpty() && Math.abs(stack.peek() - c) == 32) {
-        stack.pop();
-      }
-      else {
-        stack.push(c);
-      }
+    public String makeGood(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (!stack.isEmpty() && isBad(c, stack.peek())) {
+                stack.pop();
+                continue;
+            }
+            stack.push(c);
+        }
+        StringBuilder sb = new StringBuilder();
+        while (!stack.isEmpty()) {
+            sb.append(stack.pop());
+        }
+        return sb.reverse().toString();
     }
-    StringBuilder sb = new StringBuilder();
-    while (!stack.isEmpty()) {
-      sb.append(stack.pop());
+
+    private static boolean isBad(char c1, char c2) {
+        if (c1 == c2) {
+            return false;
+        }
+        return Character.toLowerCase(c1) == Character.toLowerCase(c2);
     }
-    return sb.reverse().toString();
-  }
 }
diff --git a/Easy/Make Three Strings Equal.java b/Easy/Make Three Strings Equal.java
new file mode 100644
index 00000000..a1e7477f
--- /dev/null
+++ b/Easy/Make Three Strings Equal.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int findMinimumOperations(String s1, String s2, String s3) {
+        int idx = 0;
+        while (idx < s1.length() && idx < s2.length() && idx < s3.length() && 
+               s1.charAt(idx) == s2.charAt(idx) && s1.charAt(idx) == s3.charAt(idx)) {
+            idx++;
+        }
+        if (idx == 0) {
+            return -1;
+        }
+        return s1.length() + s2.length() + s3.length() - 3 * idx;
+    }
+}
diff --git a/Easy/Make Two Arrays Equal by Reversing Subarrays.java b/Easy/Make Two Arrays Equal by Reversing Subarrays.java
new file mode 100644
index 00000000..62ce7dca
--- /dev/null
+++ b/Easy/Make Two Arrays Equal by Reversing Subarrays.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public boolean canBeEqual(int[] target, int[] arr) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : target) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        for (int num : arr) {
+            if (!map.containsKey(num)) {
+                return false;
+            }
+            map.put(num, map.get(num) - 1);
+            if (map.get(num) == 0) {
+                map.remove(num);
+            }
+        }
+        return map.isEmpty();
+    }
+}
diff --git a/Easy/Make a Square with the Same Color.java b/Easy/Make a Square with the Same Color.java
new file mode 100644
index 00000000..2f5524d8
--- /dev/null
+++ b/Easy/Make a Square with the Same Color.java	
@@ -0,0 +1,40 @@
+class Solution {
+
+    int[][] DIRS = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
+
+    public boolean canMakeSquare(char[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (isPossible(grid, i, j, rows, cols)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean isPossible(char[][] grid, int i, int j, int rows, int cols) {
+        int white = 0;
+        int black = 0;
+        int invalid = 0;
+        for (int[] dir : DIRS) {
+            int newX = i + dir[0];
+            int newY = j + dir[1];
+            if (newX >= 0 && newY >= 0 && newX < rows && newY < cols) {
+                white += grid[newX][newY] == 'W' ? 1 : 0;
+                black += grid[newX][newY] == 'B' ? 1 : 0;
+            } else {
+                invalid++;
+            }
+        }
+        if (invalid > 0) {
+            return false;
+        }
+        if (white == 4 || black == 4) {
+            return true;
+        }
+        return white == 1 || black == 1;
+    }
+}
diff --git a/Easy/Matrix Similarity After Cyclic Shifts.java b/Easy/Matrix Similarity After Cyclic Shifts.java
new file mode 100644
index 00000000..624bcf08
--- /dev/null
+++ b/Easy/Matrix Similarity After Cyclic Shifts.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public boolean areSimilar(int[][] mat, int k) {
+        for (int j = 0; j < mat.length; j++) {
+            if (j % 2 != 0) {
+                continue;
+            }
+            int[] row = mat[j];
+            int n = row.length;
+            for (int i = 0; i < n; i++) {
+                if (row[i] != row[(i + k) % n]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
diff --git a/Easy/Max Pair Sum in an Array.java b/Easy/Max Pair Sum in an Array.java
new file mode 100644
index 00000000..e7f6332e
--- /dev/null
+++ b/Easy/Max Pair Sum in an Array.java	
@@ -0,0 +1,54 @@
+class Solution {
+    public int maxSum(int[] nums) {
+        Map<Integer, Pair> map = new HashMap<>();
+        for (int num : nums) {
+            int maxDigit = getMaxDigit(num);
+            if (!map.containsKey(maxDigit)) {
+                map.put(maxDigit, new Pair());
+            }
+            map.get(maxDigit).record(num);
+        }
+        int result = -1;
+        for (Integer key : map.keySet()) {
+            result = Math.max(result, map.get(key).getPairSum());
+        }
+        return result;
+    }
+    
+    private int getMaxDigit(int num) {
+        int maxDigit = 0;
+        while (num > 0) {
+            maxDigit = Math.max(maxDigit, num % 10);
+            num /= 10;
+        }
+        return maxDigit;
+    }
+    
+    private static class Pair {
+        int maximum;
+        int secondMaximum;
+        
+        public Pair() {
+            maximum = -1;
+            secondMaximum = -1;
+        }
+        
+        public void record(int num) {
+            if (maximum < num) {
+                if (secondMaximum < maximum) {
+                    secondMaximum = maximum;
+                }
+                maximum = num;
+            } else if (secondMaximum < num) {
+                secondMaximum = num;
+            }
+        }
+        
+        public int getPairSum() {
+            if (maximum == -1 || secondMaximum == -1) {
+                return -1;
+            }
+            return maximum + secondMaximum;
+        }
+    }
+}
diff --git a/Easy/Maximum Ascending Subarray Sum.java b/Easy/Maximum Ascending Subarray Sum.java
index fb436414..fd64c04c 100644
--- a/Easy/Maximum Ascending Subarray Sum.java	
+++ b/Easy/Maximum Ascending Subarray Sum.java	
@@ -1,14 +1,15 @@
 class Solution {
-  public int maxAscendingSum(int[] nums) {
-    int maximumSum = 0;
-    int idx = 0;
-    while (idx < nums.length) {
-      int currSum = nums[idx++];
-      while (idx < nums.length && nums[idx] > nums[idx - 1]) {
-        currSum += nums[idx++];
-      }
-      maximumSum = Math.max(maximumSum, currSum);
+    public int maxAscendingSum(int[] nums) {
+        int maxSum = 0;
+        int idx = 0;
+        int n = nums.length;
+        while (idx < n) {
+            int currSum = nums[idx++];
+            while (idx < n && nums[idx] > nums[idx - 1]) {
+                currSum += nums[idx++];
+            }
+            maxSum = Math.max(maxSum, currSum);
+        }
+        return maxSum;
     }
-    return maximumSum;
-  }
 }
diff --git a/Easy/Maximum Containers on a Ship.java b/Easy/Maximum Containers on a Ship.java
new file mode 100644
index 00000000..e113027d
--- /dev/null
+++ b/Easy/Maximum Containers on a Ship.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public int maxContainers(int n, int w, int maxWeight) {
+        if (n * n * w <= maxWeight) {
+            return n * n;
+        }
+        return maxWeight / w;
+    }
+}
diff --git a/Easy/Maximum Count of Positive Integer and Negative Integer.java b/Easy/Maximum Count of Positive Integer and Negative Integer.java
new file mode 100644
index 00000000..73e0dba8
--- /dev/null
+++ b/Easy/Maximum Count of Positive Integer and Negative Integer.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int maximumCount(int[] nums) {
+        int positiveCount = 0;
+        int negativeCount = 0;
+        for (int num : nums) {
+            positiveCount += num > 0 ? 1 : 0;
+            negativeCount += num < 0 ? 1 : 0;
+        }
+        return Math.max(positiveCount, negativeCount);
+    }
+}
diff --git a/Easy/Maximum Difference Between Even and Odd Frequency I.java b/Easy/Maximum Difference Between Even and Odd Frequency I.java
new file mode 100644
index 00000000..ec68c06f
--- /dev/null
+++ b/Easy/Maximum Difference Between Even and Odd Frequency I.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maxDifference(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : s.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+        int maxOdd = Integer.MIN_VALUE;
+        int minEven = Integer.MAX_VALUE;
+        for (Character key : map.keySet()) {
+            Integer value = map.get(key);
+            if (value % 2 == 0) {
+                minEven = Math.min(minEven, value);
+            } else {
+                maxOdd = Math.max(maxOdd, value);
+            }
+        }
+        return maxOdd - minEven;
+    }
+}
diff --git a/Easy/Maximum Difference by Remapping a Digit.java b/Easy/Maximum Difference by Remapping a Digit.java
new file mode 100644
index 00000000..5241297f
--- /dev/null
+++ b/Easy/Maximum Difference by Remapping a Digit.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int minMaxDifference(int num) {
+        char digitsOne[] = String.valueOf(num).toCharArray();
+        char digitsTwo[] = String.valueOf(num).toCharArray();
+        char firstDigitOne = digitsOne[0];
+        char firstDigitTwo = digitsOne[0];
+        for (int i = 0; i < digitsOne.length; i++) {
+            if (digitsOne[i] != '9') {
+                firstDigitOne = digitsOne[i];
+                break;
+            }
+        }
+        for (int i = 0; i < digitsOne.length; i++) {
+            if (digitsOne[i] == firstDigitOne) {
+                digitsOne[i] = '9';
+            }
+        }
+        for(int i = 0; i < digitsOne.length; i++) {
+            if (digitsTwo[i] == firstDigitTwo) {
+                digitsTwo[i] = '0';
+            }
+        }
+        return Integer.parseInt(String.valueOf(digitsOne)) - Integer.parseInt(String.valueOf(digitsTwo));
+    }
+}
diff --git a/Easy/Maximum Distance in Arrays.java b/Easy/Maximum Distance in Arrays.java
deleted file mode 100644
index 71a4581d..00000000
--- a/Easy/Maximum Distance in Arrays.java	
+++ /dev/null
@@ -1,17 +0,0 @@
-class Solution {
-    public static int maxDistance(List<List<Integer>> arrays) {
-        int min = arrays.get(0).get(0);
-        int max = arrays.get(0).get(arrays.get(0).size()-1);
-        int result = Integer.MIN_VALUE;
-
-        for (int i=1; i<arrays.size(); i++) {
-            result = Math.max(result, Math.abs(arrays.get(i).get(arrays.get(i).size()-1) - min));
-            result = Math.max(result, Math.abs(arrays.get(i).get(0) - max));
-
-            max = Math.max(max, arrays.get(i).get(arrays.get(i).size()-1));
-            min = Math.min(min, arrays.get(i).get(0));
-        }
-        
-        return result;
-    }
-}
diff --git a/Easy/Maximum Enemy Forts That Can Be Captured.java b/Easy/Maximum Enemy Forts That Can Be Captured.java
new file mode 100644
index 00000000..207f220c
--- /dev/null
+++ b/Easy/Maximum Enemy Forts That Can Be Captured.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int captureForts(int[] forts) {
+        int maximumCapture = 0;
+        for (int i = 0, j = 0; i < forts.length; i++) {
+            if (forts[i] != 0) {
+                if (forts[i] == -1 * forts[j]) {
+                    maximumCapture = Math.max(maximumCapture, i - j - 1);
+                }
+                j = i;
+            }
+        }
+        return maximumCapture;
+    }
+}
diff --git a/Easy/Maximum Length Substring With Two Occurrences.java b/Easy/Maximum Length Substring With Two Occurrences.java
new file mode 100644
index 00000000..44e281b1
--- /dev/null
+++ b/Easy/Maximum Length Substring With Two Occurrences.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maximumLengthSubstring(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        int start = 0;
+        int end = 0;
+        int n = s.length();
+        int result = 0;
+        while (end < n) {
+            map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
+            while (start <= end && map.get(s.charAt(end)) > 2) {
+                map.put(s.charAt(start), map.get(s.charAt(start)) - 1);
+                start++;
+            }
+            end++;
+            result = Math.max(result, end - start);
+        }
+        return result;
+    }
+}
diff --git a/Easy/Maximum Nesting Depth of the Parentheses.java b/Easy/Maximum Nesting Depth of the Parentheses.java
index 19a50736..8ce9eac2 100644
--- a/Easy/Maximum Nesting Depth of the Parentheses.java	
+++ b/Easy/Maximum Nesting Depth of the Parentheses.java	
@@ -1,11 +1,13 @@
 class Solution {
-  public int maxDepth(String s) {
-    int currCount = 0;
-    int maxCount = 0;
-    for (char c : s.toCharArray()) {
-      currCount += c == '(' ? 1 : (c == ')' ? -1 : 0);
-      maxCount = Math.max(maxCount, currCount);
+    public int maxDepth(String s) {
+        int count = 0;
+        int result = 0;
+        for (char c : s.toCharArray()) {
+            if (c == '(' || c == ')') {
+                count += c == '(' ? 1 : -1;
+            }
+            result = Math.max(result, count);
+        }
+        return result;
     }
-    return maxCount;
-  }
 }
diff --git a/Easy/Maximum Number of Operations With the Same Score I.java b/Easy/Maximum Number of Operations With the Same Score I.java
new file mode 100644
index 00000000..22f6648d
--- /dev/null
+++ b/Easy/Maximum Number of Operations With the Same Score I.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int maxOperations(int[] nums) {
+        int score = -1;
+        int operations = 0;
+        for (int i = 0; i <= nums.length - 2; i += 2) {
+            int currScore = nums[i] + nums[i + 1];
+            if (score != -1 && score != currScore) {
+                break;
+            } 
+            score = currScore;
+            operations++;
+        }
+        return operations;
+    }
+}
diff --git a/Easy/Maximum Odd Binary Number.java b/Easy/Maximum Odd Binary Number.java
new file mode 100644
index 00000000..861a3fd1
--- /dev/null
+++ b/Easy/Maximum Odd Binary Number.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public String maximumOddBinaryNumber(String s) {
+        int oneCount = 0;
+        for (char c : s.toCharArray()) {
+            oneCount += c == '1' ? 1 : 0;
+        }
+        if (oneCount == 0) {
+            return s;
+        }
+        int zeroCount = s.length() - oneCount;
+        return "1".repeat(oneCount - 1) + "0".repeat(zeroCount) + "1";
+    }
+}
diff --git a/Easy/Maximum Product of Two Digits.java b/Easy/Maximum Product of Two Digits.java
new file mode 100644
index 00000000..c61f3c3a
--- /dev/null
+++ b/Easy/Maximum Product of Two Digits.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxProduct(int n) {
+        int maximum = Integer.MIN_VALUE;
+        int secondMaximum = Integer.MIN_VALUE;
+        while (n > 0) {
+            int num = n % 10;
+            n /= 10;
+            if (num > maximum) {
+                secondMaximum = maximum;
+                maximum = num;
+            } else if (num > secondMaximum) {
+                secondMaximum = num;
+            }
+        }
+        return maximum * secondMaximum;
+    }
+}
diff --git a/Easy/Maximum Score After Splitting a String.java b/Easy/Maximum Score After Splitting a String.java
new file mode 100644
index 00000000..60649ebf
--- /dev/null
+++ b/Easy/Maximum Score After Splitting a String.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxScore(String s) {
+        int n = s.length();
+        int ones = 0;
+        for (int i = 0; i < n; i++) {
+            ones += s.charAt(i) == '1' ? 1 : 0;
+        }
+        int score = 0;
+        int zeros = 0;
+        for (int i = 0; i < n - 1; i++) {
+            ones -= s.charAt(i) == '1' ? 1 : 0;
+            zeros += s.charAt(i) == '0' ? 1 : 0;
+            score = Math.max(score, zeros + ones);
+        }
+        return score;
+    }
+}
diff --git a/Easy/Maximum Subarray.java b/Easy/Maximum Subarray.java
deleted file mode 100644
index 46b106c7..00000000
--- a/Easy/Maximum Subarray.java	
+++ /dev/null
@@ -1,14 +0,0 @@
-class Solution {
-  public int maxSubArray(int[] nums) {
-    int currSum = 0;
-    int maxSum = Integer.MIN_VALUE;
-    for (int num : nums) {
-      currSum += num;
-      if (num > currSum) {
-        currSum = num;
-      }
-      maxSum = Math.max(maxSum, currSum);
-    }
-    return maxSum;
-  }
-}
diff --git a/Easy/Maximum Sum With Exactly K Elements.java b/Easy/Maximum Sum With Exactly K Elements.java
new file mode 100644
index 00000000..ad738207
--- /dev/null
+++ b/Easy/Maximum Sum With Exactly K Elements.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int maximizeSum(int[] nums, int k) {
+        int maxNum = 0;
+        for (int num : nums) {
+            maxNum = Math.max(num, maxNum);
+        }
+        int score = 0;
+        while (k-- > 0) {
+            score += maxNum++;
+        }
+        return score;
+    }
+}
diff --git a/Easy/Maximum Unique Subarray Sum After Deletion.java b/Easy/Maximum Unique Subarray Sum After Deletion.java
new file mode 100644
index 00000000..e0a6a2ae
--- /dev/null
+++ b/Easy/Maximum Unique Subarray Sum After Deletion.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxSum(int[] nums) {
+        int max = nums[0];
+        int sum = 0;
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            max = Math.max(num, max);
+            if (num > 0 && set.add(num)) {
+                sum += num;
+            }
+        }
+        if (max < 0) {
+            return max;
+        }
+        return sum;
+    }
+}
diff --git a/Easy/Maximum Value of a String in an Array.java b/Easy/Maximum Value of a String in an Array.java
new file mode 100644
index 00000000..29b0ec25
--- /dev/null
+++ b/Easy/Maximum Value of a String in an Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maximumValue(String[] strs) {
+        return Arrays.stream(strs)
+                .mapToInt(Solution::getStringValue)
+                .max()
+                .orElse(0);
+    }
+
+    private static int getStringValue(String s) {
+        for (char c : s.toCharArray()) {
+            if (!Character.isDigit(c)) {
+                return s.length();
+            }
+        }
+        return Integer.parseInt(s);
+    }
+}
diff --git a/Easy/Maximum Value of an Ordered Triplet I.java b/Easy/Maximum Value of an Ordered Triplet I.java
new file mode 100644
index 00000000..870e4602
--- /dev/null
+++ b/Easy/Maximum Value of an Ordered Triplet I.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public long maximumTripletValue(int[] nums) {
+        int n = nums.length;
+        int[] maxLeft = new int[n];
+        int[] maxRight = new int[n];
+        maxLeft[0] = nums[0];
+        for (int i = 1; i < n; i++) {
+            maxLeft[i] = Math.max(maxLeft[i - 1], nums[i]);
+        }
+        maxRight[n - 1] = nums[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            maxRight[i] = Math.max(maxRight[i + 1], nums[i]);
+        }
+        long maxValue = -1;
+        for (int i = 1; i < n - 1; i++) {
+            long left = (long) maxLeft[i - 1];
+            long right = (long) maxRight[i + 1];
+            maxValue = Math.max(maxValue, (left - nums[i]) * right);
+        }
+        return maxValue == -1 ? 0 : maxValue;
+    }
+}
diff --git a/Easy/Merge Strings Alternately.java b/Easy/Merge Strings Alternately.java
index 65fb9904..7b851597 100644
--- a/Easy/Merge Strings Alternately.java	
+++ b/Easy/Merge Strings Alternately.java	
@@ -1,19 +1,16 @@
 class Solution {
-  public String mergeAlternately(String word1, String word2) {
-    int idx1 = 0;
-    int idx2 = 0;
-    StringBuilder sb = new StringBuilder();
-    boolean first = true;
-    while (idx1 < word1.length() && idx2 < word2.length()) {
-      sb.append(first ? word1.charAt(idx1++) : word2.charAt(idx2++));
-      first = !first;
+    public String mergeAlternately(String word1, String word2) {
+        StringBuilder sb = new StringBuilder();
+        int idxOne = 0;
+        int idxTwo = 0;
+        while (idxOne < word1.length() || idxTwo < word2.length()) {
+            if (idxOne < word1.length()) {
+                sb.append(word1.charAt(idxOne++));
+            }
+            if (idxTwo < word2.length()) {
+                sb.append(word2.charAt(idxTwo++));
+            }
+        }
+        return sb.toString();
     }
-    while (idx1 < word1.length()) {
-      sb.append(word1.charAt(idx1++));
-    }
-    while (idx2 < word2.length()) {
-      sb.append(word2.charAt(idx2++));
-    }
-    return sb.toString();
-  }
 }
diff --git a/Easy/Merge Two 2D Arrays by Summing Values.java b/Easy/Merge Two 2D Arrays by Summing Values.java
new file mode 100644
index 00000000..87d07080
--- /dev/null
+++ b/Easy/Merge Two 2D Arrays by Summing Values.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public int[][] mergeArrays(int[][] nums1, int[][] nums2) {
+        int[] totalSum = new int[1001];
+        int count = nums1.length;
+        for (int i = 0; i < nums1.length; i++) {
+            int id = nums1[i][0];
+            int val = nums1[i][1];
+            totalSum[id] = val;
+        }
+        for (int i = 0; i < nums2.length; i++) {
+            int id = nums2[i][0];
+            int val = nums2[i][1];
+            if (totalSum[id] == 0) {
+                count++;
+            }
+            totalSum[id] += val;
+        }
+        int[][] result = new int[count][2];
+        int idx = 0;
+        for (int i = 1; i <= 1000; i++) {
+            if (totalSum[i] != 0) {
+                result[idx++] = new int[]{i, totalSum[i]};
+            }
+        }
+        return result;
+    }
+}
diff --git a/Easy/Merge Two Sorted Lists.java b/Easy/Merge Two Sorted Lists.java
index cb2fff94..e594a670 100644
--- a/Easy/Merge Two Sorted Lists.java	
+++ b/Easy/Merge Two Sorted Lists.java	
@@ -9,39 +9,29 @@
  * }
  */
 class Solution {
-  public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
-    if (list1 == null || list2 == null) {
-      return list1 == null ? list2 : list1;
-    }
-    ListNode prev = null;
-    ListNode head = null;
-    while (list1 != null && list2 != null) {
-      if (list1.val <= list2.val) {
-        prev = list1;
-        if (head == null) {
-          head = list1;
-        }
-        list1 = list1.next;
-      } else {
-        ListNode node = list2;
-        list2 = list2.next;
-        if (prev == null) {
-          node.next = list1;
-          prev = node;
-          head = prev;
-        } else {
-          prev.next = node;
-          node.next = list1;
-          prev = node;
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        ListNode dummy = new ListNode();
+        ListNode curr = dummy;
+        while (l1 != null || l2 != null) {
+            int val = -1;
+            if (l1 != null && l2 != null) {
+                if (l1.val > l2.val) {
+                    val = l2.val;
+                    l2 = l2.next;
+                } else {
+                    val = l1.val;
+                    l1 = l1.next;
+                }
+            } else if (l1 != null && l2 == null) {
+                val = l1.val;
+                l1 = l1.next;
+            } else {
+                val = l2.val;
+                l2 = l2.next;
+            }
+            curr.next = new ListNode(val);
+            curr = curr.next;
         }
-      }
-    }
-    if (list2 != null) {
-      prev.next = list2;
-    }
-    if (list1 != null) {
-      prev.next = list1;
+        return dummy.next;
     }
-    return head;
-  }
 }
diff --git a/Easy/Min Cost Climbing Stairs.java b/Easy/Min Cost Climbing Stairs.java
index 7a718918..1db8f19d 100644
--- a/Easy/Min Cost Climbing Stairs.java	
+++ b/Easy/Min Cost Climbing Stairs.java	
@@ -1,13 +1,12 @@
 class Solution {
-  public int minCostClimbingStairs(int[] cost) {
-    int n = cost.length;
-    int first = cost[0];
-    int second = cost[1];
-    for (int i = 2; i < n; i++) {
-      int curr = cost[i] + Math.min(first, second);
-      first = second;
-      second = curr;
+    public int minCostClimbingStairs(int[] cost) {
+        int stepOneCost = cost[0];
+        int stepTwoCost = cost[1];
+        for (int i = 2; i < cost.length; i++) {
+            int currCost = cost[i] + Math.min(stepOneCost, stepTwoCost);
+            stepOneCost = stepTwoCost;
+            stepTwoCost = currCost;
+        }
+        return Math.min(stepOneCost, stepTwoCost);
     }
-    return Math.min(first, second);
-  }
 }
diff --git a/Easy/Minimize String Length.java b/Easy/Minimize String Length.java
new file mode 100644
index 00000000..48d8ab26
--- /dev/null
+++ b/Easy/Minimize String Length.java	
@@ -0,0 +1,7 @@
+class Solution {
+    public int minimizedStringLength(String s) {
+        return (int) s.chars()
+            .distinct()
+            .count();
+    }
+}
diff --git a/Easy/Minimum  Absolute Difference in BST.java b/Easy/Minimum  Absolute Difference in BST.java
index d29da542..80248dc1 100644
--- a/Easy/Minimum  Absolute Difference in BST.java	
+++ b/Easy/Minimum  Absolute Difference in BST.java	
@@ -14,24 +14,22 @@
  * }
  */
 class Solution {
-  int minDiff;
-  TreeNode prev;
-  public int getMinimumDifference(TreeNode root) {
-    minDiff = Integer.MAX_VALUE;
-    prev = null;
-    helper(root);
-    return minDiff;
-  }
-  
-  private void helper(TreeNode root) {
-    if (root == null) {
-      return;
+    public int getMinimumDifference(TreeNode root) {
+        List<Integer> nodeValues = new ArrayList<>();
+        inorder(root, nodeValues);
+        int minDifference = Integer.MAX_VALUE;
+        for (int i = 1; i < nodeValues.size(); i++) {
+            minDifference = Math.min(minDifference, nodeValues.get(i) - nodeValues.get(i - 1));
+        }
+        return minDifference;
     }
-    helper(root.left);
-    if (prev != null) {
-      minDiff = Math.min(minDiff, Math.abs(root.val - prev.val));
+
+    private void inorder(TreeNode root, List<Integer> nodeValues) {
+        if (root == null) {
+            return;
+        }
+        inorder(root.left, nodeValues);
+        nodeValues.add(root.val);
+        inorder(root.right, nodeValues);
     }
-    prev = root;
-    helper(root.right);
-  }
 }
diff --git a/Easy/Minimum Average of Smallest and Largest Elements.java b/Easy/Minimum Average of Smallest and Largest Elements.java
new file mode 100644
index 00000000..f1fd9e2d
--- /dev/null
+++ b/Easy/Minimum Average of Smallest and Largest Elements.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public double minimumAverage(int[] nums) {
+        double minAverage = Double.MAX_VALUE;
+        Arrays.sort(nums);
+        int left = 0;
+        int right = nums.length - 1;
+        while (left < right) {
+            double average = (nums[left] + nums[right]) / 2.0;
+            minAverage = Math.min(minAverage, average);
+            left++;
+            right--;
+        }
+        return minAverage;
+    }
+}
diff --git a/Easy/Minimum Changes To Make Alternating Binary String.java b/Easy/Minimum Changes To Make Alternating Binary String.java
index 539d9a42..95f9aaae 100644
--- a/Easy/Minimum Changes To Make Alternating Binary String.java	
+++ b/Easy/Minimum Changes To Make Alternating Binary String.java	
@@ -1,11 +1,16 @@
 class Solution {
-  public int minOperations(String s) {
-    int numOfChanges = 0;
-    for (int i = 0; i < s.length(); i++) {
-      if (s.charAt(i) - '0' != i % 2) {
-        numOfChanges++;
-      }
+    public int minOperations(String s) {
+        int startZero = 0;
+        int startOne = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (i % 2 == 0) {
+                startOne += s.charAt(i) == '0' ? 1 : 0;
+                startZero += s.charAt(i) == '1' ? 1 : 0;
+            } else {
+                startOne += s.charAt(i) == '1' ? 1 : 0;
+                startZero += s.charAt(i) == '0' ? 1 : 0;
+            }
+        }
+        return Math.min(startZero, startOne);
     }
-    return Math.min(numOfChanges, s.length() - numOfChanges);
-  }
 }
diff --git a/Easy/Minimum Common Value.java b/Easy/Minimum Common Value.java
new file mode 100644
index 00000000..5062e9a3
--- /dev/null
+++ b/Easy/Minimum Common Value.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int getCommon(int[] nums1, int[] nums2) {
+        int idxOne = 0;
+        int idxTwo = 0;
+        while (idxOne < nums1.length && idxTwo < nums2.length) {
+            if (nums1[idxOne] < nums2[idxTwo]) {
+                idxOne++;
+            } else if (nums2[idxTwo] < nums1[idxOne]) {
+                idxTwo++;
+            } else {
+                return nums1[idxOne];
+            }
+        }
+        return -1;
+    }
+}
diff --git a/Easy/Minimum Cost to Reach Every Position.java b/Easy/Minimum Cost to Reach Every Position.java
new file mode 100644
index 00000000..1b142d2c
--- /dev/null
+++ b/Easy/Minimum Cost to Reach Every Position.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int[] minCosts(int[] cost) {
+        int n = cost.length;
+        int[] result = new int[n];
+        int minCost = Integer.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            int curr = cost[i];
+            minCost = Math.min(minCost, curr);
+            result[i] = minCost;
+        }
+        return result;
+    }
+}
diff --git a/Easy/Minimum Depth of a Binary Tree.java b/Easy/Minimum Depth of a Binary Tree.java
index e1d21cc6..0da04114 100644
--- a/Easy/Minimum Depth of a Binary Tree.java	
+++ b/Easy/Minimum Depth of a Binary Tree.java	
@@ -14,31 +14,29 @@
  * }
  */
 class Solution {
-  public int minDepth(TreeNode root) {
-    if (root == null) {
-      return 0;
-    }
-    int steps = 1;
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      // Level iteration
-      while (size-- > 0) {
-        TreeNode removed = queue.remove();
-        // Leaf reached
-        if (removed.left == null && removed.right == null) {
-          return steps;
-        }
-        if (removed.left != null) {
-          queue.add(removed.left);
+    public int minDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
         }
-        if (removed.right != null) {
-          queue.add(removed.right);
+        int level = 1;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                if (removed.left == null && removed.right == null) {
+                    return level;
+                }
+                if (removed.left != null) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null) {
+                    queue.add(removed.right);
+                }
+            }
+            level++;
         }
-      }
-      steps++;
+        return level;
     }
-    return steps;
-  }
 }
diff --git a/Easy/Minimum Distance Between BST Nodes.java b/Easy/Minimum Distance Between BST Nodes.java
index 4c147e39..af92feb0 100644
--- a/Easy/Minimum Distance Between BST Nodes.java	
+++ b/Easy/Minimum Distance Between BST Nodes.java	
@@ -14,25 +14,22 @@
  * }
  */
 class Solution {
-  Integer minDiff;
-  Integer prev;
-  public int minDiffInBST(TreeNode root) {
-    minDiff = Integer.MAX_VALUE;
-    prev = null;
-    helper(root);
-    return minDiff;
-  }
-  
-  private void helper(TreeNode root) {
-    if (root == null) {
-      return;
+    public int minDiffInBST(TreeNode root) {
+        int[] minDiff = {Integer.MAX_VALUE};
+        Integer[] prevVal = {null};
+        inorder(root, minDiff, prevVal);
+        return minDiff[0];
     }
-    helper(root.left);
-    if (prev != null) {
-      minDiff = Math.min(minDiff, root.val - prev);
+    
+    private void inorder(TreeNode node, int[] minDiff, Integer[] prevValue) {
+        if (node == null) {
+            return;
+        }
+        inorder(node.left, minDiff, prevValue);
+        if (prevValue[0] != null) {
+            minDiff[0] = Math.min(minDiff[0], node.val - prevValue[0]);
+        }
+        prevValue[0] = node.val;
+        inorder(node.right, minDiff, prevValue);
     }
-    prev = root.val;
-    helper(root.right);
-  }
 }
-
diff --git a/Easy/Minimum Number Game.java b/Easy/Minimum Number Game.java
new file mode 100644
index 00000000..a3377cb7
--- /dev/null
+++ b/Easy/Minimum Number Game.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int[] numberGame(int[] nums) {
+        int[] result = new int[nums.length];
+        Arrays.sort(nums);
+        for (int i = 0; i < nums.length; i += 2) {
+            result[i] = nums[i + 1];
+            result[i + 1] = nums[i];
+        }
+        return result;
+    }
+}
diff --git a/Easy/Minimum Number of Chairs in a Waiting Room.java b/Easy/Minimum Number of Chairs in a Waiting Room.java
new file mode 100644
index 00000000..d7db8060
--- /dev/null
+++ b/Easy/Minimum Number of Chairs in a Waiting Room.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int minimumChairs(String s) {
+        int requiredChairCount = 0;
+        int currChairCount = 0;
+        for (char c : s.toCharArray()) {
+            currChairCount += c == 'E' ? 1 : -1;
+            requiredChairCount = Math.max(requiredChairCount, currChairCount);
+        }
+        return requiredChairCount;
+    }
+}
diff --git a/Easy/Minimum Number of Operations to Make Elements in Array Distinct.java b/Easy/Minimum Number of Operations to Make Elements in Array Distinct.java
new file mode 100644
index 00000000..a61239e7
--- /dev/null
+++ b/Easy/Minimum Number of Operations to Make Elements in Array Distinct.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int minimumOperations(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        int index = -1;
+        for (int i = nums.length - 1; i >= 0; i--) {
+            if (set.contains(nums[i])) {
+                index = i;
+                break;
+            }
+            set.add(nums[i]);
+        }
+        if (index == -1) {
+            return 0;
+        }
+        index++;
+        return index % 3 == 0 ? index / 3 : (index / 3) + 1;
+    }
+}
diff --git a/Easy/Minimum Number of Pushes to Type Word I.java b/Easy/Minimum Number of Pushes to Type Word I.java
new file mode 100644
index 00000000..0a6bbc24
--- /dev/null
+++ b/Easy/Minimum Number of Pushes to Type Word I.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int minimumPushes(String word) {
+        int pushes = 0;
+        int idx = 0;
+        int multiple = 1;
+        while (idx < word.length()) {
+            int count = Math.min(8, word.length() - idx);
+            pushes += count * multiple;
+            multiple++;
+            idx += count;
+        }
+        return pushes;
+    }
+}
diff --git a/Easy/Minimum Operations to Collect Elements.java b/Easy/Minimum Operations to Collect Elements.java
new file mode 100644
index 00000000..59e9d7c4
--- /dev/null
+++ b/Easy/Minimum Operations to Collect Elements.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int minOperations(List<Integer> nums, int k) {
+        boolean[] found = new boolean[k];
+        int foundCount = 0;
+        for (int i = nums.size() - 1; i >= 0; i--) {
+            if (nums.get(i) <= k && !found[nums.get(i) - 1]) {
+                found[nums.get(i) - 1] = true;
+                foundCount++;
+            }
+            if (foundCount == k) {
+                return nums.size() - i;
+            }
+        }
+        return -1;
+    }
+}
diff --git a/Easy/Minimum Operations to Exceed Threshold Value I.java b/Easy/Minimum Operations to Exceed Threshold Value I.java
new file mode 100644
index 00000000..6f792f07
--- /dev/null
+++ b/Easy/Minimum Operations to Exceed Threshold Value I.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int minOperations(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        pq.addAll(map.keySet());
+        int count = 0;
+        while (!pq.isEmpty() && pq.peek() < k) {
+            count += map.get(pq.poll());
+        }
+        return count;
+    }
+}
diff --git a/Easy/Minimum Operations to Make Array Sum Divisible by K.java b/Easy/Minimum Operations to Make Array Sum Divisible by K.java
new file mode 100644
index 00000000..c941b50a
--- /dev/null
+++ b/Easy/Minimum Operations to Make Array Sum Divisible by K.java	
@@ -0,0 +1,9 @@
+class Solution {
+    public int minOperations(int[] nums, int k) {
+        int sum = 0;  
+        for (int num : nums) {
+            sum += num;
+        }
+        return sum % k;
+    }
+}
diff --git a/Easy/Minimum Right Shifts to Sort the Array.java b/Easy/Minimum Right Shifts to Sort the Array.java
new file mode 100644
index 00000000..aad801a0
--- /dev/null
+++ b/Easy/Minimum Right Shifts to Sort the Array.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int minimumRightShifts(List<Integer> nums) {
+        int mismatchIdx = -1;
+        int count = 0;
+        for (int i = 1; i < nums.size(); i++) {
+            if (nums.get(i - 1) > nums.get(i)) {
+                mismatchIdx = i;
+                count++;
+            }
+        }
+        if (count > 1) {
+            return -1;
+        }
+        if (count == 0) {
+            return 0;
+        }
+        return nums.get(nums.size() - 1) > nums.get(0) ? -1 : nums.size() - mismatchIdx;
+    }
+}
diff --git a/Easy/Minimum String Length After Removing Substrings.java b/Easy/Minimum String Length After Removing Substrings.java
new file mode 100644
index 00000000..606d3394
--- /dev/null
+++ b/Easy/Minimum String Length After Removing Substrings.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int minLength(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (!stack.isEmpty() && c == 'B' && stack.peek() == 'A') {
+                stack.pop();
+            } else if (!stack.isEmpty() && c == 'D' && stack.peek() == 'C') {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        return stack.size();
+    }
+}
diff --git a/Easy/Minimum Sum of Mountain Triplets I.java b/Easy/Minimum Sum of Mountain Triplets I.java
new file mode 100644
index 00000000..cabcd870
--- /dev/null
+++ b/Easy/Minimum Sum of Mountain Triplets I.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int minimumSum(int[] nums) {
+        int n = nums.length;
+        int[] smallestRight = new int[n];
+        smallestRight[n - 1] = nums[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            smallestRight[i] = Math.min(smallestRight[i + 1], nums[i]);
+        }
+        int smallestLeft = nums[0];
+        int result = Integer.MAX_VALUE;
+        for (int i = 1; i < n; i++) {
+            if (smallestLeft < nums[i] && smallestRight[i] < nums[i]) {
+                result = Math.min(result, nums[i] + smallestRight[i] + smallestLeft);
+            }
+            smallestLeft = Math.min(smallestLeft, nums[i]);
+        }
+        return result == Integer.MAX_VALUE ? -1 : result;
+    }
+}
diff --git a/Easy/Minimum Time Visiting All Points.java b/Easy/Minimum Time Visiting All Points.java
index 774ac97c..ee1a85b1 100644
--- a/Easy/Minimum Time Visiting All Points.java	
+++ b/Easy/Minimum Time Visiting All Points.java	
@@ -1,13 +1,17 @@
 class Solution {
-  public int minTimeToVisitAllPoints(int[][] points) {
-    int time = 0;
-    for (int i = 1; i < points.length; i++) {
-      int[] prevPoint = points[i - 1];
-      int[] currPoint = points[i];
-      time += Math.max(
-        Math.abs(prevPoint[0] - currPoint[0]), Math.abs(prevPoint[1] - currPoint[1])
-      );
+    public int minTimeToVisitAllPoints(int[][] points) {
+        int time = 0;
+        int idx = 0;
+        while (idx < points.length - 1) {
+            time += calculateTime(points[idx], points[idx + 1]);
+            idx++;
+        }
+        return time;
+    }
+    
+    private static int calculateTime(int[] p1, int[] p2) {
+        int x = Math.abs(p1[0] - p2[0]);
+        int y = Math.abs(p1[1] - p2[1]);
+        return Math.max(x, y);
     }
-    return time;
-  }
 }
diff --git a/Easy/Modify the Matrix.java b/Easy/Modify the Matrix.java
new file mode 100644
index 00000000..f238aa68
--- /dev/null
+++ b/Easy/Modify the Matrix.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int[][] modifiedMatrix(int[][] matrix) {
+        int rows = matrix.length;
+        int cols = matrix[0].length;
+        for (int c = 0; c < cols; c++) {
+            int max = -1;
+            for (int r = 0; r < rows; r++) {
+                max = Math.max(max, matrix[r][c]);
+            }
+            for (int r = 0; r < rows; r++) {
+                matrix[r][c] = matrix[r][c] == -1 ? max : matrix[r][c];
+            }
+        }
+        return matrix;
+    }
+}
diff --git a/Easy/Monotonic Array.java b/Easy/Monotonic Array.java
index 4a348d71..e460648c 100644
--- a/Easy/Monotonic Array.java	
+++ b/Easy/Monotonic Array.java	
@@ -1,21 +1,19 @@
 class Solution {
-  public boolean isMonotonic(int[] nums) {
-    int idx = 0;
-    int sign = 0;
-    while (idx < nums.length - 1 && sign == 0) {
-      if (nums[idx] < nums[idx + 1]) {
-        sign = 1;
-      } else if (nums[idx] > nums[idx + 1]) {
-        sign = -1;
-      }
-      idx++;
+    public boolean isMonotonic(int[] nums) {
+        int idx = 0;
+        while (idx + 1 < nums.length && nums[idx] == nums[idx + 1]) {
+            idx++;
+        } 
+        boolean increasing = idx + 1 < nums.length && nums[idx] < nums[idx + 1];
+        while (idx + 1 < nums.length) {
+            if (nums[idx] > nums[idx + 1] && increasing) {
+                return false;
+            }
+            if (nums[idx] < nums[idx + 1] && !increasing) {
+                return false;
+            }
+            idx++;
+        }
+        return true;
     }
-    while (idx < nums.length - 1) {
-      if ((sign == 1 && nums[idx] > nums[idx + 1]) || (sign == -1 && nums[idx] < nums[idx + 1])) {
-        return false;
-      }
-      idx++;
-    }
-    return true;
-  }
 }
diff --git a/Easy/Moving Average from Data Stream.java b/Easy/Moving Average from Data Stream.java
index e52fa84a..ec9dca5b 100644
--- a/Easy/Moving Average from Data Stream.java	
+++ b/Easy/Moving Average from Data Stream.java	
@@ -1,23 +1,23 @@
 class MovingAverage {
-  
-  private int currSum;
-  private Queue<Integer> queue;
-  private int size;
-  
-  public MovingAverage(int size) {
-    this.currSum = 0;
-    this.size = size;
-    this.queue = new LinkedList<>();
-  }
 
-  public double next(int val) {
-    this.queue.add(val);
-    this.currSum += val;
-    if (this.queue.size() > this.size) {
-      this.currSum -= this.queue.remove();
+    private final Queue<Integer> queue;
+    private double currSum;
+    private final int size;
+    
+    public MovingAverage(int size) {
+        this.queue = new LinkedList<>();
+        this.currSum = 0;
+        this.size = size;
+    }
+    
+    public double next(int val) {
+        this.queue.add(val);
+        this.currSum += val;
+        if (this.queue.size() > this.size) {
+            this.currSum -= this.queue.remove();
+        }
+        return this.currSum / this.queue.size();
     }
-    return ((double) this.currSum) / this.queue.size();
-  }
 }
 
 /**
diff --git a/Easy/Neither Minimum nor Maximum.java b/Easy/Neither Minimum nor Maximum.java
new file mode 100644
index 00000000..b5d7a6d1
--- /dev/null
+++ b/Easy/Neither Minimum nor Maximum.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int findNonMinOrMax(int[] nums) {
+        int min = nums[0];   
+        int max = nums[0];
+        for (int num : nums) {
+            min = Math.min(num, min);
+            max = Math.max(num, max);
+        }
+        final int arrayMin = min;
+        final int arrayMax = max;
+        return Arrays.stream(nums)
+            .filter(num -> num != arrayMin && num != arrayMax)
+            .findFirst()
+            .orElse(-1);
+    }
+}
diff --git a/Easy/Number of Beautiful Pairs.java b/Easy/Number of Beautiful Pairs.java
new file mode 100644
index 00000000..2993a81e
--- /dev/null
+++ b/Easy/Number of Beautiful Pairs.java	
@@ -0,0 +1,29 @@
+class Solution {
+    public int countBeautifulPairs(int[] nums) {
+        int pairCount = 0;
+        for (int i = 0; i < nums.length; i++) {
+            int lastDigit = nums[i] % 10;
+            for (int j = 0; j < i; j++) {
+                int firstDigit = getFirstDigit(nums[j]);
+                pairCount += gcd(firstDigit, lastDigit) == 1 ? 1 : 0;
+            }
+        }
+        return pairCount;
+    }
+    
+    private static int getFirstDigit(int num) {
+        while (num >= 10) {
+            num /= 10;
+        }
+        return num;
+    }
+    
+    private static int gcd(int a, int b) {
+        while (b != 0) {
+            int temp = a % b;
+            a = b;
+            b = temp;
+        }
+        return a;
+    }
+}
diff --git a/Easy/Number of Changing Keys.java b/Easy/Number of Changing Keys.java
new file mode 100644
index 00000000..bb6bc939
--- /dev/null
+++ b/Easy/Number of Changing Keys.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int countKeyChanges(String s) {
+        int changes = 0;
+        for (int i = 1; i < s.length(); i++) {
+            if (Character.toLowerCase(s.charAt(i)) != Character.toLowerCase(s.charAt(i - 1))) {
+                changes++;
+            }
+        }
+        return changes;
+    }
+}
diff --git a/Easy/Number of Employees Who Met the Target.java b/Easy/Number of Employees Who Met the Target.java
new file mode 100644
index 00000000..64f20287
--- /dev/null
+++ b/Easy/Number of Employees Who Met the Target.java	
@@ -0,0 +1,5 @@
+class Solution {
+    public int numberOfEmployeesWhoMetTarget(int[] hours, int target) {
+        return (int) Arrays.stream(hours).filter(hour -> hour >= target).count();
+    }
+}
diff --git a/Easy/Number of Good Pairs.java b/Easy/Number of Good Pairs.java
index d3c347af..edb3a754 100644
--- a/Easy/Number of Good Pairs.java	
+++ b/Easy/Number of Good Pairs.java	
@@ -1,11 +1,11 @@
 class Solution {
-  public int numIdenticalPairs(int[] nums) {
-    Map<Integer, Integer> map = new HashMap<>();
-    int count = 0;
-    for (int num : nums) {
-      count += map.getOrDefault(num, 0);
-      map.put(num, map.getOrDefault(num, 0) + 1);
+    public int numIdenticalPairs(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int count = 0;
+        for (int num : nums) {
+            count += map.getOrDefault(num, 0);
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        return count;
     }
-    return count;
-  }
 }
diff --git a/Easy/Number of Senior Citizens.java b/Easy/Number of Senior Citizens.java
new file mode 100644
index 00000000..cb658ee0
--- /dev/null
+++ b/Easy/Number of Senior Citizens.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public int countSeniors(String[] details) {
+        return (int) Arrays.stream(details)
+            .map(s -> Integer.parseInt(s.substring(11, 13)))
+            .filter(age -> age > 60)
+            .count();
+    }
+}
diff --git a/Easy/Paint Fence.java b/Easy/Paint Fence.java
deleted file mode 100644
index 72ea89e6..00000000
--- a/Easy/Paint Fence.java	
+++ /dev/null
@@ -1,12 +0,0 @@
-class Solution {
-  public int numWays(int n, int k) {
-    int[] ways = new int[Math.max(n + 1, 3)];
-    ways[0] = 0;
-    ways[1] = k;
-    ways[2] = k * k;
-    for (int i = 3; i <= n; i++) {
-      ways[i] = (ways[i - 1] * (k - 1)) + (ways[i - 2] * (k - 1));
-    }
-    return ways[n];
-  }
-}
diff --git a/Easy/Paint House.java b/Easy/Paint House.java
deleted file mode 100644
index 797243d2..00000000
--- a/Easy/Paint House.java	
+++ /dev/null
@@ -1,18 +0,0 @@
-class Solution {
-    public int minCost(int[][] costs) {
-        if (costs.length == 0) {
-            return 0;
-        }
-        
-        for (int i=1; i<costs.length; i++) {
-            costs[i][0] = costs[i][0] + Math.min(costs[i-1][1], costs[i-1][2]);
-            costs[i][1] = costs[i][1] + Math.min(costs[i-1][0], costs[i-1][2]);
-            costs[i][2] = costs[i][2] + Math.min(costs[i-1][1], costs[i-1][0]);
-        }
-        
-        int idx = costs.length - 1;
-        int minCost = costs[idx][0];
-        
-        return Math.min(costs[idx][0], Math.min(costs[idx][1], costs[idx][2]));
-    }
-}
diff --git a/Easy/Palindrome Linked List.java b/Easy/Palindrome Linked List.java
index 946427e6..11c23754 100644
--- a/Easy/Palindrome Linked List.java	
+++ b/Easy/Palindrome Linked List.java	
@@ -9,39 +9,35 @@
  * }
  */
 class Solution {
-  public boolean isPalindrome(ListNode head) {
-    if (head.next == null) {
-      return true;
+    public boolean isPalindrome(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        ListNode secondHalf = slow;
+        secondHalf = reverse(secondHalf);
+        ListNode firstHalf = head;
+        while (secondHalf != null && firstHalf != null) {
+            if (firstHalf.val != secondHalf.val) {
+                return false;
+            }
+            firstHalf = firstHalf.next;
+            secondHalf = secondHalf.next;
+        }
+        return true;
     }
-    ListNode slow = head;
-    ListNode fast = head;
-    ListNode prev = null;
-    while (fast != null && fast.next != null) {
-      prev = slow;
-      fast = fast.next.next;
-      slow = slow.next;
+
+    private ListNode reverse(ListNode node) {
+        ListNode curr = node;
+        ListNode prev = null;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
     }
-    ListNode revNode = reverse(slow);
-    while (revNode != null) {
-      if (revNode.val != head.val) {
-        return false;
-      }
-      revNode = revNode.next;
-      head = head.next;
-    }
-    return true;
-  }
-  
-  private ListNode reverse(ListNode node) {
-    ListNode prev = null;
-    ListNode curr = node;
-    ListNode next = node;
-    while (curr != null) {
-      next = curr.next;
-      curr.next = prev;
-      prev = curr;
-      curr = next;
-    }
-    return prev;
-  }
 }
diff --git a/Easy/Pascal's Triangle.java b/Easy/Pascal's Triangle.java
index a64f8bd4..86ea8bdb 100644
--- a/Easy/Pascal's Triangle.java	
+++ b/Easy/Pascal's Triangle.java	
@@ -1,15 +1,17 @@
 class Solution {
-  public List<List<Integer>> generate(int numRows) {
-    List<List<Integer>> result = new ArrayList<>();
-    for (int i = 0; i < numRows; i++) {
-      List<Integer> temp = new ArrayList<>();
-      for (int j = 0; j <= i; j++) {
-        temp.add(
-          (j == 0 || j == i) ? 1 : 
-          (result.get(i - 1).get(j - 1) + result.get(i - 1).get(j)));
-      }
-      result.add(temp);
+    public List<List<Integer>> generate(int numRows) {
+        List<List<Integer>> result = new ArrayList<>();
+        for (int i = 0; i < numRows; i++) {
+            List<Integer> temp = new ArrayList<>();
+            for (int j = 0; j <= i; j++) {
+                if (j == 0 || j == i) {
+                    temp.add(1);
+                } else {
+                    temp.add(result.get(i - 1).get(j - 1) + result.get(i - 1).get(j));
+                }
+            }
+            result.add(temp);
+        }
+        return result;
     }
-    return result;
-  }
 }
diff --git a/Easy/Pass the Pillow.java b/Easy/Pass the Pillow.java
new file mode 100644
index 00000000..e9ae16ea
--- /dev/null
+++ b/Easy/Pass the Pillow.java	
@@ -0,0 +1,7 @@
+class Solution {
+    public int passThePillow(int n, int time) {
+        int factor = time / (n - 1);
+        int remainder = time % (n - 1);
+        return factor % 2 != 0 ? (n - remainder) : (1 + remainder);
+    }
+}
diff --git a/Easy/Path Crossing.java b/Easy/Path Crossing.java
index 32b241c3..e3f7d9a9 100644
--- a/Easy/Path Crossing.java	
+++ b/Easy/Path Crossing.java	
@@ -1,21 +1,29 @@
 class Solution {
-  int[][] dirs = {{0, 1}, {0, -1}, {-1, 0}, {1, 0}};
-  public boolean isPathCrossing(String path) {
-    Set<String> set = new HashSet<>();
-    int currX = 0;
-    int currY = 0;
-    String dirSymbol = "NSEW";
-    set.add(currX + "|" + currY);
-    for (char c : path.toCharArray()) {
-      int dirIdx = dirSymbol.indexOf(c);
-      currX += dirs[dirIdx][0];
-      currY += dirs[dirIdx][1];
-      String hash = currX + "|" + currY;
-      if (set.contains(hash)) {
-        return true;
-      }
-      set.add(hash);
+    public boolean isPathCrossing(String path) {
+        Set<String> visited = new HashSet<>();
+        visited.add("0|0");
+        int x = 0;
+        int y = 0;
+        for (Character step : path.toCharArray()) {
+            switch (step) {
+                case 'N':
+                    x++;
+                    break;
+                case 'S':
+                    x--;
+                    break;
+                case 'E':
+                    y--;
+                    break;
+                case 'W':
+                    y++;
+                    break;
+            }
+            String key = x + "|" + y;
+            if (!visited.add(key)) {
+                return true;
+            }
+        }
+        return false;
     }
-    return false;
-  }
 }
diff --git a/Easy/Peak Index in a Mountain Array.java b/Easy/Peak Index in a Mountain Array.java
deleted file mode 100644
index 818dbf9c..00000000
--- a/Easy/Peak Index in a Mountain Array.java	
+++ /dev/null
@@ -1,16 +0,0 @@
-class Solution {
-  public int peakIndexInMountainArray(int[] A) {
-    int low = 0;
-    int high = A.length - 1;
-    while (low < high) {
-      int mid = low + (high - low) / 2;
-      if (A[mid] < A[mid + 1]) {
-        low = mid + 1;
-      }
-      else {
-        high = mid;
-      }
-    }
-    return low;
-  }
-}
diff --git a/Easy/Points That Intersect With Cars.java b/Easy/Points That Intersect With Cars.java
new file mode 100644
index 00000000..8443505c
--- /dev/null
+++ b/Easy/Points That Intersect With Cars.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int numberOfPoints(List<List<Integer>> coordinates) {
+        coordinates.sort(Comparator.comparingInt((List<Integer> o) -> o.get(0)).thenComparingInt(o -> o.get(1)));
+        int points = 0;
+        int intervalStart = -1;
+        int intervalEnd = -1;
+        for (List<Integer> coordinate : coordinates) {
+            if (intervalStart == -1) {
+                intervalStart = coordinate.get(0);
+            } else {
+                if (intervalEnd < coordinate.get(0)) {
+                    points += intervalEnd - intervalStart + 1;
+                    intervalStart = coordinate.get(0);
+                }
+            }
+            intervalEnd = Math.max(intervalEnd, coordinate.get(1));
+        }
+        return points + intervalEnd - intervalStart + 1;
+    }
+}
diff --git a/Easy/Power of Four.java b/Easy/Power of Four.java
index 18dd30c1..269c7bd7 100644
--- a/Easy/Power of Four.java	
+++ b/Easy/Power of Four.java	
@@ -1,19 +1,5 @@
 class Solution {
-  public boolean isPowerOfFour(int n) {
-    long left = 0;
-    long right = n / 2 + 1;
-    while (left <= right) {
-      long mid = (left + right) / 2;
-      long pow = (long) (Math.pow(4, mid));
-      if (pow == ((long) n)) {
-        return true;
-      }
-      if (pow > ((long) n)) {
-        right = mid - 1;
-      } else {
-        left = mid + 1;
-      }
+    public boolean isPowerOfFour(int n) {
+        return n > 0 && Math.log(n) / Math.log(2) % 2 == 0;
     }
-    return false;
-  }
 }
diff --git a/Easy/Prime In Diagonal.java b/Easy/Prime In Diagonal.java
new file mode 100644
index 00000000..16b34fda
--- /dev/null
+++ b/Easy/Prime In Diagonal.java	
@@ -0,0 +1,30 @@
+class Solution {
+    public int diagonalPrime(int[][] nums) {
+        int n = nums.length;
+        int maxPrime = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if ((i == j || i + j == n - 1) && isPrime(nums[i][j])) {
+                    maxPrime = Math.max(maxPrime, nums[i][j]);
+                }
+            }
+        }
+        return maxPrime;
+    }
+    
+    private static boolean isPrime(int n) {
+        if (n <= 1) {
+            return false;
+        }
+        if (n == 2) {
+            return true;
+        }
+        int midPoint = ((int) Math.sqrt(n)) + 1;
+        for (int i = 2; i <= midPoint; i++) {
+            if (n % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    } 
+}
diff --git a/Easy/README.md b/Easy/README.md
index 423b1cfa..ff578ea7 100644
--- a/Easy/README.md
+++ b/Easy/README.md
@@ -2,453 +2,608 @@
 S.no | Coding Problem 
 --- | --- 
 1|[Count Binary Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Binary%20Substrings.java)
-2|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
-3|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
-4|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java)
-5|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Stack.java)
-6|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
-7|[Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java)
-8|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
-9|[Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java)
-10|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
-11|[Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java)
-12|[Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java)
-13|[The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java)
-14|[Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java)
-15|[Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java)
-16|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
-17|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
-18|[Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java)
-19|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
-20|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bold%20Words%20in%20String.java)
-21|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
-22|[Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java)
-23|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
-24|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
-25|[Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java)
-26|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java)
-27|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
-28|[Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java)
-29|[Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java)
-30|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
-31|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
-32|[X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java)
-33|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Integer.java)
-34|[Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java)
-35|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java)
-36|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
-37|[Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java)
-38|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
-39|[Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java)
-40|[Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java)
-41|[Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java)
-42|[Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java)
-43|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
-44|[Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java)
-45|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Non-decreasing%20Array.java)
-46|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
-47|[Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java)
-48|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
-49|[Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java)
-50|[Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java)
-51|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
-52|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
-53|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
-54|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
-55|[Power of four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20four.java)
-56|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
-57|[Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java)
-58|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
-59|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
-60|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
-61|[Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java)
-62|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
-63|[Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java)
-64|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
-65|[Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java)
-66|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
-67|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
-68|[Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java)
-69|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java)
-70|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java)
-71|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
-72|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java)
-73|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
-74|[Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java)
-75|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
-76|[Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java)
-77|[Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java)
-78|[Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java)
-79|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
-80|[Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java)
-81|[Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java)
-82|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
-83|[Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
-84|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
-85|[Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java)
-86|[Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java)
-87|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
-88|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
-89|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java)
-90|[Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java)
-91|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
-92|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java)
-93|[Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java)
-94|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
-95|[Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java)
-96|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
-97|[Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java)
-98|[Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java)
-99|[Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java)
-100|[Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java)
-101|[Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java)
-102|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20and%20Say.java)
-103|[Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java)
-104|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
-105|[Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java)
-106|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
-107|[Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java)
-108|[Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java)
-109|[DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java)
-110|[Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java)
-111|[Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java)
-112|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java)
-113|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
-114|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java)
-115|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
-116|[Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java)
-117|[Maximum Product of three numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20three%20numbers.java)
-118|[Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java)
-119|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
-120|[Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java)
-121|[Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java)
-122|[Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java)
-123|[Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java)
-124|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
-125|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
-126|[Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java)
-127|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
-128|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
-129|[Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java)
-130|[Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java)
-131|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
-132|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
-133|[Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java)
-134|[Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java)
-135|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
-136|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
-137|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java)
-138|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
-139|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
-140|[Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java)
-141|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
-142|[Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java)
-143|[Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reorder%20Data%20in%20Log%20Files.java)
-144|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
-145|[trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
-146|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
-147|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
-148|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java)
-149|[Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java)
-150|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Area%20of%20Island.java)
-151|[Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java)
-152|[Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java)
-153|[String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java)
-154|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
-155|[Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java)
-156|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
-157|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
-158|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java)
-159|[Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java)
-160|[Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java)
-161|[Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java)
-162|[Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java)
-163|[Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java)
-164|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
-165|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
-166|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotated%20Digits.java)
-167|[Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java)
-168|[Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java)
-169|[Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java)
-170|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java)
-171|[Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java)
-172|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/House%20Robber.java)
-173|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
-174|[Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java)
-175|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
-176|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
-177|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
-178|[Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java)
-179|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java)
-180|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
-181|[SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
-182|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java)
-183|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
-184|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
-185|[Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java)
-186|[Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java)
-187|[Two Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20II.java)
-188|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
-189|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java)
-190|[Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java)
-191|[Sum of left leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20left%20leaves.java)
-192|[Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java)
-193|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
-194|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
-195|[Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java)
-196|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Peak%20Index%20in%20a%20Mountain%20Array.java)
-197|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
-198|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Closest%20Points%20to%20Origin.java)
-199|[Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Time%20for%20Given%20Digits.java)
-200|[range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
-201|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
-202|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
-203|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
-204|[Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java)
-205|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
-206|[Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java)
-207|[Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java)
-208|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
-209|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
-210|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
-211|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java)
-212|[Valid Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbrevation.java)
-213|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java)
-214|[Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java)
-215|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
-216|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Anagrams%20in%20a%20String.java)
-217|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
-218|[Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java)
-219|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
-220|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
-221|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
-222|[How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java)
-223|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java)
-224|[Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java)
-225|[Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java)
-226|[Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java)
-227|[Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java)
-228|[Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java)
-229|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Stack.java)
-230|[Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java)
-231|[Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java)
-232|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
-233|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
-234|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
-235|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
-236|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
-237|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
-238|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
-239|[Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java)
-240|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
-241|[Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java)
-242|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
-243|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
-244|[Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java)
-245|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Level%20Order%20Traversal.java)
-246|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
-247|[First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java)
-248|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
-249|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
-250|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
-251|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
-252|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subdomain%20Visit%20Count.java)
-253|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
-254|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java)
-255|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
-256|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
-257|[Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java)
-258|[Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
-259|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
-260|[Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java)
-261|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
-262|[Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java)
-263|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
-264|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
-265|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Even%20Numbers%20After%20Queries.java)
-266|[Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java)
-267|[Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java)
-268|[Intersection of two arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20arrays%20II.java)
-269|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
-270|[Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java)
-271|[Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java)
-272|[Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java)
-273|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
-274|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java)
-275|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
-276|[Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java)
-277|[Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java)
-278|[Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java)
-279|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java)
-280|[Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java)
-281|[Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java)
-282|[Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java)
-283|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
-284|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
-285|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
-286|[Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java)
-287|[Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java)
-288|[Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java)
-289|[Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java)
-290|[Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java)
-291|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
-292|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
-293|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
-294|[Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java)
-295|[Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java)
-296|[Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java)
-297|[nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
-298|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
-299|[Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java)
-300|[Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java)
-301|[Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java)
-302|[Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java)
-303|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java)
-304|[Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java)
-305|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
-306|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray.java)
-307|[Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java)
-308|[Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java)
-309|[Build Array from Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20Array%20from%20Permutation.java)
-310|[Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java)
-311|[Best time to buy & sell a stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20time%20to%20buy%20&%20sell%20a%20stock%20II.java)
-312|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
-313|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
-314|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
-315|[Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java)
-316|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
-317|[Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java)
-318|[Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java)
-319|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
-320|[Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java)
-321|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
-322|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
-323|[Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java)
-324|[Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java)
-325|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java)
-326|[Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java)
-327|[Best Time to Buy and Sell Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Time%20to%20Buy%20and%20Sell%20Stock.java)
-328|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Compression.java)
-329|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
-330|[Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java)
-331|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
-332|[Leaf Similar Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf%20Similar%20Tree.java)
-333|[Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java)
-334|[Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java)
-335|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
-336|[Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java)
-337|[Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java)
-338|[Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java)
-339|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
-340|[Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java)
-341|[Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java)
-342|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
-343|[Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java)
-344|[Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java)
-345|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
-346|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
-347|[Delete node in a linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20node%20in%20a%20linked%20list.java)
-348|[Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java)
-349|[Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java)
-350|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
-351|[Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java)
-352|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
-353|[Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java)
-354|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
-355|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
-356|[Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java)
-357|[Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java)
-358|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
-359|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java)
-360|[Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java)
-361|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java)
-362|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
-363|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
-364|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
-365|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
-366|[Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java)
-367|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
-368|[Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java)
-369|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
-370|[Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java)
-371|[Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java)
-372|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
-373|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
-374|[Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java)
-375|[Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java)
-376|[Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java)
-377|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
-378|[Add Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Digits.java)
-379|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java)
-380|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20City%20Scheduling.java)
-381|[Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java)
-382|[contains_duplicates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/contains_duplicates.java)
-383|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java)
-384|[Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java)
-385|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
-386|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
-387|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
-388|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum%20III.java)
-389|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
-390|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
-391|[Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java)
-392|[Average Salary Excluding the Minimum and Maximum Salary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Salary%20Excluding%20the%20Minimum%20and%20Maximum%20Salary.java)
-393|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
-394|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
-395|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
-396|[Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java)
-397|[Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java)
-398|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
-399|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
-400|[Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java)
-401|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
-402|[Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java)
-403|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
-404|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
-405|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
-406|[Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java)
-407|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java)
-408|[Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java)
-409|[Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java)
-410|[Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java)
-411|[Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java)
-412|[Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java)
-413|[Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java)
-414|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java)
-415|[Fibonacci Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Numbers.java)
-416|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
-417|[Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java)
-418|[Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java)
-419|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
-420|[Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java)
-421|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
-422|[Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
-423|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
-424|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
-425|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
-426|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
-427|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
-428|[Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java)
-429|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
-430|[Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java)
-431|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Unsorted%20Continuous%20Subarray.java)
-432|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
-433|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
-434|[Array Transformation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Transformation.java)
-435|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
-436|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
-437|[Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java)
-438|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
-439|[Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java)
-440|[sum_of_two_integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/sum_of_two_integers.java)
-441|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java)
-442|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
-443|[Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java)
-444|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
-445|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
-446|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
-447|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java)
-448|[Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java)
-449|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
-450|[Average of Levels in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20Levels%20in%20Binary%20Tree.java)
-451|[Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java)
+2|[Check if All A's Appears Before All B's](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20A's%20Appears%20Before%20All%20B's.java)
+3|[Longest Harmonious Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Harmonious%20Subsequence.java)
+4|[Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Ranges.java)
+5|[High Five](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/High%20Five.java)
+6|[Binary Tree Tilt](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Tilt.java)
+7|[Number of Boomerangs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Boomerangs.java)
+8|[Count the Number of Consistent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Consistent%20Strings.java)
+9|[Sentence Similarity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sentence%20Similarity.java)
+10|[Strong Password Checker II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strong%20Password%20Checker%20II.java)
+11|[Perform String Shifts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perform%20String%20Shifts.java)
+12|[Kth Largest Element in a Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Largest%20Element%20in%20a%20Stream.java)
+13|[Kth Missing Positive Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Missing%20Positive%20Number.java)
+14|[Check If String Is a Prefix of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20String%20Is%20a%20Prefix%20of%20Array.java)
+15|[Capitalize the Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Capitalize%20the%20Title.java)
+16|[The K Weakest Rows in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20K%20Weakest%20Rows%20in%20a%20Matrix.java)
+17|[Missing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number.java)
+18|[Remove Duplicates from Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20from%20Sorted%20Array.java)
+19|[Implement strStr](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20strStr.java)
+20|[Reverse String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String.java)
+21|[Create Target Array in the Given Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Create%20Target%20Array%20in%20the%20Given%20Order.java)
+22|[Increasing Order Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Order%20Search%20Tree.java)
+23|[Minimum Number of Moves to Seat Everyone](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Moves%20to%20Seat%20Everyone.java)
+24|[Minimum Absolute Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Absolute%20Difference.java)
+25|[Maximum 69 Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%2069%20Number.java)
+26|[Largest Perimeter Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Perimeter%20Triangle.java)
+27|[Minimum Cost of Buying Candies With Discount](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20of%20Buying%20Candies%20With%20Discount.java)
+28|[Number of Equivalent Domino Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Equivalent%20Domino%20Pairs.java)
+29|[Summary Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Summary%20Ranges.java)
+30|[Binary Number with Alternating Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Number%20with%20Alternating%20Bits.java)
+31|[Find the Distinct Difference Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distinct%20Difference%20Array.java)
+32|[Buy Two Chocolates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buy%20Two%20Chocolates.java)
+33|[Intersection of Multiple Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Multiple%20Arrays.java)
+34|[Palindrome Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Linked%20List.java)
+35|[Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rectangle%20Overlap.java)
+36|[Intersection of Three Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Three%20Sorted%20Arrays.java)
+37|[Minimum Changes To Make Alternating Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Changes%20To%20Make%20Alternating%20Binary%20String.java)
+38|[Jewels and Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Jewels%20and%20Stones.java)
+39|[Number of Valid Words in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Valid%20Words%20in%20a%20Sentence.java)
+40|[Greatest English Letter in Upper and Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20English%20Letter%20in%20Upper%20and%20Lower%20Case.java)
+41|[Unique Email Addresses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Email%20Addresses.java)
+42|[X of a Kind in a Deck of Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/X%20of%20a%20Kind%20in%20a%20Deck%20of%20Cards.java)
+43|[Longest Nice Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Nice%20Substring.java)
+44|[Count Primes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Primes.java)
+45|[Positions of Large Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Positions%20of%20Large%20Groups.java)
+46|[Maximum Population Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Population%20Year.java)
+47|[Min Cost Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Cost%20Climbing%20Stairs.java)
+48|[Number of Days Between Two Dates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20Between%20Two%20Dates.java)
+49|[Minimum Distance to the Target Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20to%20the%20Target%20Element.java)
+50|[Path Crossing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Crossing.java)
+51|[Check If N and Its Double Exist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20N%20and%20Its%20Double%20Exist.java)
+52|[Word Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Word%20Pattern.java)
+53|[Maximum Nesting Depth of the Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Nesting%20Depth%20of%20the%20Parentheses.java)
+54|[Two Sum IV - Input is a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20IV%20-%20Input%20is%20a%20BST.java)
+55|[Find Positive Integer Solution for a Given Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Positive%20Integer%20Solution%20for%20a%20Given%20Equation.java)
+56|[Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hamming%20Distance.java)
+57|[Defuse the Bomb](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defuse%20the%20Bomb.java)
+58|[Check if The Number is Fascinating](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20The%20Number%20is%20Fascinating.java)
+59|[Minimum Common Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Common%20Value.java)
+60|[Final Prices With a Special Discount in a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Prices%20With%20a%20Special%20Discount%20in%20a%20Shop.java)
+61|[Plus One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Plus%20One.java)
+62|[Submission Detail](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Submission%20Detail.java)
+63|[Rotate String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rotate%20String.java)
+64|[Minimum Depth of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Depth%20of%20a%20Binary%20Tree.java)
+65|[Power of Four](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Four.java)
+66|[Valid Perfect Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Perfect%20Square.java)
+67|[Find N Unique Integers Sum up to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20N%20Unique%20Integers%20Sum%20up%20to%20Zero.java)
+68|[Remove Trailing Zeros From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Trailing%20Zeros%20From%20a%20String.java)
+69|[Paint Fence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20Fence.java)
+70|[Detect Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Capital.java)
+71|[XOR Operation in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/XOR%20Operation%20in%20an%20Array.java)
+72|[Divide a String Into Groups of Size k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20a%20String%20Into%20Groups%20of%20Size%20k.java)
+73|[Flipping an Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flipping%20an%20Image.java)
+74|[Subtract the Product and Sum of Digits of an Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtract%20the%20Product%20and%20Sum%20of%20Digits%20of%20an%20Integer.java)
+75|[Two Sum III - Data Structure Design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20III%20-%20Data%20Structure%20Design.java)
+76|[Check if Binary String Has at Most One Segment of Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Binary%20String%20Has%20at%20Most%20One%20Segment%20of%20Ones.java)
+77|[Number Complement](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Complement.java)
+78|[Longer Contiguous Segments of Ones than Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longer%20Contiguous%20Segments%20of%20Ones%20than%20Zeros.java)
+79|[Design HashSet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashSet.java)
+80|[Convert 1D Array Into 2D Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%201D%20Array%20Into%202D%20Array.java)
+81|[Odd String Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Odd%20String%20Difference.java)
+82|[Remove Digit From Number to Maximize Result](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Digit%20From%20Number%20to%20Maximize%20Result.java)
+83|[Find Mode in Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Mode%20in%20Binary%20Search%20Tree.java)
+84|[Count Hills and Valleys in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Hills%20and%20Valleys%20in%20an%20Array.java)
+85|[Maximum Repeating Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Repeating%20Substring.java)
+86|[Number of Unequal Triplets in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Unequal%20Triplets%20in%20Array.java)
+87|[Split Strings by Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20Strings%20by%20Separator.java)
+88|[Find Closest Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Closest%20Number%20to%20Zero.java)
+89|[1-bit and 2-bit Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/1-bit%20and%202-bit%20Characters.java)
+90|[Binary Gap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Gap.java)
+91|[Subtree of Another Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Subtree%20of%20Another%20Tree.java)
+92|[Binary Tree Level Order Traversal II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Level%20Order%20Traversal%20II.java)
+93|[Count Prefixes of a Given String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Prefixes%20of%20a%20Given%20String.java)
+94|[Find the Width of Columns of a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Width%20of%20Columns%20of%20a%20Grid.java)
+95|[Defanging an IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Defanging%20an%20IP%20Address.java)
+96|[Find Target Indices After Sorting Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Target%20Indices%20After%20Sorting%20Array.java)
+97|[Truncate Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Truncate%20Sentence.java)
+98|[Diameter of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diameter%20of%20Binary%20Tree.java)
+99|[Best Poker Hand](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Poker%20Hand.java)
+100|[Range Sum of BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20of%20BST.java)
+101|[Maximum Average Subarray I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Average%20Subarray%20I.java)
+102|[Fizz Buzz](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fizz%20Buzz.java)
+103|[Check if All the Integers in a Range Are Covered](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20the%20Integers%20in%20a%20Range%20Are%20Covered.java)
+104|[Find First Palindromic String in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20First%20Palindromic%20String%20in%20the%20Array.java)
+105|[Duplicate Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Duplicate%20Zeros.java)
+106|[Minimum Subsequence in Non-Increasing Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Subsequence%20in%20Non-Increasing%20Order.java)
+107|[Smallest Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Range%20I.java)
+108|[Employee Importance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Employee%20Importance.java)
+109|[Minimum_index_sum_of_two_lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum_index_sum_of_two_lists.java)
+110|[Points That Intersect With Cars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Points%20That%20Intersect%20With%20Cars.java)
+111|[Number of segments in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20segments%20in%20a%20String.java)
+112|[Delete Columns to Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Columns%20to%20Make%20Sorted.java)
+113|[Reverse Only Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Only%20Letters.java)
+114|[Evaluate Boolean Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Evaluate%20Boolean%20Binary%20Tree.java)
+115|[Repeated String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20String%20Match.java)
+116|[Neither Minimum nor Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Neither%20Minimum%20nor%20Maximum.java)
+117|[Maximum Value of an Ordered Triplet I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20an%20Ordered%20Triplet%20I.java)
+118|[Uncommon Words from Two Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Uncommon%20Words%20from%20Two%20Sentences.java)
+119|[Assign Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Assign%20Cookies.java)
+120|[Most Frequent Number Following Key In an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Number%20Following%20Key%20In%20an%20Array.java)
+121|[Element Appearing More Than 25% In Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Element%20Appearing%20More%20Than%2025%%20In%20Sorted%20Array.java)
+122|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Town%20Judge.java)
+123|[Buddy Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Buddy%20Strings.java)
+124|[Teoplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teoplitz%20Matrix.java)
+125|[Leaf-Similar Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Leaf-Similar%20Trees.java)
+126|[Minimum Hours of Training to Win a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Hours%20of%20Training%20to%20Win%20a%20Competition.java)
+127|[Goat Latin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goat%20Latin.java)
+128|[Flower Planting With No Adjacent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flower%20Planting%20With%20No%20Adjacent.java)
+129|[Largest Triangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Triangle%20Area.java)
+130|[Row With Maximum Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Row%20With%20Maximum%20Ones.java)
+131|[Determine Color of a Chessboard Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Color%20of%20a%20Chessboard%20Square.java)
+132|[Richest Customer Wealth](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Richest%20Customer%20Wealth.java)
+133|[Consecutive Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Consecutive%20Characters.java)
+134|[Latest Time by Replacing Hidden Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Latest%20Time%20by%20Replacing%20Hidden%20Digits.java)
+135|[Robot Return to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Robot%20Return%20to%20Origin.java)
+136|[Determine Whether Matrix Can Be Obtained By Rotation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20Whether%20Matrix%20Can%20Be%20Obtained%20By%20Rotation.java)
+137|[Flip Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flip%20Game.java)
+138|[Minimum Value to Get Positive Step by Step Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Value%20to%20Get%20Positive%20Step%20by%20Step%20Sum.java)
+139|[Average Value of Even Numbers That Are Divisible by Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Value%20of%20Even%20Numbers%20That%20Are%20Divisible%20by%20Three.java)
+140|[Reshape the matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reshape%20the%20matrix.java)
+141|[Valid Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Anagram.java)
+142|[Number of Strings That Appear as Substrings in Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Strings%20That%20Appear%20as%20Substrings%20in%20Word.java)
+143|[DI String Match](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/DI%20String%20Match.java)
+144|[Running Sum of 1d Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Running%20Sum%20of%201d%20Array.java)
+145|[Special Array With X Elements Greater Than or Equal X](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Array%20With%20X%20Elements%20Greater%20Than%20or%20Equal%20X.java)
+146|[Number of Distinct Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Distinct%20Averages.java)
+147|[Check if an Array Is Consecutive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20an%20Array%20Is%20Consecutive.java)
+148|[Backspace String Compare](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Backspace%20String%20Compare.java)
+149|[Rings and Rods](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rings%20and%20Rods.java)
+150|[Implement Stack using Queues](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Stack%20using%20Queues.java)
+151|[Baseball Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Baseball%20Game.java)
+152|[Pairs of Songs With Total Durations Divisible by 60](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pairs%20of%20Songs%20With%20Total%20Durations%20Divisible%20by%2060.java)
+153|[Destination City](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Destination%20City.java)
+154|[Maximum Product of Three Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Three%20Numbers.java)
+155|[Three Consecutive Odds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Consecutive%20Odds.java)
+156|[Set Mismatch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Set%20Mismatch.java)
+157|[Sort Array by Increasing Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20by%20Increasing%20Frequency.java)
+158|[Find the Distance Value Between Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Distance%20Value%20Between%20Two%20Arrays.java)
+159|[Find Anagram Mappings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Anagram%20Mappings.java)
+160|[Check if Array is Good](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20is%20Good.java)
+161|[Decompress Run-Length Encoded List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decompress%20Run-Length%20Encoded%20List.java)
+162|[Flood Fill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Flood%20Fill.java)
+163|[Magic Squares In Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Magic%20Squares%20In%20Grid.java)
+164|[Smallest Even Multiple](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Even%20Multiple.java)
+165|[Hexspeak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Hexspeak.java)
+166|[Diet Plan Performance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Diet%20Plan%20Performance.java)
+167|[Maximum Number of Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balloons.java)
+168|[Find Smallest Letter Greater Than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Smallest%20Letter%20Greater%20Than%20Target.java)
+169|[Check if Array Is Sorted and Rotated](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Array%20Is%20Sorted%20and%20Rotated.java)
+170|[Maximum Enemy Forts That Can Be Captured](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Enemy%20Forts%20That%20Can%20Be%20Captured.java)
+171|[Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20Sum.java)
+172|[Day of the Year](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Year.java)
+173|[Number of Beautiful Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Beautiful%20Pairs.java)
+174|[Can Make Arithmetic Progression From Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Make%20Arithmetic%20Progression%20From%20Sequence.java)
+175|[Furthest Point From Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Furthest%20Point%20From%20Origin.java)
+176|[Find the Highest Altitude](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Highest%20Altitude.java)
+177|[Root Equals Sum of Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Root%20Equals%20Sum%20of%20Children.java)
+178|[Powerful Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Powerful%20Integers.java)
+179|[Merge Two Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%20Sorted%20Lists.java)
+180|[Binary Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Search.java)
+181|[K-diff Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K-diff%20Pairs%20in%20an%20Array.java)
+182|[Repeated Substring Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Repeated%20Substring%20Pattern.java)
+183|[Calculate Digit Sum of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Digit%20Sum%20of%20a%20String.java)
+184|[Reformat Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Phone%20Number.java)
+185|[Longest Continuous Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Continuous%20Increasing%20Subsequence.java)
+186|[Shuffle the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20the%20Array.java)
+187|[Count Pairs Of Similar Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Of%20Similar%20Strings.java)
+188|[Ransom Note](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ransom%20Note.java)
+189|[trailing_zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/trailing_zeroes.java)
+190|[Height Checker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Height%20Checker.java)
+191|[License Key Formatting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/License%20Key%20Formatting.java)
+192|[Sum of Values at Indices With K Set Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Values%20at%20Indices%20With%20K%20Set%20Bits.java)
+193|[Balanced Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Balanced%20Binary%20Tree.java)
+194|[Check If It Is a Straight Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20It%20Is%20a%20Straight%20Line.java)
+195|[Binary Watch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Watch.java)
+196|[Count Special Quadruplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Special%20Quadruplets.java)
+197|[Three Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Three%20Divisors.java)
+198|[Make Array Zero by Subtracting Equal Amounts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20Array%20Zero%20by%20Subtracting%20Equal%20Amounts.java)
+199|[Maximum Number of Words You Can Type](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20You%20Can%20Type.java)
+200|[Contains Duplicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate.java)
+201|[Decode the Message](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20the%20Message.java)
+202|[String Matching in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Matching%20in%20an%20Array.java)
+203|[Count the Digits That Divide a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Digits%20That%20Divide%20a%20Number.java)
+204|[Distance Between Bus Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distance%20Between%20Bus%20Stops.java)
+205|[Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Ugly%20Number.java)
+206|[Faulty Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Faulty%20Keyboard.java)
+207|[Find the Pivot Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Pivot%20Integer.java)
+208|[Pascal's Triangle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle%20II.java)
+209|[Maximum Count of Positive Integer and Negative Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Count%20of%20Positive%20Integer%20and%20Negative%20Integer.java)
+210|[Count Symmetric Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Symmetric%20Integers.java)
+211|[Pascal's Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pascal's%20Triangle.java)
+212|[Binary Prefix Divisible By 5](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Prefix%20Divisible%20By%205.java)
+213|[Number Of Rectangles That Can Form The Largest Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20Of%20Rectangles%20That%20Can%20Form%20The%20Largest%20Square.java)
+214|[Separate the Digits in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Separate%20the%20Digits%20in%20an%20Array.java)
+215|[Count Negative Numbers in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Negative%20Numbers%20in%20a%20Sorted%20Matrix.java)
+216|[Remove One Element to Make the Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20One%20Element%20to%20Make%20the%20Array%20Strictly%20Increasing.java)
+217|[Two Furthest Houses With Different Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Furthest%20Houses%20With%20Different%20Colors.java)
+218|[Special Positions in a Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Special%20Positions%20in%20a%20Binary%20Matrix.java)
+219|[Check if All Characters Have Equal Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20All%20Characters%20Have%20Equal%20Number%20of%20Occurrences.java)
+220|[Valid Word Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Sequence.java)
+221|[Counting Words With a Given Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Words%20With%20a%20Given%20Prefix.java)
+222|[Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Inorder%20Traversal.java)
+223|[Minimum Moves to Convert String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Convert%20String.java)
+224|[Design Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Linked%20List.java)
+225|[Kth Distinct String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kth%20Distinct%20String%20in%20an%20Array.java)
+226|[Count Good Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Good%20Triplets.java)
+227|[Design an Ordered System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20System.java)
+228|[Get Maximum in Generated Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Get%20Maximum%20in%20Generated%20Array.java)
+229|[Convert the Temperature](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20the%20Temperature.java)
+230|[Arranging Coins](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Arranging%20Coins.java)
+231|[Count Pairs Whose Sum is Less than Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Pairs%20Whose%20Sum%20is%20Less%20than%20Target.java)
+232|[Check if Word Equals Summation of Two Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Word%20Equals%20Summation%20of%20Two%20Words.java)
+233|[Fair Candy Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fair%20Candy%20Swap.java)
+234|[Design Parking System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Parking%20System.java)
+235|[Transpose Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Transpose%20Matrix.java)
+236|[Delete Greatest Value in Each Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Greatest%20Value%20in%20Each%20Row.java)
+237|[Excel Sheet Column Title](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Title.java)
+238|[First Letter to Appear Twice](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Letter%20to%20Appear%20Twice.java)
+239|[Linked List Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Linked%20List%20Cycle.java)
+240|[Find All the Lonely Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20the%20Lonely%20Nodes.java)
+241|[Find the Maximum Achievable Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Maximum%20Achievable%20Number.java)
+242|[Base 7](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Base%207.java)
+243|[Reverse Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Bits.java)
+244|[SqrtX](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/SqrtX.java)
+245|[Check if Strings Can be Made Equal With Operations I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Strings%20Can%20be%20Made%20Equal%20With%20Operations%20I.java)
+246|[Similar RGB Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Similar%20RGB%20Color.java)
+247|[Sort the People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20the%20People.java)
+248|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Is%20Subsequence.java)
+249|[Longest Even Odd Subarray With Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Even%20Odd%20Subarray%20With%20Threshold.java)
+250|[Reverse Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Linked%20List.java)
+251|[Shortest Distance to a Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20a%20Character.java)
+252|[Count of Matches in Tournament](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20of%20Matches%20in%20Tournament.java)
+253|[Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Parentheses.java)
+254|[Convert Sorted Array To Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Sorted%20Array%20To%20Binary%20Search%20Tree.java)
+255|[Count Vowel Substrings of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Vowel%20Substrings%20of%20a%20String.java)
+256|[Construct the rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20the%20rectangle.java)
+257|[Maximum Units on a Truck](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Units%20on%20a%20Truck.java)
+258|[Sum of Left Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Left%20Leaves.java)
+259|[Decrypt String from Alphabet to Integer Mapping](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decrypt%20String%20from%20Alphabet%20to%20Integer%20Mapping.java)
+260|[Number of Employees Who Met the Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Employees%20Who%20Met%20the%20Target.java)
+261|[Find Pivot Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Pivot%20Index.java)
+262|[Factorial Trailing Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Factorial%20Trailing%20Zeroes.java)
+263|[Build an Array With Stack Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20an%20Array%20With%20Stack%20Operations.java)
+264|[Last Stone Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Last%20Stone%20Weight.java)
+265|[range_addition_II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/range_addition_II.java)
+266|[Isomorphic Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Isomorphic%20Strings.java)
+267|[Longest Subsequence With Limited Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Subsequence%20With%20Limited%20Sum.java)
+268|[Split a String in Balanced Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20a%20String%20in%20Balanced%20Strings.java)
+269|[To Lower Case](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/To%20Lower%20Case.java)
+270|[Sum of Digits of String After Convert](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20of%20String%20After%20Convert.java)
+271|[Number of Senior Citizens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Senior%20Citizens.java)
+272|[Minimum Cost to Move Chips to The Same Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cost%20to%20Move%20Chips%20to%20The%20Same%20Position.java)
+273|[Read N characters Given Read4](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Read%20N%20characters%20Given%20Read4.java)
+274|[Longest Alternating Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Alternating%20Subarray.java)
+275|[Delete N Nodes After M Nodes of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20N%20Nodes%20After%20M%20Nodes%20of%20a%20Linked%20List.java)
+276|[Count Items Matching a Rule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Items%20Matching%20a%20Rule.java)
+277|[Reverse Vowels of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Vowels%20of%20a%20String.java)
+278|[Largest Local Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Local%20Values%20in%20a%20Matrix.java)
+279|[A Number After a Double Reversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/A%20Number%20After%20a%20Double%20Reversal.java)
+280|[Roman to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Roman%20to%20Integer.java)
+281|[Cousins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cousins%20in%20Binary%20Tree.java)
+282|[Binary Tree Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Paths.java)
+283|[Complement of Base 10 Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Complement%20of%20Base%2010%20Integer.java)
+284|[Find if Path Exists in Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20if%20Path%20Exists%20in%20Graph.java)
+285|[Minimum Difference Between Highest and Lowest of K Scores](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Difference%20Between%20Highest%20and%20Lowest%20of%20K%20Scores.java)
+286|[Number of Days in a Month](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Days%20in%20a%20Month.java)
+287|[Find Resultant Array After Removing Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Resultant%20Array%20After%20Removing%20Anagrams.java)
+288|[Minimum String Length After Removing Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20String%20Length%20After%20Removing%20Substrings.java)
+289|[Palindrome Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Number.java)
+290|[Find Subarrays With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Subarrays%20With%20Equal%20Sum.java)
+291|[Account Balance After Rounded Purchase](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Account%20Balance%20After%20Rounded%20Purchase.java)
+292|[Minimum Amount of Time to Fill Cups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Amount%20of%20Time%20to%20Fill%20Cups.java)
+293|[Detect Pattern of Length M Repeated K or More Times](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Detect%20Pattern%20of%20Length%20M%20Repeated%20K%20or%20More%20Times.java)
+294|[Largest Positive Integer That Exists With Its Negative](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Positive%20Integer%20That%20Exists%20With%20Its%20Negative.java)
+295|[Univalued Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Univalued%20Binary%20Tree.java)
+296|[Single-Row Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single-Row%20Keyboard.java)
+297|[Remove Linked List Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Linked%20List%20Elements.java)
+298|[How Many Numbers Are Smaller Than the Current Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Numbers%20Are%20Smaller%20Than%20the%20Current%20Number.java)
+299|[Most Frequent Even Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Frequent%20Even%20Element.java)
+300|[Maximum Odd Binary Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Odd%20Binary%20Number.java)
+301|[Armstrong Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Armstrong%20Number.java)
+302|[Counting Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Elements.java)
+303|[Make The String Great](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Make%20The%20String%20Great.java)
+304|[Cells with Odd Values in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20with%20Odd%20Values%20in%20a%20Matrix.java)
+305|[Power of Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Two.java)
+306|[Decode XORed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Decode%20XORed%20Array.java)
+307|[Long Pressed Name](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Long%20Pressed%20Name.java)
+308|[Kids With the Greatest Number of Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Kids%20With%20the%20Greatest%20Number%20of%20Candies.java)
+309|[N-ary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Postorder%20Traversal.java)
+310|[Max Consecutive Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Consecutive%20Ones.java)
+311|[Find Words That Can Be Formed by Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Words%20That%20Can%20Be%20Formed%20by%20Characters.java)
+312|[Number of 1 bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%201%20bits.java)
+313|[Largest Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Unique%20Number.java)
+314|[The Employee That Worked on the Longest Task](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/The%20Employee%20That%20Worked%20on%20the%20Longest%20Task.java)
+315|[Paint House](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Paint%20House.java)
+316|[Logger Rate Limiter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Logger%20Rate%20Limiter.java)
+317|[Substrings of Size Three with Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Substrings%20of%20Size%20Three%20with%20Distinct%20Characters.java)
+318|[Maximum Difference by Remapping a Digit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20by%20Remapping%20a%20Digit.java)
+319|[Monotonic Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Monotonic%20Array.java)
+320|[Check if One String Swap Can Make Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20One%20String%20Swap%20Can%20Make%20Strings%20Equal.java)
+321|[Valid Palindrome II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome%20II.java)
+322|[Occurrences After Bigram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Occurrences%20After%20Bigram.java)
+323|[Minimum Sum of Four Digit Number After Splitting Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Sum%20of%20Four%20Digit%20Number%20After%20Splitting%20Digits.java)
+324|[Move Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Move%20Zeroes.java)
+325|[Number of Arithmetic Triplets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Arithmetic%20Triplets.java)
+326|[Count Number of Pairs With Absolute Difference K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Number%20of%20Pairs%20With%20Absolute%20Difference%20K.java)
+327|[Number of Lines To Write String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Lines%20To%20Write%20String.java)
+328|[First Unique Character in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Unique%20Character%20in%20a%20String.java)
+329|[Maximum depth of Binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20depth%20of%20Binary%20tree.java)
+330|[Largest Number At Least Twice of Others](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20At%20Least%20Twice%20of%20Others.java)
+331|[Reverse String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20String%20II.java)
+332|[Letter Case Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Letter%20Case%20Permutation.java)
+333|[Two Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum.java)
+334|[Climbing Stairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Climbing%20Stairs.java)
+335|[Projection Area of 3D Shapes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Projection%20Area%20of%203D%20Shapes.java)
+336|[Maximize Sum Of Array After K Negations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximize%20Sum%20Of%20Array%20After%20K%20Negations.java)
+337|[Third Maximum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Third%20Maximum%20Number.java)
+338|[Sign of the Product of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sign%20of%20the%20Product%20of%20an%20Array.java)
+339|[Heaters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Heaters.java)
+340|[Remove Palindromic Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Palindromic%20Subsequences.java)
+341|[Time Needed to Buy Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Time%20Needed%20to%20Buy%20Tickets.java)
+342|[Find the K-Beauty of a Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20K-Beauty%20of%20a%20Number.java)
+343|[Find All K-Distant Indices in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20K-Distant%20Indices%20in%20an%20Array.java)
+344|[Student Attendance Record I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Student%20Attendance%20Record%20I.java)
+345|[Delete Characters to Make Fancy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Characters%20to%20Make%20Fancy%20String.java)
+346|[Longest Uncommon Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Uncommon%20Subsequence.java)
+347|[Check Distances Between Same Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Distances%20Between%20Same%20Letters.java)
+348|[Valid Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Mountain%20Array.java)
+349|[Shortest Word Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Word%20Distance.java)
+350|[Check if String Is Decomposable Into Value-Equal Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20String%20Is%20Decomposable%20Into%20Value-Equal%20Substrings.java)
+351|[Matrix Cells in Distance Order](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Cells%20in%20Distance%20Order.java)
+352|[Final Value of Variable After Performing Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Final%20Value%20of%20Variable%20After%20Performing%20Operations.java)
+353|[Shuffle String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shuffle%20String.java)
+354|[Sum of Square Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Square%20Numbers.java)
+355|[Percentage of Letter in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Percentage%20of%20Letter%20in%20String.java)
+356|[Intersection of Two Arrays II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays%20II.java)
+357|[Most Common Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Common%20Word.java)
+358|[Count Asterisks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Asterisks.java)
+359|[Sum of Squares of Special Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Squares%20of%20Special%20Elements.java)
+360|[Largest 3-Same-Digit Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%203-Same-Digit%20Number%20in%20String.java)
+361|[Number of Students Doing Homework at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Doing%20Homework%20at%20a%20Given%20Time.java)
+362|[Invert Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Invert%20Binary%20Tree.java)
+363|[Check if the Sentence Is Pangram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20the%20Sentence%20Is%20Pangram.java)
+364|[Island Perimeter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Island%20Perimeter.java)
+365|[Available Captures for Rook](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Available%20Captures%20for%20Rook.java)
+366|[Count Common Words With One Occurrence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Common%20Words%20With%20One%20Occurrence.java)
+367|[Degree of an array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Degree%20of%20an%20array.java)
+368|[Sum of Root To Leaf Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Root%20To%20Leaf%20Binary%20Numbers.java)
+369|[Circular Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Circular%20Sentence.java)
+370|[Sort Array By Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity.java)
+371|[Number of Good Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Good%20Pairs.java)
+372|[Convert a number to hexadecimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20a%20number%20to%20hexadecimal.java)
+373|[Check If a Word Occurs As a Prefix of Any Word in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Word%20Occurs%20As%20a%20Prefix%20of%20Any%20Word%20in%20a%20Sentence.java)
+374|[Calculate Delayed Arrival Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Delayed%20Arrival%20Time.java)
+375|[Concatenation of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Concatenation%20of%20Array.java)
+376|[Number of Recent Calls](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Recent%20Calls.java)
+377|[Fixed Point](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fixed%20Point.java)
+378|[Valid Boomerang](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Boomerang.java)
+379|[Minimum Moves to Equal an Array Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Moves%20to%20Equal%20an%20Array%20Element.java)
+380|[Calculate Money in Leetcode Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Money%20in%20Leetcode%20Bank.java)
+381|[Check If Two String Arrays are Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20Two%20String%20Arrays%20are%20Equivalent.java)
+382|[Find Nearest Point That Has the Same X or Y Coordinate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Nearest%20Point%20That%20Has%20the%20Same%20X%20or%20Y%20Coordinate.java)
+383|[Maximum Product Difference Between Two Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20Difference%20Between%20Two%20Pairs.java)
+384|[Goal Parser Interpretation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Goal%20Parser%20Interpretation.java)
+385|[Find the Losers of the Circular Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Losers%20of%20the%20Circular%20Game.java)
+386|[Judge Route Cycle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Judge%20Route%20Cycle.java)
+387|[K Items With the Maximum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/K%20Items%20With%20the%20Maximum%20Sum.java)
+388|[Middle of the linked list](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Middle%20of%20the%20linked%20list.java)
+389|[Maximum Number of Pairs in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Pairs%20in%20Array.java)
+390|[Check if Matrix Is X-Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Matrix%20Is%20X-Matrix.java)
+391|[Compare Strings by Frequency of the Smallest Character](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Compare%20Strings%20by%20Frequency%20of%20the%20Smallest%20Character.java)
+392|[Intersection of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20Two%20Arrays.java)
+393|[Bulls and Cows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Bulls%20and%20Cows.java)
+394|[Slowest Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Slowest%20Key.java)
+395|[Count Equal and Divisible Pairs in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Equal%20and%20Divisible%20Pairs%20in%20an%20Array.java)
+396|[nim_game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/nim_game.java)
+397|[Min Max Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Min%20Max%20Game.java)
+398|[Groups of Special-Equivalent Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Groups%20of%20Special-Equivalent%20Strings.java)
+399|[Reformat The String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20The%20String.java)
+400|[Minimum Number of Operations to Convert Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Number%20of%20Operations%20to%20Convert%20Time.java)
+401|[Form Smallest Number From Two Digit Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Form%20Smallest%20Number%20From%20Two%20Digit%20Arrays.java)
+402|[Minimum Operations to Collect Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Collect%20Elements.java)
+403|[Count Elements With Strictly Smaller and Greater Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Elements%20With%20Strictly%20Smaller%20and%20Greater%20Elements.java)
+404|[Determine the Winner of a Bowling Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20the%20Winner%20of%20a%20Bowling%20Game.java)
+405|[Minimum Operations to Make the Array Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Operations%20to%20Make%20the%20Array%20Increasing.java)
+406|[Minimum Right Shifts to Sort the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Right%20Shifts%20to%20Sort%20the%20Array.java)
+407|[Index Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Index%20Pairs%20of%20a%20String.java)
+408|[Number of Steps to Reduce a Number to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Steps%20to%20Reduce%20a%20Number%20to%20Zero.java)
+409|[Confusing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Confusing%20Number.java)
+410|[Convert BST to Greater Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20BST%20to%20Greater%20Tree.java)
+411|[Find All Numbers Disappeared in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20All%20Numbers%20Disappeared%20in%20an%20Array.java)
+412|[Largest Number After Digit Swaps by Parity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Number%20After%20Digit%20Swaps%20by%20Parity.java)
+413|[Merge Two 2D Arrays by Summing Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Two%202D%20Arrays%20by%20Summing%20Values.java)
+414|[Reformat Date](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reformat%20Date.java)
+415|[Largest Odd Number in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Odd%20Number%20in%20String.java)
+416|[Build Array from Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Build%20Array%20from%20Permutation.java)
+417|[Find Lucky Integer in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Lucky%20Integer%20in%20an%20Array.java)
+418|[Reverse Prefix of Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20Prefix%20of%20Word.java)
+419|[Nested List Weight Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nested%20List%20Weight%20Sum.java)
+420|[Relative ranks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20ranks.java)
+421|[Palindrome Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Palindrome%20Permutation.java)
+422|[Find Winner on a Tic Tac Toe Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Winner%20on%20a%20Tic%20Tac%20Toe%20Game.java)
+423|[Merge two binary trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20two%20binary%20trees.java)
+424|[Check if Numbers Are Ascending in a Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Numbers%20Are%20Ascending%20in%20a%20Sentence.java)
+425|[Power of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Power%20of%20Three.java)
+426|[Remove Letter To Equalize Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Letter%20To%20Equalize%20Frequency.java)
+427|[Lemonade Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lemonade%20Change.java)
+428|[Length of last word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Length%20of%20last%20word.java)
+429|[Increasing Decreasing String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Increasing%20Decreasing%20String.java)
+430|[N-th Tribonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-th%20Tribonacci%20Number.java)
+431|[Longest Common Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Common%20Prefix.java)
+432|[Minimum Time Visiting All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20Visiting%20All%20Points.java)
+433|[Calculate Amount Paid in Taxes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Calculate%20Amount%20Paid%20in%20Taxes.java)
+434|[Number of Different Integers in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Different%20Integers%20in%20a%20String.java)
+435|[Minimize String Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimize%20String%20Length.java)
+436|[Add Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Strings.java)
+437|[Maximum Ascending Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Ascending%20Subarray%20Sum.java)
+438|[Best Time to Buy and Sell Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Best%20Time%20to%20Buy%20and%20Sell%20Stock.java)
+439|[Lowest Common Ancestor of a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree.java)
+440|[Determine if String Halves Are Alike](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20String%20Halves%20Are%20Alike.java)
+441|[Find the difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20difference.java)
+442|[Check if Every Row and Column Contains All Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers.java)
+443|[Replace All Digits with Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20Digits%20with%20Characters.java)
+444|[Largest Substring Between Two Equal Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Largest%20Substring%20Between%20Two%20Equal%20Characters.java)
+445|[Strobogrammatic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Strobogrammatic%20Number.java)
+446|[Rearrange Characters to Make Target String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Characters%20to%20Make%20Target%20String.java)
+447|[Next Greater Element I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element%20I.java)
+448|[Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Counting%20Bits.java)
+449|[Remove Outermost Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Outermost%20Parentheses.java)
+450|[Count the Number of Vowel Strings in Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20the%20Number%20of%20Vowel%20Strings%20in%20Range.java)
+451|[Determine if Two Events Have Conflict](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Determine%20if%20Two%20Events%20Have%20Conflict.java)
+452|[Replace All ?'s to Avoid Consecutive Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20All%20?'s%20to%20Avoid%20Consecutive%20Repeating%20Characters.java)
+453|[Two Sum Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Sum%20Less%20Than%20K.java)
+454|[Majority Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Majority%20Element.java)
+455|[Merge Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Sorted%20Array.java)
+456|[Unique Morse Code Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Morse%20Code%20Words.java)
+457|[Divisor Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divisor%20Game.java)
+458|[Find Numbers with Even Number of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Numbers%20with%20Even%20Number%20of%20Digits.java)
+459|[Categorize Box According to Criteria](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Categorize%20Box%20According%20to%20Criteria.java)
+460|[Implement Queue using Stacks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Implement%20Queue%20using%20Stacks.java)
+461|[N-ary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-ary%20Tree%20Preorder%20Traversal.java)
+462|[Smallest Index With Equal Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Smallest%20Index%20With%20Equal%20Value.java)
+463|[Total Distance Traveled](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Total%20Distance%20Traveled.java)
+464|[Delete Node in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Delete%20Node%20in%20a%20Linked%20List.java)
+465|[Sort Array By Parity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Array%20By%20Parity%20II.java)
+466|[Most Visited Sector in a Circular Track](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Most%20Visited%20Sector%20in%20a%20Circular%20Track.java)
+467|[Greatest Common Divisor of Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Greatest%20Common%20Divisor%20of%20Strings.java)
+468|[Remove Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Element.java)
+469|[Maximum Subarray Sum I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Subarray%20Sum%20I.java)
+470|[Partition Array Into Three Parts With Equal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Partition%20Array%20Into%20Three%20Parts%20With%20Equal%20Sum.java)
+471|[Remove Duplicates From Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Duplicates%20From%20Sorted%20Lists.java)
+472|[Minimum Bit Flips to Convert Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Bit%20Flips%20to%20Convert%20Number.java)
+473|[Sort Even and Odd Indices Independently](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Even%20and%20Odd%20Indices%20Independently.java)
+474|[Meeting Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Meeting%20Rooms.java)
+475|[Crawler Log Folder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Crawler%20Log%20Folder.java)
+476|[Maximum Difference Between Increasing Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Difference%20Between%20Increasing%20Elements.java)
+477|[Left and Right Sum Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Left%20and%20Right%20Sum%20Differences.java)
+478|[Find the Middle Index in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Middle%20Index%20in%20Array.java)
+479|[Range Sum Query Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Range%20Sum%20Query%20Immutable.java)
+480|[Intersection of two Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Intersection%20of%20two%20Linked%20Lists.java)
+481|[Merge Similar Items](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Similar%20Items.java)
+482|[Can Place Flowers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Can%20Place%20Flowers.java)
+483|[Generate a String With Characters That Have Odd Counts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Generate%20a%20String%20With%20Characters%20That%20Have%20Odd%20Counts.java)
+484|[Count Operations to Obtain Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Operations%20to%20Obtain%20Zero.java)
+485|[Array Partition I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Partition%20I.java)
+486|[Next Greater Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Next%20Greater%20Element.java)
+487|[Perfect Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Perfect%20Number.java)
+488|[Sum of Digits in the Minimum Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20the%20Minimum%20Number.java)
+489|[Guess Number Higher or Lower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Guess%20Number%20Higher%20or%20Lower.java)
+490|[Find the Array Concatenation Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Array%20Concatenation%20Value.java)
+491|[Self Dividing Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Self%20Dividing%20Number.java)
+492|[Design HashMap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20HashMap.java)
+493|[Minimum Time to Type Word Using Special Typewriter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Time%20to%20Type%20Word%20Using%20Special%20Typewriter.java)
+494|[Check Whether Two Strings are Almost Equivalent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Whether%20Two%20Strings%20are%20Almost%20Equivalent.java)
+495|[Shortest Distance to Target String in a Circular Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Distance%20to%20Target%20String%20in%20a%20Circular%20Array.java)
+496|[Cells in a Range on an Excel Sheet](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Cells%20in%20a%20Range%20on%20an%20Excel%20Sheet.java)
+497|[Number of Common Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Common%20Factors.java)
+498|[Keep Multiplying Found Values by Two](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keep%20Multiplying%20Found%20Values%20by%20Two.java)
+499|[Search in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20in%20a%20Binary%20Search%20Tree.java)
+500|[Count Largest Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Largest%20Group.java)
+501|[Sum of Unique Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Unique%20Elements.java)
+502|[Moving Average from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Moving%20Average%20from%20Data%20Stream.java)
+503|[Symmetric Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Symmetric%20Tree.java)
+504|[Maximum Product of Two Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Product%20of%20Two%20Elements%20in%20an%20Array.java)
+505|[Difference Between Element Sum and Digit Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Difference%20Between%20Element%20Sum%20and%20Digit%20Sum%20of%20an%20Array.java)
+506|[Find Common Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Common%20Characters.java)
+507|[Lucky Numbers in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Lucky%20Numbers%20in%20a%20Matrix.java)
+508|[Remove Vowels from a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20Vowels%20from%20a%20String.java)
+509|[Add Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Digits.java)
+510|[Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Teemo%20Attacking.java)
+511|[Contains Duplicate II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Contains%20Duplicate%20II.java)
+512|[Count Integers With Even Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Integers%20With%20Even%20Digit%20Sum.java)
+513|[Minimum Index Sum of Two Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Index%20Sum%20of%20Two%20Lists.java)
+514|[Two Out of Three](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Two%20Out%20of%20Three.java)
+515|[Closest Binary Search Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Closest%20Binary%20Search%20Tree%20Value.java)
+516|[Distribute Money to Maximum Children](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Money%20to%20Maximum%20Children.java)
+517|[Sum of Digits in Base K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20Digits%20in%20Base%20K.java)
+518|[Fibonacci Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Fibonacci%20Number.java)
+519|[Distribute Candies to People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies%20to%20People.java)
+520|[Valid Word Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Square.java)
+521|[Distribute Candies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Distribute%20Candies.java)
+522|[Check If a Number Is Majority Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20If%20a%20Number%20Is%20Majority%20Element%20in%20a%20Sorted%20Array.java)
+523|[Alternating Digit Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Alternating%20Digit%20Sum.java)
+524|[Take Gifts From the Richest Pile](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Take%20Gifts%20From%20the%20Richest%20Pile.java)
+525|[Verifying an Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Verifying%20an%20Alien%20Dictionary.java)
+526|[Longest Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Palindrome.java)
+527|[Sum of All Odd Length Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20of%20All%20Odd%20Length%20Subarrays.java)
+528|[Average Salary Excluding the Minimum and Maximum Salary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20Salary%20Excluding%20the%20Minimum%20and%20Maximum%20Salary.java)
+529|[Apply Operations to an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Apply%20Operations%20to%20an%20Array.java)
+530|[Single Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Single%20Number.java)
+531|[Keyboard Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Keyboard%20Row.java)
+532|[Count Distinct Numbers on Board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Distinct%20Numbers%20on%20Board.java)
+533|[Squares of a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Squares%20of%20a%20Sorted%20Array.java)
+534|[Find the Longest Balanced Substring of a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Longest%20Balanced%20Substring%20of%20a%20Binary%20String.java)
+535|[Binary Tree Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Binary%20Tree%20Postorder%20Traversal.java)
+536|[Rearrange Spaces Between Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rearrange%20Spaces%20Between%20Words.java)
+537|[Minimum Recolors to Get K Consecutive Black Blocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Recolors%20to%20Get%20K%20Consecutive%20Black%20Blocks.java)
+538|[Count Square Sum Triples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Square%20Sum%20Triples.java)
+539|[Maximum Distance in Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Distance%20in%20Arrays.java)
+540|[Unique Number of Occurrences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Unique%20Number%20of%20Occurrences.java)
+541|[Day of the Week](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Day%20of%20the%20Week.java)
+542|[Design an Ordered Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20an%20Ordered%20Stream.java)
+543|[Minimum Distance Between BST Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Distance%20Between%20BST%20Nodes.java)
+544|[Maximum Sum With Exactly K Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Sum%20With%20Exactly%20K%20Elements.java)
+545|[Number of Students Unable to Eat Lunch](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Number%20of%20Students%20Unable%20to%20Eat%20Lunch.java)
+546|[Check if Number Has Equal Digit Count and Digit Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20Number%20Has%20Equal%20Digit%20Count%20and%20Digit%20Value.java)
+547|[Sum Of Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sum%20Of%20Two%20Integers.java)
+548|[Check if a String Is an Acronym of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20if%20a%20String%20Is%20an%20Acronym%20of%20Words.java)
+549|[Search Insert Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Search%20Insert%20Position.java)
+550|[Max Pair Sum in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Max%20Pair%20Sum%20in%20an%20Array.java)
+551|[Longest Univalue Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Univalue%20Path.java)
+552|[Maximum Depth of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Depth%20of%20N-ary%20Tree.java)
+553|[Thousand Separator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Thousand%20Separator.java)
+554|[Add Binary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20Binary.java)
+555|[Convert Binary Number in a Linked List to Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Convert%20Binary%20Number%20in%20a%20Linked%20List%20to%20Integer.java)
+556|[Sorting the Sentence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sorting%20the%20Sentence.java)
+557|[Replace Elements with Greatest Element on Right Side](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Replace%20Elements%20with%20Greatest%20Element%20on%20Right%20Side.java)
+558|[Matrix Diagonal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Matrix%20Diagonal%20Sum.java)
+559|[Check Array Formation Through Concatenation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Check%20Array%20Formation%20Through%20Concatenation.java)
+560|[Water Bottles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Water%20Bottles.java)
+561|[Add to Array-Form of Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Add%20to%20Array-Form%20of%20Integer.java)
+562|[Prime In Diagonal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Prime%20In%20Diagonal.java)
+563|[Pass the Pillow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Pass%20the%20Pillow.java)
+564|[Missing Number In Arithmetic Progression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Missing%20Number%20In%20Arithmetic%20Progression.java)
+565|[Divide Array Into Equal Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Divide%20Array%20Into%20Equal%20Pairs.java)
+566|[Maximum Value of a String in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Value%20of%20a%20String%20in%20an%20Array.java)
+567|[Maximum Number of Balls in a Box](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Balls%20in%20a%20Box.java)
+568|[Mean of Array After Removing Some Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Mean%20of%20Array%20After%20Removing%20Some%20Elements.java)
+569|[N-Repeated Element in Size 2N Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/N-Repeated%20Element%20in%20Size%202N%20Array.java)
+570|[Redistribute Characters to Make All Strings Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Redistribute%20Characters%20to%20Make%20All%20Strings%20Equal.java)
+571|[Remove All Adjacent Duplicates In String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Remove%20All%20Adjacent%20Duplicates%20In%20String.java)
+572|[Minimum  Absolute Difference in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20%20Absolute%20Difference%20in%20BST.java)
+573|[Image Smoother](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Image%20Smoother.java)
+574|[Find the Difference of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20the%20Difference%20of%20Two%20Arrays.java)
+575|[How Many Apples Can You Put into the Basket](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/How%20Many%20Apples%20Can%20You%20Put%20into%20the%20Basket.java)
+576|[Second Minimum Node in a binary tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Minimum%20Node%20in%20a%20binary%20tree.java)
+577|[Excel Sheet Column Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Excel%20Sheet%20Column%20Number.java)
+578|[Same Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Same%20Tree.java)
+579|[Count Odd Numbers in an Interval Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Odd%20Numbers%20in%20an%20Interval%20Range.java)
+580|[String Without AAA or BBB](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/String%20Without%20AAA%20or%20BBB.java)
+581|[Find Greatest Common Divisor of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Greatest%20Common%20Divisor%20of%20Array.java)
+582|[Longest Word in Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Longest%20Word%20in%20Dictionary.java)
+583|[Happy Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Happy%20Number.java)
+584|[Array Transformation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Array%20Transformation.java)
+585|[Design Compressed String Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Design%20Compressed%20String%20Iterator.java)
+586|[Reverse words in a String III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Reverse%20words%20in%20a%20String%20III.java)
+587|[Rank Transform of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Rank%20Transform%20of%20an%20Array.java)
+588|[First Bad Version](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/First%20Bad%20Version.java)
+589|[Sort Integers by The Number of 1 Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Sort%20Integers%20by%20The%20Number%20of%201%20Bits.java)
+590|[Split With Minimum Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Split%20With%20Minimum%20Sum.java)
+591|[Construct String from Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Construct%20String%20from%20Binary%20Tree.java)
+592|[Maximum Number of Words Found in Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Maximum%20Number%20of%20Words%20Found%20in%20Sentences.java)
+593|[Toeplitz Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Toeplitz%20Matrix.java)
+594|[Find Maximum Number of String Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Find%20Maximum%20Number%20of%20String%20Pairs.java)
+595|[Finding 3-Digit Even Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Finding%203-Digit%20Even%20Numbers.java)
+596|[Valid Word Abbreviation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Word%20Abbreviation.java)
+597|[Second Largest Digit in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Second%20Largest%20Digit%20in%20a%20String.java)
+598|[Valid Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Valid%20Palindrome.java)
+599|[Relative Sort Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Relative%20Sort%20Array.java)
+600|[Minimum Cuts to Divide a Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Minimum%20Cuts%20to%20Divide%20a%20Circle.java)
+601|[Path In Zigzag Labelled Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Path%20In%20Zigzag%20Labelled%20Binary%20Tree.java)
+602|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Shortest%20Completing%20Word.java)
+603|[Nim Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Nim%20Game.java)
+604|[Count Substrings with Only One Distinct Letter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Count%20Substrings%20with%20Only%20One%20Distinct%20Letter.java)
+605|[Average of Levels in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Average%20of%20Levels%20in%20Binary%20Tree.java)
+606|[Merge Strings Alternately](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Easy/Merge%20Strings%20Alternately.java)
diff --git a/Easy/Range Sum of BST.java b/Easy/Range Sum of BST.java
index b3d21555..3ed8dfdd 100644
--- a/Easy/Range Sum of BST.java	
+++ b/Easy/Range Sum of BST.java	
@@ -14,22 +14,22 @@
  * }
  */
 class Solution {
-  public int rangeSumBST(TreeNode root, int low, int high) {
-    Stack<TreeNode> stack = new Stack<>();
-    stack.push(root);
-    int sum = 0;
-    while (!stack.isEmpty()) {
-        TreeNode removed = stack.pop();
-        if (removed.val > low && removed.left != null) { 
-          stack.push(removed.left); 
-        } 
-        if (removed.val < high && removed.right != null) { 
-          stack.push(removed.right); 
-        }
-        if (low <= removed.val && removed.val <= high) {
-          sum += removed.val; 
+    public int rangeSumBST(TreeNode root, int low, int high) {
+        int sum = 0;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            TreeNode removed = queue.remove();
+            if (removed.val >= low && removed.val <= high) {
+                sum += removed.val;
+            }
+            if (removed.val >= low && removed.left != null) {
+                queue.add(removed.left);
+            }
+            if (removed.val <= high && removed.right != null) {
+                queue.add(removed.right);
+            }
         }
+        return sum;
     }
-    return sum;
-  }
 }
diff --git a/Easy/Rank Transform of an Array.java b/Easy/Rank Transform of an Array.java
index 401c317b..3f9192fd 100644
--- a/Easy/Rank Transform of an Array.java	
+++ b/Easy/Rank Transform of an Array.java	
@@ -1,20 +1,19 @@
 class Solution {
-  public int[] arrayRankTransform(int[] arr) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>();
-    for (int num : arr) {
-      pq.add(num);
+    public int[] arrayRankTransform(int[] arr) {
+        int[] copyArr = Arrays.copyOf(arr, arr.length);
+        Arrays.sort(arr);
+        int rank = 1;
+        Map<Integer, Integer> numToRank = new HashMap<>();
+        for (int num : arr) {
+            if (numToRank.containsKey(num)) {
+                continue;
+            }
+            numToRank.put(num, rank++);
+        }
+        int[] result = new int[arr.length];
+        for (int i = 0; i < arr.length; i++) {
+            result[i] = numToRank.get(copyArr[i]);
+        }
+        return result;
     }
-    int rank = 1;
-    Map<Integer, Integer> map = new HashMap<>();
-    while (!pq.isEmpty()) {
-      int removed = pq.poll();
-      if (!map.containsKey(removed)) {
-        map.put(removed, rank++);
-      }
-    }
-    for (int i = 0; i < arr.length; i++) {
-      arr[i] = map.get(arr[i]);
-    }
-    return arr;
-  }
 }
diff --git a/Easy/Remove Trailing Zeros From a String.java b/Easy/Remove Trailing Zeros From a String.java
new file mode 100644
index 00000000..996c079e
--- /dev/null
+++ b/Easy/Remove Trailing Zeros From a String.java	
@@ -0,0 +1,9 @@
+class Solution {
+    public String removeTrailingZeros(String num) {
+        int idx = num.length() - 1;
+        while (idx >= 0 && num.charAt(idx) == '0') {
+            idx--;
+        }
+        return num.substring(0, idx + 1);
+    }
+}
diff --git a/Easy/Repeated Substring Pattern.java b/Easy/Repeated Substring Pattern.java
index 79ea250c..fc817f7e 100644
--- a/Easy/Repeated Substring Pattern.java	
+++ b/Easy/Repeated Substring Pattern.java	
@@ -1,19 +1,16 @@
 class Solution {
-  public boolean repeatedSubstringPattern(String s) {
-    int n = s.length();
-    for (int i = n / 2; i >= 1; i--) {
-      if (n % i == 0) {
-        int count = n / i;
-        StringBuilder sb = new StringBuilder();
-        String sub = s.substring(0, i);
-        while (count-- > 0) {
-          sb.append(sub);
+    public boolean repeatedSubstringPattern(String s) {
+        int n = s.length();
+        for (int i = n / 2; i > 0; i--) {
+            if (n % i == 0) {
+                int count = n / i;
+                String substring = s.substring(0, i);
+                String repeatedString = substring.repeat(count);
+                if (repeatedString.equals(s)) {
+                    return true;
+                }
+            }
         }
-        if (sb.toString().equals(s)) {
-          return true;
-        }
-      }
+        return false;
     }
-    return false;
-  }
 }
diff --git a/Easy/Reshape the matrix.java b/Easy/Reshape the matrix.java
index 1093a616..ca61f4e4 100644
--- a/Easy/Reshape the matrix.java	
+++ b/Easy/Reshape the matrix.java	
@@ -1,31 +1,22 @@
 class Solution {
-    public int[][] matrixReshape(int[][] nums, int r, int c) {
-        int numOfElem = nums.length*nums[0].length;
-        if (numOfElem != r*c) {
-            return nums;
+    public int[][] matrixReshape(int[][] mat, int r, int c) {
+        int m = mat.length;
+        int n = mat[0].length;
+        if (m * n != r * c) {
+            return mat;
         }
-        
-        int[] expandedArray = new int[numOfElem];
-        int k = 0;
-        
-        for (int i=0;i<nums.length;i++) {
-            for (int j=0;j<nums[i].length;j++) {
-                expandedArray[k] = nums[i][j];
-                k++;
+        int[][] result = new int[r][c];
+        int rowIdx = 0;
+        int colIdx = 0;
+        for (int i = 0; i < r; i++) {
+            for (int j = 0; j < c; j++) {
+                result[i][j] = mat[rowIdx][colIdx++];
+                if (colIdx == n) {
+                    colIdx = 0;
+                    rowIdx++;
+                }
             }
         }
-        
-        int[][] ans = new int[r][c];
-        int i=0;
-        int j=0;
-        for(k=0;k<numOfElem;k++) {
-            ans[i][j] = expandedArray[k];
-            j++;
-            if (j == c) {
-                j = 0;
-                i++;
-            }
-        }
-        return ans;
+        return result;
     }
 }
diff --git a/Easy/Reverse Degree of a String.java b/Easy/Reverse Degree of a String.java
new file mode 100644
index 00000000..db8f4e91
--- /dev/null
+++ b/Easy/Reverse Degree of a String.java	
@@ -0,0 +1,9 @@
+class Solution {
+    public int reverseDegree(String s) {
+        int result = 0;
+        for (int i = 0; i < s.length(); i++) {
+            result += (i + 1) * (26 - (s.charAt(i) - 'a'));
+        }
+        return result;
+    }
+}
diff --git a/Easy/Reverse Vowels of a String.java b/Easy/Reverse Vowels of a String.java
index c1ea0294..ea10d13c 100644
--- a/Easy/Reverse Vowels of a String.java	
+++ b/Easy/Reverse Vowels of a String.java	
@@ -1,24 +1,24 @@
 class Solution {
-  public String reverseVowels(String s) {
-    int left = 0;
-    int right = s.length() - 1;
-    String vowels = "aeiouAEIOU";
-    char[] chars = s.toCharArray();
-    while (left < right) {
-      int vowelIndexLeft = vowels.indexOf(chars[left]);
-      int vowelIndexRight = vowels.indexOf(chars[right]);
-      if (vowelIndexLeft != -1 && vowelIndexRight != -1) {
-        char temp = chars[left];
-        chars[left++] = chars[right];
-        chars[right--] = temp;
-      }
-      else if (vowelIndexRight == -1) {
-        right--;
-      }
-      else {
-        left++;
-      }
+    
+    private static final Set<Character> VOWELS = Set.of('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U');
+    
+    public String reverseVowels(String s) {
+        int left = 0;
+        int right = s.length() - 1;
+        char[] chars = s.toCharArray();
+        while (left <= right) {
+            if (VOWELS.contains(chars[left]) && VOWELS.contains(chars[right])) {
+                char temp = chars[left];
+                chars[left] = chars[right];
+                chars[right] = temp;
+                left++;
+                right--;
+            } else if (!VOWELS.contains(chars[left])) {
+                left++;
+            } else if (!VOWELS.contains(chars[right])) {
+                right--;
+            }
+        }
+        return String.valueOf(chars);
     }
-    return String.valueOf(chars);
-  }
 }
diff --git a/Easy/Reverse words in a String III.java b/Easy/Reverse words in a String III.java
index e50dd770..c6c46160 100644
--- a/Easy/Reverse words in a String III.java	
+++ b/Easy/Reverse words in a String III.java	
@@ -1,23 +1,30 @@
 class Solution {
-  public String reverseWords(String s) {
-    int idx = 0;
-    int n = s.length();
-    StringBuilder sb = new StringBuilder();
-    int start = 0;
-    while (idx < n) {
-      while (idx < n && s.charAt(idx) != ' ') {
-        idx++;
-      }
-      int curr = idx - 1;
-      while (curr >= start) {
-        sb.append(s.charAt(curr--));
-      }
-      if (idx != n) {
-        sb.append(" ");
-      }
-      idx++;
-      start = idx;
+    public String reverseWords(String s) {
+        int start = 0;
+        int end = 0;
+        char[] chars = s.toCharArray();
+        while (end < s.length()) {
+            if (chars[end] == ' ') {
+                if (start < end - 1) {
+                    reverse(chars, start, end - 1);
+                }
+                end++;
+                start = end;
+            } else {
+                end++;
+            }
+        }
+        if (start < end) {
+            reverse(chars, start, end - 1);
+        }
+        return String.valueOf(chars);
+    }
+
+    private void reverse(char[] chars, int start, int end) {
+        while (start < end) {
+            char temp = chars[start];
+            chars[start++] = chars[end];
+            chars[end--] = temp;
+        }
     }
-    return sb.toString();
-  }
 }
diff --git a/Easy/Row With Maximum Ones.java b/Easy/Row With Maximum Ones.java
new file mode 100644
index 00000000..e1d32424
--- /dev/null
+++ b/Easy/Row With Maximum Ones.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int[] rowAndMaximumOnes(int[][] mat) {
+        int maxOnes = 0;
+        int maxOnesRow = 0;
+        for (int i = 0; i < mat.length; i++) {
+            int oneCount = 0;
+            for (int num : mat[i]) {
+                oneCount += num == 1 ? 1 : 0;
+            }
+            if (oneCount > maxOnes) {
+                maxOnes = oneCount;
+                maxOnesRow = i;
+            }
+        }
+        return new int[]{maxOnesRow, maxOnes};
+    }
+}
diff --git a/Easy/Score of a String.java b/Easy/Score of a String.java
new file mode 100644
index 00000000..fafcca05
--- /dev/null
+++ b/Easy/Score of a String.java	
@@ -0,0 +1,9 @@
+class Solution {
+    public int scoreOfString(String s) {
+        int score = 0;
+        for (int i = 1; i < s.length(); i++) {
+            score += Math.abs(s.charAt(i) - s.charAt(i - 1));
+        }
+        return score;
+    }
+}
diff --git a/Easy/Search in a Binary Search Tree.java b/Easy/Search in a Binary Search Tree.java
index 63e2f736..e3c00460 100644
--- a/Easy/Search in a Binary Search Tree.java	
+++ b/Easy/Search in a Binary Search Tree.java	
@@ -14,13 +14,21 @@
  * }
  */
 class Solution {
-  public TreeNode searchBST(TreeNode root, int val) {
-    if (root == null) {
-      return root;
+    public TreeNode searchBST(TreeNode root, int val) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            TreeNode removed = queue.remove();
+            if (removed.val == val) {
+                return removed;
+            }
+            if (removed.val > val && removed.left != null) {
+                queue.add(removed.left);
+            } 
+            if (removed.val < val && removed.right != null) {
+                queue.add(removed.right);
+            }
+        }
+        return null;
     }
-    if (root.val == val) {
-      return root;
-    }
-    return root.val > val ? searchBST(root.left, val) : searchBST(root.right, val);
-  }
 }
diff --git a/Easy/Separate the Digits in an Array.java b/Easy/Separate the Digits in an Array.java
new file mode 100644
index 00000000..9bd6878f
--- /dev/null
+++ b/Easy/Separate the Digits in an Array.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int[] separateDigits(int[] nums) {
+        List<Integer> result = new ArrayList<>();
+        for (int num : nums) {
+            int startIdx = result.size();
+            while (num > 0) {
+                result.add(num % 10);
+                num /= 10;
+            }
+            int endIdx = result.size() - 1;
+            while (startIdx < endIdx) {
+                int temp = result.get(startIdx);
+                result.set(startIdx++, result.get(endIdx));
+                result.set(endIdx--, temp);
+            }
+        }
+        return result.stream().mapToInt(Integer::intValue).toArray();
+    }
+}
diff --git a/Easy/Set Mismatch.java b/Easy/Set Mismatch.java
index 9660688d..eac82238 100644
--- a/Easy/Set Mismatch.java	
+++ b/Easy/Set Mismatch.java	
@@ -1,18 +1,19 @@
 class Solution {
-  public int[] findErrorNums(int[] nums) {
-    int[] result = new int[2];
-    Set<Integer> set = new HashSet<>();
-    int n = nums.length;
-    for (int num : nums) {
-      if (!set.add(num)) {
-        result[0] = num;
-      }
+    public int[] findErrorNums(int[] nums) {
+        int n = nums.length;
+        int[] result = new int[2];
+        Set<Integer> set = new HashSet<>();
+        for (int i = 1; i <= n; i++) {
+            if (!set.add(nums[i - 1])) {
+                result[0] = nums[i - 1];
+            }
+        }
+        for (int i = 1; i <= n; i++) {
+            if (!set.contains(i)) {
+                result[1] = i;
+                break;
+            }
+        }
+        return result;
     }
-    for (int i = 1; i <= n; i++) {
-      if (!set.contains(i)) {
-        result[1] = i;
-      }
-    }
-    return result;
-  }
 }
diff --git a/Easy/Shortest Distance to Target String in a Circular Array.java b/Easy/Shortest Distance to Target String in a Circular Array.java
new file mode 100644
index 00000000..9280c7b9
--- /dev/null
+++ b/Easy/Shortest Distance to Target String in a Circular Array.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int closetTarget(String[] words, String target, int startIndex) {
+        int firstIdx = -1;
+        int lastIdx = -1;
+        int n = words.length;
+        int minDistance = Integer.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            if (words[i].equals(target)) {
+                if (firstIdx == -1) {
+                    firstIdx = i;
+                }
+                lastIdx = i;
+                minDistance = Math.min(minDistance, Math.abs(i - startIndex));
+            }
+        }
+        if (minDistance == Integer.MAX_VALUE) {
+            return -1;
+        }
+        return Math.min(minDistance, Math.min(
+            n - startIndex + firstIdx, // Reach first instance by circulating from end of array 
+            startIndex + n - lastIdx // Reach last instance by circulating from start of array
+        ));
+    }
+}
diff --git a/Easy/Shortest Subarray With OR at Least K I.java b/Easy/Shortest Subarray With OR at Least K I.java
new file mode 100644
index 00000000..0032852b
--- /dev/null
+++ b/Easy/Shortest Subarray With OR at Least K I.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int minimumSubarrayLength(int[] nums, int k) {
+        int n = nums.length;
+        int result = Integer.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            int curr = 0;
+            for (int j = i; j < n; j++) {
+                curr |= nums[j];
+                if (curr >= k) {
+                    result = Math.min(result, j - i + 1);
+                    break;
+                }
+            }
+        }
+        return result == Integer.MAX_VALUE ? -1 : result;
+    }
+}
diff --git a/Easy/Shuffle String.java b/Easy/Shuffle String.java
index 10340050..f38bf1c2 100644
--- a/Easy/Shuffle String.java	
+++ b/Easy/Shuffle String.java	
@@ -1,24 +1,10 @@
 class Solution {
-  public String restoreString(String s, int[] indices) {
-    char[] letters = s.toCharArray();
-    for (int i = 0; i < indices.length; i++) {
-      while (indices[i] != i) {
-        swapLetter(letters, i, indices[i]);
-        swapIndex(indices, i, indices[i]); 
-      }
+    public String restoreString(String s, int[] indices) {
+        char[] result = new char[s.length()];
+        for (int i = 0; i < s.length(); i++) {
+            int index = indices[i];
+            result[index] = s.charAt(i);
+        }
+        return String.valueOf(result);
     }
-    return String.valueOf(letters);
-  }
-
-  private void swapLetter(char[] arr, int idxOne, int idxTwo) {
-    char temp = arr[idxOne];
-    arr[idxOne] = arr[idxTwo];
-    arr[idxTwo] = temp;
-  }
-
-  private void swapIndex(int[] arr, int idxOne, int idxTwo) {
-    int temp = arr[idxOne];
-    arr[idxOne] = arr[idxTwo];
-    arr[idxTwo] = temp;
-  }
 }
diff --git a/Easy/Sign of the Product of an Array.java b/Easy/Sign of the Product of an Array.java
index 8f286c24..b4f1172c 100644
--- a/Easy/Sign of the Product of an Array.java	
+++ b/Easy/Sign of the Product of an Array.java	
@@ -1,12 +1,12 @@
 class Solution {
-  public int arraySign(int[] nums) {
-    int negativeCount = 0;
-    for (int num : nums) {
-      if (num == 0) {
-        return 0;
-      }
-      negativeCount += num < 0 ? 1 : 0;
+    public int arraySign(int[] nums) {
+        int negCount = 0;
+        for (int num : nums) {
+            if (num == 0) {
+                return 0;
+            }
+            negCount += num > 0 ? 0 : 1;
+        }
+        return negCount % 2 == 0 ? 1 : -1;
     }
-    return negativeCount % 2 == 0 ? 1 : -1;
-  }
 }
diff --git a/Easy/Single-Row Keyboard.java b/Easy/Single-Row Keyboard.java
index 5a59a1d6..f09a641c 100644
--- a/Easy/Single-Row Keyboard.java	
+++ b/Easy/Single-Row Keyboard.java	
@@ -1,16 +1,15 @@
 class Solution {
-  public int calculateTime(String keyboard, String word) {
-    Map<Character, Integer> map = new HashMap<>();
-    int pos = 0;
-    for (char c : keyboard.toCharArray()) {
-      map.put(c, pos++);
+    public int calculateTime(String keyboard, String word) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (int i = 0; i < 26; i++) {
+            map.put(keyboard.charAt(i), i);
+        }
+        int position = 0;
+        int time = 0;
+        for (char c : word.toCharArray()) {
+            time += Math.abs(position - map.get(c));
+            position = map.get(c);
+        }
+        return time;
     }
-    int total = 0;
-    int currPos = 0;
-    for (char c : word.toCharArray()) {
-      total += Math.abs(currPos - map.get(c));
-      currPos = map.get(c);
-    }
-    return total;
-  }
 }
diff --git a/Easy/Snake in Matrix.java b/Easy/Snake in Matrix.java
new file mode 100644
index 00000000..5dce2568
--- /dev/null
+++ b/Easy/Snake in Matrix.java	
@@ -0,0 +1,22 @@
+class Solution {
+
+    private static final Map<String, int[]> COMMAND_TO_DIRECTION = Map.of(
+        "UP", new int[]{-1, 0},
+        "DOWN", new int[]{1, 0},
+        "LEFT", new int[]{0, -1},
+        "RIGHT", new int[]{0, 1}
+    );
+
+    public int finalPositionOfSnake(int n, List<String> commands) {
+        int position = 0;
+        int x = 0;
+        int y = 0;
+        for (String command : commands) {
+            int[] change = COMMAND_TO_DIRECTION.get(command);
+            x += change[0];
+            y += change[1];
+            position = x * n + y;
+        }
+        return position;
+    }
+}
diff --git a/Easy/Sort Array By Parity.java b/Easy/Sort Array By Parity.java
index c74dcae0..0b54ae53 100644
--- a/Easy/Sort Array By Parity.java	
+++ b/Easy/Sort Array By Parity.java	
@@ -1,17 +1,16 @@
 class Solution {
-  public int[] sortArrayByParity(int[] A) {
-    int evenIdx = 0;
-    int oddIdx = A.length - 1;
-    while (evenIdx < oddIdx) {
-      if (A[evenIdx] % 2 == 0) {
-        evenIdx++;
-      } 
-      else {
-        int temp = A[evenIdx];
-        A[evenIdx] = A[oddIdx];
-        A[oddIdx--] = temp;
-      }
+    public int[] sortArrayByParity(int[] nums) {
+        int start = 0;
+        int end = 0;
+        int n = nums.length;
+        while (end < n) {
+            if (nums[end] % 2 == 0) {
+                int temp = nums[start];
+                nums[start++] = nums[end];
+                nums[end] = temp;
+            }
+            end++;
+        }
+        return nums;
     }
-    return A;
-  }
 }
diff --git a/Easy/Special Array I.java b/Easy/Special Array I.java
new file mode 100644
index 00000000..5057f626
--- /dev/null
+++ b/Easy/Special Array I.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public boolean isArraySpecial(int[] nums) {
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] % 2 == nums[i - 1] % 2) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/Easy/Split Strings by Separator.java b/Easy/Split Strings by Separator.java
new file mode 100644
index 00000000..2292a309
--- /dev/null
+++ b/Easy/Split Strings by Separator.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public List<String> splitWordsBySeparator(List<String> words, char separator) {
+        List<String> result = new ArrayList<>();
+        for (String word : words) {
+            int startIdx = 0;
+            int currIdx = 0;
+            while (currIdx < word.length()) {
+                if (word.charAt(currIdx) == separator) {
+                    if (currIdx - startIdx > 0) {
+                        result.add(word.substring(startIdx, currIdx));
+                    }
+                    startIdx = currIdx + 1;
+                }
+                currIdx++;
+            }
+            if (currIdx - startIdx > 0) {
+                result.add(word.substring(startIdx, currIdx));
+            }
+        }
+        return result;
+    }
+}
diff --git a/Easy/Split With Minimum Sum.java b/Easy/Split With Minimum Sum.java
new file mode 100644
index 00000000..3f816605
--- /dev/null
+++ b/Easy/Split With Minimum Sum.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int splitNum(int num) {
+        List<Integer> digits = new ArrayList<>();
+        while (num > 0) {
+            digits.add(num % 10);
+            num /= 10;
+        }
+        Collections.sort(digits);
+        int numOne = 0;
+        int numTwo = 0;
+        boolean flag = true;
+        for (int digit : digits) {
+            if (flag) {
+                numOne = numOne * 10 + digit;
+            } else {
+                numTwo = numTwo * 10 + digit;
+            }
+            flag = !flag;
+        }
+        return numOne + numTwo;
+    }
+}
diff --git a/Easy/Split the Array.java b/Easy/Split the Array.java
new file mode 100644
index 00000000..607a2de0
--- /dev/null
+++ b/Easy/Split the Array.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public boolean isPossibleToSplit(int[] nums) {
+        return Arrays.stream(nums)
+                .boxed()
+                .collect(Collectors.groupingBy(Function.identity(), HashMap::new, Collectors.counting()))
+                .values()
+                .stream()
+                .allMatch(v -> v <= 2);
+    }
+}
diff --git a/Easy/Squares of a Sorted Array.java b/Easy/Squares of a Sorted Array.java
index 046fcf9c..08f5faa6 100644
--- a/Easy/Squares of a Sorted Array.java	
+++ b/Easy/Squares of a Sorted Array.java	
@@ -1,26 +1,18 @@
 class Solution {
-  public int[] sortedSquares(int[] nums) {
-    int negativeIdx = 0;
-    int positiveIdx = nums.length - 1;
-    int[] result = new int[nums.length];
-    int resultIdx = nums.length - 1;
-    while(resultIdx >= 0) {
-      if (nums[negativeIdx] < 0 && nums[positiveIdx] >= 0) {
-        if (Math.abs(nums[negativeIdx]) > nums[positiveIdx]) {
-          result[resultIdx--] = nums[negativeIdx] * nums[negativeIdx];
-          negativeIdx++;
-        } else {
-          result[resultIdx--] = nums[positiveIdx] * nums[positiveIdx];
-          positiveIdx--;
+    public int[] sortedSquares(int[] nums) {
+        int n = nums.length;
+        int start = 0;
+        int end = n - 1;
+        int[] result = new int[n];
+        for (int i = n - 1; i >= 0; i--) {
+            if (Math.abs(nums[start]) >= Math.abs(nums[end])) {
+                result[i] = nums[start] * nums[start];
+                start++;
+            } else {
+                result[i] = nums[end] * nums[end];
+                end--;
+            }
         }
-      } else if (nums[negativeIdx] < 0 && nums[positiveIdx] < 0) {
-        result[resultIdx--] = nums[negativeIdx] * nums[negativeIdx];
-        negativeIdx++;
-      } else {
-        result[resultIdx--] = nums[positiveIdx] * nums[positiveIdx];
-        positiveIdx--;  
-      }
+        return result;
     }
-    return result;
-  }
 }
diff --git a/Easy/Subarrays Distinct Element Sum of Squares I.java b/Easy/Subarrays Distinct Element Sum of Squares I.java
new file mode 100644
index 00000000..fa7cee6a
--- /dev/null
+++ b/Easy/Subarrays Distinct Element Sum of Squares I.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int sumCounts(List<Integer> nums) {
+        int sum = 0;
+        int n = nums.size();
+        for (int i = 0; i < n; i++) {
+            Set<Integer> set = new HashSet<>();
+            for (int j = i; j < n; j++) {
+                set.add(nums.get(j));
+                int size = set.size();
+                sum += size * size;
+            }
+        }
+        return sum;
+    }
+}
diff --git a/Easy/Subtree of Another Tree.java b/Easy/Subtree of Another Tree.java
index a88e3642..c0e307eb 100644
--- a/Easy/Subtree of Another Tree.java	
+++ b/Easy/Subtree of Another Tree.java	
@@ -14,26 +14,21 @@
  * }
  */
 class Solution {
-  public boolean isSubtree(TreeNode root, TreeNode subRoot) {
-    if (root == null) {
-      return false;
+    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
+        if (root == null) {
+            return false;
+        }
+        boolean result = root.val == subRoot.val && isSubtreeHelper(root, subRoot);
+        return result || isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
     }
-    if (isSubtreeHelper(root, subRoot)) {
-      return true;
+    
+    private boolean isSubtreeHelper(TreeNode root, TreeNode subRoot) {
+        if (root == null && subRoot == null) {
+            return true;
+        }
+        if (root == null || subRoot == null) {
+            return false;
+        }
+        return root.val == subRoot.val && isSubtreeHelper(root.left, subRoot.left) && isSubtreeHelper(root.right, subRoot.right);
     }
-    return isSubtree(root.left, subRoot) || isSubtree(root.right, subRoot);
-  }
-  
-  private boolean isSubtreeHelper(TreeNode root, TreeNode subRoot) {
-    if (root == null && subRoot == null) {
-      return true;
-    }
-    if (root == null || subRoot == null) {
-      return false;
-    }
-    if (root.val != subRoot.val) {
-      return false;
-    }
-    return isSubtreeHelper(root.left, subRoot.left) && isSubtreeHelper(root.right, subRoot.right);
-  }
 }
diff --git a/Easy/Sum of All Subset XOR Totals.java b/Easy/Sum of All Subset XOR Totals.java
new file mode 100644
index 00000000..fe82567a
--- /dev/null
+++ b/Easy/Sum of All Subset XOR Totals.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int subsetXORSum(int[] nums) {
+        return recurse(nums, 0, 0);
+    }
+
+    private int recurse(int[] nums, int idx, int currXor) {
+        if (idx == nums.length) {
+            return currXor;
+        }
+        int performXor = recurse(nums, idx + 1, currXor ^ nums[idx]);
+        int notPerformXor = recurse(nums, idx + 1, currXor);
+        return performXor + notPerformXor;
+    }
+}
diff --git a/Easy/Sum of Digits of String After Convert.java b/Easy/Sum of Digits of String After Convert.java
index c86c724c..3b78aaae 100644
--- a/Easy/Sum of Digits of String After Convert.java	
+++ b/Easy/Sum of Digits of String After Convert.java	
@@ -1,17 +1,18 @@
 class Solution {
-  public int getLucky(String s, int k) {
-    StringBuilder sb = new StringBuilder();
-    for (char c : s.toCharArray()) {
-      sb.append(c - 'a' + 1);
+    public int getLucky(String s, int k) {
+        StringBuilder sb = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            sb.append(c - 'a' + 1);
+        }
+        while (k-- > 0) {
+            String temp = sb.toString();
+            sb.setLength(0);
+            int val = 0;
+            for (char c : temp.toCharArray()) {
+                val += Character.getNumericValue(c);
+            }
+            sb.append(val);
+        }
+        return Integer.parseInt(sb.toString());
     }
-    String num = sb.toString();
-    while (k-- > 0) {
-      int sum = 0;
-      for (char c : num.toCharArray()) {
-        sum += Character.getNumericValue(c);
-      }
-      num = String.valueOf(sum);
-    }
-    return Integer.parseInt(num);
-  }
 }
diff --git a/Easy/Sum of Square Numbers.java b/Easy/Sum of Square Numbers.java
deleted file mode 100644
index 61e26dde..00000000
--- a/Easy/Sum of Square Numbers.java	
+++ /dev/null
@@ -1,17 +0,0 @@
-class Solution {
-  public boolean judgeSquareSum(int c) {
-    int left = 0;
-    int right = (int) Math.sqrt(c);
-    while (left <= right) {
-      int currSquareSum = left * left + right * right;
-      if (currSquareSum < c) {
-        left++;
-      } else if (currSquareSum > c) {
-        right--;
-      } else {
-        return true;
-      }
-    }
-    return false;
-  }
-}
diff --git a/Easy/Sum of Squares of Special Elements.java b/Easy/Sum of Squares of Special Elements.java
new file mode 100644
index 00000000..2072eee5
--- /dev/null
+++ b/Easy/Sum of Squares of Special Elements.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public int sumOfSquares(int[] nums) {
+        return IntStream.range(0, nums.length)
+                .filter(i -> nums.length % (i + 1) == 0)
+                .map(i -> nums[i] * nums[i])
+                .sum();
+    }
+}
diff --git a/Easy/Sum of Values at Indices With K Set Bits.java b/Easy/Sum of Values at Indices With K Set Bits.java
new file mode 100644
index 00000000..598f65c1
--- /dev/null
+++ b/Easy/Sum of Values at Indices With K Set Bits.java	
@@ -0,0 +1,8 @@
+class Solution {
+    public int sumIndicesWithKSetBits(List<Integer> nums, int k) {
+        return IntStream.range(0, nums.size())
+            .filter(idx -> Integer.bitCount(idx) == k)
+            .map(idx -> nums.get(idx))
+            .sum();
+    }
+}
diff --git a/Easy/Sum of Variable Length Subarrays.java b/Easy/Sum of Variable Length Subarrays.java
new file mode 100644
index 00000000..5dc7d585
--- /dev/null
+++ b/Easy/Sum of Variable Length Subarrays.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int subarraySum(int[] nums) {
+        int n = nums.length;
+        int[] prefixSum = new int[n];
+        int sum = 0;
+        int result = 0;
+        for (int i = 0; i < n; i++) {
+            sum += nums[i];
+            prefixSum[i] = sum;
+            int start = Math.max(0, i - nums[i]);
+            int subarraySum = prefixSum[i];
+            if (start > 0) {
+                subarraySum -= prefixSum[start - 1];
+            }
+            result += subarraySum;
+        }
+        return result;
+    }
+}
diff --git a/Easy/Summary Ranges.java b/Easy/Summary Ranges.java
index cf67a700..0de1dc7b 100644
--- a/Easy/Summary Ranges.java	
+++ b/Easy/Summary Ranges.java	
@@ -1,18 +1,16 @@
 class Solution {
-  public List<String> summaryRanges(int[] nums) {
-    List<String> result = new ArrayList<>();
-    int idx = 0;
-    int n = nums.length;
-    while (idx < n) {
-      int start = nums[idx];
-      int end = start;
-      idx++;
-      while (idx < n && nums[idx] == end + 1) {
-        end = nums[idx];
-        idx++;
-      }
-      result.add(start == end ? String.valueOf(start) : (start + "->" + end));
+    public List<String> summaryRanges(int[] nums) {
+        List<String> result = new ArrayList<>();
+        int idx = 0;
+        while (idx < nums.length) {
+            int startIdx = idx;
+            int endIdx = idx;
+            idx++;
+            while (idx < nums.length && nums[idx] - nums[idx - 1] == 1) {
+                endIdx = idx++;
+            }
+            result.add(startIdx == endIdx ? String.valueOf(nums[startIdx]) : nums[startIdx] + "->" + nums[endIdx]);
+        }
+        return result;
     }
-    return result;
-  }
 }
diff --git a/Easy/Symmetric Tree.java b/Easy/Symmetric Tree.java
index b20e39a5..929d6ade 100644
--- a/Easy/Symmetric Tree.java	
+++ b/Easy/Symmetric Tree.java	
@@ -12,19 +12,30 @@
  *         this.right = right;
  *     }
  * }
-*/
+ */
 class Solution {
-  public boolean isSymmetric(TreeNode root) {
-    return helper(root.left, root.right);
-  }
-  
-  private boolean helper(TreeNode leftNode, TreeNode rightNode) {
-    if (leftNode == null && rightNode == null) {
-      return true;
+    public boolean isSymmetric(TreeNode root) {
+        Queue<TreeNode[]> queue = new LinkedList<>();
+        queue.add(new TreeNode[]{root.left, root.right});
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                TreeNode[] removed = queue.remove();
+                TreeNode nodeOne = removed[0];
+                TreeNode nodeTwo = removed[1];
+                if (nodeOne == null && nodeTwo == null) {
+                    continue;
+                }
+                if (nodeOne == null || nodeTwo == null) {
+                    return false;
+                }
+                if (nodeOne.val != nodeTwo.val) {
+                    return false;
+                }
+                queue.add(new TreeNode[]{nodeOne.left, nodeTwo.right});
+                queue.add(new TreeNode[]{nodeOne.right, nodeTwo.left});
+            }
+        }
+        return true;
     }
-    if ((leftNode == null || rightNode == null) || leftNode.val != rightNode.val) {
-      return false;
-    }
-    return helper(leftNode.left, rightNode.right) && helper(leftNode.right, rightNode.left);
-  }
 }
diff --git a/Easy/Take Gifts From the Richest Pile.java b/Easy/Take Gifts From the Richest Pile.java
new file mode 100644
index 00000000..ea754818
--- /dev/null
+++ b/Easy/Take Gifts From the Richest Pile.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public long pickGifts(int[] gifts, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        long totalGifts = 0;
+        for (int gift : gifts) {
+            pq.add(gift);
+            totalGifts += gift;
+        }
+        while (k-- > 0) {
+            int removedGift = pq.poll();
+            int remainingGift = (int) Math.sqrt(removedGift);
+            totalGifts -= removedGift - remainingGift;
+            pq.add(remainingGift);
+        }
+        return totalGifts;
+    }
+}
diff --git a/Easy/The K Weakest Rows in a Matrix.java b/Easy/The K Weakest Rows in a Matrix.java
index 09e395be..a4a52ad7 100644
--- a/Easy/The K Weakest Rows in a Matrix.java	
+++ b/Easy/The K Weakest Rows in a Matrix.java	
@@ -1,28 +1,28 @@
 class Solution {
-  public int[] kWeakestRows(int[][] mat, int k) {
-    PriorityQueue<int[]> pq = new PriorityQueue<>(
-        Comparator.comparingInt((int[] o) -> o[1]).thenComparingInt(o -> o[0]));
-    for (int i = 0; i < mat.length; i++) {
-      pq.add(new int[]{i, getNumberOfOnes(mat[i])});
+    public int[] kWeakestRows(int[][] mat, int k) {
+        PriorityQueue<int[]> pq =
+                new PriorityQueue<>(Comparator.comparingInt((int[] o) -> o[1]).thenComparingInt(o -> o[0]));
+        for (int i = 0; i < mat.length; i++) {
+            pq.add(new int[]{i, findNumberOfSoldiers(mat[i])});
+        }
+        int[] result = new int[k];
+        for (int i = 0; i < k && !pq.isEmpty(); i++){
+            result[i] = pq.poll()[0];
+        }
+        return result;
     }
-    int[] result = new int[k];
-    for (int i = 0; i < result.length && !pq.isEmpty(); i++) {
-      result[i] = pq.poll()[0];
-    }
-    return result;
-  }
 
-  private int getNumberOfOnes(int[] arr) {
-    int start = 0;
-    int end = arr.length - 1;
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (arr[mid] == 0) {
-        end = mid - 1;
-      } else {
-        start = mid + 1;
-      }
+    private int findNumberOfSoldiers(int[] row) {
+        int left = 0;
+        int right = row.length - 1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (row[mid] == 0) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return right < 0 ? 0 : left;
     }
-    return end < 0 ? 0 : start;
-  }
 }
diff --git a/Easy/Total Distance Traveled.java b/Easy/Total Distance Traveled.java
new file mode 100644
index 00000000..e9697899
--- /dev/null
+++ b/Easy/Total Distance Traveled.java	
@@ -0,0 +1,5 @@
+class Solution {
+    public int distanceTraveled(int mainTank, int additionalTank) {
+        return (mainTank + Math.min((mainTank - 1) / 4, additionalTank)) * 10;
+    }
+}
diff --git a/Easy/Type of Triangle II.java b/Easy/Type of Triangle II.java
new file mode 100644
index 00000000..09f0cb88
--- /dev/null
+++ b/Easy/Type of Triangle II.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public String triangleType(int[] nums) {
+        Arrays.sort(nums);
+        if (nums[0] + nums[1] <= nums[2]) {
+            return "none";
+        }
+        if (nums[0] == nums[1] && nums[1] == nums[2]) {
+            return "equilateral";
+        }
+        if (nums[0] == nums[1] || nums[1] == nums[2] || nums[0] == nums[2]) {
+            return "isosceles";
+        }
+        return "scalene";
+    }
+}
diff --git a/Easy/Valid Word Square.java b/Easy/Valid Word Square.java
index 69e1925d..0226d4d5 100644
--- a/Easy/Valid Word Square.java	
+++ b/Easy/Valid Word Square.java	
@@ -1,16 +1,23 @@
 class Solution {
-  public boolean validWordSquare(List<String> words) {
-    return IntStream.range(0, words.size())
-        .allMatch(i -> words.get(i).equals(verticalRepresentation(words, i)));
-  }
-
-  private String verticalRepresentation(List<String> words, int col){
-    StringBuilder sb = new StringBuilder();
-    for (String word : words) {
-      if (col < word.length()) {
-        sb.append(word.charAt(col));
-      }
+    public boolean validWordSquare(List<String> words) {
+        int column = 0;
+        for (String rowWord : words) {
+            String columnWord = getColumnWord(words, column++);
+            if (!rowWord.equals(columnWord)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    private String getColumnWord(List<String> words, int column) {
+        StringBuilder sb = new StringBuilder();
+        for (String word : words) {
+            if (column >= word.length()) {
+                break;
+            }
+            sb.append(word.charAt(column));
+        }
+        return sb.toString();
     }
-    return sb.toString();
-  }
 }
diff --git a/Easy/Valid Word.java b/Easy/Valid Word.java
new file mode 100644
index 00000000..c9611bbd
--- /dev/null
+++ b/Easy/Valid Word.java	
@@ -0,0 +1,21 @@
+class Solution {
+
+    private static final Set<Character> VOWELS = Set.of('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U');
+
+    public boolean isValid(String word) {
+        boolean vowelFound = false;
+        boolean consonantFound = false;
+        for (char c : word.toCharArray()) {
+            if (Character.isLetter(c)) {
+                if (VOWELS.contains(c)) {
+                    vowelFound = true;
+                } else {
+                    consonantFound = true;
+                }
+            } else if (!Character.isDigit(c)) {
+                return false;
+            }
+        }
+        return word.length() >= 3 && vowelFound && consonantFound;
+    }
+}
diff --git a/Easy/Verifying an Alien Dictionary.java b/Easy/Verifying an Alien Dictionary.java
index e11a4728..08bf111e 100644
--- a/Easy/Verifying an Alien Dictionary.java	
+++ b/Easy/Verifying an Alien Dictionary.java	
@@ -1,27 +1,27 @@
 class Solution {
-  public boolean isAlienSorted(String[] words, String order) {
-    Map<Character, Integer> map = new HashMap<>();
-    int idx = 0;
-    for (char c : order.toCharArray()) {
-      map.put(c, idx++);
-    }
-    for (int i = 1; i < words.length; i++) {
-      if (!isSorted(words[i - 1], words[i], map)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  
-  private boolean isSorted(String wordOne, String wordTwo, Map<Character, Integer> map) {
-    for (int i = 0; i < Math.min(wordOne.length(), wordTwo.length()); i++) {
-      int diff = map.get(wordOne.charAt(i)) - map.get(wordTwo.charAt(i));
-      if (diff > 0) {
-        return false;
-      } else if (diff < 0) {
+    public boolean isAlienSorted(String[] words, String order) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (int i = 0; i < order.length(); i++) {
+            map.put(order.charAt(i), i);
+        }
+        for (int i = 0; i < words.length - 1; i++) {
+            if (!inOrder(words[i], words[i + 1], map)) {
+                return false;
+            }
+        }
         return true;
-      }
     }
-    return wordOne.length() <= wordTwo.length();
-  }
+    
+    private static boolean inOrder(String wordOne, String wordTwo, Map<Character, Integer> map) {
+        for (int i = 0; i < Math.min(wordOne.length(), wordTwo.length()); i++) {
+            int diff = map.get(wordOne.charAt(i)) - map.get(wordTwo.charAt(i));
+            if (diff < 0) {
+                return true;
+            }
+            if (diff > 0) {
+                return false;
+            }
+        }
+        return wordOne.length() <= wordTwo.length();
+    }
 }
diff --git a/Easy/Winner of the Linked List Game.java b/Easy/Winner of the Linked List Game.java
new file mode 100644
index 00000000..198fdd75
--- /dev/null
+++ b/Easy/Winner of the Linked List Game.java	
@@ -0,0 +1,23 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public String gameResult(ListNode head) {
+        ListNode curr = head;
+        int count = 0;
+        while (curr != null) {
+            int even = curr.val;
+            int odd = curr.next.val;
+            count += even == odd ? 0 : (even > odd ? 1 : -1);
+            curr = curr.next.next;
+        }
+        return count == 0 ? "Tie" : (count > 0 ? "Even" : "Odd");
+    }
+}
diff --git a/Easy/XOR Operation in an Array.java b/Easy/XOR Operation in an Array.java
new file mode 100644
index 00000000..17908959
--- /dev/null
+++ b/Easy/XOR Operation in an Array.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public int xorOperation(int n, int start) {
+        int xor = start;
+        for (int i = 1; i < n; i++) {
+            int nextNum = start + 2 * i;
+            xor = xor ^ nextNum;
+        }
+        return xor;
+    }
+}
diff --git a/Hard/Add Edges to Make Degrees of All Nodes Even.java b/Hard/Add Edges to Make Degrees of All Nodes Even.java
new file mode 100644
index 00000000..2258af63
--- /dev/null
+++ b/Hard/Add Edges to Make Degrees of All Nodes Even.java	
@@ -0,0 +1,48 @@
+class Solution {
+    public boolean isPossible(int n, List<List<Integer>> edges) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (List<Integer> edge : edges) {
+            graph.computeIfAbsent(edge.get(0), k -> new HashSet<>()).add(edge.get(1));
+            graph.computeIfAbsent(edge.get(1), k -> new HashSet<>()).add(edge.get(0));
+        }
+        List<Integer> nodeWithOddEdges = graph.entrySet()
+            .stream()
+            .filter(e -> e.getValue().size() % 2 != 0)
+            .map(Map.Entry::getKey)
+            .collect(Collectors.toList());
+        if (nodeWithOddEdges.size() == 0) {
+            return true;
+        }
+        if (nodeWithOddEdges.size() == 2) {
+            Integer nodeOne = nodeWithOddEdges.get(0);
+            Integer nodeTwo = nodeWithOddEdges.get(1);
+            if (!hasEdge(graph, nodeOne, nodeTwo)) {
+                return true;
+            }
+            for (int i = 1; i <= n; i++) {
+                if (i == nodeOne || i == nodeTwo) {
+                    continue;
+                }
+                if (!hasEdge(graph, i, nodeOne) && !hasEdge(graph, i, nodeTwo)) {
+                    return true;
+                }
+            }
+        }
+        if (nodeWithOddEdges.size() == 4) {
+            Integer nodeOne = nodeWithOddEdges.get(0);
+            Integer nodeTwo = nodeWithOddEdges.get(1);
+            Integer nodeThree = nodeWithOddEdges.get(2);
+            Integer nodeFour = nodeWithOddEdges.get(3);
+            if ((!hasEdge(graph, nodeOne, nodeTwo) && !hasEdge(graph, nodeThree, nodeFour)) || 
+                (!hasEdge(graph, nodeOne, nodeThree) && !hasEdge(graph, nodeTwo, nodeFour)) || 
+                (!hasEdge(graph, nodeOne, nodeFour) && !hasEdge(graph, nodeTwo, nodeThree))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    private static boolean hasEdge(Map<Integer, Set<Integer>> graph, int nodeOne, int nodeTwo) {
+        return graph.getOrDefault(nodeOne, new HashSet<>()).contains(nodeTwo);
+    }
+}
diff --git a/Hard/Alien Dictionary.java b/Hard/Alien Dictionary.java
new file mode 100644
index 00000000..939de634
--- /dev/null
+++ b/Hard/Alien Dictionary.java	
@@ -0,0 +1,48 @@
+class Solution {
+    public String alienOrder(String[] words) {
+        Map<Character, Set<Character>> graph = new HashMap<>();
+        for (String word : words) {
+            for (char c : word.toCharArray()) {
+                graph.computeIfAbsent(c, k -> new HashSet<>());
+            }
+        }
+        for (int i = 0; i < words.length - 1; i++) {
+            String word1 = words[i];
+            String word2 = words[i + 1];
+            int minLength = Math.min(word1.length(), word2.length());
+            if (word1.length() > word2.length() && word1.startsWith(word2)) {
+                return "";
+            }
+            for (int j = 0; j < minLength; j++) {
+                if (word1.charAt(j) != word2.charAt(j)) {
+                    graph.get(word1.charAt(j)).add(word2.charAt(j));
+                    break;
+                }
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        Map<Character, Boolean> visited = new HashMap<>();
+        for (Character c : graph.keySet()) {
+            if (dfs(c, graph, sb, visited)) {
+                return "";
+            }
+        }
+        return sb.reverse().toString();
+    }
+
+    private boolean dfs(Character c, Map<Character, Set<Character>> graph, 
+                        StringBuilder sb, Map<Character, Boolean> visited) {
+        if (visited.containsKey(c)) {
+            return visited.get(c);
+        }
+        visited.put(c, true);
+        for (Character neighbor : graph.getOrDefault(c, new HashSet<>())) {
+            if (dfs(neighbor, graph, sb, visited)) {
+                return true;
+            }
+        }
+        visited.put(c, false);
+        sb.append(c);
+        return false;
+    }
+}
diff --git a/Hard/All O`one Data Structure.java b/Hard/All O`one Data Structure.java
new file mode 100644
index 00000000..211e4f01
--- /dev/null
+++ b/Hard/All O`one Data Structure.java	
@@ -0,0 +1,108 @@
+class AllOne {
+    private final NodeList head;
+    private final NodeList tail;
+    private final Map<Integer, NodeList> countToNodeMapping;
+    private final Map<String, Integer> keyToCountMapping;
+
+    public AllOne() {
+        head = new NodeList(Integer.MIN_VALUE);
+        tail = new NodeList(Integer.MAX_VALUE);
+        head.next = tail;
+        tail.prev = head;
+        countToNodeMapping = new HashMap<>();
+        keyToCountMapping = new HashMap<>();
+    }
+
+    public void inc(String key) {
+        if (keyToCountMapping.containsKey(key)) {
+            updateKey(key, 1);
+        } else {
+            keyToCountMapping.put(key, 1);
+            if (head.next.count != 1) {
+                addNodeAfter(new NodeList(1), head);
+            }
+            head.next.keys.add(key);
+            countToNodeMapping.put(1, head.next);
+        }
+    }
+
+    public void dec(String key) {
+        if (keyToCountMapping.containsKey(key)) {
+            int count = keyToCountMapping.get(key);
+            if (count == 1) {
+                keyToCountMapping.remove(key);
+                removeKey(countToNodeMapping.get(count), key);
+            } else {
+                updateKey(key, -1);
+            }
+        }
+    }
+
+    public String getMaxKey() {
+        return tail.prev == head ? "" : tail.prev.keys.iterator().next();
+    }
+
+    public String getMinKey() {
+        return head.next == tail ? "" : head.next.keys.iterator().next();
+    }
+
+    private void updateKey(String key, int diff) {
+        int count = keyToCountMapping.get(key);
+        keyToCountMapping.put(key, count + diff);
+        NodeList currNode = countToNodeMapping.get(count);
+        NodeList newNode;
+        if (countToNodeMapping.containsKey(count + diff)) {
+            newNode = countToNodeMapping.get(count + diff);
+        } else {
+            newNode = new NodeList(count + diff);
+            countToNodeMapping.put(count + diff, newNode);
+            // If diff == 1 then new node will have count greater than currNode else it will have count less than currNode
+            addNodeAfter(newNode, diff == 1 ? currNode : currNode.prev);
+        }
+        newNode.keys.add(key);
+        removeKey(currNode, key);
+    }
+
+    private void removeKey(NodeList nodeList, String key) {
+        nodeList.keys.remove(key);
+        if (nodeList.keys.isEmpty()) {
+            removeNodeList(nodeList);
+            countToNodeMapping.remove(nodeList.count);
+        }
+    }
+
+    private void removeNodeList(NodeList nodeList) {
+        nodeList.prev.next = nodeList.next;
+        nodeList.next.prev = nodeList.prev;
+        nodeList.next = null;
+        nodeList.prev = null;
+    }
+
+    private void addNodeAfter(NodeList node, NodeList prevNode) {
+        node.prev = prevNode;
+        node.next = prevNode.next;
+        prevNode.next.prev = node;
+        prevNode.next = node;
+    }
+
+    private static class NodeList {
+        int count;
+        Set<String> keys;
+        NodeList next;
+        NodeList prev;
+
+        public NodeList(int count) {
+            this.count = count;
+            keys = new HashSet<>();
+        }
+    }
+}
+
+/**
+ * Your AllOne object will be instantiated and called as such:
+ * AllOne obj = new AllOne();
+ * obj.inc(key);
+ * obj.dec(key);
+ * String param_3 = obj.getMaxKey();
+ * String param_4 = obj.getMinKey();
+ */
diff --git a/Hard/Arithmetic Slices II - Subsequence.java b/Hard/Arithmetic Slices II - Subsequence.java
new file mode 100644
index 00000000..f193579f
--- /dev/null
+++ b/Hard/Arithmetic Slices II - Subsequence.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int numberOfArithmeticSlices(int[] nums) {
+        int n = nums.length;
+        Map<Integer, Integer>[] count = new Map[n];
+        int result = 0;
+        for (int i = 0; i < n; i++) {
+            count[i] = new HashMap<>();
+            for (int j = 0; j < i; j++) {
+                long delta = ((long) nums[i]) - ((long) nums[j]);
+                if (delta < Integer.MIN_VALUE || delta > Integer.MAX_VALUE) {
+                    continue;
+                }
+                int diff = (int) delta;
+                int sum = count[j].getOrDefault(diff, 0);
+                int current = count[i].getOrDefault(diff, 0);
+                count[i].put(diff, current + sum + 1);
+                result += sum;
+            }
+        }
+        return result;
+    }
+}
diff --git a/Hard/Build Array Where You Can Find The Maximum Exactly K Comparisons.java b/Hard/Build Array Where You Can Find The Maximum Exactly K Comparisons.java
new file mode 100644
index 00000000..c7ede11f
--- /dev/null
+++ b/Hard/Build Array Where You Can Find The Maximum Exactly K Comparisons.java	
@@ -0,0 +1,28 @@
+class Solution {
+    
+    private static final int MOD = (int) 1000_000_007;
+
+    public int numOfArrays(int n, int m, int k) {
+        int[][][] dp = new int[n + 1][m + 1][k + 1];
+        for (int i = 0; i < dp[0].length; i++) {
+            dp[n][i][0] = 1;
+        }
+        for (int i = n - 1; i >= 0; i--) {
+            for (int j = m; j >= 0; j--) {
+                for (int l = 0; l <= k; l++) {
+                    int result = 0;
+                    for (int num = 1; num <= j; num++) {
+                        result = (result + dp[i + 1][j][l]) % MOD;
+                    }
+                    if (l > 0) {
+                        for (int num = j + 1; num <= m; num++) {
+                            result = (result + dp[i + 1][num][l - 1]) % MOD;
+                        }
+                    }
+                    dp[i][j][l] = result;
+                }
+            }
+        }
+        return dp[0][0][k];
+    }
+}
diff --git a/Hard/Bus Routes.java b/Hard/Bus Routes.java
new file mode 100644
index 00000000..54c2762a
--- /dev/null
+++ b/Hard/Bus Routes.java	
@@ -0,0 +1,39 @@
+class Solution {
+    public int numBusesToDestination(int[][] routes, int source, int target) {
+        if (source == target) {
+            return 0;
+        }
+        Map<Integer, Set<Integer>> stopToBusMapping = new HashMap<>();
+        for (int i = 0; i < routes.length; i++) {
+            for (int stop : routes[i]) {
+                stopToBusMapping.computeIfAbsent(stop, k -> new HashSet<>()).add(i);
+            }
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        Set<Integer> visited = new HashSet<>();
+        for (int route : stopToBusMapping.get(source)) {
+            queue.add(route);
+            visited.add(route);
+        }
+        int buses = 1;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int removed = queue.remove();
+                for (int stop : routes[removed]) {
+                    if (stop == target) {
+                        return buses;
+                    }
+                    for (int nextBus : stopToBusMapping.getOrDefault(stop, new HashSet<>())) {
+                        if (!visited.contains(nextBus)) {
+                            visited.add(nextBus);
+                            queue.add(nextBus);
+                        }
+                    }
+                }
+            }
+            buses++;
+        }
+        return -1;
+    }
+}
diff --git a/Hard/Candy.java b/Hard/Candy.java
index 5bf67db1..269d4d6a 100644
--- a/Hard/Candy.java
+++ b/Hard/Candy.java
@@ -1,19 +1,22 @@
 class Solution {
-  public int candy(int[] ratings) {
-    int[] candies = new int[ratings.length];
-    Arrays.fill(candies, 1);
-    for (int i = 1; i < ratings.length; i++) {
-      if (ratings[i] > ratings[i - 1]) {
-        candies[i] = candies[i - 1] + 1;
-      }
+    public int candy(int[] ratings) {
+        int n = ratings.length;
+        int[] candies = new int[n];
+        Arrays.fill(candies, 1);
+        for (int i = 1; i < n; i++) {
+            if (ratings[i] > ratings[i - 1]) {
+                candies[i] = candies[i - 1] + 1;
+            }
+        }
+        for (int i = n - 2; i >= 0; i--) {
+            if (ratings[i] > ratings[i + 1]) {
+                candies[i] = Math.max(candies[i], candies[i + 1] + 1);
+            }
+        }
+        int totalCandies = 0;
+        for (int i = 0; i < n; i++) {
+            totalCandies += candies[i];
+        }
+        return totalCandies;
     }
-    int totalCandies = candies[candies.length - 1];
-    for (int i = ratings.length - 2; i >= 0; i--) {
-      if (ratings[i] > ratings[i + 1]) {
-        candies[i] = Math.max(candies[i], candies[i + 1] + 1);
-      }
-      totalCandies += candies[i];
-    }
-    return totalCandies;
-  }
 }
diff --git a/Hard/Checking Existence of Edge Length Limited Paths.java b/Hard/Checking Existence of Edge Length Limited Paths.java
new file mode 100644
index 00000000..d03848ef
--- /dev/null
+++ b/Hard/Checking Existence of Edge Length Limited Paths.java	
@@ -0,0 +1,41 @@
+class Solution {
+    public boolean[] distanceLimitedPathsExist(int n, int[][] edgeList, int[][] queries) {
+        UnionFind unionFind = new UnionFind(n);
+        for (int i = 0; i < queries.length; i++) {
+            queries[i] = new int[]{queries[i][0], queries[i][1], queries[i][2], i};
+        }
+        Arrays.sort(queries, Comparator.comparingInt(a -> a[2]));
+        Arrays.sort(edgeList, Comparator.comparingInt(a -> a[2]));
+        boolean[] result = new boolean[queries.length];
+        for (int i = 0, j = 0; i < queries.length; i++) {
+            int[] query = queries[i];
+            while (j < edgeList.length && edgeList[j][2] < query[2]) {
+                unionFind.union(edgeList[j][0], edgeList[j++][1]);
+            }
+            result[query[3]] = unionFind.find(query[0]) == unionFind.find(query[1]);
+        }
+        return result;
+    }
+    
+    private static class UnionFind {
+        private final int[] parent;
+        
+        public UnionFind(int n) {
+            this.parent = new int[n];
+            for (int i = 0; i < n; i++) {
+                parent[i] = i;
+            }
+        }
+        
+        public int find(int node) {
+            if (parent[node] != node) {
+                parent[node] = find(parent[node]);
+            }
+            return parent[node];
+        }
+        
+        public void union(int x, int y) {
+            parent[find(x)] = parent[find(y)];
+        }
+    }
+}
diff --git a/Hard/Cherry Pickup II.java b/Hard/Cherry Pickup II.java
new file mode 100644
index 00000000..1786e8cc
--- /dev/null
+++ b/Hard/Cherry Pickup II.java	
@@ -0,0 +1,32 @@
+class Solution {
+    public int cherryPickup(int[][] grid) {
+        int m = grid.length;
+        int n = grid[0].length;
+        Integer[][][] cache = new Integer[m][n][n];
+        return recurse(0, 0, n - 1, grid, cache);
+    }
+
+    private int recurse(int row, int colOne, int colTwo, int[][] grid, Integer[][][] cache) {
+        if (colOne < 0 || colOne >= grid[0].length || colTwo < 0 || colTwo >= grid[0].length) {
+            return 0;
+        }
+        if (cache[row][colOne][colTwo] != null) {
+            return cache[row][colOne][colTwo];
+        }
+        int result = 0;
+        result += grid[row][colOne];
+        if (colOne != colTwo) {
+            result += grid[row][colTwo];
+        }
+        if (row != grid.length - 1) {
+            int max = 0;
+            for (int c1 = colOne - 1; c1 <= colOne + 1; c1++) {
+                for (int c2 = colTwo - 1; c2 <= colTwo + 1; c2++) {
+                    max = Math.max(max, recurse(row + 1, c1, c2, grid, cache));
+                } 
+            }
+            result += max;
+        }
+        return cache[row][colOne][colTwo] = result;
+    }
+}
diff --git a/Hard/Constrained Subsequence Sum.java b/Hard/Constrained Subsequence Sum.java
new file mode 100644
index 00000000..9dabd1d4
--- /dev/null
+++ b/Hard/Constrained Subsequence Sum.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int constrainedSubsetSum(int[] nums, int k) {
+        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> b[0] - a[0]);
+        pq.add(new int[]{nums[0], 0});
+        int result = nums[0];
+        for (int i = 1; i < nums.length; i++) {
+            while (i - pq.peek()[1] > k) {
+                pq.remove();
+            }
+            int curr = Math.max(0, pq.peek()[0]) + nums[i];
+            result = Math.max(result, curr);
+            pq.add(new int[]{curr, i});
+        }
+        return result;
+    }
+}
diff --git a/Hard/Count Subarrays With Fixed Bounds.java b/Hard/Count Subarrays With Fixed Bounds.java
new file mode 100644
index 00000000..2846d647
--- /dev/null
+++ b/Hard/Count Subarrays With Fixed Bounds.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public long countSubarrays(int[] nums, int minK, int maxK) {
+        long result = 0;
+        int minPosition = -1;
+        int maxPosition = -1;
+        int leftIdx = -1;
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] < minK || nums[i] > maxK) {
+                leftIdx = i;
+            }
+            if (nums[i] == minK) {
+                minPosition = i;
+            }
+            if (nums[i] == maxK) {
+                maxPosition = i;
+            }
+            result += Math.max(0, Math.min(maxPosition, minPosition) - leftIdx);
+        }
+        return result;
+    }
+}
diff --git a/Hard/Design Graph With Shortest Path Calculator.java b/Hard/Design Graph With Shortest Path Calculator.java
new file mode 100644
index 00000000..0b7fddf1
--- /dev/null
+++ b/Hard/Design Graph With Shortest Path Calculator.java	
@@ -0,0 +1,43 @@
+class Graph {
+
+    private final Map<Integer, List<Connection>> graph;
+
+    public Graph(int n, int[][] edges) {
+        this.graph = new HashMap<>();
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], edge[2]));
+        }
+    }
+
+    public void addEdge(int[] edge) {
+        graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], edge[2]));
+    }
+
+    public int shortestPath(int node1, int node2) {
+        PriorityQueue<int[]> queue = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
+        queue.add(new int[]{node1, 0});
+        Set<Integer> seen = new HashSet<>();
+        while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            int node = removed[0];
+            if (node == node2) {
+                return removed[1];
+            }
+            if (graph.containsKey(node) && seen.add(node)) {
+                for (Connection connection : graph.getOrDefault(removed[0], new ArrayList<>())) {
+                    queue.add(new int[]{connection.node, removed[1] + connection.cost});
+                }
+            }
+        }
+        return -1;
+    }
+
+    private record Connection(int node, int cost) { }
+}
+
+/**
+ * Your Graph object will be instantiated and called as such:
+ * Graph obj = new Graph(n, edges);
+ * obj.addEdge(edge);
+ * int param_2 = obj.shortestPath(node1,node2);
+ */
diff --git a/Hard/Design In-Memory File System.java b/Hard/Design In-Memory File System.java
index 9bc2ba8e..9002c758 100644
--- a/Hard/Design In-Memory File System.java	
+++ b/Hard/Design In-Memory File System.java	
@@ -1,104 +1,148 @@
+import java.util.Optional;
+
 class FileSystem {
 
-  private final FileNode root;
-
-  public FileSystem() {
-    this.root = new FileNode("ROOT", FileType.FOLDER);
-  }
-
-  /*
-   * If path is a file path, returns a list that only contains this file's name.
-   * If path is a directory path, returns the list of file and directory names in this directory.
-   * */
-  public List<String> ls(String path) {
-    String[] split = path.split("/");
-    FileNode currNode = root;
-    for (int i = 1; i < split.length; i++) {
-      currNode = currNode.subFiles.get(split[i]);
+    private final Node root;
+
+    public FileSystem() {
+        this.root = new DirectoryNode("/");
     }
-    if (currNode.fileType.equals(FileType.FILE)) {
-      return List.of(currNode.value);
-    } else {
-      return currNode.subFiles.keySet().stream().sorted().collect(Collectors.toList());
+
+    public List<String> ls(String path) {
+        String[] splits = path.split("/");
+        if (splits.length == 0) {
+            return buildlsResult((DirectoryNode) root);
+        }
+        Node curr = root;
+        for (int i = 1; i < splits.length - 1; i++) {
+            curr = ((DirectoryNode) curr).getNode(splits[i]).get();
+        }
+        Node lastNode = ((DirectoryNode) curr).getNode(splits[splits.length - 1]).get();
+        if (lastNode.isFile()) {
+            return Collections.singletonList(lastNode.getName());
+        }
+        return buildlsResult((DirectoryNode) lastNode);
     }
-  }
-
-  /*
-   * Makes a new directory according to the given path. The given directory path does not exist.
-   * If the middle directories in the path do not exist, you should create them as well.
-   * */
-  public void mkdir(String path) {
-    String[] splits = path.split("/");
-    FileNode currNode = root;
-    for (int i = 1; i < splits.length; i++) {
-      String fileName = splits[i];
-      if (!currNode.subFiles.containsKey(fileName)) {
-        currNode.subFiles.put(fileName, new FileNode(fileName, FileType.FOLDER));
-      }
-      currNode = currNode.subFiles.get(fileName);
+
+    public void mkdir(String path) {
+        String[] splits = path.split("/");
+        createIfNotExists(splits);
     }
-  }
-
-  /*
-   * If filePath does not exist, creates that file containing given content.
-   * If filePath already exists, appends the given content to original content.
-   * */
-  public void addContentToFile(String filePath, String content) {
-    String[] splits = filePath.split("/");
-    FileNode currNode = root;
-    for (int i = 1; i < splits.length - 1; i++) {
-      String folderName = splits[i];
-      if (!currNode.subFiles.containsKey(folderName)) {
-        currNode.subFiles.put(folderName, new FileNode(folderName, FileType.FOLDER));
-      }
-      currNode = currNode.subFiles.get(folderName);
+
+    public void addContentToFile(String filePath, String content) {
+        String[] splits = filePath.split("/");
+        DirectoryNode directoryNode = createIfNotExists(Arrays.copyOfRange(splits, 0, splits.length));
+        String fileName = splits[splits.length - 1];
+        if (directoryNode.getNode(fileName).isEmpty()) {
+            FileNode fileNode = new FileNode(fileName);
+            directoryNode.addContent(fileName, fileNode);
+        }
+        FileNode fileNode = (FileNode) directoryNode.getNode(fileName).get();
+        fileNode.addContent(content);
     }
-    String fileName = splits[splits.length - 1];
-    if (!currNode.subFiles.containsKey(fileName) ||
-        !currNode.subFiles.get(fileName).fileType.equals(FileType.FILE)) {
-      currNode.subFiles.put(fileName, new FileNode(fileName, FileType.FILE));
+
+    public String readContentFromFile(String filePath) {
+        String[] splits = filePath.split("/");
+        DirectoryNode directoryNode = createIfNotExists(Arrays.copyOfRange(splits, 0, splits.length));
+        String fileName = splits[splits.length - 1];
+        FileNode fileNode = (FileNode) directoryNode.getNode(fileName).get();
+        return fileNode.getContents();
     }
-    currNode = currNode.subFiles.get(fileName);
-    currNode.addContentToFile(content);
-  }
-
-  /*
-   * Returns the content in the file at filePath.
-   * */
-  public String readContentFromFile(String filePath) {
-    String[] splits = filePath.split("/");
-    FileNode currNode = root;
-    for (int i = 1; i < splits.length; i++) {
-      String folderName = splits[i];
-      currNode = currNode.subFiles.get(folderName);
+
+    private static List<String> buildlsResult(DirectoryNode curr) {
+        return curr
+                .getContents()
+                .stream()
+                .map(Node::getName)
+                .sorted()
+                .collect(Collectors.toList());
     }
-    return currNode.fileContent.toString();
-  }
 
-  enum FileType {
-    FILE, FOLDER
-  }
+    private DirectoryNode createIfNotExists(String[] splits) {
+        DirectoryNode curr = (DirectoryNode) root;
+        for (int i = 1; i < splits.length; i++) {
+            Optional<Node> nextDirectory = curr.getNode(splits[i]);
+            if (nextDirectory.isEmpty()) {
+                DirectoryNode node = new DirectoryNode(splits[i]);
+                curr.addContent(splits[i], node);
+                curr = node;
+            } else {
+                curr = (DirectoryNode) nextDirectory.get();
+            }
+        }
+        return curr;
+    }
+
+    private static class FileNode implements Node {
+
+        private final String name;
+
+        private final StringBuilder contents;
+
+        public FileNode(String name) {
+            this.name = name;
+            this.contents = new StringBuilder();
+        }
+
+        public void addContent(String content) {
+            this.contents.append(content);
+        }
 
-  static class FileNode {
+        public String getContents() {
+            return contents.toString();
+        }
 
-    private final String value;
-    private final Map<String, FileNode> subFiles;
-    private final FileType fileType;
-    private StringBuilder fileContent;
+        @Override
+        public String getName() {
+            return this.name;
+        }
 
-    public FileNode(String value, FileType fileType) {
-      this.value = value;
-      this.fileType = fileType;
-      this.subFiles = new HashMap<>();
+        @Override
+        public boolean isFile() {
+            return true;
+        }
     }
 
-    public void addContentToFile(String content) {
-      if (fileContent == null) {
-        fileContent = new StringBuilder();
-      }
-      fileContent.append(content);
+    private static class DirectoryNode implements Node {
+
+        private String name;
+
+        private final Map<String, Node> contents;
+
+        public DirectoryNode(String name) {
+            this.name = name;
+            this.contents = new HashMap<>();
+        }
+
+        @Override
+        public String getName() {
+            return name;
+        }
+
+        @Override
+        public boolean isFile() {
+            return false;
+        }
+
+        public void addContent(String key, Node node) {
+            contents.put(key, node);
+        }
+
+        public List<Node> getContents() {
+            return contents.values().stream().toList();
+        }
+
+        public Optional<Node> getNode(String nodeName) {
+            return Optional.ofNullable(contents.getOrDefault(nodeName, null));
+        }
+    }
+
+    private interface Node {
+
+        String getName();
+
+        boolean isFile();
     }
-  }
 }
 
 /**
diff --git a/Hard/Edit Distance.java b/Hard/Edit Distance.java
index c4000645..b7ae5930 100644
--- a/Hard/Edit Distance.java	
+++ b/Hard/Edit Distance.java	
@@ -1,26 +1,34 @@
 class Solution {
-  public int minDistance(String word1, String word2) {
-    int n = word1.length();
-    int m = word2.length();
-    if (n * m == 0) {
-      return n + m;
+   public int minDistance(String word1, String word2) {
+        return minDistanceHelper(
+                word1, 
+                word2, 
+                word1.length(), 
+                word2.length(), 
+                new Integer[word1.length() + 1][word2.length() + 1]);
     }
-    int[][] dp = new int[n + 1][m + 1];
-    for (int i = 0; i <= n; i++) {
-      dp[i][0] = i;
-    }
-    for (int j = 0; j <= m; j++) {
-      dp[0][j] = j;
-    }
-    for (int i = 1; i <= n; i++) {
-      for (int j = 1; j <= m; j++) {
-        if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
-          dp[i][j] = dp[i - 1][j - 1];
+
+    private int minDistanceHelper(String word1, String word2, int word1Index, int word2Index, Integer[][] memo) {
+        if (word1Index == 0) {
+            return word2Index;
+        }
+        if (word2Index == 0) {
+            return word1Index;
+        }
+        if (memo[word1Index][word2Index] != null) {
+            return memo[word1Index][word2Index];
+        }
+        int minEditDistance = 0;
+        if (word1.charAt(word1Index - 1) == word2.charAt(word2Index - 1)) {
+            minEditDistance = minDistanceHelper(word1, word2, word1Index - 1, word2Index - 1, memo);
         } else {
-          dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i - 1][j], dp[i][j - 1])) + 1;
+            int distanceWithInsertion = minDistanceHelper(word1, word2, word1Index, word2Index - 1, memo);
+            int distanceWithDeletion = minDistanceHelper(word1, word2, word1Index - 1, word2Index, memo);
+            int distanceWithReplace = minDistanceHelper(word1, word2, word1Index - 1, word2Index - 1, memo);
+            minEditDistance = Math.min(distanceWithInsertion, 
+                    Math.min(distanceWithDeletion, distanceWithReplace)) + 1;
         }
-      }
+        memo[word1Index][word2Index] = minEditDistance;
+        return minEditDistance;
     }
-    return dp[n][m];
-  }
 }
diff --git a/Hard/Find All People With Secret.java b/Hard/Find All People With Secret.java
new file mode 100644
index 00000000..b18f289a
--- /dev/null
+++ b/Hard/Find All People With Secret.java	
@@ -0,0 +1,39 @@
+class Solution {
+    public List<Integer> findAllPeople(int n, int[][] meetings, int firstPerson) {
+        Map<Integer, List<int[]>> graph = new HashMap<>();
+        for (int[] meeting : meetings) {
+            int x = meeting[0];
+            int y = meeting[1];
+            int time = meeting[2];
+            graph.computeIfAbsent(x, k -> new ArrayList<>()).add(new int[]{time, y});
+            graph.computeIfAbsent(y, k -> new ArrayList<>()).add(new int[]{time, x});
+        }
+        int[] earliestTime = new int[n];
+        Arrays.fill(earliestTime, Integer.MAX_VALUE);
+        earliestTime[0] = 0;
+        earliestTime[firstPerson] = 0;
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{0, 0}); 
+        queue.add(new int[]{firstPerson, 0}); 
+        while (!queue.isEmpty()) {
+            int[] removed = queue.poll();
+            int person = removed[0];
+            int time = removed[1];
+            for (int[] conn : graph.getOrDefault(person, new ArrayList<>())) {
+                int t = conn[0];
+                int p = conn[1];
+                if (t >= time && earliestTime[p] > t) {
+                    earliestTime[p] = t;
+                    queue.add(new int[]{p, t});
+                }
+            }
+        }
+        List<Integer> result = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (earliestTime[i] != Integer.MAX_VALUE) {
+                result.add(i);
+            }
+        }
+        return result;
+    }
+}
diff --git a/Hard/Find K-th Smallest Pair Distance.java b/Hard/Find K-th Smallest Pair Distance.java
new file mode 100644
index 00000000..6d84cfa8
--- /dev/null
+++ b/Hard/Find K-th Smallest Pair Distance.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public int smallestDistancePair(int[] nums, int k) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        int left = 0;
+        int right = nums[n - 1] - nums[0];
+        while (left < right) {
+            int mid = (left + right) / 2;
+            int count = countPairs(nums, mid);
+            if (count < k) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return left;
+    }
+
+    private int countPairs(int[] nums, int distance) {
+        int count = 0;
+        int n = nums.length;
+        int left = 0;
+        for (int i = 0; i < n; i++) {
+            while (nums[i] - nums[left] > distance) {
+                left++;
+            }
+            count += i - left;
+        }
+        return count;
+    }
+}
diff --git a/Hard/Find in Mountain Array.java b/Hard/Find in Mountain Array.java
new file mode 100644
index 00000000..d030c247
--- /dev/null
+++ b/Hard/Find in Mountain Array.java	
@@ -0,0 +1,49 @@
+/**
+ * // This is MountainArray's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * interface MountainArray {
+ *     public int get(int index) {}
+ *     public int length() {}
+ * }
+ */
+ 
+class Solution {
+    public int findInMountainArray(int target, MountainArray mountainArr) {
+        int n = mountainArr.length();
+        int start = 1;
+        int end = n - 2;
+        while (start != end) {
+            int mid = (start + end) / 2;
+            if (mountainArr.get(mid) < mountainArr.get(mid + 1)) {
+                start = mid + 1;
+            } else {
+                end = mid;
+            }
+        }
+        int peakIndex = start;
+        start = 0;
+        end = peakIndex;
+        while (start != end) {
+            int mid = (start + end) / 2;
+            if (mountainArr.get(mid) < target) {
+                start = mid + 1;
+            } else {
+                end = mid;
+            }
+        }
+        if (mountainArr.get(start) == target) {
+            return start;
+        }
+        start = peakIndex + 1;
+        end = n - 1;
+        while (start != end) {
+            int mid = (start + end) / 2;
+            if (mountainArr.get(mid) > target) {
+                start = mid + 1;
+            } else {
+                end = mid;
+            }
+        }
+        return mountainArr.get(start) == target ? start : -1;
+    }
+}
diff --git a/Hard/Find the Longest Valid Obstacle Course at Each Position.java b/Hard/Find the Longest Valid Obstacle Course at Each Position.java
new file mode 100644
index 00000000..fcd272fb
--- /dev/null
+++ b/Hard/Find the Longest Valid Obstacle Course at Each Position.java	
@@ -0,0 +1,34 @@
+class Solution {
+    public int[] longestObstacleCourseAtEachPosition(int[] obstacles) {
+        int n = obstacles.length;
+        int lisLength = 0;
+        int[] result = new int[n];
+        int[] lis = new int[n];
+        for (int i = 0; i < n; i++) {
+            int height = obstacles[i];
+            int idx = bisect(lis, height, lisLength);
+            if (idx == lisLength) {
+                lisLength++;
+            }
+            lis[idx] = height;
+            result[i] = idx + 1;
+        }
+        return result;
+    }
+    
+    private int bisect(int[] lis, int target, int right) {
+        if (right == 0) {
+            return 0;
+        }
+        int left = 0;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            if (lis[mid] <= target) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return left;
+    }
+}
diff --git a/Hard/First Missing Positive.java b/Hard/First Missing Positive.java
index 91b5b6fd..3b501319 100644
--- a/Hard/First Missing Positive.java	
+++ b/Hard/First Missing Positive.java	
@@ -1,28 +1,27 @@
 class Solution {
-  public int firstMissingPositive(int[] nums) {
-    int n = nums.length;
-    int idx = 0;
-    while (idx < n) {
-      if (nums[idx] > 0 && nums[idx] < n && nums[nums[idx]] != nums[idx]) {
-        swap(nums, idx, nums[idx]);
-      }
-      else {
-        idx++;
-      }
+    public int firstMissingPositive(int[] nums) {
+        int n = nums.length;
+        for (int i = 0; i < n; i++) {
+            if (nums[i] < 0) {
+                nums[i] = 0;
+            }
+        } 
+        for (int i = 0; i < n; i++) {
+            int val = Math.abs(nums[i]);
+            if (val >= 1 && val <= n) {
+                int idx = val - 1;
+                if (nums[idx] > 0) {
+                    nums[idx] *= -1;
+                } else if (nums[idx] == 0) {
+                    nums[idx] = -1 * (n + 1);
+                }
+            }
+        }
+        for (int i = 1; i <= n; i++) {
+            if (nums[i - 1] >= 0) {
+                return i;
+            }
+        }  
+        return n + 1; 
     }
-    idx = 1;
-    while (idx < n && nums[idx] == idx) {
-      idx++;
-    }
-    if (n == 0 || idx < n) {
-      return idx;
-    }
-    return nums[0] == idx ? idx + 1 : idx;
-  }
-  
-  private void swap(int[] nums, int i, int j) {
-    int temp = nums[i];
-    nums[i] = nums[j];
-    nums[j] = temp;
-  }
 }
diff --git a/Hard/Greatest Common Divisor Traversal.java b/Hard/Greatest Common Divisor Traversal.java
new file mode 100644
index 00000000..81ab07de
--- /dev/null
+++ b/Hard/Greatest Common Divisor Traversal.java	
@@ -0,0 +1,80 @@
+class Solution {
+
+    private static final int MAX = 100_000;
+
+    public boolean canTraverseAllPairs(int[] nums) {
+        int n = nums.length;
+        if (n == 1) {
+            return true;
+        }
+        boolean[] exists = new boolean[MAX + 1];
+        for (int num : nums) {
+            exists[num] = true;
+        }
+        if (exists[1]) {
+            return false;
+        }
+        int[] sieve = new int[MAX + 1];
+        for (int i = 2; i <= MAX; i++) {
+            if (sieve[i] == 0) {
+                for (int j = i; j <= MAX; j += i) {
+                    sieve[j] = i;
+                }
+            }
+        }
+        Union union = new Union(2 * MAX + 1);
+        for (int num : nums) {
+            int curr = num;
+            while (curr > 1) {
+                int prime = sieve[curr];
+                int root = prime + MAX;
+                if (union.find(root) != union.find(num)) {
+                    union.merge(root, num);
+                }
+                while (curr % prime == 0) {
+                    curr /= prime;
+                }
+            }
+        }
+        int count = 0;
+        for (int i = 2; i <= MAX; i++) {
+            if (exists[i] && union.find(i) == i) {
+                count++;
+            }
+        }
+        return count == 1;
+    }
+
+    private class Union {
+        private final int[] union;
+        private final int[] size;
+
+        public Union(int n) {
+            this.union = new int[n + 1];
+            this.size = new int[n + 1];
+            for (int i = 0; i <= n; i++) {
+                union[i] = i;
+                size[i] = 1;
+            }
+        }
+
+        public int find(int num) {
+            return union[num] == num ? num : (union[num] = find(union[num]));
+        }
+
+        public void merge(int x, int y) {
+            int findX = find(x);
+            int findY = find(y);
+            if (findX == findY) {
+                return;
+            }
+            if (size[findX] > size[findY]) {
+                int temp = findX;
+                findX = findY;
+                findY = temp;
+            }
+            union[findX] = findY;
+            size[findY] += size[findX];
+        }
+    }
+}
diff --git a/Hard/Height of Binary Tree After Subtree Removal Queries.java b/Hard/Height of Binary Tree After Subtree Removal Queries.java
new file mode 100644
index 00000000..ebd9acbe
--- /dev/null
+++ b/Hard/Height of Binary Tree After Subtree Removal Queries.java	
@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int[] treeQueries(TreeNode root, int[] queries) {
+        Map<Integer, Integer> result = new HashMap<>();
+        Map<TreeNode, Integer> heightCache = new HashMap<>();
+        dfs(root, 0, 0, result, heightCache);
+        int[] answer = new int[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            answer[i] = result.get(queries[i]);
+        }
+        return answer;
+    }
+
+    private void dfs(TreeNode node, int depth, int maxDepth, Map<Integer, Integer> result, Map<TreeNode, Integer> heightCache) {
+        if (node == null) {
+            return;
+        }
+        result.put(node.val, maxDepth);
+        dfs(node.left, depth + 1, Math.max(maxDepth, depth + 1 + height(node.right, heightCache)), result, heightCache);
+        dfs(node.right, depth + 1, Math.max(maxDepth, depth + 1 + height(node.left, heightCache)), result, heightCache);
+    }
+    
+    private int height(TreeNode node, Map<TreeNode, Integer> heightCache) {
+        if (node == null) {
+            return -1;
+        }
+        if (heightCache.containsKey(node)) {
+            return heightCache.get(node);
+        }
+        int currHeight = 1 + Math.max(height(node.left, heightCache), height(node.right, heightCache));
+        heightCache.put(node, currHeight);
+        return currHeight;
+    }
+}
diff --git a/Hard/IPO.java b/Hard/IPO.java
new file mode 100644
index 00000000..26cfaac8
--- /dev/null
+++ b/Hard/IPO.java
@@ -0,0 +1,31 @@
+class Solution {
+    public int findMaximizedCapital(int k, int w, int[] profits, int[] capital) {
+        int n = profits.length;
+        Project[] projects = new Project[n];
+        int maximumCapital = w;
+        for (int i = 0; i < n; i++) {
+            projects[i] = new Project(capital[i], profits[i]);
+        }
+        Arrays.sort(projects);
+        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
+        int idx = 0;
+        for (int i = 0; i < k; i++) {
+            while (idx < n && projects[idx].capital <= maximumCapital) {
+                pq.add(projects[idx++].profit);
+            }
+            if (pq.isEmpty()) {
+                break;
+            }
+            maximumCapital += pq.poll();
+        }
+        return maximumCapital;
+    }
+    
+    private record Project(int capital, int profit) implements Comparable<Project> {
+
+        @Override
+        public int compareTo(Project o) {
+            return capital - o.capital;
+        }
+    }
+}
diff --git a/Hard/Jump Game IV.java b/Hard/Jump Game IV.java
new file mode 100644
index 00000000..960ce4b7
--- /dev/null
+++ b/Hard/Jump Game IV.java	
@@ -0,0 +1,39 @@
+class Solution {
+    public int minJumps(int[] arr) {
+        int n = arr.length;
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            graph.computeIfAbsent(arr[i], k -> new ArrayList<>()).add(i);
+        }
+        Queue<Integer> path = new LinkedList<>();
+        Set<Integer> visited = new HashSet<>();
+        path.add(0);
+        int steps = 0;
+        while (!path.isEmpty()) {
+            int size = path.size();
+            while (size-- > 0) {
+                int removed = path.remove();
+                if (removed == n - 1) {
+                    return steps;
+                }
+                for (Integer child : graph.get(arr[removed])) {
+                    if (!visited.contains(child)) {
+                        visited.add(child);
+                        path.add(child);
+                    }
+                }
+                graph.get(arr[removed]).clear();
+                if (removed + 1 < n && !visited.contains(removed + 1)) {
+                    visited.add(removed + 1);
+                    path.add(removed + 1);
+                }
+                if (removed - 1 >= 0 && !visited.contains(removed - 1)) {
+                    visited.add(removed - 1);
+                    path.add(removed - 1);
+                }
+            }
+            steps++;
+        }
+        return -1;
+    }
+}
diff --git a/Hard/K-th Smallest in Lexicographical Order.java b/Hard/K-th Smallest in Lexicographical Order.java
new file mode 100644
index 00000000..9063cd56
--- /dev/null
+++ b/Hard/K-th Smallest in Lexicographical Order.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public int findKthNumber(int n, int k) {
+        int curr = 1;
+        k--;
+        while (k > 0) {
+            int count = countNumsWithPrefix(n, curr, curr + 1);
+            if (count <= k) {
+                curr++;
+                k -= count;
+            } else {
+                curr *= 10;
+                k--;
+            }
+        }
+        return curr;
+    }
+
+    private int countNumsWithPrefix(int n, long start, long end) {
+        int count = 0;
+        while (start <= n) {
+            count += Math.min(n + 1, end) - start;
+            start *= 10;
+            end *= 10;
+        }
+        return count;
+    }
+}
diff --git a/Hard/LFU Cache.java b/Hard/LFU Cache.java
index 4d52ade6..d4caef70 100644
--- a/Hard/LFU Cache.java	
+++ b/Hard/LFU Cache.java	
@@ -1,112 +1,125 @@
 class LFUCache {
 
-  private final Map<Integer, Node> keyToNodeMap;
-  private final Map<Integer, Node[]> frequencyToNodeMap;
-  private final Map<Integer, Integer> keyToFrequencyMap;
-  private int capacity;
-  private int currentCapacity;
-
-  public LFUCache(int capacity) {
-    this.capacity = capacity;
-    this.currentCapacity = 0;
-    this.keyToNodeMap = new HashMap<>();
-    this.frequencyToNodeMap = new TreeMap<>();
-    this.keyToFrequencyMap = new HashMap<>();
-  }
-
-  public int get(int key) {
-    if (!keyToNodeMap.containsKey(key)) {
-      return -1;
+    private final TreeMap<Integer, NodeLinkedList> frequencyToNodeMap;
+    private final Map<Integer, Node> keyToNodeMap;
+    private final int capacity;
+
+    public LFUCache(int capacity) {
+        this.frequencyToNodeMap = new TreeMap<>();
+        this.keyToNodeMap = new HashMap<>();
+        this.capacity = capacity;
+    }
+
+    public int get(int key) {
+        if (!keyToNodeMap.containsKey(key)) {
+            return -1;
+        }
+        Node node = keyToNodeMap.get(key);
+        updateNodeForFrequencyChange(node);
+        return node.value;
     }
-    Node node = keyToNodeMap.get(key);
-    removeNode(node);
-    int currentFrequency = keyToFrequencyMap.get(key);
-    int newFrequency = currentFrequency + 1;
-    keyToFrequencyMap.put(key, newFrequency);
-    addNodeToFrequencyHead(node, newFrequency);
-    return node.val;
-  }
-
-  public void put(int key, int value) {
-    if (this.capacity == 0) {
-      return;
+
+    public void put(int key, int value) {
+        if (this.keyToNodeMap.containsKey(key)) {
+            updateNode(key, value);
+        } else {
+            addNewNode(key, value);
+        }
     }
-    removeNodeIfCapacityReached(key);
-    Node node = getNode(key, value);
-    int newFrequency = keyToFrequencyMap.getOrDefault(key, 0) + 1;
-    keyToFrequencyMap.put(key, newFrequency);
-    keyToNodeMap.put(key, node);
-    if (newFrequency > 1) {
-      removeNode(node);
+
+    private void updateNode(int key, int value) {
+        Node node = keyToNodeMap.get(key);
+        node.value = value;
+        updateNodeForFrequencyChange(node);
     }
-    addNodeToFrequencyHead(node, newFrequency);
-  }
-
-  private void removeNodeIfCapacityReached(int key) {
-    if (!keyToNodeMap.containsKey(key) && this.currentCapacity == capacity) {
-      for (Integer freq : frequencyToNodeMap.keySet()) {
-        Node[] nodes = frequencyToNodeMap.get(freq);
-        if (nodes[1].prev.val == -1) {
-          continue;
+
+    private void addNewNode(int key, int value) {
+        if (capacity == 0) {
+            return;
+        }
+        if (capacity == keyToNodeMap.size()) {
+            evictCache();
+        }
+        Node node = new Node(key, value);
+        addToFrequencyMap(node);
+        keyToNodeMap.put(key, node);
+    }
+
+    private void evictCache() {
+        int firstKey = frequencyToNodeMap.firstKey();
+        Node nodeToEvict = frequencyToNodeMap.get(firstKey).getFirstNode();
+        removeNode(nodeToEvict);
+        keyToNodeMap.remove(nodeToEvict.key);
+        if (frequencyToNodeMap.get(firstKey).getFirstNode().value == -1) {
+            frequencyToNodeMap.remove(firstKey);
+        }
+    }
+
+    private void updateNodeForFrequencyChange(Node node) {
+        int prevFrequency = node.frequency;
+        node.frequency = node.frequency + 1;
+        removeNode(node);
+        if (frequencyToNodeMap.get(prevFrequency).getFirstNode().value == -1) {
+            frequencyToNodeMap.remove(prevFrequency);
         }
-        Node toRemove = nodes[1].prev;
-        removeNode(toRemove);
-        keyToNodeMap.remove(toRemove.key);
-        keyToFrequencyMap.remove(toRemove.key);
-        this.currentCapacity--;
-        break;
-      }
+        addToFrequencyMap(node);
     }
-  }
-
-  private Node getNode(int key, int value) {
-    Node node;
-    if (keyToNodeMap.containsKey(key)) {
-      node = keyToNodeMap.get(key);
-      removeNode(node);
-      node.val = value;
-    } else {
-      this.currentCapacity++;
-      node = new Node(value, key);
+
+    private void removeNode(Node node) {
+        Node prevToNode = node.prev;
+        Node nextToNode = node.next;
+        prevToNode.next = nextToNode;
+        nextToNode.prev = prevToNode;
     }
-    return node;
-  }
-
-  private void addNodeToFrequencyHead(Node node, int newFrequency) {
-    if (!frequencyToNodeMap.containsKey(newFrequency)) {
-      Node head = new Node(-1, Integer.MIN_VALUE);
-      Node tail = new Node(-1, Integer.MAX_VALUE);
-      head.next = tail;
-      tail.prev = head;
-      frequencyToNodeMap.put(newFrequency, new Node[]{head, tail});
+
+    private void addToFrequencyMap(Node node) {
+        if (!frequencyToNodeMap.containsKey(node.frequency)) {
+            frequencyToNodeMap.put(node.frequency, new NodeLinkedList());
+        }
+        frequencyToNodeMap.get(node.frequency).addNode(node);
     }
-    Node headNode = frequencyToNodeMap.get(newFrequency)[0];
-    Node nextToHead = headNode.next;
-    nextToHead.prev = node;
-    node.next = nextToHead;
-    headNode.next = node;
-    node.prev = headNode;
-  }
-  
-  private void removeNode(Node node) {
-    Node prevNode = node.prev;
-    Node nextNode = node.next;
-    prevNode.next = nextNode;
-    nextNode.prev = prevNode;
-  }
-
-  private static class Node {
-    int val;
-    int key;
-    Node next;
-    Node prev;
-
-    public Node(int val, int key) {
-      this.val = val;
-      this.key = key;
+
+    private static class NodeLinkedList {
+        private final Node head;
+        private final Node tail;
+
+        public NodeLinkedList() {
+            this.head = new Node(-1, -1);
+            this.tail = new Node(-1, -1);
+            head.next = tail;
+            tail.prev = head;
+        }
+
+        public Node getFirstNode() {
+            return head.next;
+        }
+
+        public void addNode(Node node) {
+            Node prevToTail = tail.prev;
+            node.prev = prevToTail;
+            prevToTail.next = node;
+            node.next = tail;
+            tail.prev = node;
+        }
+    }
+
+    private static class Node {
+        private final int key;
+        private int value;
+        private int frequency;
+        private Node next;
+        private Node prev;
+
+        public Node(int key, int value) {
+            this.key = key;
+            this.value = value;
+            this.frequency = 1;
+            this.next = null;
+            this.prev = null;
+        }
     }
-  }
 }
+
 /**
  * Your LFUCache object will be instantiated and called as such:
  * LFUCache obj = new LFUCache(capacity);
diff --git a/Hard/Largest Color Value in a Directed Graph.java b/Hard/Largest Color Value in a Directed Graph.java
new file mode 100644
index 00000000..2d2fe6d5
--- /dev/null
+++ b/Hard/Largest Color Value in a Directed Graph.java	
@@ -0,0 +1,39 @@
+class Solution {
+    public int largestPathValue(String colors, int[][] edges) {
+        int n = colors.length();
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        int[] indegree = new int[n];
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new ArrayList<>())
+                .add(edge[1]);
+            indegree[edge[1]]++;
+        }
+        int[][] count = new int[n][26];
+        Queue<Integer> queue = new LinkedList<>();
+        for (int i = 0; i < n; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i);
+            }
+        }
+        int result = 1;
+        int seen = 0;
+        while (!queue.isEmpty()) {
+            int node = queue.remove();
+            result = Math.max(result, ++count[node][colors.charAt(node) - 'a']);
+            seen++;
+            if (!graph.containsKey(node)) {
+                continue;
+            }
+            for (int neighbor : graph.get(node)) {
+                for (int i = 0; i < 26; i++) {
+                    count[neighbor][i] = Math.max(count[neighbor][i], count[node][i]);
+                }
+                indegree[neighbor]--;
+                if (indegree[neighbor] == 0) {
+                    queue.add(neighbor);
+                }
+            }
+        }
+        return seen < n ? -1 : result;
+    }
+}
diff --git a/Hard/Longest Cycle in a Graph.java b/Hard/Longest Cycle in a Graph.java
new file mode 100644
index 00000000..6405e016
--- /dev/null
+++ b/Hard/Longest Cycle in a Graph.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int longestCycle(int[] edges) {
+        int n = edges.length;
+        boolean[] visited = new boolean[n];
+        int[] result = {-1};
+        for (int i = 0; i < n; i++) {
+            if (!visited[i]) {
+                Map<Integer, Integer> map = new HashMap<>();
+                map.put(i, 1);
+                dfs(i, edges, map, visited, result);
+            }
+        }
+        return result[0];
+    }
+    
+    private void dfs(int node, int[] edges, Map<Integer, Integer> map, boolean[] visited, int[] result) {
+        visited[node] = true;
+        int neighbor = edges[node];
+        if (neighbor != -1 && !visited[neighbor]) {
+            map.put(neighbor, map.get(node) + 1);
+            dfs(neighbor, edges, map, visited, result);
+        } else if (neighbor != -1 && map.containsKey(neighbor)) {
+            result[0] = Math.max(result[0], map.get(node) - map.get(neighbor) + 1);
+        }
+    }
+}
diff --git a/Hard/Make Array Strictly Increasing.java b/Hard/Make Array Strictly Increasing.java
new file mode 100644
index 00000000..77bed2a8
--- /dev/null
+++ b/Hard/Make Array Strictly Increasing.java	
@@ -0,0 +1,41 @@
+class Solution {
+    public int makeArrayIncreasing(int[] arr1, int[] arr2) {
+        Arrays.sort(arr2);
+        Map<Pair<Integer, Integer>, Integer> dp = new HashMap<>();
+        int result = dfs(0, -1, arr1, arr2, dp);
+        return result < 2001 ? result : -1;
+    }
+    
+    private int dfs(int idx, int prev, int[] arr1, int[] arr2, Map<Pair<Integer, Integer>, Integer> dp) {
+        if (idx == arr1.length) {
+            return 0;
+        }
+        if (dp.containsKey(new Pair<>(idx, prev))) {
+            return dp.get(new Pair<>(idx, prev));
+        }
+        int cost = 2001;
+        if (arr1[idx] > prev) {
+            cost = dfs(idx + 1, arr1[idx], arr1, arr2, dp);
+        }
+        int replaceIdx = binarySearch(arr2, prev);
+        if (replaceIdx < arr2.length) {
+            cost = Math.min(cost, 1 + dfs(idx + 1, arr2[replaceIdx], arr1, arr2, dp));
+        }
+        dp.put(new Pair<>(idx, prev), cost);
+        return cost;
+    }
+    
+    private static int binarySearch(int[] arr, int value) {
+        int left = 0;
+        int right = arr.length;
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (arr[mid] <= value) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return left;
+    }
+}
diff --git a/Hard/Making A Large Island.java b/Hard/Making A Large Island.java
new file mode 100644
index 00000000..d1026bd7
--- /dev/null
+++ b/Hard/Making A Large Island.java	
@@ -0,0 +1,68 @@
+class Solution {
+
+    private static final int[][] DIRS = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
+
+    public int largestIsland(int[][] grid) {
+        int n = grid.length;
+        int tag = 2;
+        int result = 0;
+        Map<Integer, Integer> tagToAreaMapping = new HashMap<>();
+        // Calculate area without changing 0 to 1 & tag each island for future reference
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (grid[i][j] == 1) {
+                    tagToAreaMapping.put(tag, dfs(grid, i, j, tag));
+                    result = Math.max(result, tagToAreaMapping.get(tag));
+                    tag++;
+                }
+            }
+        }
+        // Now start changing each 0 to 1 & add the area of all connected islands by referencing their tags
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (grid[i][j] == 0) {
+                    Set<Integer> visited = new HashSet<>();
+                    int currArea = 1;
+                    List<int[]> moves = getMoves(i, j, n);
+                    for (int[] move : moves) {
+                        int x = move[0];
+                        int y = move[1];
+                        int currTag = grid[x][y];
+                        if (currTag > 1 && visited.add(currTag)) {
+                            currArea += tagToAreaMapping.get(currTag);
+                        }
+                    }
+                    result = Math.max(result, currArea);
+                }
+            }
+        }
+        return result;
+    }
+
+    private int dfs(int[][] grid, int x, int y, int tag) {
+        int area = 1;
+        int n = grid.length;
+        grid[x][y] = tag;
+        List<int[]> moves = getMoves(x, y, n);
+        for (int[] move : moves) {
+            int i = move[0];
+            int j = move[1];
+            if (grid[i][j] == 1) {
+                area += dfs(grid, i, j, tag);
+            }
+        }
+        return area;
+    }
+
+    private List<int[]> getMoves(int x, int y, int n) {
+        List<int[]> moves = new ArrayList<>();
+        for (int[] dir : DIRS) {
+            int newX = x + dir[0];
+            int newY = y + dir[1];
+            if (newX >= 0 && newX < n && newY >= 0 && newY < n) {
+                moves.add(new int[]{newX, newY});
+            }
+        }
+        return moves;
+    }
+}
diff --git a/Hard/Max Dot Product of Two Subsequences.java b/Hard/Max Dot Product of Two Subsequences.java
new file mode 100644
index 00000000..c2eca127
--- /dev/null
+++ b/Hard/Max Dot Product of Two Subsequences.java	
@@ -0,0 +1,30 @@
+class Solution {
+    public int maxDotProduct(int[] nums1, int[] nums2) {
+        int maxOne = Integer.MIN_VALUE;
+        int maxTwo = Integer.MIN_VALUE;
+        int minOne = Integer.MAX_VALUE;
+        int minTwo = Integer.MAX_VALUE;
+        for (int num : nums1) {
+            maxOne = Math.max(maxOne, num);
+            minOne = Math.min(minOne, num);
+        }
+        for (int num : nums2) {
+            maxTwo = Math.max(maxTwo, num);
+            minTwo = Math.min(minTwo, num);
+        }
+        if (maxOne < 0 && minTwo > 0) {
+            return maxOne * minTwo;
+        }
+        if (minOne > 0 && maxTwo < 0) {
+            return minOne * maxTwo;
+        }
+        int[][] dp = new int[nums1.length + 1][nums2.length + 1];
+        for (int i = nums1.length - 1; i >= 0; i--) {
+            for (int j = nums2.length - 1; j >= 0; j--) {
+                int curr = nums1[i] * nums2[j] + dp[i + 1][j + 1];
+                dp[i][j] = Math.max(curr, Math.max(dp[i + 1][j], dp[i][j + 1]));
+            }
+        }
+        return dp[0][0];
+    }
+}
diff --git a/Hard/Maximize Score After N Operations.java b/Hard/Maximize Score After N Operations.java
new file mode 100644
index 00000000..2ed4f892
--- /dev/null
+++ b/Hard/Maximize Score After N Operations.java	
@@ -0,0 +1,37 @@
+class Solution {
+    public int maxScore(int[] nums) {
+        int dpSize = 1 << nums.length;
+        int[] dp = new int[dpSize];
+        Arrays.fill(dp, -1);
+        return backtrack(nums, 0, 0, dp);
+    }
+    
+    private int backtrack(int[] nums, int mask, int pickCount, int[] dp) {
+        if (2 * pickCount == nums.length) {
+            return 0;
+        }
+        if (dp[mask] != -1) {
+            return dp[mask];
+        }
+        int maxScore = 0;
+        for (int i = 0; i < nums.length; i++) {
+            for (int j = i + 1; j < nums.length; j++) {
+                if (((mask >> i) & 1) == 1 || ((mask >> j) & 1) == 1) {
+                    continue;
+                }
+                int newMask = mask | (1 << i) | (1 << j);
+                int curr = (pickCount + 1) * gcd(nums[i], nums[j]);
+                int remaining = backtrack(nums, newMask, pickCount + 1, dp);
+                maxScore = Math.max(maxScore, curr + remaining);
+            }
+        }
+        return dp[mask] = maxScore;
+    }
+    
+    private int gcd(int a, int b) {
+        if (b == 0) {
+            return a;
+        }
+        return gcd(b, a % b);
+    }
+}
diff --git a/Hard/Maximum Profit in Job Scheduling.java b/Hard/Maximum Profit in Job Scheduling.java
index f95e58ab..8a785d43 100644
--- a/Hard/Maximum Profit in Job Scheduling.java	
+++ b/Hard/Maximum Profit in Job Scheduling.java	
@@ -1,28 +1,46 @@
 class Solution {
     public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
-        int n = startTime.length;
+        int n = profit.length;
         int[][] jobs = new int[n][3];
         for (int i = 0; i < n; i++) {
             jobs[i] = new int[]{startTime[i], endTime[i], profit[i]};
         }
         Arrays.sort(jobs, (a, b) -> a[0] - b[0]);
-        Integer[] cache = new Integer[n];
-        return dfs(0, jobs, cache);
+        for (int i = 0; i < n; i++) {
+            startTime[i] = jobs[i][0];
+        }
+        int[] dp = new int[n + 1];
+        Arrays.fill(dp, -1);
+        return findMaxProfit(jobs, startTime, 0, n, dp);
     }
-    
-    private int dfs(int idx, int[][] jobs, Integer[] cache) {
-        if (idx == jobs.length) {
+
+    private int findMaxProfit(int[][] jobs, int[] startTime, int position, int n, int[] dp) {
+        if (position == n) {
             return 0;
         }
-        if (cache[idx] != null) {
-            return cache[idx];
+        if (dp[position] != -1) {
+            return dp[position];
         }
-        int nextIdx = idx + 1;
-        while (nextIdx < jobs.length && jobs[idx][1] > jobs[nextIdx][0]) {
-            nextIdx++;
+        int nextPosition = binarySearch(startTime, jobs[position][1]);
+        return dp[position] = Math.max(
+            findMaxProfit(jobs, startTime, position + 1, n, dp), // skip executing current job
+            jobs[position][2] + findMaxProfit(jobs, startTime, nextPosition, n, dp) // execute current job & move to next position
+        );
+    }
+
+    private static int binarySearch(int[] startTime, int endTime) {
+        int left = 0;
+        int right = startTime.length - 1;
+        int nextPosition = startTime.length;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (startTime[mid] >= endTime) {
+                nextPosition = mid;
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
         }
-        int jobScheduled = jobs[idx][2] + dfs(nextIdx, jobs, cache);
-        int jobNotScheduled = dfs(idx + 1, jobs, cache);
-        return cache[idx] = Math.max(jobScheduled, jobNotScheduled);
+        return nextPosition;
     }
 }
diff --git a/Hard/Maximum Value of K Coins From Piles.java b/Hard/Maximum Value of K Coins From Piles.java
new file mode 100644
index 00000000..08fbc802
--- /dev/null
+++ b/Hard/Maximum Value of K Coins From Piles.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int maxValueOfCoins(List<List<Integer>> piles, int k) {
+        int n = piles.size();
+        int[][] dp = new int[n + 1][k + 1];
+        for (int i = 1; i <= n; i++) {
+            for (int coins = 0; coins <= k; coins++) {
+                int currSum = 0;
+                for (int currCoins = 0; 
+                     currCoins <= Math.min((int) piles.get(i - 1).size(), coins); 
+                     currCoins++) {
+                    if (currCoins > 0) {
+                        currSum += piles.get(i - 1).get(currCoins - 1);
+                    }
+                    dp[i][coins] = Math.max(dp[i][coins], dp[i - 1][coins - currCoins] + currSum);
+                }
+            }
+        }
+        return dp[n][k];
+    }
+}
diff --git a/Hard/Median of Two Sorted Arrays.java b/Hard/Median of Two Sorted Arrays.java
index 375c07fa..33ec700b 100644
--- a/Hard/Median of Two Sorted Arrays.java	
+++ b/Hard/Median of Two Sorted Arrays.java	
@@ -1,42 +1,25 @@
 class Solution {
     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
-        int n = nums1.length + nums2.length;
-        ArrayList<Integer> arr = new ArrayList<>();
-        
-        int i = 0;
-        int j = 0;
-        int k = 0;
-        int limit = (n)/2 + 1;
-        
-        while (i < nums1.length && j < nums2.length && k < limit) {
-            if (nums1[i] < nums2[j]) {
-                arr.add(nums1[i]);
-                i++;
-            }
-            else {
-                arr.add(nums2[j]);
-                j++;
-            }
-            k++;
-        }
-        
-        if (i < nums1.length) {
-            while (i < nums1.length && k < limit) {
-                arr.add(nums1[i]);
-                i++;
-                k++;
-            }
+        if (nums1.length < nums2.length) {
+            return findMedianSortedArrays(nums2, nums1);
         }
-        else {
-            while (j < nums2.length && k < limit) {
-                arr.add (nums2[j]);
-                j++;
-                k++;
+        int low = 0;
+        int high = nums2.length * 2;
+        while (low <= high) {
+            int midTwo = (low + high) / 2;
+            int midOne = nums1.length + nums2.length - midTwo;
+            double leftOne = (midOne == 0) ? Integer.MIN_VALUE : nums1[(midOne - 1) / 2];	
+            double leftTwo = (midTwo == 0) ? Integer.MIN_VALUE : nums2[(midTwo - 1) / 2];
+            double rightOne = (midOne == nums1.length * 2) ? Integer.MAX_VALUE : nums1[(midOne) / 2];
+            double rightTwo = (midTwo == nums2.length * 2) ? Integer.MAX_VALUE : nums2[(midTwo) / 2];
+            if (leftOne > rightTwo) {
+                low = midTwo + 1;
+            } else if (leftTwo > rightOne) {
+                high = midTwo - 1;
+            } else {
+                return (Math.max(leftOne, leftTwo) + Math.min(rightOne, rightTwo)) / 2;	
             }
         }
-        
-        k--;
-        
-        return n%2 == 0 ? (double) (arr.get(k - 1) + arr.get(k)) / 2.0 : (double) arr.get(k);
+        return -1;
     }
 }
diff --git a/Hard/Meeting Rooms III.java b/Hard/Meeting Rooms III.java
new file mode 100644
index 00000000..48167f8c
--- /dev/null
+++ b/Hard/Meeting Rooms III.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public int mostBooked(int n, int[][] meetings) {
+        Arrays.sort(meetings, Comparator.comparingInt(o -> o[0]));
+        PriorityQueue<int[]> ongoingMeetings = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
+        int[] frequency = new int[n];
+        PriorityQueue<long[]> pq = new PriorityQueue<>((o1, o2) -> o1[0] == o2[0] ? (int) (o1[1] - o2[1]) : (int) (o1[0] - o2[0]));
+        for (int i = 0; i < n; i++) {
+            pq.add(new long[]{0, i});
+        }
+        for (int[] meeting : meetings) {
+            int startTime = meeting[0];
+            while (pq.peek()[0] < startTime) {
+                pq.add(new long[]{startTime, pq.poll()[1]});
+            }
+            long[] finishedMeeting = pq.poll();
+            int room = (int) finishedMeeting[1];
+            long endTime = finishedMeeting[0] + (meeting[1] - meeting[0]);
+            frequency[room]++;
+            pq.add(new long[]{endTime, room});
+        }
+        int maxCount = 0;
+        int roomWithMaxCount = 0;
+        for (int i = 0; i < n; i++) {
+            if (frequency[i] > maxCount) {
+                maxCount = frequency[i];
+                roomWithMaxCount = i;
+            }
+        }
+        return roomWithMaxCount;
+    }
+}
diff --git a/Hard/Minimize Deviation in Array.java b/Hard/Minimize Deviation in Array.java
index 736ccbd0..905621e6 100644
--- a/Hard/Minimize Deviation in Array.java	
+++ b/Hard/Minimize Deviation in Array.java	
@@ -1,21 +1,21 @@
 class Solution {
-  public int minimumDeviation(int[] nums) {
-    int currMinimum = Integer.MAX_VALUE;
-    PriorityQueue<Integer> priorityQueue = new PriorityQueue<>((a, b) -> b - a);
-    for (int num : nums) {
-      if (num % 2 != 0) {
-        num *= 2;
-      }
-      currMinimum = Math.min(currMinimum, num);
-      priorityQueue.add(num);
+    public int minimumDeviation(int[] nums) {
+        int currMinimum = Integer.MAX_VALUE;
+        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
+        for (int num : nums) {
+            if (num % 2 != 0) {
+                num *= 2;
+            }
+            currMinimum = Math.min(currMinimum, num);
+            pq.add(num);
+        }
+        int deviation = Integer.MAX_VALUE;
+        while (pq.peek() % 2 == 0) {
+            int removed = pq.poll() / 2;
+            currMinimum = Math.min(currMinimum, removed);
+            pq.add(removed);
+            deviation = Math.min(deviation, pq.peek() - currMinimum);
+        }
+        return deviation;
     }
-    int deviation = Integer.MAX_VALUE;
-    while (priorityQueue.peek() % 2 == 0) {
-      int removed = priorityQueue.poll() / 2;
-      currMinimum = Math.min(currMinimum, removed);
-      priorityQueue.add(removed);
-      deviation = Math.min(deviation, priorityQueue.peek() - currMinimum);
-    }
-    return deviation;
-  }
 }
diff --git a/Hard/Minimum Cost to Make Array Equal.java b/Hard/Minimum Cost to Make Array Equal.java
new file mode 100644
index 00000000..9fe9b8f9
--- /dev/null
+++ b/Hard/Minimum Cost to Make Array Equal.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public long minCost(int[] nums, int[] cost) {
+        int n = nums.length;
+        int[][] numWithCost = new int[n][2];
+        for (int i = 0; i < n; i++) {
+            numWithCost[i] = new int[]{nums[i], cost[i]};    
+        }
+        Arrays.sort(numWithCost, (a, b) -> a[0] - b[0]);
+        long[] prefixCost = new long[n];
+        prefixCost[0] = numWithCost[0][1];
+        for (int i = 1; i < n; i++) {
+            prefixCost[i] = numWithCost[i][1] + prefixCost[i - 1];
+        }
+        long totalCost = 0;
+        for (int i = 1; i < n; i++) {
+            totalCost += 1L * numWithCost[i][1] * (numWithCost[i][0] - numWithCost[0][0]);
+        }
+        long result = totalCost;  
+        for (int i = 1; i < n; ++i) {
+            int gap = numWithCost[i][0] - numWithCost[i - 1][0];
+            totalCost += 1L * prefixCost[i - 1] * gap;
+            totalCost -= 1L * (prefixCost[n - 1] - prefixCost[i - 1]) * gap;
+            result = Math.min(result, totalCost);
+        }
+        return result;
+    }
+}
diff --git a/Hard/Minimum Difficulty of a Job Schedule.java b/Hard/Minimum Difficulty of a Job Schedule.java
index 58722245..ebc94cc7 100644
--- a/Hard/Minimum Difficulty of a Job Schedule.java	
+++ b/Hard/Minimum Difficulty of a Job Schedule.java	
@@ -1,30 +1,30 @@
 class Solution {
-  public int minDifficulty(int[] jobDifficulty, int d) {
-    int n = jobDifficulty.length;
-    if (n < d) {
-      return -1;
+    
+    private static final int INVALID_VALUE = 300_001;
+
+    public int minDifficulty(int[] jobDifficulty, int d) {
+        if (jobDifficulty.length < d) {
+            return -1;
+        }
+        Integer[][][] dp = new Integer[jobDifficulty.length][d + 1][1001];
+        return dfs(jobDifficulty, 0, d, 0, dp);
     }
-    Integer[][] dp = new Integer[n][d + 1];
-    return minDifficulty(/* index= */0, d, jobDifficulty, dp);
-  }
-  
-  private int minDifficulty(int index, int dLeft, int[] jobDifficulty, Integer[][] dp)  {
-    if (dp[index][dLeft] != null) {
-      return dp[index][dLeft];
+
+    private int dfs(int[] jobDifficulty, int idx, int d, int currMax, Integer[][][] dp) {
+        if (idx == jobDifficulty.length) {
+            return d == 0 ? 0 : INVALID_VALUE;
+        }
+        if (d == 0) {
+            return INVALID_VALUE;
+        }
+        if (dp[idx][d][currMax] != null) {
+            return dp[idx][d][currMax];
+        }
+        currMax = Math.max(currMax, jobDifficulty[idx]);
+        int result = Math.min(dfs(
+                jobDifficulty, idx + 1, d, currMax, dp), // continue same sequence
+                currMax + dfs(jobDifficulty, idx + 1, d - 1, 0, dp) // break sequence
+        );
+        return dp[idx][d][currMax] = result;
     }
-    if (dLeft == 1) {
-      int result = 0;
-      for (int j = index; j < jobDifficulty.length; j++) {
-        result = Math.max(result, jobDifficulty[j]);
-      }
-      return result;
-    }
-    int result = Integer.MAX_VALUE;
-    int dailyMaxJobDiff = 0;
-    for (int j = index; j < jobDifficulty.length - dLeft + 1; j++) {
-      dailyMaxJobDiff = Math.max(dailyMaxJobDiff, jobDifficulty[j]);
-      result = Math.min(result, dailyMaxJobDiff + minDifficulty(j + 1, dLeft - 1, jobDifficulty, dp));
-    }
-    return dp[index][dLeft] = result;
-  } 
 }
diff --git a/Hard/Minimum Insertion Steps to Make a String Palindrome.java b/Hard/Minimum Insertion Steps to Make a String Palindrome.java
new file mode 100644
index 00000000..3ffd2f07
--- /dev/null
+++ b/Hard/Minimum Insertion Steps to Make a String Palindrome.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int minInsertions(String s) {
+        int n = s.length();
+        return n - lcs(s, new StringBuilder(s).reverse().toString(), n, n);
+    }
+    
+    private int lcs(String s1, String s2, int m, int n) {
+        int[][] dp = new int[m + 1][n + 1];
+        for (int i = 0; i <= m; i++) {
+            for (int j = 0; j <= n; j++) {
+                if (i == 0 || j == 0) {
+                    dp[i][j] = 0;
+                } else if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                } else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                }
+            }
+        }
+        return dp[m][n];
+    }
+}
diff --git a/Hard/Minimum Number of Operations to Make Array Continuous.java b/Hard/Minimum Number of Operations to Make Array Continuous.java
new file mode 100644
index 00000000..f6f07059
--- /dev/null
+++ b/Hard/Minimum Number of Operations to Make Array Continuous.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int minOperations(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            set.add(num);
+        }
+        int[] arr = new int[set.size()];
+        int idx = 0;
+        for (Integer num : set) {
+            arr[idx++] = num;
+        }
+        Arrays.sort(arr);
+        int n = nums.length;
+        int result = n;
+        int j = 0;
+        for (int i = 0; i < arr.length; i++) {
+            while (j < arr.length && arr[j] < arr[i] + n) {
+                j++;
+            }
+            int count = j - i;
+            result = Math.min(result, n - count);
+        }
+        return result;
+    }
+}
diff --git a/Hard/Minimum Number of Removals to Make Mountain Array.java b/Hard/Minimum Number of Removals to Make Mountain Array.java
new file mode 100644
index 00000000..b74f6feb
--- /dev/null
+++ b/Hard/Minimum Number of Removals to Make Mountain Array.java	
@@ -0,0 +1,30 @@
+class Solution {
+    public int minimumMountainRemovals(int[] nums) {
+        int n = nums.length;
+        int[] leftIncreasingLength = new int[n];
+        int[] rightDecreasingLength = new int[n];
+        Arrays.fill(leftIncreasingLength, 1);
+        Arrays.fill(rightDecreasingLength, 1);
+        for (int i = 0; i < n; i++) {
+            for (int j = i - 1; j >= 0; j--) {
+                if (nums[i] > nums[j]) {
+                    leftIncreasingLength[i] = Math.max(leftIncreasingLength[i], leftIncreasingLength[j] + 1);
+                }
+            }
+        }
+        for (int i = n - 1; i >= 0; i--) {
+            for (int j = i + 1; j < n; j++) {
+                if (nums[i] > nums[j]) {
+                    rightDecreasingLength[i] = Math.max(rightDecreasingLength[i], rightDecreasingLength[j] + 1);
+                }
+            }
+        }
+        int minRemovals = Integer.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            if (leftIncreasingLength[i] > 1 && rightDecreasingLength[i] > 1) {
+                minRemovals = Math.min(minRemovals, n - leftIncreasingLength[i] - rightDecreasingLength[i] + 1);
+            }
+        }
+        return minRemovals;
+    }
+}
diff --git a/Hard/Minimum Replacements to Sort the Array.java b/Hard/Minimum Replacements to Sort the Array.java
new file mode 100644
index 00000000..1c3cfc4f
--- /dev/null
+++ b/Hard/Minimum Replacements to Sort the Array.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public long minimumReplacement(int[] nums) {
+        int n = nums.length;
+        long numOfOperations = 0;
+        for (int i = n - 2; i >= 0; i--) {
+            if (nums[i] > nums[i + 1]) {
+                long numElements = (long)(nums[i] + nums[i + 1] - 1) / (long)nums[i + 1];
+                numOfOperations += numElements - 1;
+                nums[i] = nums[i] / (int)numElements;
+            }
+        }
+        return numOfOperations;
+    }
+}
diff --git a/Hard/Minimum Window Subsequence.java b/Hard/Minimum Window Subsequence.java
index 88c2a006..d1a9b971 100644
--- a/Hard/Minimum Window Subsequence.java	
+++ b/Hard/Minimum Window Subsequence.java	
@@ -1,29 +1,39 @@
 class Solution {
-  public String minWindow(String s1, String s2) {
-    String window = "";
-    int j = 0;
-    int minLength = s1.length() + 1;
-    for (int i = 0; i < s1.length(); i++) {
-      if (s1.charAt(i) == s2.charAt(j)) {
-        j++;
-        if (j == s2.length()) {
-          int end = i + 1;
-          j--;
-          while (j >= 0) {
-            if (s1.charAt(i) == s2.charAt(j)) {
-              j--;
+    public String minWindow(String s1, String s2) {
+        int right = 0;
+        int minWindowLength = Integer.MAX_VALUE;
+        String result = "";
+        while (right < s1.length()) {
+            int s2Idx = 0;
+            while (right < s1.length()) {
+                if (s1.charAt(right) == s2.charAt(s2Idx)) {
+                    s2Idx++;
+                }
+                if (s2Idx == s2.length()) {
+                    break;
+                }
+                right++;
             }
-            i--;
-          }
-          j++;
-          i++;
-          if (end - i < minLength) {
-            minLength = end - i;
-            window = s1.substring(i, end);
-          }
+            if (right == s1.length()) {
+                break;
+            }
+            int s1EndIdx = right;
+            int s2EndIdx = s2.length() - 1;
+            while (s1EndIdx >= 0) {
+                if (s1.charAt(s1EndIdx) == s2.charAt(s2EndIdx)) {
+                    s2EndIdx--;
+                }
+                if (s2EndIdx < 0) {
+                    break;
+                }
+                s1EndIdx--;
+            }
+            if (right - s1EndIdx + 1 < minWindowLength) {
+                minWindowLength = right - s1EndIdx + 1;
+                result = s1.substring(s1EndIdx, right + 1);
+            }
+            right = s1EndIdx + 1;
         }
-      }
+        return result;
     }
-    return window;
-  }
 }
diff --git a/Hard/Minimum Window Substring.java b/Hard/Minimum Window Substring.java
index 2e8bb271..40cfa2ce 100644
--- a/Hard/Minimum Window Substring.java	
+++ b/Hard/Minimum Window Substring.java	
@@ -1,38 +1,38 @@
 class Solution {
-  public String minWindow(String s, String t) {
-    Map<Character, Integer> map = new HashMap<>();
-    for (char c : t.toCharArray()) {
-      map.put(c, map.getOrDefault(c, 0) + 1);
-    }
-    int count = map.size();
-    int start = 0;
-    int end = 0;
-    int minWindowLength = Integer.MAX_VALUE;
-    int minWindowStart = 0;
-    int minWindowEnd = 0;
-    while (end < s.length()) {
-      char c = s.charAt(end++);
-      if (map.containsKey(c)) {
-        map.put(c, map.get(c) - 1);
-        if (map.get(c) == 0) {
-          count--;
-        }
-      }
-      while (count == 0 && start < end) {
-        if (end - start < minWindowLength) {
-          minWindowLength = end - start;
-          minWindowStart = start;
-          minWindowEnd = end;
+    public String minWindow(String s, String t) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : t.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
         }
-        char temp = s.charAt(start++);
-        if (map.containsKey(temp)) {
-          map.put(temp, map.get(temp) + 1);
-          if (map.get(temp) == 1) {
-            count++;
-          }
+        int targetSize = map.size();
+        int start = 0;
+        int minLength = Integer.MAX_VALUE;
+        int minStart = -1;
+        int minEnd = -1;
+        int n = s.length();
+        for (int i = 0; i < n; i++) {
+            if (map.containsKey(s.charAt(i))) {
+                map.put(s.charAt(i), map.get(s.charAt(i)) - 1);
+                if (map.get(s.charAt(i)) == 0) {
+                    targetSize--;
+                }
+            }
+            while (start <= i && targetSize == 0) {
+                int currLength = i - start;
+                if (minLength > currLength) {
+                    minLength = currLength;
+                    minStart = start;
+                    minEnd = i + 1;
+                }   
+                if (map.containsKey(s.charAt(start))) {
+                    map.put(s.charAt(start), map.get(s.charAt(start)) + 1);
+                    if (map.get(s.charAt(start)) == 1) {
+                        targetSize++;
+                    }
+                }
+                start++;
+            }
         }
-      }
+        return minLength == Integer.MAX_VALUE ? "" : s.substring(minStart, minEnd);
     }
-    return s.substring(minWindowStart, minWindowEnd);
-  }
 }
diff --git a/Hard/Naming a Company.java b/Hard/Naming a Company.java
new file mode 100644
index 00000000..c24f78fe
--- /dev/null
+++ b/Hard/Naming a Company.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public long distinctNames(String[] ideas) {
+        Map<Character, Set<String>> map = new HashMap<>();
+        for (String idea : ideas) {
+            map.computeIfAbsent(idea.charAt(0), k -> new HashSet<>()).add(idea.substring(1, idea.length()));
+        }
+        long result = 0;
+        for (Character key1 : map.keySet()) {
+            for (Character key2 : map.keySet()) {
+                if (key1 == key2) {
+                    continue;
+                }
+                int intersection = 0;
+                for (String word : map.get(key1)) {
+                    if (map.get(key2).contains(word)) {
+                        intersection++;
+                    }
+                }
+                int distinctOne = map.get(key1).size() - intersection;
+                int distinctTwo = map.get(key2).size() - intersection;
+                result += distinctOne * distinctTwo;
+            }    
+        }
+        return result;
+    }
+}
diff --git a/Hard/Number of Flowers in Full Bloom.java b/Hard/Number of Flowers in Full Bloom.java
new file mode 100644
index 00000000..37bb43e7
--- /dev/null
+++ b/Hard/Number of Flowers in Full Bloom.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int[] fullBloomFlowers(int[][] flowers, int[] people) {
+        int[] peopleCopy = Arrays.copyOf(people, people.length);
+        Arrays.sort(peopleCopy);
+        Arrays.sort(flowers, (a, b) -> Arrays.compare(a, b));
+        Map<Integer, Integer> map = new HashMap<>();
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        int idx = 0;
+        for (int person : peopleCopy) {
+            while (idx < flowers.length && flowers[idx][0] <= person) {
+                pq.add(flowers[idx][1]);
+                idx++;
+            }
+            while (!pq.isEmpty() && pq.peek() < person) {
+                pq.poll();
+            }
+            map.put(person, pq.size());
+        }
+        int[] result = new int[people.length];
+        for (int i = 0; i < people.length; i++) {
+            result[i] = map.get(people[i]);
+        }
+        return result;
+    }
+}
diff --git a/Hard/Number of Ways of Cutting a Pizza.java b/Hard/Number of Ways of Cutting a Pizza.java
new file mode 100644
index 00000000..a96b2064
--- /dev/null
+++ b/Hard/Number of Ways of Cutting a Pizza.java	
@@ -0,0 +1,37 @@
+class Solution {
+    
+    private static final int MOD = 1000_000_007; 
+    
+    public int ways(String[] pizza, int k) {
+        int rows = pizza.length;
+        int cols = pizza[0].length();
+        int[][] apples = new int[rows + 1][cols + 1];
+        int[][][] dp = new int[k][rows][cols];
+        for (int row = rows - 1; row >= 0; row--) {
+            for (int col = cols - 1; col >= 0; col--) {
+                apples[row][col] = (pizza[row].charAt(col) == 'A' ? 1 : 0) + apples[row + 1][col] + apples[row][col + 1] - apples[row + 1][col + 1];
+                dp[0][row][col] = apples[row][col] > 0 ? 1 : 0;
+            }
+        }
+        
+        for (int i = 1; i < k; i++) {
+            for (int row = 0; row < rows; row++) {
+                for (int col = 0; col < cols; col++) {
+                    for (int nextRow = row + 1; nextRow < rows; nextRow++) {
+                        if (apples[row][col] - apples[nextRow][col] > 0) {
+                            dp[i][row][col] += dp[i - 1][nextRow][col];
+                            dp[i][row][col] %= MOD;
+                        }
+                    }
+                    for (int nextCol = col + 1; nextCol < cols; nextCol++) {
+                        if (apples[row][col] - apples[row][nextCol] > 0) {
+                            dp[i][row][col] += dp[i - 1][row][nextCol];
+                            dp[i][row][col] %= MOD;
+                        }
+                    }
+                }
+            }
+        }
+        return dp[k - 1][0][0];
+    }
+}
diff --git a/Hard/Number of Ways to Form a Target String Given a Dictionary.java b/Hard/Number of Ways to Form a Target String Given a Dictionary.java
new file mode 100644
index 00000000..a6354f1f
--- /dev/null
+++ b/Hard/Number of Ways to Form a Target String Given a Dictionary.java	
@@ -0,0 +1,28 @@
+class Solution {
+    
+    private static final int MOD = 1000_000_007;
+    
+    public int numWays(String[] words, String target) {
+        int m = target.length();
+        int k = words[0].length();
+        int[][] count = new int[26][k];
+        for (int i = 0; i < k; i++) {
+            for (String word : words) {
+                count[word.charAt(i) - 'a'][i]++;
+            }
+        }
+        long[][] dp = new long[m + 1][k + 1];
+        dp[0][0] = 1l;
+        for (int i = 0; i <= m; i++) {
+            for (int j = 0; j < k; j++) {
+                if (i < m) {
+                    dp[i + 1][j + 1] += count[target.charAt(i) - 'a'][j] * dp[i][j];
+                    dp[i + 1][j + 1] %= MOD;
+                }
+                dp[i][j + 1] += dp[i][j];
+                dp[i][j + 1] %= MOD;
+            }
+        }
+        return (int) dp[m][k];
+    }
+}
diff --git a/Hard/Number of Ways to Reorder Array to Get Same BST.java b/Hard/Number of Ways to Reorder Array to Get Same BST.java
new file mode 100644
index 00000000..a47c1f1d
--- /dev/null
+++ b/Hard/Number of Ways to Reorder Array to Get Same BST.java	
@@ -0,0 +1,38 @@
+class Solution {
+    
+    private static final long MOD = 1000_000_007;
+    
+    public int numOfWays(int[] nums) {
+        int n = nums.length;
+        long[][] dp = new long[n][n];
+        for (int i = 0; i < n; i++) {
+            dp[i][0] = dp[i][i] = 1; 
+        }
+        for (int i = 2; i < n; i++) {
+            for (int j = 1; j < i; j++) {
+                dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % MOD;
+            }
+        }
+        List<Integer> list = Arrays.stream(nums).boxed().collect(Collectors.toList());
+        return (int) ((dfs(list, dp) - 1) % MOD);
+    }
+    
+    private long dfs(List<Integer> nums, long[][] dp) {
+        int n = nums.size();
+        if (n < 3) {
+            return 1;
+        }
+        List<Integer> leftNodes = new ArrayList<>();
+        List<Integer> rightNodes = new ArrayList<>();
+        for (int i = 1; i < n; i++) {
+            if (nums.get(i) < nums.get(0)) {
+                leftNodes.add(nums.get(i));
+            } else {
+                rightNodes.add(nums.get(i));
+            }
+        }
+        long leftCount = dfs(leftNodes, dp) % MOD;
+        long rightCount = dfs(rightNodes, dp) % MOD;
+        return (((leftCount * rightCount) % MOD) * dp[n - 1][leftNodes.size()]) % MOD;
+    }
+}
diff --git a/Hard/Number of Ways to Stay in the Same Place After Some Steps.java b/Hard/Number of Ways to Stay in the Same Place After Some Steps.java
new file mode 100644
index 00000000..a9ce7edf
--- /dev/null
+++ b/Hard/Number of Ways to Stay in the Same Place After Some Steps.java	
@@ -0,0 +1,23 @@
+class Solution {
+
+    private static final int MOD = 1000_000_007;
+
+    public int numWays(int steps, int arrLen) {
+        arrLen = Math.min(arrLen, steps);
+        int[][] dp = new int[arrLen][steps + 1];
+        dp[0][0] = 1;
+        for (int i = 1; i <= steps; i++) {
+            for (int j = arrLen - 1; j >= 0; j--) {
+                int result = dp[j][i - 1];
+                if (j > 0) {
+                    result = (result + dp[j - 1][i - 1]) % MOD;
+                }
+                if (j < arrLen - 1) {
+                    result = (result + dp[j + 1][i - 1]) % MOD;
+                }
+                dp[j][i] = result;
+            }
+        }
+        return dp[0][steps];
+    }
+}
diff --git a/Hard/Paint House II.java b/Hard/Paint House II.java
new file mode 100644
index 00000000..23ac7a3d
--- /dev/null
+++ b/Hard/Paint House II.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public int minCostII(int[][] costs) {
+        int n = costs.length;
+        int k = costs[0].length;
+        int[][] dp = new int[n][k];
+        for (int i = 0; i < k; i++) {
+            dp[0][i] = costs[0][i];
+        }
+        for (int i = 1; i < n; i++) {
+            for (int j = 0; j < k; j++) {
+                dp[i][j] = minCost(dp[i - 1], j) + costs[i][j];
+            }
+        }
+        return minCost(dp[n - 1], -1);
+    }
+    
+    private int minCost(int[] dp, int currPaintIdx) {
+        int cost = Integer.MAX_VALUE;
+        int idx = 0;
+        while (idx < dp.length) {
+            if (!(currPaintIdx != -1 && idx == currPaintIdx)) {
+                cost = Math.min(cost, dp[idx]);
+            }
+            idx++;
+        }
+        return cost;
+    }
+}
diff --git a/Hard/Painting the Walls.java b/Hard/Painting the Walls.java
new file mode 100644
index 00000000..ceeb36f2
--- /dev/null
+++ b/Hard/Painting the Walls.java	
@@ -0,0 +1,26 @@
+class Solution {
+
+    private static final int INVALID_VALUE = 1000_000_000;
+
+    public int paintWalls(int[] cost, int[] time) {
+        int n = cost.length;
+        Integer[][] dp = new Integer[n][n + 1];
+        return compute(0, n, cost, time, dp, n);
+    }
+
+    private int compute(int idx, int remain, int[] cost, int[] time, Integer[][] dp, int n) {
+        if (remain <= 0) {
+            return 0;
+        }
+        if (idx == n) {
+            return INVALID_VALUE;
+        }
+        if (dp[idx][remain] != null) {
+            return dp[idx][remain];
+        }
+        int paint = cost[idx] + compute(idx + 1, remain - 1 - time[idx], cost, time, dp, n);
+        int noPaint = compute(idx + 1, remain, cost, time, dp, n);
+        dp[idx][remain] = Math.min(paint, noPaint);
+        return dp[idx][remain];
+    }
+}
diff --git a/Hard/Parallel Courses III.java b/Hard/Parallel Courses III.java
new file mode 100644
index 00000000..f557c244
--- /dev/null
+++ b/Hard/Parallel Courses III.java	
@@ -0,0 +1,35 @@
+class Solution {
+    public int minimumTime(int n, int[][] relations, int[] time) {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        int[] indegree = new int[n + 1];
+        for (int[] relation : relations) {
+            int course = relation[0];
+            int prereq = relation[1];
+            indegree[course]++;
+            map.computeIfAbsent(prereq, k -> new ArrayList<>()).add(course);
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        int[] maxTime = new int[n + 1];
+        for (int i = 1; i <= n; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i);
+                maxTime[i] = time[i - 1];
+            }
+        }
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            for (Integer dependent : map.getOrDefault(removed, new ArrayList<>())) {
+                maxTime[dependent] = Math.max(maxTime[dependent], maxTime[removed] + time[dependent - 1]);
+                indegree[dependent]--;
+                if (indegree[dependent] == 0) {
+                    queue.add(dependent);
+                }
+            }
+        }
+        int result = 0;
+        for (int i = 1; i <= n; i++) {
+            result = Math.max(result, maxTime[i]);
+        }
+        return result;
+    }
+}
diff --git a/Hard/Parsing A Boolean Expression.java b/Hard/Parsing A Boolean Expression.java
index 2c419aa8..97a56130 100644
--- a/Hard/Parsing A Boolean Expression.java	
+++ b/Hard/Parsing A Boolean Expression.java	
@@ -1,72 +1,43 @@
 class Solution {
     public boolean parseBoolExpr(String expression) {
-        char[] chars = expression.toCharArray();
-        Stack<Character> operations = new Stack<>();
-        Stack<Character> boolValues = new Stack<>();
-
-        for (int i = 0; i < chars.length; i++) {
-            char c = chars[i];
-            if (c == '!' || c == '&' || c == '|') {
-                operations.push(c);
-            }
-            else if (c == '(') {
-                boolValues.push('#');
-            }
-            else if (c == 't' || c == 'f') {
-                boolValues.push(chars[i]);
-            }
-            else if (c == ',') {
-                continue;
-            }
-            else {
-                List<Character> list = new ArrayList<>();
-                while (!boolValues.isEmpty()) {
-                    char temp = boolValues.pop();
-                    if (temp == '#') {
-                        break;
-                    }
-
-                    list.add(temp);
+        Stack<Character> stack = new Stack<>();
+        for (char c : expression.toCharArray()) {
+            if (c == ')') {
+                List<Character> values = new ArrayList<>();
+                while (stack.peek() != '(') {
+                    values.add(stack.pop());
                 }
-                
-                boolValues.push(performOperation(list, operations.pop()));
+                stack.pop();
+                char operation = stack.pop();
+                char result = evaluate(operation, values);
+                stack.push(result);
+            } else if (c != ',') {
+                stack.push(c);
             }
         }
-
-        return boolValues.peek() == 't' ? true : false;
+        return stack.peek() == 't';
     }
 
-    private Character performOperation(List<Character> list, Character operation) {
-        if (operation == '|') {
-            return performOr(list);
-        }
-        else if (operation == '&') {
-            return performAnd(list);
+    private static char evaluate(char operation, List<Character> values) {
+        if (operation == '!') {
+            return values.get(0) == 't' ? 'f' : 't';
         }
-        else {
-            return list.get(0) == 't' ? 'f' : 't';
-        }
-    }
-
-    private Character performAnd(List<Character> list) {
-        boolean val = getBooleanValue(list.get(0));
-        for (int i = 1; i < list.size(); i++) {
-            val &= getBooleanValue(list.get(i));
+        if (operation == '&') {
+            for (char value : values) {
+                if (value == 'f') {
+                    return 'f';
+                }
+            }
+            return 't';
         }
-
-        return val ? 't' : 'f';
-    }
-
-    private Character performOr(List<Character> list) {
-        boolean val = getBooleanValue(list.get(0));
-        for (int i = 1; i < list.size(); i++) {
-            val |= getBooleanValue(list.get(i));
+        if (operation == '|') {
+            for (char value : values) {
+                if (value == 't') {
+                    return 't';
+                }
+            }
+            return 'f';
         }
-
-        return val ? 't' : 'f';
-    }
-
-    private boolean getBooleanValue(Character character) {
-        return character == 't' ? true : false;
+        return 'f';
     }
 }
diff --git a/Hard/Patching Array.java b/Hard/Patching Array.java
new file mode 100644
index 00000000..6bf2a8ed
--- /dev/null
+++ b/Hard/Patching Array.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int minPatches(int[] nums, int n) {
+        int patches = 0;
+        long miss = 1;
+        int idx = 0;
+        while (miss <= n) {
+            if (idx < nums.length && nums[idx] <= miss) {
+                miss += nums[idx++];
+            } else {
+                miss += miss;
+                patches++;
+            }
+        }
+        return patches;
+    }
+}
diff --git a/Hard/Profitable Schemes.java b/Hard/Profitable Schemes.java
new file mode 100644
index 00000000..7a1cabc4
--- /dev/null
+++ b/Hard/Profitable Schemes.java	
@@ -0,0 +1,23 @@
+class Solution {
+    
+    private static final int MOD = 1000_000_007;
+    
+    public int profitableSchemes(int n, int minProfit, int[] group, int[] profit) {
+        Integer[][][] dp = new Integer[101][101][101];
+        return helper(0, 0, 0, n, minProfit, group, profit, dp);
+    }
+    
+    private int helper(int pos, int count, int profit, int n, int minProfit, int[] group, int[] profits, Integer[][][] dp) {
+        if (pos == group.length) {
+            return profit >= minProfit ? 1 : 0;
+        }
+        if (dp[pos][count][profit] != null) {
+            return dp[pos][count][profit];
+        }
+        int totalWays = helper(pos + 1, count, profit, n, minProfit, group, profits, dp);
+        if (count + group[pos] <= n) {
+            totalWays += helper(pos + 1, count + group[pos], Math.min(minProfit, profit + profits[pos]), n, minProfit, group, profits, dp);
+        }
+        return dp[pos][count][profit] = totalWays % MOD;
+    }
+}
diff --git a/Hard/README.md b/Hard/README.md
index 06ab9137..0e44bb8b 100644
--- a/Hard/README.md
+++ b/Hard/README.md
@@ -2,68 +2,126 @@
 S.no | Coding Problem 
 --- | --- 
 1|[Concatenated Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Concatenated%20Words.java)
-2|[Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java)
-3|[First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
-4|[Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java)
-5|[Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
-6|[Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
-7|[Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
-8|[Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
-9|[Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
-10|[Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java)
-11|[Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Interval.java)
-12|[Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
-13|[Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
-14|[Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
-15|[Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
-16|[Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java)
-17|[Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java)
-18|[Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parallel%20Courses.java)
-19|[LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
-20|[Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
-21|[K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
-22|[Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
-23|[N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
-24|[Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
-25|[Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
-26|[Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
-27|[Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
-28|[Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
-29|[Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java)
-30|[Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java)
-31|[Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
-32|[Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
-33|[Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java)
-34|[Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
-35|[LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LRU%20Cache.java)
-36|[Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java)
-37|[Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
-38|[Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
-39|[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Hard.md)
-40|[Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
-41|[Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
-42|[Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
-43|[Find Median From Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20From%20Data%20Stream.java)
-44|[Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
-45|[Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
-46|[Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
-47|[Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java)
-48|[Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java)
-49|[Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
-50|[Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
-51|[Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Interleaving%20String.java)
-52|[Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java)
-53|[Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java)
-54|[Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
-55|[Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
-56|[Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
-57|[Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java)
-58|[Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
-59|[Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
-60|[Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
-61|[Binary Tree PostOrder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20PostOrder%20Traversal.java)
-62|[Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
-63|[Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
-64|[Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java)
-65|[Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java)
-66|[Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
+2|[Minimum Cost to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Make%20Array%20Equal.java)
+3|[Max Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Stack.java)
+4|[Course Schedule III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Course%20Schedule%20III.java)
+5|[Binary Tree Cameras](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Cameras.java)
+6|[Remove Invalid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Invalid%20Parentheses.java)
+7|[First Missing Positive](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/First%20Missing%20Positive.java)
+8|[Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reconstruct%20Itinerary.java)
+9|[Frog Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Frog%20Jump.java)
+10|[Sort Items by Groups Respecting Dependencies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sort%20Items%20by%20Groups%20Respecting%20Dependencies.java)
+11|[Shortest Path Visiting All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Path%20Visiting%20All%20Nodes.java)
+12|[Critical Connections in a Network](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Critical%20Connections%20in%20a%20Network.java)
+13|[Sliding Window Median](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Median.java)
+14|[Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Edit%20Distance.java)
+15|[Checking Existence of Edge Length Limited Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Checking%20Existence%20of%20Edge%20Length%20Limited%20Paths.java)
+16|[Perfect Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Perfect%20Rectangle.java)
+17|[Minimum Window Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Subsequence.java)
+18|[Remove Max Number of Edges to Keep Graph Fully Traversable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Remove%20Max%20Number%20of%20Edges%20to%20Keep%20Graph%20Fully%20Traversable.java)
+19|[K Inverse Pairs Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Inverse%20Pairs%20Array.java)
+20|[Merge K Sorted Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Merge%20K%20Sorted%20Lists.java)
+21|[Minimum Replacements to Sort the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Replacements%20to%20Sort%20the%20Array.java)
+22|[Design Movie Rental System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Movie%20Rental%20System.java)
+23|[Sliding Window Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Sliding%20Window%20Maximum.java)
+24|[My Calendar III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/My%20Calendar%20III.java)
+25|[Longest Cycle in a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Cycle%20in%20a%20Graph.java)
+26|[Text Justification](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Text%20Justification.java)
+27|[Design In-Memory File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20In-Memory%20File%20System.java)
+28|[Basic Calculator III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator%20III.java)
+29|[Integer to English Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Integer%20to%20English%20Words.java)
+30|[Naming a Company](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Naming%20a%20Company.java)
+31|[Minimum Number of Refueling Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Number%20of%20Refueling%20Stops.java)
+32|[Rearrange String k Distance Apart](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Rearrange%20String%20k%20Distance%20Apart.java)
+33|[Make Array Strictly Increasing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Make%20Array%20Strictly%20Increasing.java)
+34|[Median of Two Sorted Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Median%20of%20Two%20Sorted%20Arrays.java)
+35|[Vertical Order Traversal Of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Vertical%20Order%20Traversal%20Of%20a%20Binary%20Tree.java)
+36|[Divide Array Into Increasing Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Divide%20Array%20Into%20Increasing%20Sequences.java)
+37|[Word Break II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Break%20II.java)
+38|[Maximum Number of Non-Overlapping Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Number%20of%20Non-Overlapping%20Substrings.java)
+39|[Paint House II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20II.java)
+40|[Subarrays with K Different Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Subarrays%20with%20K%20Different%20Integers.java)
+41|[Maximum Performance of a Team](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Performance%20of%20a%20Team.java)
+42|[Jump Game IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Jump%20Game%20IV.java)
+43|[Paint House III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Paint%20House%20III.java)
+44|[LFU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/LFU%20Cache.java)
+45|[Scramble String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Scramble%20String.java)
+46|[Word Search II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Word%20Search%20II.java)
+47|[K Empty Slots](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/K%20Empty%20Slots.java)
+48|[Employee Free Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Employee%20Free%20Time.java)
+49|[Maximize Score After N Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximize%20Score%20After%20N%20Operations.java)
+50|[Max Points on a Line](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Max%20Points%20on%20a%20Line.java)
+51|[The Skyline Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/The%20Skyline%20Problem.java)
+52|[N-Queens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens.java)
+53|[Longest Palindrome Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Palindrome%20Product.java)
+54|[Odd Even Jump](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Odd%20Even%20Jump.java)
+55|[Palindrome Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Palindrome%20Pairs.java)
+56|[Stream of Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stream%20of%20Characters.java)
+57|[Cut Off Trees for Golf Event](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Cut%20Off%20Trees%20for%20Golf%20Event.java)
+58|[Kth Smallest Number in Multiplication Table](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Kth%20Smallest%20Number%20in%20Multiplication%20Table.java)
+59|[String Compression II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/String%20Compression%20II.java)
+60|[Minimize Deviation in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimize%20Deviation%20in%20Array.java)
+61|[Minimum Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Cost%20to%20Hire%20K%20Workers.java)
+62|[Find the Longest Valid Obstacle Course at Each Position](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Longest%20Valid%20Obstacle%20Course%20at%20Each%20Position.java)
+63|[Number of Valid Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Valid%20Subarrays.java)
+64|[Maximum Value of K Coins From Piles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Value%20of%20K%20Coins%20From%20Piles.java)
+65|[Substring with Concatenation of All Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Substring%20with%20Concatenation%20of%20All%20Words.java)
+66|[Number of Paths with Max Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Paths%20with%20Max%20Score.java)
+67|[Profitable Schemes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Profitable%20Schemes.java)
+68|[Design Search Autocomplete System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Search%20Autocomplete%20System.java)
+69|[Number of Squareful Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Squareful%20Arrays.java)
+70|[N-Queens II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/N-Queens%20II.java)
+71|[Robot Room Cleaner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Robot%20Room%20Cleaner.java)
+72|[Poor Pigs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Poor%20Pigs.java)
+73|[Minimum Window Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Window%20Substring.java)
+74|[Number of Ways of Cutting a Pizza](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20of%20Cutting%20a%20Pizza.java)
+75|[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Hard.md)
+76|[Parsing A Boolean Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Parsing%20A%20Boolean%20Expression.java)
+77|[Trapping Rain Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Trapping%20Rain%20Water.java)
+78|[Similar String Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Similar%20String%20Groups.java)
+79|[Number of Ways to Form a Target String Given a Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20to%20Form%20a%20Target%20String%20Given%20a%20Dictionary.java)
+80|[Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20the%20Kth%20Smallest%20Sum%20of%20a%20Matrix%20With%20Sorted%20Rows.java)
+81|[Optimal Account Balancing](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Optimal%20Account%20Balancing.java)
+82|[Design Skiplist](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Design%20Skiplist.java)
+83|[Wildcard Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Wildcard%20Matching.java)
+84|[Expression Add Operators](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Expression%20Add%20Operators.java)
+85|[Count of Smaller Numbers After Self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20of%20Smaller%20Numbers%20After%20Self.java)
+86|[Number of Ways to Reorder Array to Get Same BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Ways%20to%20Reorder%20Array%20to%20Get%20Same%20BST.java)
+87|[Find Median from Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Median%20from%20Data%20Stream.java)
+88|[Best Time to Buy and Sell Stock IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20IV.java)
+89|[Find Minimum in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Find%20Minimum%20in%20Rotated%20Sorted%20Array%20II.java)
+90|[Longest Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Valid%20Parentheses.java)
+91|[Stone Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stone%20Game%20III.java)
+92|[Reducing Dishes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reducing%20Dishes.java)
+93|[Count Subarrays With Fixed Bounds](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Subarrays%20With%20Fixed%20Bounds.java)
+94|[Stamping The Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Stamping%20The%20Sequence.java)
+95|[Number of Submatrices That Sum to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Number%20of%20Submatrices%20That%20Sum%20to%20Target.java)
+96|[Candy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Candy.java)
+97|[Minimum Insertion Steps to Make a String Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Insertion%20Steps%20to%20Make%20a%20String%20Palindrome.java)
+98|[Shortest Distance from All Buildings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Shortest%20Distance%20from%20All%20Buildings.java)
+99|[Recover a Tree From Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Recover%20a%20Tree%20From%20Preorder%20Traversal.java)
+100|[Count Vowels Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Count%20Vowels%20Permutation.java)
+101|[Longest Increasing Path in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Longest%20Increasing%20Path%20in%20a%20Matrix.java)
+102|[Maximum Profit in Job Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Profit%20in%20Job%20Scheduling.java)
+103|[Closest Binary Search Tree Values II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Closest%20Binary%20Search%20Tree%20Values%20II.java)
+104|[Basic Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Basic%20Calculator.java)
+105|[Alien Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Alien%20Dictionary.java)
+106|[Prefix and Suffix Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Prefix%20and%20Suffix%20Search.java)
+107|[Construct Target Array With Multiple Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Construct%20Target%20Array%20With%20Multiple%20Sums.java)
+108|[Tallest Billboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Tallest%20Billboard.java)
+109|[Largest Color Value in a Directed Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Color%20Value%20in%20a%20Directed%20Graph.java)
+110|[Valid Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Valid%20Number.java)
+111|[Dice Roll Simulation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Dice%20Roll%20Simulation.java)
+112|[Maximum Frequency Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Frequency%20Stack.java)
+113|[Reverse Nodes in k-Group](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Reverse%20Nodes%20in%20k-Group.java)
+114|[Serialize and Deserialize N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20N-ary%20Tree.java)
+115|[Serialize and Deserialize a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Serialize%20and%20Deserialize%20a%20Binary%20Tree.java)
+116|[Minimum Difficulty of a Job Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Minimum%20Difficulty%20of%20a%20Job%20Schedule.java)
+117|[Unique Paths III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Unique%20Paths%20III.java)
+118|[Restore The Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Restore%20The%20Array.java)
+119|[IPO](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/IPO.java)
+120|[Insert Delete GetRandom O(1) - Duplicates Allowed](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Insert%20Delete%20GetRandom%20O(1)%20-%20Duplicates%20Allowed.java)
+121|[Add Edges to Make Degrees of All Nodes Even](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Add%20Edges%20to%20Make%20Degrees%20of%20All%20Nodes%20Even.java)
+122|[Maximum Sum BST in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Maximum%20Sum%20BST%20in%20Binary%20Tree.java)
+123|[Binary Tree Maximum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Binary%20Tree%20Maximum%20Path%20Sum.java)
+124|[Largest Rectangle in Histogram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Hard/Largest%20Rectangle%20in%20Histogram.java)
diff --git a/Hard/Rearrange String k Distance Apart.java b/Hard/Rearrange String k Distance Apart.java
new file mode 100644
index 00000000..da212877
--- /dev/null
+++ b/Hard/Rearrange String k Distance Apart.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public String rearrangeString(String s, int k) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : s.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+        PriorityQueue<Character> pq = new PriorityQueue<>((a, b) -> map.get(b).compareTo(map.get(a)));
+        Queue<Character> busy = new LinkedList<>();
+        StringBuilder sb = new StringBuilder();
+        pq.addAll(map.keySet());
+        while (!pq.isEmpty()) {
+            Character removed = pq.poll();
+            sb.append(removed);
+            map.put(removed, map.get(removed) - 1);
+            busy.add(removed);
+            if (busy.size() < k) {
+                continue;
+            }
+            Character busyRemoved = busy.remove();
+            if (map.get(busyRemoved) > 0) {
+                pq.add(busyRemoved);
+            }
+        }
+        return sb.length() == s.length() ? sb.toString() : "";
+    }
+}
diff --git a/Hard/Reconstruct Itinerary.java b/Hard/Reconstruct Itinerary.java
index 0c3c962f..e5616f94 100644
--- a/Hard/Reconstruct Itinerary.java	
+++ b/Hard/Reconstruct Itinerary.java	
@@ -1,22 +1,19 @@
 class Solution {
-  public List<String> findItinerary(List<List<String>> tickets) {
-    Map<String, PriorityQueue<String>> map = new HashMap<>();
-    for (List<String> ticket : tickets) {
-      String from = ticket.get(0);
-      String to = ticket.get(1);
-      map.computeIfAbsent(from, k -> new PriorityQueue<>()).add(to);
+    public List<String> findItinerary(List<List<String>> tickets) {
+        Map<String, PriorityQueue<String>> map = new HashMap<>();
+        for (List<String> ticket : tickets) {
+            map.computeIfAbsent(ticket.get(0), k -> new PriorityQueue<>()).add(ticket.get(1));
+        }
+        Stack<String> stack = new Stack<>();
+        stack.push("JFK");
+        List<String> result = new ArrayList<>();
+        while (!stack.isEmpty()) {
+            while (map.containsKey(stack.peek()) && !map.get(stack.peek()).isEmpty()) {
+                stack.push(map.get(stack.peek()).poll());
+            }
+            result.add(stack.pop());
+        }
+        Collections.reverse(result);
+        return result;
     }
-    Stack<String> stack = new Stack<>();
-    LinkedList<String> result = new LinkedList<>();
-    stack.push("JFK");
-    while (!stack.isEmpty()) {
-      String destination = stack.peek();
-      if (!map.getOrDefault(destination, new PriorityQueue<>()).isEmpty()) {
-        stack.push(map.get(destination).remove());
-      } else {
-        result.addFirst(stack.pop());
-      }
-    }
-    return result;
-  }
 }
diff --git a/Hard/Recover a Tree From Preorder Traversal.java b/Hard/Recover a Tree From Preorder Traversal.java
index 69f3fe55..b851ca44 100644
--- a/Hard/Recover a Tree From Preorder Traversal.java	
+++ b/Hard/Recover a Tree From Preorder Traversal.java	
@@ -4,41 +4,45 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    public TreeNode recoverFromPreorder(String S) {
-        Map<Integer, TreeNode> map = new HashMap<>();
+    public TreeNode recoverFromPreorder(String traversal) {
+        Stack<TreeNode> stack = new Stack<>();
         int idx = 0;
-        int n = S.length();
-
-        while (idx < n) {
-            int level = 0;
-            StringBuilder sb = new StringBuilder();
-
-            while (idx < n && S.charAt(idx) == '-') {
-                level++;
+        while (idx < traversal.length()) {
+            int depth = 0;
+            while (idx < traversal.length() && traversal.charAt(idx) == '-') {
+                depth++;
                 idx++;
             }
-
-            while (idx < n && Character.isDigit(S.charAt(idx))) {
-                sb.append(S.charAt(idx++));
+            int value = 0;
+            while (idx < traversal.length() && Character.isDigit(traversal.charAt(idx))) {
+                value = value * 10 + Character.getNumericValue(traversal.charAt(idx++));
             }
-
-            TreeNode currNode = new TreeNode(Integer.parseInt(sb.toString()));
-            map.put(level, currNode);
-            if (level > 0) {
-                TreeNode parent = map.get(level - 1);
-                if (parent.left == null) {
-                    parent.left = currNode;
-                }
-                else {
-                    parent.right = currNode;
+            TreeNode node = new TreeNode(value);
+            while (stack.size() > depth) {
+                stack.pop();
+            }
+            if (!stack.isEmpty()) {
+                if (stack.peek().left == null) {
+                    stack.peek().left = node;
+                } else {
+                    stack.peek().right = node;
                 }
             }
+            stack.push(node);
+        }
+        while (stack.size() > 1) {
+            stack.pop();
         }
-
-        return map.get(0);
+        return stack.peek();
     }
 }
diff --git a/Hard/Reducing Dishes.java b/Hard/Reducing Dishes.java
new file mode 100644
index 00000000..2a69540e
--- /dev/null
+++ b/Hard/Reducing Dishes.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int maxSatisfaction(int[] satisfaction) {
+        Arrays.sort(satisfaction);
+        int n = satisfaction.length;
+        Integer[][] dp = new Integer[n + 1][n + 1];
+        return helper(satisfaction, 0, 1, dp);
+    }
+    
+    private int helper(int[] satisfaction, int idx, int time, Integer[][] dp) {
+        if (idx == satisfaction.length) {
+            return 0;
+        }
+        if (dp[idx][time] != null) {
+            return dp[idx][time];
+        }
+        dp[idx][time] = Math.max(satisfaction[idx] * time + helper(satisfaction, idx + 1, time + 1, dp),
+                                 helper(satisfaction, idx + 1, time, dp));
+        return dp[idx][time];
+    }
+}
diff --git a/Hard/Remove Max Number of Edges to Keep Graph Fully Traversable.java b/Hard/Remove Max Number of Edges to Keep Graph Fully Traversable.java
new file mode 100644
index 00000000..152ab81b
--- /dev/null
+++ b/Hard/Remove Max Number of Edges to Keep Graph Fully Traversable.java	
@@ -0,0 +1,67 @@
+class Solution {
+    public int maxNumEdgesToRemove(int n, int[][] edges) {
+        UnionFind alice = new UnionFind(n);
+        UnionFind bob = new UnionFind(n);
+        int requiredEdges = 0;
+        for (int[] edge : edges) {
+            if (edge[0] == 3) {
+                requiredEdges += (alice.union(edge[1], edge[2]) | bob.union(edge[1], edge[2]));
+            }
+        }
+        for (int[] edge : edges) {
+            if (edge[0] == 1) {
+                requiredEdges += alice.union(edge[1], edge[2]);
+            } else if (edge[0] == 2) {
+                requiredEdges += bob.union(edge[1], edge[2]);
+            }
+        }
+        if (alice.isConnected() && bob.isConnected()) {
+            return edges.length - requiredEdges;
+        }
+        return -1;
+    }
+    
+    private class UnionFind {
+        private final int[] representatives;
+        private final int[] componentSize;
+        private int components;
+        
+        public UnionFind(int n) {
+            this.representatives = new int[n + 1];
+            this.componentSize = new int[n + 1];
+            this.components = n;
+            for (int i = 0; i <= n; i++) {
+                componentSize[i] = 1;
+                representatives[i] = i;
+            }
+        }
+        
+        public int find(int x) {
+            if (representatives[x] == x) {
+                return x;
+            }
+            return representatives[x] = find(representatives[x]);
+        }
+        
+        public int union(int x, int y) {
+            x = find(x);
+            y = find(y);
+            if (x == y) {
+                return 0;
+            }
+            if (componentSize[x] > componentSize[y]) {
+                componentSize[x] += componentSize[y];
+                representatives[y] = x;
+            } else {
+                componentSize[y] += componentSize[x];
+                representatives[x] = y;
+            }
+            components--;
+            return 1;
+        }
+        
+        public boolean isConnected() {
+            return components == 1;
+        }
+    }
+}
diff --git a/Hard/Restore The Array.java b/Hard/Restore The Array.java
new file mode 100644
index 00000000..9b6ffc76
--- /dev/null
+++ b/Hard/Restore The Array.java	
@@ -0,0 +1,31 @@
+class Solution {
+    
+    private static final int MOD = 1000_000_007;
+    
+    public int numberOfArrays(String s, int k) {
+        int n = s.length();
+        int[] dp = new int[n + 1];
+        return dfs(dp, 0, s, k);
+    }
+    
+    private int dfs(int[] dp, int start, String s, int k) {
+        if (dp[start] != 0) {
+            return dp[start];
+        }
+        if (start == s.length()) {
+            return 1;
+        }
+        if (s.charAt(start) == '0') {
+            return 0;
+        }
+        int count = 0;
+        for (int end = start; end < s.length(); end++) {
+            String currNum = s.substring(start, end + 1);
+            if (Long.parseLong(currNum) > k) {
+                break;
+            }
+            count = (count + dfs(dp, end + 1, s, k)) % MOD;
+        }
+        return dp[start] = count;
+    }
+}
diff --git a/Hard/Robot Collisions.java b/Hard/Robot Collisions.java
new file mode 100644
index 00000000..4202122c
--- /dev/null
+++ b/Hard/Robot Collisions.java	
@@ -0,0 +1,38 @@
+class Solution {
+    public List<Integer> survivedRobotsHealths(int[] positions, int[] healths, String directions) {
+        int n = positions.length;
+        Integer[] indices = new Integer[n];
+        for (int i = 0; i < n; i++) {
+            indices[i] = i;
+        }
+        Arrays.sort(indices, (a, b) -> Integer.compare(positions[a], positions[b]));
+        Stack<Integer> stack = new Stack<>();
+        for (Integer index : indices) {
+            if (directions.charAt(index) == 'R') {
+                stack.push(index);
+            } else {
+                while (!stack.isEmpty() && healths[index] > 0) {
+                    int poppedIndex = stack.pop();
+                    if (healths[poppedIndex] > healths[index]) {
+                        healths[poppedIndex]--;
+                        healths[index] = 0;
+                        stack.push(poppedIndex);
+                    } else if (healths[poppedIndex] < healths[index]) {
+                        healths[index]--;
+                        healths[poppedIndex] = 0;
+                    } else {
+                        healths[poppedIndex] = 0;
+                        healths[index] = 0;
+                    }
+                }
+            }
+        }
+        List<Integer> result = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (healths[i] > 0) {
+                result.add(healths[i]);
+            }
+        }
+        return result;
+    }
+}
diff --git a/Hard/Scramble String.java b/Hard/Scramble String.java
new file mode 100644
index 00000000..ac35d39c
--- /dev/null
+++ b/Hard/Scramble String.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public boolean isScramble(String s1, String s2) {
+        int n = s1.length();
+        Boolean[][][] dp = new Boolean[n][n][n + 1];
+        return helper(s1, s2, 0, 0, n, dp);
+    }
+    
+    private boolean helper(String s1, String s2, int idxOne, int idxTwo, int n, Boolean[][][] dp) {
+        if (dp[idxOne][idxTwo][n] != null) {
+            return dp[idxOne][idxTwo][n];
+        }
+        if (n == 1) {
+            return dp[idxOne][idxTwo][n]  = s1.charAt(idxOne) == s2.charAt(idxTwo);
+        }
+        for (int l = 1; l < n; l++) {
+            if (helper(s1, s2, idxOne, idxTwo, l, dp) && helper(s1, s2, idxOne + l, idxTwo + l, n - l, dp)) {
+                return dp[idxOne][idxTwo][n] = true;
+            }
+            if (helper(s1, s2, idxOne, idxTwo + n - l, l, dp) && helper(s1, s2, idxOne + l, idxTwo, n - l, dp)) {
+                return dp[idxOne][idxTwo][n] = true;
+            }
+        }
+        return dp[idxOne][idxTwo][n] = false;
+    }
+}
diff --git a/Hard/Shortest Palindrome.java b/Hard/Shortest Palindrome.java
new file mode 100644
index 00000000..3ff38e40
--- /dev/null
+++ b/Hard/Shortest Palindrome.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public String shortestPalindrome(String s) {
+        int n = s.length();
+        if (n == 0) {
+            return s;
+        }
+        int left = 0;
+        for (int right = n - 1; right >= 0; right--) {
+            if (s.charAt(right) == s.charAt(left)) {
+                left++;
+            }
+        }
+        if (left == n) {
+            return s;
+        }
+        String nonPalindromeSuffix = s.substring(left);
+        StringBuilder reverseSuffix = new StringBuilder(nonPalindromeSuffix).reverse();
+        return reverseSuffix
+            .append(shortestPalindrome(s.substring(0, left)))
+            .append(nonPalindromeSuffix)
+            .toString();
+    }
+}
diff --git a/Hard/Shortest Path Visiting All Nodes.java b/Hard/Shortest Path Visiting All Nodes.java
new file mode 100644
index 00000000..8d08ecfa
--- /dev/null
+++ b/Hard/Shortest Path Visiting All Nodes.java	
@@ -0,0 +1,33 @@
+class Solution {
+    public int shortestPathLength(int[][] graph) {
+        int n = graph.length;
+        Map<Integer, Set<Set<Integer>>> map = new HashMap<>();
+        Queue<State> queue = new LinkedList<>();
+        for (int i = 0; i < n; i++) {
+            Set<Integer> visited = new HashSet<>();
+            visited.add(i);
+            map.put(i, new HashSet<>(List.of(visited)));
+            queue.add(new State(i, 0, visited));
+        }
+        while (!queue.isEmpty()) {
+            State removed = queue.remove();
+            int node = removed.node();
+            int steps = removed.steps();
+            Set<Integer> visited = removed.visited();
+            if (visited.size() == n) {
+                return steps;
+            }
+            for (int conn : graph[node]) {
+                Set<Integer> connVisited = new HashSet<>(visited);
+                connVisited.add(conn);
+                if (!map.get(conn).contains(connVisited)) {
+                    queue.add(new State(conn, steps + 1, connVisited));
+                    map.computeIfAbsent(conn, k -> new HashSet<>()).add(connVisited);
+                }
+            }
+        }
+        return -1;
+    }
+
+    private static record State(int node, int steps, Set<Integer> visited) {}
+}
diff --git a/Hard/Similar String Groups.java b/Hard/Similar String Groups.java
new file mode 100644
index 00000000..50eb13d2
--- /dev/null
+++ b/Hard/Similar String Groups.java	
@@ -0,0 +1,51 @@
+class Solution {
+    public int numSimilarGroups(String[] strs) {
+        int n = strs.length;
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                if (isSimilar(strs[i], strs[j])) {
+                    graph.computeIfAbsent(i, k -> new ArrayList<>()).add(j);
+                    graph.computeIfAbsent(j, k -> new ArrayList<>()).add(i);
+                }
+            }
+        }
+        boolean[] visited = new boolean[n];
+        int count = 0;
+        for (int i = 0; i < n; i++) {
+            if (!visited[i]) {
+                bfs(i, graph, visited);
+                count++;
+            }
+        }
+        return count;
+    }
+    
+    private boolean isSimilar(String s1, String s2) {
+        int diff = 0;
+        for (int i = 0; i < s1.length(); i++) {
+            if (s1.charAt(i) != s2.charAt(i)) {
+                diff++;
+            }
+        }
+        return diff == 0 || diff == 2;
+    }
+    
+    private void bfs(int node, Map<Integer, List<Integer>> graph, boolean[] visited) {
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(node);
+        visited[node] = true;
+        while (!queue.isEmpty()) {
+            node = queue.poll();
+            if (!graph.containsKey(node)) {
+                continue;
+            }
+            for (int neighbor : graph.get(node)) {
+                if (!visited[neighbor]) {
+                    visited[neighbor] = true;
+                    queue.add(neighbor);
+                }
+            }
+        }
+    }
+}
diff --git a/Hard/Sliding Window Maximum.java b/Hard/Sliding Window Maximum.java
index c1ae146e..635720b8 100644
--- a/Hard/Sliding Window Maximum.java	
+++ b/Hard/Sliding Window Maximum.java	
@@ -1,23 +1,19 @@
 class Solution {
-  public int[] maxSlidingWindow(int[] nums, int k) {
-    int n = nums.length;
-    if (n == 0 || k == 0) {
-      return new int[0];
+    public int[] maxSlidingWindow(int[] nums, int k) {
+        Deque<Integer> dequeue = new ArrayDeque<>();
+        int[] result = new int[nums.length - k + 1];
+        for (int i = 0; i < nums.length; i++) {
+            if (!dequeue.isEmpty() && dequeue.getFirst() == i - k) {
+                dequeue.removeFirst();
+            }
+            while (!dequeue.isEmpty() && nums[i] > nums[dequeue.getLast()]) {
+                dequeue.removeLast();
+            }
+            dequeue.addLast(i);
+            if (i >= k - 1) {
+                result[i - k + 1] = nums[dequeue.getFirst()];
+            }
+        }
+        return result;
     }
-    int[] result = new int[n - k + 1];
-    Deque<Integer> deque = new ArrayDeque<>();
-    for (int i = 0; i < n; i++) {
-      while (deque.size() > 0 && deque.peekFirst() <= i - k) {
-        deque.pollFirst();
-      }
-      while (deque.size() > 0 && nums[deque.peekLast()] < nums[i]) {
-        deque.pollLast();
-      }
-      deque.offerLast(i);
-      if (i >= k - 1) {
-        result[i -k + 1] = nums[deque.peekFirst()];
-      }
-    }
-    return result;
-  }
 }
diff --git a/Hard/Sliding Window Median.java b/Hard/Sliding Window Median.java
index 944af371..e37c289d 100644
--- a/Hard/Sliding Window Median.java	
+++ b/Hard/Sliding Window Median.java	
@@ -1,72 +1,59 @@
 class Solution {
-    List<Long> list;
-    double[] ans;
-    boolean isEven;
-
-    public double[] medianSlidingWindow(int[] nums, int k) {
-        list = new ArrayList<>();
-        ans = new double[nums.length - k + 1];
-        isEven = k % 2 == 0;
-
-        for (int i=0; i<k; i++) {
-            list.add((long) nums[i]);
-        }
-
-        Collections.sort(list);
-        int idx = 0;
-        ans[idx++] = getMedian();
-
-        for (int i=k; i<nums.length; i++) {
-            removeElement(nums[idx - 1]);
-            int tempIdx = getBinarySearchIdx(nums[i]);
-            list.add(tempIdx, (long) nums[i]);
-
-            ans[idx++] = getMedian();
-        }
-
-        return ans;
-    }
-
-    private int getBinarySearchIdx(int num) {
-        if (list.size() == 0 || num < list.get(0)) {
-            return 0;
-        }
-        if (num > list.get(list.size() - 1)) {
-            return list.size();
-        }
-
-        int start = 0;
-        int end = list.size();
-
-        while (start < end) {
-            int mid = (start + end) / 2;
-
-            if (list.get(mid) < num) {
-                start = mid + 1;
-            }
-            else {
-                end = mid;
+    public double[] medianSlidingWindow(int[] nums, int windowSize) {
+        double[] medians = new double[nums.length - windowSize + 1];
+        Map<Integer, Integer> delayedRemovals = new HashMap<>();
+        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());  
+        PriorityQueue<Integer> minHeap = new PriorityQueue<>();                          
+        int currentIndex = 0;
+        while (currentIndex < windowSize) {
+            maxHeap.add(nums[currentIndex++]);
+        }
+        for (int j = 0; j < windowSize / 2; j++) {
+            minHeap.add(maxHeap.poll());
+        }
+        int medianIndex = 0;
+        while (true) {
+            if (windowSize % 2 == 1) {
+                medians[medianIndex++] = maxHeap.peek();
+            } else {
+                medians[medianIndex++] = ((double) maxHeap.peek() + (double) minHeap.peek()) / 2.0;
             }
-        }
-
-        return end;
-    }
-
-    private void removeElement(int num) {
-        for (int i=0; i<list.size(); i++) {
-            if (list.get(i) == num) {
-                list.remove(i);
+            if (currentIndex >= nums.length) {
                 break;
             }
+            int outNum = nums[currentIndex - windowSize];  
+            int inNum = nums[currentIndex++];             
+            int balance = 0;                        
+            // Handle outgoing number
+            balance += (outNum <= maxHeap.peek() ? -1 : 1);
+            delayedRemovals.put(outNum, delayedRemovals.getOrDefault(outNum, 0) + 1);
+            // Handle incoming number
+            if (!maxHeap.isEmpty() && inNum <= maxHeap.peek()) {
+                balance++;
+                maxHeap.add(inNum);
+            } else {
+                balance--;
+                minHeap.add(inNum);
+            }
+            // Rebalance heaps
+            if (balance < 0) {
+                maxHeap.add(minHeap.poll());
+                balance++;
+            }
+            if (balance > 0) {
+                minHeap.add(maxHeap.poll());
+                balance--;
+            }
+            // Remove invalid numbers from the top of the heaps
+            while (delayedRemovals.getOrDefault(maxHeap.peek(), 0) > 0) {
+                delayedRemovals.put(maxHeap.peek(), delayedRemovals.get(maxHeap.peek()) - 1);
+                maxHeap.poll();
+            }
+            while (!minHeap.isEmpty() && delayedRemovals.getOrDefault(minHeap.peek(), 0) > 0) {
+                delayedRemovals.put(minHeap.peek(), delayedRemovals.get(minHeap.peek()) - 1);
+                minHeap.poll();
+            }
         }
-    }
-
-    private double getMedian() {
-        if (isEven) {
-            return (double) (list.get(list.size()/2) + list.get(list.size()/2 - 1)) / 2;
-        }
-        else {
-            return (double) list.get(list.size()/2);
-        }
+        return medians;
     }
 }
diff --git a/Hard/Smallest Range Covering Elements from K Lists.java b/Hard/Smallest Range Covering Elements from K Lists.java
new file mode 100644
index 00000000..4e814027
--- /dev/null
+++ b/Hard/Smallest Range Covering Elements from K Lists.java	
@@ -0,0 +1,29 @@
+class Solution {
+    public int[] smallestRange(List<List<Integer>> nums) {
+        PriorityQueue<int[]> pq = new PriorityQueue<>(
+            Comparator.comparingInt(a -> a[0]));
+        int max = Integer.MIN_VALUE;
+        int start = 0;
+        int end = Integer.MAX_VALUE;
+        for (int i = 0; i < nums.size(); i++) {
+            pq.add(new int[]{nums.get(i).get(0), i, 0});
+            max = Math.max(max, nums.get(i).get(0));
+        }
+        while (pq.size() == nums.size()) {
+            int[] removed = pq.poll();
+            int min = removed[0];
+            int row = removed[1];
+            int col = removed[2];
+            if (max - min < end - start) {
+                start = min;
+                end = max;
+            }
+            if (col + 1 < nums.get(row).size()) {
+                int next = nums.get(row).get(col + 1);
+                pq.add(new int[]{next, row, col + 1});
+                max = Math.max(max, next);
+            }
+        }
+        return new int[]{start, end};
+    }
+}
diff --git a/Hard/Sort Items by Groups Respecting Dependencies.java b/Hard/Sort Items by Groups Respecting Dependencies.java
new file mode 100644
index 00000000..38c531a3
--- /dev/null
+++ b/Hard/Sort Items by Groups Respecting Dependencies.java	
@@ -0,0 +1,62 @@
+class Solution {
+    public int[] sortItems(int n, int m, int[] group, List<List<Integer>> beforeItems) {
+        int groupId = m;
+        for (int i = 0; i < group.length; i++) {
+            if (group[i] == -1) {
+                group[i] = groupId++;
+            }
+        }
+        Map<Integer, List<Integer>> nodeToDependentNodes = new HashMap<>();
+        Map<Integer, List<Integer>> groupToDependentGroups = new HashMap<>();
+        int[] itemIndegree = new int[n];
+        int[] groupIndegree = new int[groupId];
+        for (int i = 0; i < beforeItems.size(); i++) {
+            for (Integer prev : beforeItems.get(i)) {
+                nodeToDependentNodes.computeIfAbsent(prev, k -> new ArrayList<>()).add(i);
+                itemIndegree[i]++;
+                if (group[i] != group[prev]) {
+                    groupToDependentGroups.computeIfAbsent(group[prev], k -> new ArrayList<>()).add(group[i]);
+                    groupIndegree[group[i]]++;
+                }
+            }
+        }
+        List<Integer> itemOrdering = topologicalSort(nodeToDependentNodes, itemIndegree);
+        List<Integer> groupOrdering = topologicalSort(groupToDependentGroups, groupIndegree);
+        if (itemOrdering.isEmpty() || groupOrdering.isEmpty()) {
+            return new int[]{};
+        }
+        Map<Integer, List<Integer>> orderedGroups = new HashMap<>();
+        for (Integer item : itemOrdering) {
+            orderedGroups.computeIfAbsent(group[item], k -> new ArrayList<>()).add(item);
+        }
+        int[] result = new int[n];
+        int idx = 0;
+        for (Integer groupNo : groupOrdering) {
+            for (Integer item : orderedGroups.getOrDefault(groupNo, new ArrayList<>())) {
+                result[idx++] = item;
+            }
+        }
+        return result;
+    }
+    
+    private static List<Integer> topologicalSort(Map<Integer, List<Integer>> graph, int[] indegree) {
+        List<Integer> visited = new ArrayList<>();
+        Queue<Integer> queue = new LinkedList<>();
+        for (int i = 0; i < indegree.length; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i);
+            }
+        }
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            visited.add(removed);
+            for (Integer conn : graph.getOrDefault(removed, new ArrayList<>())) {
+                indegree[conn]--;
+                if (indegree[conn] == 0) {
+                    queue.add(conn);
+                }
+            }
+        }
+        return visited.size() == indegree.length ? visited : new ArrayList<>();
+    }
+}
diff --git a/Hard/Stone Game III.java b/Hard/Stone Game III.java
new file mode 100644
index 00000000..0ee4e539
--- /dev/null
+++ b/Hard/Stone Game III.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public String stoneGameIII(int[] stoneValue) {
+        int n = stoneValue.length;
+        int[] dp = new int[n + 1];
+        for (int i = n - 1; i >= 0; i--) {
+            dp[i] = stoneValue[i] - dp[i + 1];
+            if (i + 2 <= n) {
+                dp[i] = Math.max(dp[i], stoneValue[i] + stoneValue[i + 1] - dp[i + 2]);
+            }
+            if (i + 3 <= n) {
+                dp[i] = Math.max(dp[i], stoneValue[i] + stoneValue[i + 1] + stoneValue[i + 2] - dp[i + 3]);
+            }
+        }
+        return dp[0] == 0 ? "Tie" : (dp[0] > 0 ? "Alice" : "Bob");
+    }
+}
diff --git a/Hard/String Compression II.java b/Hard/String Compression II.java
index d2f3d371..ac420adf 100644
--- a/Hard/String Compression II.java	
+++ b/Hard/String Compression II.java	
@@ -1,69 +1,58 @@
 class Solution {
-  
-  /**
-  * First dimension : Current index
-  * Second dimension : Amount of available deletions
-  * Third dimension : Index of previous character
-  * Fourth dimension : Consecutive count of previous character
-  */
-  private static int[][][][] dp = new int[100][101][100][26];
-  
-  public int getLengthOfOptimalCompression(String s, int k) {
-    int n = s.length();
-    for(int i = 0; i < n; i++) {
-      for(int j = 0; j <= k; j++) {
-        for(int z = 0; z < n; z++) {
-          for(int l = 0; l < 26; l++) {
-            dp[i][j][z][l]=-1;
-          }
+
+    private static int[][][][] dp = new int[100][101][100][26];
+
+    public int getLengthOfOptimalCompression(String s, int k) {
+        int n = s.length();
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j <= k; j++) {
+                for (int x = 0; x < n; x++) {
+                    for (int y = 0; y < 26; y++) {
+                        dp[i][j][x][y] = -1;
+                    }
+                }
+            }
         }
-      }
+        return solver(s.toCharArray(), 0, k, 0, s.charAt(0));
     }
-    return best(s.toCharArray(), /* idx= */ 0, k, /* count= */ 0, /* prevChar= */ s.charAt(0));
-  }
-  
-  private int best(char[] letters, int idx, int k, int count, char prevChar) {
-    if (idx == letters.length) {
-      return countNumberOfLetters(count);
-    }
-    if (dp[idx][k][count][prevChar - 'a'] != -1) {
-      return dp[idx][k][count][prevChar - 'a'];
-    }
-    if (k == 0) {
-      int result = 0;
-      if (letters[idx] == prevChar) {
-        result = best(letters, idx + 1, k, count + 1, prevChar);
-      } else {
-        result = countNumberOfLetters(count) + best(letters, idx + 1, k, 1, letters[idx]);
-      }
-      dp[idx][k][count][prevChar - 'a'] = result;
-      return result;
-    }
-    int result = 0;
-    if (letters[idx] == prevChar) {
-      result = Math.min(
-        best(letters, idx + 1, k, count + 1, prevChar), // Delete and recurse forward
-        best(letters, idx + 1, k - 1, count, prevChar)); // Don't delete and recurse forward
-    } else {
-      result = Math.min(
-        countNumberOfLetters(count) + best(letters, idx + 1, k, /* count= */ 1, /* prevChar= */ letters[idx]), // Don't delete current char and recurse forward with new count
-        best(letters, idx + 1, k - 1, count, prevChar)); // Delete current character and recurse forward
-    }
-    dp[idx][k][count][prevChar - 'a'] = result;
-    return result;
-  }
-  
-  private static int countNumberOfLetters(int count) {
-    if (count == 0) {
-      return count;
+
+    private int solver(char[] letters, int idx, int k, int currFrequency, char prevChar) {
+        if (idx == letters.length) {
+            return getLetterCount(currFrequency);
+        }
+        if (dp[idx][k][currFrequency][prevChar - 'a'] != -1) {
+            return dp[idx][k][currFrequency][prevChar - 'a'];
+        }
+        int result = 0;
+        if (letters[idx] == prevChar) {
+            result = k == 0 ? 
+                solver(letters, idx + 1, k, currFrequency + 1, prevChar) : 
+                Math.min(
+                    solver(letters, idx + 1, k , currFrequency + 1, prevChar), // don't delete
+                    solver(letters, idx + 1, k - 1 , currFrequency, prevChar) // delete
+                );
+        } else {
+            result = k == 0 ?
+                getLetterCount(currFrequency) + solver(letters, idx + 1, k, 1, letters[idx]) :
+                Math.min(
+                    getLetterCount(currFrequency) + solver(letters, idx + 1, k, 1, letters[idx]), // don't delete
+                    solver(letters, idx + 1, k - 1, currFrequency, prevChar) // delete
+                );
+        }
+        return dp[idx][k][currFrequency][prevChar - 'a'] = result;
     }
-    int numberOfDigits = 1;
-    if (count > 9) {
-      numberOfDigits = 2;
-    } 
-    if (count > 99) {
-      numberOfDigits = 3;
+
+    private static int getLetterCount(int frequency) {
+        if (frequency == 0) {
+            return 0;
+        }
+        int digits = 1;
+        if (frequency > 9) {
+            digits = 2;
+        }
+        if (frequency > 99) {
+            digits = 3;
+        }
+        return frequency == 1 ? 1 : (digits + 1);
     }
-    return count == 1 ? 1 : (numberOfDigits + 1);
-  }
 }
diff --git a/Hard/Subarrays with K Different Integers.java b/Hard/Subarrays with K Different Integers.java
index 42224709..0a1d5559 100644
--- a/Hard/Subarrays with K Different Integers.java	
+++ b/Hard/Subarrays with K Different Integers.java	
@@ -1,29 +1,23 @@
 class Solution {
-  public int subarraysWithKDistinct(int[] A, int K) {
-    return atMostK(A, K) - atMostK(A, K - 1);
-  }
-  
-  private int atMostK(int[] A, int K) {
-    int start = 0;
-    int end = 0;
-    int n = A.length;
-    Map<Integer, Integer> map = new HashMap<>();
-    int count = 0;
-    while (end < n) {
-      if (map.getOrDefault(A[end], 0) == 0) {
-        K--;
-      }
-      map.put(A[end], map.getOrDefault(A[end], 0) + 1);
-      while (K < 0) {
-        map.put(A[start], map.getOrDefault(A[start], 0) - 1);
-        if (map.get(A[start]) == 0) {
-          K++;
+    public int subarraysWithKDistinct(int[] nums, int k) {
+        return slidingWindowAtMost(nums, k) - slidingWindowAtMost(nums, k - 1);
+    }
+
+    private int slidingWindowAtMost(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int left = 0;
+        int count = 0;
+        for (int right = 0; right < nums.length; right++) {
+            map.put(nums[right], map.getOrDefault(nums[right], 0) + 1);
+            while (map.size() > k) {
+                map.put(nums[left], map.get(nums[left]) - 1);
+                if (map.get(nums[left]) == 0) {
+                    map.remove(nums[left]);
+                }
+                left++;
+            }
+            count += right - left + 1;
         }
-        start++;
-      }
-      count += end - start + 1;
-      end++;
+        return count;
     }
-    return count;
-  }
 }
diff --git a/Hard/Tallest Billboard.java b/Hard/Tallest Billboard.java
new file mode 100644
index 00000000..04f81763
--- /dev/null
+++ b/Hard/Tallest Billboard.java	
@@ -0,0 +1,35 @@
+class Solution {
+    public int tallestBillboard(int[] rods) {
+        int n = rods.length;
+        Map<Integer, Integer> firstHalf = helper(rods, 0, n / 2);
+        Map<Integer, Integer> secondHalf = helper(rods, n / 2, n);
+        int result = 0;
+        for (Integer difference : firstHalf.keySet()) {
+            if (secondHalf.containsKey(-1 * difference)) {
+                result = Math.max(result, firstHalf.get(difference) + secondHalf.get(-1 * difference));
+            }
+        }
+        return result;
+    }
+    
+    private Map<Integer, Integer> helper(int[] rods, int leftIdx, int rightIdx) {
+        Set<Pair<Integer, Integer>> states = new HashSet<>();
+        states.add(new Pair(0, 0));
+        for (int i = leftIdx; i < rightIdx; i++) {
+            int rod = rods[i];
+            Set<Pair<Integer, Integer>> newStates = new HashSet<>();
+            for (Pair<Integer, Integer> state : states) {
+                newStates.add(new Pair(state.getKey() + rod, state.getValue()));
+                newStates.add(new Pair(state.getKey(), state.getValue() + rod));
+            }
+            states.addAll(newStates);
+        }
+        Map<Integer, Integer> dp = new HashMap<>();
+        for (Pair<Integer, Integer> pair : states) {
+            Integer left = pair.getKey();
+            Integer right = pair.getValue();
+            dp.put(left - right, Math.max(dp.getOrDefault(left - right, 0), left));
+        }
+        return dp;
+    }
+}
diff --git a/Hard/Trapping Rain Water.java b/Hard/Trapping Rain Water.java
index 8747d76b..263ab08a 100644
--- a/Hard/Trapping Rain Water.java	
+++ b/Hard/Trapping Rain Water.java	
@@ -1,27 +1,23 @@
 class Solution {
-  public int trap(int[] height) {
-    int leftIdx = 0;
-    int rightIdx = height.length - 1;
-    int leftMax = 0;
-    int rightMax = 0;
-    int result = 0;
-    while (leftIdx < rightIdx) {
-      if (height[leftIdx] < height[rightIdx]) {
-        if (height[leftIdx] >= leftMax) {
-          leftMax = height[leftIdx];
-        } else {
-          result += leftMax - height[leftIdx];
+    public int trap(int[] height) {
+        if (height.length == 0) {
+            return 0;
         }
-        leftIdx++;
-      } else {
-        if (height[rightIdx] >= rightMax) {
-          rightMax = height[rightIdx];
-        } else {
-          result += rightMax - height[rightIdx];
+        int n = height.length;
+        int[] leftMax = new int[n];
+        leftMax[0] = height[0];
+        for (int i = 1; i < n; i++) {
+            leftMax[i] = Math.max(height[i], leftMax[i - 1]);
         }
-        rightIdx--;
-      }
+        int[] rightMax = new int[n];
+        rightMax[n - 1] = height[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            rightMax[i] = Math.max(rightMax[i + 1], height[i]);
+        }
+        int result = 0;
+        for (int i = 1; i < n - 1; i++) {
+            result += Math.min(leftMax[i], rightMax[i]) - height[i];
+        }
+        return result;
     }
-    return result;
-  }
 }
diff --git a/Hard/Valid Number.java b/Hard/Valid Number.java
index d9a68285..1cdebfa8 100644
--- a/Hard/Valid Number.java	
+++ b/Hard/Valid Number.java	
@@ -1,90 +1,62 @@
 class Solution {
-        public boolean isNumber(String s) {
-        s = s.trim();
-        char[] ch = s.toCharArray();
+    public boolean isNumber(String s) {
         int idx = 0;
-        int n = ch.length;
-        boolean signFound = false;
-        boolean decimalFound = false;
-        boolean numFound = false;
-        boolean expoFound = false;
-
+        boolean isDecimal = false;
+        boolean isDigit = false;
+        boolean digitsBeforeDecimal = false;
+        boolean digitsAfterDecimal = false;
+        int n = s.length();
+        if (s.charAt(idx) == '-' || s.charAt(idx) == '+') {
+            idx++;
+        }
         while (idx < n) {
-            if (ch[idx] == '+' || ch[idx] == '-') {
-                if (numFound || signFound || decimalFound) {
+            if (s.charAt(idx) == '.') {
+                if (isDecimal) {
                     return false;
                 }
-
-                signFound = true;
-            }
-            else if (ch[idx] == '.') {
-                if (decimalFound) {
+                isDecimal = true;
+            } else if (s.charAt(idx) == 'e' || s.charAt(idx) == 'E') {
+                if (!isDigit) {
                     return false;
                 }
-                decimalFound = true;
-            }
-            else if (Character.isLetter(ch[idx])) {
-                if (ch[idx] == 'e') {
-                    if (!numFound) {
-                        return false;
-                    }
-                    idx++;
-                    expoFound = true;
-                    break;
-                }
-                else {
+                boolean valid = isValidExponent(s, idx + 1);
+                if (!valid) {
                     return false;
                 }
-            }
-            else if (Character.isDigit(ch[idx])) {
-                numFound = true;
-            }
-            else if (ch[idx] == ' ') {
-                if (numFound || signFound || decimalFound) {
-                    return false;
+                break;
+            } else if (Character.isDigit(s.charAt(idx))) {
+                if (isDecimal) {
+                    digitsAfterDecimal = true;
+                } else {
+                    digitsBeforeDecimal = true;
                 }
+                isDigit = true;
+            } else {
+                return false;
             }
-
             idx++;
         }
-
-        if (!numFound) {
-            return false;
+        if (isDecimal) {
+            return digitsBeforeDecimal || digitsAfterDecimal;
         }
+        return isDigit;
+    } 
 
-        if (expoFound && idx == n) {
+    private boolean isValidExponent(String s, int idx) {
+        if (idx == s.length()) {
             return false;
         }
-
-        signFound = false;
-        numFound = false;
-        while (idx < n) {
-            if (ch[idx] == '.') {
-                return false;
-            }
-            else if (ch[idx] == '+' || ch[idx] == '-') {
-                if (signFound) {
-                    return false;
-                }
-                if (numFound) {
-                    return false;
-                }
-                signFound = true;
-            }
-            else if (Character.isDigit(ch[idx])) {
-                numFound = true;
-            }
-            else {
+        if (s.charAt(idx) == '-' || s.charAt(idx) == '+') {
+            idx++;
+        }
+        boolean digitFound = false;
+        while (idx < s.length()) {
+            if (!Character.isDigit(s.charAt(idx))) {
                 return false;
             }
-
+            digitFound = true;
             idx++;
         }
-
-        if (expoFound && !numFound) {
-            return false;
-        }
-
-        return true;
+        return digitFound;
     }
 }
diff --git a/Hard/Valid Palindrome III.java b/Hard/Valid Palindrome III.java
new file mode 100644
index 00000000..dc97a304
--- /dev/null
+++ b/Hard/Valid Palindrome III.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public boolean isValidPalindrome(String s, int k) {
+        int n = s.length();
+        Integer[][] dp = new Integer[n][n];
+        return isValidPalindrome(s, 0, n - 1, dp) <= k;
+    }
+
+    private int isValidPalindrome(String s, int left, int right, Integer[][] dp) {
+        if (left == right) {
+            return 0;
+        }
+        if (left == right - 1) {
+            return s.charAt(left) != s.charAt(right) ? 1 : 0;
+        }
+        if (dp[left][right] != null) {
+            return dp[left][right];
+        }
+        if (s.charAt(left) == s.charAt(right)) {
+            return isValidPalindrome(s, left + 1, right - 1, dp); // move both pointers
+        }
+        return dp[left][right] = 1 + Math.min(
+            isValidPalindrome(s, left + 1, right, dp), // move only left pointer
+            isValidPalindrome(s, left, right - 1, dp) // move only right pointer
+        );
+    }
+}
diff --git a/Medium/132 Pattern.java b/Medium/132 Pattern.java
index 80a6c64e..54937149 100644
--- a/Medium/132 Pattern.java	
+++ b/Medium/132 Pattern.java	
@@ -1,25 +1,23 @@
 class Solution {
-  public boolean find132pattern(int[] nums) {
-    if (nums.length < 3) {
-      return false;
-    }
-    int[] minTillIndex = new int[nums.length];
-    minTillIndex[0] = nums[0];
-    for (int idx = 1; idx < nums.length; idx++) {
-      minTillIndex[idx] = Math.min(minTillIndex[idx - 1], nums[idx]);
-    }
-    Stack<Integer> stack = new Stack<>();
-    for (int idx = nums.length - 1; idx >= 0; idx--) {
-      if (nums[idx] > minTillIndex[idx]) {
-        while (!stack.isEmpty() && stack.peek() <= minTillIndex[idx]) {
-          stack.pop();
+    public boolean find132pattern(int[] nums) {
+        int n = nums.length;
+        int[] uptoIdxMin = new int[n];
+        uptoIdxMin[0] = nums[0];
+        for (int i = 1; i < n; i++) {
+            uptoIdxMin[i] = Math.min(uptoIdxMin[i - 1], nums[i]);
         }
-        if (!stack.isEmpty() && stack.peek() < nums[idx]) {
-          return true;
+        Stack<Integer> stack = new Stack<>();
+        for (int i = n - 1; i >= 0; i--) {
+            if (nums[i] > uptoIdxMin[i]) {
+                while (!stack.isEmpty() && stack.peek() <= uptoIdxMin[i]) {
+                    stack.pop();
+                }
+                if (!stack.isEmpty() && stack.peek() < nums[i]) {
+                    return true;
+                }
+                stack.push(nums[i]);
+            }
         }
-        stack.push(nums[idx]);
-      }
+        return false;
     }
-    return false;
-  }
 }
diff --git a/Medium/3Sum.java b/Medium/3Sum.java
index fc4f25fa..3c615e51 100644
--- a/Medium/3Sum.java
+++ b/Medium/3Sum.java
@@ -1,21 +1,25 @@
 class Solution {
-  public List<List<Integer>> threeSum(int[] nums) {
-    Set<List<Integer>> result = new HashSet<>();
-    Set<Integer> duplicates = new HashSet<>();
-    Map<Integer, Integer> map = new HashMap<>();
-    for (int i = 0; i < nums.length; i++) {
-      if (duplicates.add(nums[i])) {
-        for (int j = i + 1; j < nums.length; j++) {
-          int target = -nums[i] - nums[j];
-          if (map.containsKey(target) && map.get(target) == i) {
-            List<Integer> temp = Arrays.asList(nums[i], nums[j], target);
-            Collections.sort(temp);
-            result.add(temp);
-          }
-          map.put(nums[j], i);
+    public List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums);
+        List<List<Integer>> result = new ArrayList<>();
+        for (int i = 0; i < nums.length; i++) {
+            if (i != 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }
+            int low = i + 1;
+            int high = nums.length - 1;
+            while (low < high) {
+                int currSum = nums[low] + nums[high] + nums[i];
+                if (currSum > 0 || (high < nums.length - 1 && nums[high] == nums[high + 1])) {
+                    high--;
+                } else if (currSum < 0 || (low > i + 1 && nums[low] == nums[low - 1])) {
+                    low++;
+                } else {
+                    result.add(Arrays.asList(nums[i], nums[low++], nums[high--]));
+                }
+                
+            }
         }
-      }
+        return result;
     }
-    return new ArrayList<>(result);
-  }
 }
diff --git a/Medium/4 Keys Keyboard.java b/Medium/4 Keys Keyboard.java
new file mode 100644
index 00000000..2ca4bb8e
--- /dev/null
+++ b/Medium/4 Keys Keyboard.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int maxA(int n) {
+        int[] dp = new int[n + 1];
+        for (int i = 0; i <= n; i++) {
+            dp[i] = i;
+        }
+        for (int i = 0; i <= n - 3; i++) {
+            for (int j = i + 3; j <= Math.min(n, i + 6); j++) {
+                dp[j] = Math.max(dp[j], (j - i - 1) * dp[i]);
+            }
+        }
+        return dp[n];
+    }
+}
diff --git a/Medium/Add Two Numbers II.java b/Medium/Add Two Numbers II.java
index fe08935f..59d717cb 100644
--- a/Medium/Add Two Numbers II.java	
+++ b/Medium/Add Two Numbers II.java	
@@ -9,40 +9,40 @@
  * }
  */
 class Solution {
-  public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
-    ListNode revL1 = reverse(l1);
-    ListNode revL2 = reverse(l2);
-    ListNode dummy = new ListNode(0);
-    ListNode curr = dummy;
-    int carry = 0;
-    while (revL1 != null || revL2 != null || carry != 0) {
-      if (revL1 != null && revL2 != null) {
-        carry += revL1.val + revL2.val;
-        revL1 = revL1.next;
-        revL2 = revL2.next;
-      } else if (revL1 != null && revL2 == null) {
-        carry += revL1.val;
-        revL1 = revL1.next;
-      } else if (revL1 == null && revL2 != null) {
-        carry += revL2.val;
-        revL2 = revL2.next;
-      }
-      curr.next = new ListNode(carry % 10);
-      carry /= 10;
-      curr = curr.next;
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        ListNode rev1 = reverse(l1);
+        ListNode rev2 = reverse(l2);
+        ListNode dummy = new ListNode();
+        ListNode curr = dummy;
+        int carry = 0;
+        while (rev1 != null || rev2 != null || carry > 0) {
+            if (rev1 != null && rev2 != null) {
+                carry += rev1.val + rev2.val;
+                rev1 = rev1.next;
+                rev2 = rev2.next;
+            } else if (rev1 == null && rev2 != null) {
+                carry += rev2.val;
+                rev2 = rev2.next;
+            } else if (rev1 != null && rev2 == null) {
+                carry += rev1.val;
+                rev1 = rev1.next;
+            }
+            curr.next = new ListNode(carry % 10);
+            curr = curr.next;
+            carry /= 10;
+        }
+        return reverse(dummy.next);
     }
-    return reverse(dummy.next);
-  }
-  
-  private ListNode reverse(ListNode root) {
-    ListNode curr = root;
-    ListNode prev = null;
-    while (curr != null) {
-      ListNode next = curr.next;
-      curr.next = prev;
-      prev = curr;
-      curr = next;
+    
+    private ListNode reverse(ListNode node) {
+        ListNode curr = node;
+        ListNode prev = null;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
     }
-    return prev;
-  }
 }
diff --git a/Medium/Add Two Polynomials Represented as Linked Lists.java b/Medium/Add Two Polynomials Represented as Linked Lists.java
new file mode 100644
index 00000000..f7eafe3a
--- /dev/null
+++ b/Medium/Add Two Polynomials Represented as Linked Lists.java	
@@ -0,0 +1,43 @@
+/**
+ * Definition for polynomial singly-linked list.
+ * class PolyNode {
+ *     int coefficient, power;
+ *     PolyNode next = null;
+ 
+ *     PolyNode() {}
+ *     PolyNode(int x, int y) { this.coefficient = x; this.power = y; }
+ *     PolyNode(int x, int y, PolyNode next) { this.coefficient = x; this.power = y; this.next = next; }
+ * }
+ */
+
+class Solution {
+    public PolyNode addPoly(PolyNode poly1, PolyNode poly2) {
+        Map<Integer, Integer> powerToValue = new HashMap<>();
+        populateMap(powerToValue, poly1);
+        populateMap(powerToValue, poly2);
+        List<Integer> powerKeys = new ArrayList<>(powerToValue.keySet());
+        Collections.sort(powerKeys);
+        PolyNode dummy = new PolyNode();
+        PolyNode curr = dummy;
+        for (int i = powerKeys.size() - 1; i >= 0; i--) {
+            if (powerToValue.get(powerKeys.get(i)) == 0) {
+                continue;
+            }
+            PolyNode node = new PolyNode(powerToValue.get(powerKeys.get(i)), powerKeys.get(i));
+            curr.next = node;
+            curr = curr.next;
+        }
+        return dummy.next;
+    }
+
+    private void populateMap(Map<Integer, Integer> powerToValue, PolyNode poly) {
+        while (poly != null) {
+            PolyNode node = poly;
+            int power = node.power;
+            if (node.coefficient != 0) {
+                powerToValue.put(power, powerToValue.getOrDefault(power, 0) + node.coefficient);
+            }
+            poly = poly.next;
+        }
+    }
+}
diff --git a/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java b/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java
index 60ab5900..36063815 100644
--- a/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java	
+++ b/Medium/All Ancestors of a Node in a Directed Acyclic Graph.java	
@@ -1,26 +1,36 @@
 class Solution {
-  public List<List<Integer>> getAncestors(int n, int[][] edges) {
-    Map<Integer, List<Integer>> graph = new HashMap<>();
-    for (int[] edge : edges) {
-      graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
-    }
-    List<List<Integer>> result = new ArrayList<>();
-    for (int i = 0; i < n; i++) {
-      List<Integer> ancestors = new ArrayList<>();
-      Set<Integer> visited = new HashSet<>();
-      Queue<Integer> queue = new LinkedList<>(graph.getOrDefault(i, new ArrayList<>()));
-      while (!queue.isEmpty()) {
-        int removed = queue.remove();
-        if (visited.contains(removed)) {
-          continue;
+    public List<List<Integer>> getAncestors(int n, int[][] edges) {
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        int[] indegree = new int[n];
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+            indegree[edge[1]]++;
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        Map<Integer, Set<Integer>> ancestors = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            if (indegree[i] == 0) {
+                queue.offer(i);
+            }
+        }
+        while (!queue.isEmpty()) {
+            int node = queue.poll();
+            ancestors.computeIfAbsent(node, k -> new HashSet<>());
+            for (int dependents : graph.getOrDefault(node, Collections.emptyList())) {
+                ancestors.computeIfAbsent(dependents, k -> new HashSet<>()).add(node);
+                ancestors.get(dependents).addAll(ancestors.get(node));
+                indegree[dependents]--;
+                if (indegree[dependents] == 0) {
+                    queue.offer(dependents);
+                }
+            }
+        }
+        List<List<Integer>> result = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            List<Integer> currNodeAncestors = new ArrayList<>(ancestors.getOrDefault(i, Collections.emptySet()));
+            currNodeAncestors.sort(Comparator.naturalOrder());
+            result.add(currNodeAncestors);
         }
-        ancestors.add(removed);
-        visited.add(removed);
-        queue.addAll(graph.getOrDefault(removed, new ArrayList<>()));
-      }
-      Collections.sort(ancestors);
-      result.add(ancestors);
+        return result;
     }
-    return result;
-  }
 }
diff --git a/Medium/All Nodes Distance K in Binary Tree.java b/Medium/All Nodes Distance K in Binary Tree.java
index 13e9485b..9f88451e 100644
--- a/Medium/All Nodes Distance K in Binary Tree.java	
+++ b/Medium/All Nodes Distance K in Binary Tree.java	
@@ -8,49 +8,48 @@
  * }
  */
 class Solution {
-  public List<Integer> distanceK(TreeNode root, TreeNode target, int k) {
-    List<Integer> result = new ArrayList<>();
-    dfs(root, target, k, result);
-    return new ArrayList<>(result);
-  }
-  
-  private int dfs(TreeNode node, TreeNode target, int k, List<Integer> result) {
-    if (node == null) {
-      return -1;
+    public List<Integer> distanceK(TreeNode root, TreeNode target, int k) {
+        List<Integer> result = new ArrayList<>();
+        dfs(root, target, k, result);
+        return result;
     }
-    if (node == target) {
-      addToResult(node, 0, result, k);
-      return 1;
-    } else {
-      int left = dfs(node.left, target, k, result);
-      int right = dfs(node.right, target, k, result);
-      if (left != -1) {
-        if (left == k) {
-          result.add(node.val);
+    
+    private int dfs(TreeNode node, TreeNode target, int k, List<Integer> result) {
+        if (node == null) {
+            return -1;
         }
-        addToResult(node.right, left + 1, result, k);
-        return left + 1;
-      } else if (right != -1) {
-        if (right == k) {
-          result.add(node.val);
+        if (node == target) {
+            dfs(node, 0, k, result);
+            return 1;
+        }
+        int left = dfs(node.left, target, k, result);
+        if (left != -1) {
+            if (left == k) {
+               result.add(node.val);
+            }
+            dfs(node.right, left + 1, k, result);
+            return left + 1;
+        }
+        int right = dfs(node.right, target, k, result);
+        if (right != -1) {
+            if (right == k) {
+               result.add(node.val);
+            }
+            dfs(node.left, right + 1, k, result);
+            return right + 1;
         }
-        addToResult(node.left, right + 1, result, k);
-        return right + 1;
-      } else {
         return -1;
-      }
-    }
-  }
-  
-  private void addToResult(TreeNode node, int dist, List<Integer> result, int k) {
-    if (node == null || dist > k) {
-      return;
     }
-    if (dist == k) {
-      result.add(node.val);
-    } else {
-      addToResult(node.left, dist + 1, result, k);
-      addToResult(node.right, dist + 1, result, k);
+    
+    private void dfs(TreeNode node, int distance, int k, List<Integer> result) {
+        if (node == null || distance > k) {
+            return;
+        }
+        if (distance == k) {
+            result.add(node.val);
+            return;
+        }
+        dfs(node.left, distance + 1, k, result);
+        dfs(node.right, distance + 1, k, result);
     }
-  }
 }
diff --git a/Medium/Amount of Time for Binary Tree to Be Infected.java b/Medium/Amount of Time for Binary Tree to Be Infected.java
new file mode 100644
index 00000000..8d5540ab
--- /dev/null
+++ b/Medium/Amount of Time for Binary Tree to Be Infected.java	
@@ -0,0 +1,65 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int amountOfTime(TreeNode root, int start) {
+        Map<TreeNode, TreeNode> nodeToParent = new HashMap<>();
+        buildNodeToParentRelationship(root, null, nodeToParent);
+        TreeNode startNode = nodeToParent.keySet()
+            .stream()
+            .filter(node -> node.val == start)
+            .findFirst()
+            .orElse(null);
+        return calculateInfectionTime(nodeToParent, startNode);
+    }
+
+    private void buildNodeToParentRelationship(TreeNode root, TreeNode parent, Map<TreeNode, TreeNode> nodeToParent) {
+        if (root == null) {
+            return;
+        }
+        nodeToParent.put(root, parent);
+        buildNodeToParentRelationship(root.left, root, nodeToParent);
+        buildNodeToParentRelationship(root.right, root, nodeToParent);
+    }
+
+    private int calculateInfectionTime(Map<TreeNode, TreeNode> nodeToParent, TreeNode startNode) {
+        int time = 0;
+        Set<Integer> isInfected = new HashSet<>();
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(startNode);
+        isInfected.add(startNode.val);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                TreeNode parent = nodeToParent.get(removed);
+                if (nodeToParent.get(removed) != null && isInfected.add(nodeToParent.get(removed).val)) {
+                    queue.add(nodeToParent.get(removed));
+                }
+                if (removed.left != null && isInfected.add(removed.left.val)) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null && isInfected.add(removed.right.val)) {
+                    queue.add(removed.right);
+                }
+            }
+            if (queue.isEmpty()) {
+                break;
+            }
+            time++;
+        }
+        return time;
+    }
+}
diff --git a/Medium/Append Characters to String to Make Subsequence.java b/Medium/Append Characters to String to Make Subsequence.java
new file mode 100644
index 00000000..af35ca3d
--- /dev/null
+++ b/Medium/Append Characters to String to Make Subsequence.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int appendCharacters(String s, String t) {
+        int idxS = 0;
+        int idxT = 0;
+        while (idxS < s.length() && idxT < t.length()) {
+            if (s.charAt(idxS) == t.charAt(idxT)) {
+                idxT++;
+            }
+            idxS++;
+        }
+        return idxT == t.length() ? 0 : t.length() - idxT;
+    }
+}
diff --git a/Medium/Apply Operations to Make String Empty.java b/Medium/Apply Operations to Make String Empty.java
new file mode 100644
index 00000000..c378a060
--- /dev/null
+++ b/Medium/Apply Operations to Make String Empty.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public String lastNonEmptyString(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        int maxFrequency = 0;
+        for (int i = 0; i < s.length(); i++) {
+            map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
+            maxFrequency = Math.max(maxFrequency, map.get(s.charAt(i)));
+        }
+        StringBuilder result = new StringBuilder();
+        for (int i = s.length() - 1; i >= 0; i--) {
+            if (map.get(s.charAt(i)) == maxFrequency) {
+                result.append(s.charAt(i));
+                map.put(s.charAt(i), map.get(s.charAt(i)) - 1);
+            }
+        }
+        return result.reverse().toString();
+    }
+}
diff --git a/Medium/As Far from Land as Possible.java b/Medium/As Far from Land as Possible.java
index 2e80a70b..6e1ba29a 100644
--- a/Medium/As Far from Land as Possible.java	
+++ b/Medium/As Far from Land as Possible.java	
@@ -1,37 +1,38 @@
 class Solution {
-  private final int[][] DIRS = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
-  
-  public int maxDistance(int[][] grid) {
-    Queue<int[]> queue = new LinkedList<>();
-    int numRows = grid.length;
-    int numCols = grid[0].length;
-    for (int i = 0; i < numRows; i++) {
-      for (int j = 0; j < numCols; j++) {
-        if (grid[i][j] == 1) {
-          queue.add(new int[]{i, j});
+    
+    private static final int[][] DIRS = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
+    
+    public int maxDistance(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        Queue<int[]> queue = new LinkedList<>();    
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (grid[i][j] == 1) {
+                    queue.add(new int[]{i, j});
+                }
+            }
         }
-      }
-    }
-    if (queue.isEmpty() || queue.size() == numRows * numCols) {
-      return -1;
-    }
-    int distance = 0;
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int[] removed = queue.remove();
-        for (int[] dir : DIRS) {
-          int x = removed[0] + dir[0];
-          int y = removed[1] + dir[1];
-          if (x < 0 || y < 0 || x >= numRows || y >= numCols || grid[x][y] == 1) {
-            continue;
-          }
-          grid[x][y] = 1;
-          queue.add(new int[]{x, y});
+        if (queue.isEmpty() || queue.size() == rows * cols) {
+            return -1;
+        }
+        int distance = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] removed = queue.remove();
+                for (int[] dir : DIRS) {
+                    int x = removed[0] + dir[0];
+                    int y = removed[1] + dir[1];
+                    if (x < 0 || y < 0 || x >= rows || y >= cols || grid[x][y] == 1) {
+                        continue;
+                    }
+                    grid[x][y] = 1;
+                    queue.add(new int[]{x, y});
+                }
+            }
+            distance++;
         }
-      }
-      distance++;
+        return distance - 1;
     }
-    return distance - 1; 
-  }
 }
diff --git a/Medium/Asteroid Collision.java b/Medium/Asteroid Collision.java
index f739ff48..64a10bf3 100644
--- a/Medium/Asteroid Collision.java	
+++ b/Medium/Asteroid Collision.java	
@@ -1,26 +1,33 @@
 class Solution {
-  public int[] asteroidCollision(int[] asteroids) {
-    Stack<Integer> stack = new Stack<>();
-    for (int asteroid : asteroids) {
-      if (asteroid < 0) {
-        while (!stack.isEmpty() && stack.peek() > 0 && stack.peek() < Math.abs(asteroid)) {
-          stack.pop();
+    public int[] asteroidCollision(int[] asteroids) {
+        List<Integer> result = new ArrayList<>();
+        int idx = 0;
+        while (idx < asteroids.length && asteroids[idx] < 0) {
+            result.add(asteroids[idx++]);
         }
-        if (!stack.isEmpty() && stack.peek() > 0) {
-          if (stack.peek() == Math.abs(asteroid)) {
-            stack.pop();
-          }
-        } else {
-          stack.push(asteroid);
+        while (idx < asteroids.length) {
+            if (asteroids[idx] > 0) {
+                result.add(asteroids[idx++]);
+            } else {
+                if (result.isEmpty() || result.get(result.size() - 1) < 0) {
+                    result.add(asteroids[idx]);
+                } else {
+                    while (!result.isEmpty() && 
+                           result.get(result.size() - 1) > 0 && 
+                           result.get(result.size() - 1) < Math.abs(asteroids[idx])) {
+                        result.remove(result.size() - 1);
+                    }
+                    if (!result.isEmpty() && result.get(result.size() - 1) > 0) {
+                        if (result.get(result.size() - 1) == Math.abs(asteroids[idx])) {
+                            result.remove(result.size() - 1);
+                        } 
+                    } else {
+                        result.add(asteroids[idx]);
+                    }
+                }
+                idx++;
+            }
         }
-      } else {
-        stack.push(asteroid);
-      }
+        return result.stream().mapToInt(Integer::valueOf).toArray();
     }
-    int[] result = new int[stack.size()];
-    for (int i = result.length - 1; i >= 0; i--) {
-      result[i] = stack.pop();
-    }
-    return result;
-  }
 }
diff --git a/Medium/Bag of Tokens.java b/Medium/Bag of Tokens.java
index d86085c3..1a409e0c 100644
--- a/Medium/Bag of Tokens.java	
+++ b/Medium/Bag of Tokens.java	
@@ -1,23 +1,23 @@
 class Solution {
-  public int bagOfTokensScore(int[] tokens, int power) {
-    int score = 0;
-    Arrays.sort(tokens);
-    int leftIdx = 0;
-    int rightIdx = tokens.length - 1;
-    int currScore = 0;
-    while (leftIdx <= rightIdx) {
-      if (power >= tokens[leftIdx]) {
-        currScore++;
-        power -= tokens[leftIdx++];
-      } else {
-        if (currScore == 0) {
-          break;
+    public int bagOfTokensScore(int[] tokens, int power) {
+        int score = 0;
+        int currScore = 0;
+        Arrays.sort(tokens);
+        int left = 0;
+        int right = tokens.length - 1;
+        while (left <= right) {
+            if (power >= tokens[left]) {
+                currScore++;
+                power -= tokens[left++];
+            } else {
+                if (currScore == 0) {
+                    break;
+                }
+                currScore--;
+                power += tokens[right--];
+            }
+            score = Math.max(score, currScore);
         }
-        currScore--;
-        power += tokens[rightIdx--];
-      }
-      score = Math.max(score, currScore);
+        return score;
     }
-    return score;
-  }
 }
diff --git a/Medium/Balance a Binary Search Tree.java b/Medium/Balance a Binary Search Tree.java
index 9fbf14ce..dd07996e 100644
--- a/Medium/Balance a Binary Search Tree.java	
+++ b/Medium/Balance a Binary Search Tree.java	
@@ -14,29 +14,37 @@
  * }
  */
 class Solution {
-  public TreeNode balanceBST(TreeNode root) {
-    List<Integer> sortedList = new ArrayList<>();
-    inorderTraversal(root, sortedList);
-    return buildBST(sortedList, 0, sortedList.size() - 1);
-  }   
-  
-  private TreeNode buildBST(List<Integer> sortedList, int start, int end) {
-    if (start > end) {
-      return null;
+    public TreeNode balanceBST(TreeNode root) {
+        List<Integer> inorder = getInorderNodes(root);
+        return createBST(inorder, 0, inorder.size() - 1);
     }
-    int mid = (start + end) / 2;
-    TreeNode root = new TreeNode(sortedList.get(mid));
-    root.left = buildBST(sortedList, start, mid - 1);
-    root.right = buildBST(sortedList, mid + 1, end);
-    return root;
-  }
-  
-  private void inorderTraversal(TreeNode root, List<Integer> sortedList) {
-    if (root == null) {
-      return;
+
+    private List<Integer> getInorderNodes(TreeNode root) {
+        Stack<TreeNode> stack = new Stack<>();
+        while (root != null) {
+            stack.push(root);
+            root = root.left;
+        }
+        List<Integer> list = new ArrayList<>();
+        while (!stack.isEmpty()) {
+            TreeNode node = stack.pop();
+            list.add(node.val);
+            TreeNode rightNode = node.right;
+            while (rightNode != null) {
+                stack.push(rightNode);
+                rightNode = rightNode.left;
+            }
+        }
+        return list;
+    }
+
+    private TreeNode createBST(List<Integer> list, int start, int end) {
+        if (start > end) {
+            return null;
+        }
+        int mid = (start + end) / 2;
+        TreeNode leftTree = createBST(list, start, mid - 1);
+        TreeNode rightTree = createBST(list, mid + 1, end);
+        return new TreeNode(list.get(mid), leftTree, rightTree);
     }
-    inorderTraversal(root.left, sortedList);
-    sortedList.add(root.val);
-    inorderTraversal(root.right, sortedList);
-  }
 }
diff --git a/Medium/Best Time to Buy and Sell Stock with Transaction Fee.java b/Medium/Best Time to Buy and Sell Stock with Transaction Fee.java
new file mode 100644
index 00000000..1251e8d0
--- /dev/null
+++ b/Medium/Best Time to Buy and Sell Stock with Transaction Fee.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int maxProfit(int[] prices, int fee) {
+        int n = prices.length;
+        int[] notHolding = new int[n];
+        int[] holding = new int[n];
+        holding[0] = -prices[0];
+        for (int i = 1; i < n; i++) {
+            holding[i] = Math.max(holding[i - 1], notHolding[i - 1] - prices[i]);
+            notHolding[i] = Math.max(notHolding[i - 1], holding[i - 1] + prices[i] - fee);
+        }
+        return notHolding[n - 1];
+    }
+}
diff --git a/Medium/Binary Search Tree Iterator II.java b/Medium/Binary Search Tree Iterator II.java
index 9f98110c..61ab1d10 100644
--- a/Medium/Binary Search Tree Iterator II.java	
+++ b/Medium/Binary Search Tree Iterator II.java	
@@ -14,49 +14,47 @@
  * }
  */
 class BSTIterator {
-  
-  private Deque<TreeNode> stack;
-  private List<Integer> arr;
-  private TreeNode lastNode;
-  private int pointer;
-  
-  public BSTIterator(TreeNode root) {
-    this.stack = new ArrayDeque();
-    this.arr = new ArrayList<>();
-    this.lastNode = root;
-    this.pointer = -1;
-  }
 
-  public boolean hasNext() {
-    return !this.stack.isEmpty() || lastNode != null || this.pointer < arr.size() - 1;
-  }
+    private final Deque<TreeNode> primary;
+    private final List<Integer> secondary;
+    private int index;
 
-  public int next() {
-    this.pointer++;
-    if (this.pointer == this.arr.size()) {
-      updateStack(lastNode);
-      TreeNode curr = this.stack.pop();
-      lastNode = curr.right;
-      this.arr.add(curr.val);
+    public BSTIterator(TreeNode root) {
+        this.primary = new ArrayDeque<>();
+        this.secondary = new ArrayList<>();
+        this.index = -1;
+        traverse(root);
+    }
+    
+    public boolean hasNext() {
+        return !primary.isEmpty() || index < secondary.size() - 1;
+    }
+    
+    public int next() {
+        index++;
+        if (index == secondary.size()) {
+            TreeNode curr = primary.pop();
+            secondary.add(curr.val);
+            traverse(curr.right);
+        }
+        return secondary.get(index);
+    }
+    
+    public boolean hasPrev() {
+        return index > 0;
+    }
+    
+    public int prev() {
+        index--;
+        return secondary.get(index);
     }
-    return this.arr.get(this.pointer);
-  }
-
-  public boolean hasPrev() {
-    return this.pointer > 0;
-  }
 
-  public int prev() {
-    this.pointer--;
-    return this.arr.get(this.pointer);
-  }
-  
-  private void updateStack(TreeNode node) {
-    while (node != null) {
-      this.stack.push(node);
-      node = node.left;
+    private void traverse(TreeNode root) {
+        while (root != null) {
+            primary.push(root);
+            root = root.left;
+        }
     }
-  }
 }
 
 /**
diff --git a/Medium/Binary Tree Preorder Traversal.java b/Medium/Binary Tree Preorder Traversal.java
index e2f64ac4..61765340 100644
--- a/Medium/Binary Tree Preorder Traversal.java	
+++ b/Medium/Binary Tree Preorder Traversal.java	
@@ -4,31 +4,33 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
     public List<Integer> preorderTraversal(TreeNode root) {
-        ArrayList<Integer> ans = new ArrayList<>();
         if (root == null) {
-            return ans;
+            return List.of();
         }
-        Stack<TreeNode> s = new Stack<>();
-        
-        s.push(root);
-        
-        while(s.size() > 0) {
-            TreeNode curr = s.pop();
-            ans.add(curr.val);
-            if(curr.right != null) {
-                s.push(curr.right);
+        Stack<TreeNode> stack = new Stack<>();
+        stack.push(root);
+        List<Integer> result = new ArrayList<>();
+        while (!stack.isEmpty()) {
+            TreeNode removed = stack.pop();
+            result.add(removed.val);
+            if (removed.right != null) {
+                stack.push(removed.right);
             }
-            
-            if(curr.left != null) {
-                s.push(curr.left);
+            if (removed.left != null) {
+                stack.push(removed.left);
             }
         }
-        
-        return ans;
+        return result;
     }
 }
diff --git a/Medium/Bitwise XOR of All Pairings.java b/Medium/Bitwise XOR of All Pairings.java
new file mode 100644
index 00000000..88dfbd41
--- /dev/null
+++ b/Medium/Bitwise XOR of All Pairings.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int xorAllNums(int[] nums1, int[] nums2) {
+        int m = nums1.length;
+        int n = nums2.length;
+        Map<Integer, Integer> freq = new HashMap<>();
+        for (int num : nums1) {
+            freq.put(num, freq.getOrDefault(num, 0) + n);
+        }
+        for (int num : nums2) {
+            freq.put(num, freq.getOrDefault(num, 0) + m);
+        }
+        int result = 0;
+        for (Integer key : freq.keySet()) {
+            if (freq.get(key) % 2 == 1) {
+                result ^= key;
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Boats to Save People.java b/Medium/Boats to Save People.java
index 725f18c7..dab79035 100644
--- a/Medium/Boats to Save People.java	
+++ b/Medium/Boats to Save People.java	
@@ -1,16 +1,16 @@
 class Solution {
-  public int numRescueBoats(int[] people, int limit) {
-    Arrays.sort(people);
-    int startIdx = 0;
-    int endIdx = people.length - 1;
-    int count = 0;
-    while (startIdx <= endIdx) {
-      int currWeight = people[endIdx--];
-      if (startIdx <= endIdx && currWeight + people[startIdx] <= limit) {
-        currWeight += people[startIdx++];
-      }
-      count++;
-    } 
-    return count;
-  } 
+    public int numRescueBoats(int[] people, int limit) {
+        Arrays.sort(people);
+        int left = 0;
+        int right = people.length - 1;
+        int count = 0;
+        while (left <= right) {
+            int capacity = people[right--];
+            if (left <= right && capacity + people[left] <= limit) {
+                left++;
+            }
+            count++;
+        }        
+        return count;
+    }
 }
diff --git a/Medium/Build an Array With Stack Operations.java b/Medium/Build an Array With Stack Operations.java
new file mode 100644
index 00000000..f36177cd
--- /dev/null
+++ b/Medium/Build an Array With Stack Operations.java	
@@ -0,0 +1,23 @@
+class Solution {
+
+    private static final String PUSH = "Push";
+    private static final String POP = "Pop";
+
+    public List<String> buildArray(int[] target, int n) {
+        int idx = 0;
+        List<String> result = new ArrayList<>();
+        for (int i = 1; i <= n; i++) {
+            if (target[idx] == i) {
+                idx++;
+                result.add(PUSH);
+            } else {
+                result.add(PUSH);
+                result.add(POP);
+            }
+            if (idx == target.length) {
+                break;
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Buildings With an Ocean View.java b/Medium/Buildings With an Ocean View.java
index b9735daa..6d52576e 100644
--- a/Medium/Buildings With an Ocean View.java	
+++ b/Medium/Buildings With an Ocean View.java	
@@ -1,13 +1,18 @@
 class Solution {
-  public int[] findBuildings(int[] heights) {
-    List<Integer> oceanViewBuildings = new ArrayList<>();
-    int maxHeight = 0;
-    for (int i = heights.length - 1; i >= 0; i--) {
-      if (heights[i] > maxHeight) {
-        oceanViewBuildings.add(i);
-      }
-      maxHeight = Math.max(maxHeight, heights[i]);
+    public int[] findBuildings(int[] heights) {
+        List<Integer> result = new ArrayList<>();
+        int maxHeight = -1;
+        for (int i = heights.length - 1; i >= 0; i--) {
+            if (heights[i] > maxHeight) {
+                result.add(i);
+            }
+            maxHeight = Math.max(maxHeight, heights[i]);
+        }
+        int[] ans = new int[result.size()];
+        Collections.reverse(result);
+        for (int i = 0; i < result.size(); i++) {
+            ans[i] = result.get(i);
+        }
+        return ans;
     }
-    return oceanViewBuildings.stream().sorted().mapToInt(Integer::valueOf).toArray();
-  }
 }
diff --git a/Medium/Calculate Score After Performing Instructions.java b/Medium/Calculate Score After Performing Instructions.java
new file mode 100644
index 00000000..789e5669
--- /dev/null
+++ b/Medium/Calculate Score After Performing Instructions.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public long calculateScore(String[] instructions, int[] values) {
+        long result = 0;
+        int n = values.length;
+        int idx = 0;
+        Set<Integer> executed = new HashSet<>();
+        while (idx < n && idx >= 0) {
+            if (!executed.add(idx)) {
+                break;
+            }
+            if (instructions[idx].equals("add")) {
+                result += values[idx++];
+            } else {
+                idx += values[idx];
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Campus Bikes II.java b/Medium/Campus Bikes II.java
index 82de40c4..692725d0 100644
--- a/Medium/Campus Bikes II.java	
+++ b/Medium/Campus Bikes II.java	
@@ -1,30 +1,28 @@
 class Solution {
-  int minDist;
-  public int assignBikes(int[][] workers, int[][] bikes) {
-    minDist = Integer.MAX_VALUE;
-    dfs(new boolean[bikes.length], workers, 0, bikes, 0);
-    return minDist;
-  }
-  
-  private void dfs(boolean[] visited, int[][] workers, int currIdx, int[][] bikes, int distance) {
-    if (currIdx >= workers.length) {
-      minDist = Math.min(minDist, distance);
-      return;
+    public int assignBikes(int[][] workers, int[][] bikes) {
+        Integer[] dp = new Integer[1024];
+        return minDistance(workers, bikes, 0, 0, dp);
     }
-    if (distance > minDist) {
-      return;
+
+    private int minDistance(int[][] workers, int[][] bikes, int workerIdx, int mask, Integer[] dp) {
+        if (workerIdx >= workers.length) {
+            return 0;
+        }
+        if (dp[mask] != null) {
+            return dp[mask];
+        }
+        int distance = Integer.MAX_VALUE;
+        for (int i = 0; i < bikes.length; i++) {
+            // if bike is available
+            if ((mask & (1 << i)) == 0) {
+                // assign the bike & traverse for remaining bikes
+                distance = Math.min(distance, calculateManhattanDistance(workers[workerIdx], bikes[i]) + minDistance(workers, bikes, workerIdx + 1, mask | (1 << i), dp));
+            }
+        }
+        return dp[mask] = distance;
     }
-    for (int i = 0; i < bikes.length; i++) {
-      if (visited[i]) {
-        continue;
-      }
-      visited[i] = true;
-      dfs(visited, workers, currIdx + 1, bikes, distance + getManahattanDist(bikes[i], workers[currIdx]));
-      visited[i] = false;
+
+    private static int calculateManhattanDistance(int[] worker, int[] bike) {
+        return Math.abs(worker[0] - bike[0]) + Math.abs(worker[1] - bike[1]);
     }
-  }
-  
-  private int getManahattanDist(int[] p1, int[] p2) {
-    return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]);
-  }
 }
diff --git a/Medium/Campus Bikes.java b/Medium/Campus Bikes.java
index 9d385afb..129f4fbc 100644
--- a/Medium/Campus Bikes.java	
+++ b/Medium/Campus Bikes.java	
@@ -1,46 +1,39 @@
 class Solution {
-  public int[] assignBikes(int[][] workers, int[][] bikes) {
-    PriorityQueue<Node> pq = new PriorityQueue<>(new Comparator<Node>(){
-      public int compare(Node n1, Node n2) {
-        int c = n1.dist - n2.dist;
-        if (c != 0) {
-          return c;
+    public int[] assignBikes(int[][] workers, int[][] bikes) {
+        int workerCount = workers.length;
+        int bikeCount = bikes.length;
+        PriorityQueue<WorkerBikePair> priorityQueue = new PriorityQueue<>();
+        for (int i = 0; i < workerCount; i++) {
+            for (int j = 0; j < bikeCount; j++) {
+                priorityQueue.add(new WorkerBikePair(manhattanDistance(workers[i], bikes[j]), i, j));
+            }
         }
-        c = n1.workIdx - n2.workIdx;
-        return c != 0 ? c : n1.cycleIdx - n2.cycleIdx;
-      }
-    });
-    for (int i = 0; i < workers.length; i++) {
-      for (int j = 0; j < bikes.length; j++) {
-        pq.add(new Node(getDist(workers[i], bikes[j]), i, j));
-      }
+        Set<Integer> bikeDone = new HashSet<>();
+        int[] result = new int[workerCount];
+        Arrays.fill(result, Integer.MIN_VALUE);
+        while (!priorityQueue.isEmpty()) {
+            WorkerBikePair removed = priorityQueue.remove();
+            if (result[removed.workerIdx] == Integer.MIN_VALUE && !bikeDone.contains(removed.bikeIdx)) {
+                result[removed.workerIdx] = removed.bikeIdx;
+                bikeDone.add(removed.bikeIdx);
+            }
+        }
+        return result;
     }
-    int[] ans = new int[workers.length];
-    boolean[] bikesTaken = new boolean[bikes.length];
-    Arrays.fill(ans, Integer.MIN_VALUE);
-    while (!pq.isEmpty()) {
-      Node node = pq.remove();
-      if (ans[node.workIdx] == Integer.MIN_VALUE && !bikesTaken[node.cycleIdx]) {
-        ans[node.workIdx] = node.cycleIdx;
-        bikesTaken[node.cycleIdx] = true;
-      }
+
+    private record WorkerBikePair(int manhattanDistance, int workerIdx, int bikeIdx) implements Comparable<WorkerBikePair> {
+        @Override
+        public int compareTo(WorkerBikePair o) {
+            int c = manhattanDistance - o.manhattanDistance;
+            if (c != 0) {
+                return c;
+            }
+            c = workerIdx - o.workerIdx;
+            return c != 0 ? c : bikeIdx - o.bikeIdx;
+        }
     }
-    return ans;
-  }
-  
-  private int getDist(int[] p1, int[] p2) {
-    return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]);
-  }
-}
 
-class Node {
-  int dist;
-  int workIdx;
-  int cycleIdx;
-  
-  public Node(int dist, int workIdx, int cycleIdx) {
-    this.dist = dist;
-    this.workIdx = workIdx;
-    this.cycleIdx = cycleIdx;
-  }
+    private static int manhattanDistance(int[] p1, int[] p2) {
+        return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1]);
+    }
 }
diff --git a/Medium/Champagne Tower.java b/Medium/Champagne Tower.java
index b8f0797e..ccd07a8b 100644
--- a/Medium/Champagne Tower.java	
+++ b/Medium/Champagne Tower.java	
@@ -1,14 +1,13 @@
 class Solution {
-  public double champagneTower(int poured, int query_row, int query_glass) {
-    double[][] glassCapacity = new double[query_row + 1][query_glass + 2];
-    glassCapacity[0][0] = poured;
-    for (int currRow = 0; currRow < query_row; currRow++) {
-      for (int currCol = 0; currCol <= query_glass; currCol++) {
-        double currCapacity = Math.max(glassCapacity[currRow][currCol] - 1.0, 0);
-        glassCapacity[currRow + 1][currCol] += currCapacity / 2.0;
-        glassCapacity[currRow + 1][currCol + 1] += currCapacity / 2.0;
-      }
+    public double champagneTower(int poured, int query_row, int query_glass) {
+        double[] glass = new double[query_row + 2];
+        glass[0] = poured;
+        for (int row = 1; row <= query_row; row++) {
+            for (int idx = row; idx >= 0; idx--) {
+                glass[idx] = Math.max(0.0, (glass[idx] - 1) / 2);
+                glass[idx + 1] += glass[idx];
+            }
+        }
+        return Math.min(glass[query_glass], 1.0);
     }
-    return Math.min(glassCapacity[query_row][query_glass], 1.0);
-  } 
 }
diff --git a/Medium/Cheapest Flights Within K Stops.java b/Medium/Cheapest Flights Within K Stops.java
new file mode 100644
index 00000000..e937fdaf
--- /dev/null
+++ b/Medium/Cheapest Flights Within K Stops.java	
@@ -0,0 +1,32 @@
+class Solution {
+    public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
+        Map<Integer, List<int[]>> graph = new HashMap<>();
+        for (int[] flight : flights) {
+            graph.computeIfAbsent(flight[0], ArrayList::new).add(new int[]{flight[1], flight[2]});
+        }
+        int[] price = new int[n];
+        Arrays.fill(price, Integer.MAX_VALUE);
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{src, 0});
+        while (k-- >= 0 && !queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] removed = queue.remove();
+                int currCity = removed[0];
+                int currPrice = removed[1];
+                if (!graph.containsKey(currCity)) {
+                    continue;
+                }
+                for (int[] node : graph.get(currCity)) {
+                    int nextCity = node[0];
+                    int flightPrice = node[1];
+                    if (currPrice + flightPrice < price[nextCity]) {
+                        price[nextCity] = currPrice + flightPrice;
+                        queue.add(new int[]{nextCity, price[nextCity]});
+                    }
+                }
+            }
+        }
+        return price[dst] == Integer.MAX_VALUE ? -1 : price[dst];
+    }
+}
diff --git a/Medium/Check Completeness of a Binary Tree.java b/Medium/Check Completeness of a Binary Tree.java
index 30ee5adb..2d0c94f0 100644
--- a/Medium/Check Completeness of a Binary Tree.java	
+++ b/Medium/Check Completeness of a Binary Tree.java	
@@ -14,22 +14,23 @@
  * }
  */
 class Solution {
-  public boolean isCompleteTree(TreeNode root) {
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    boolean end = false;
-    while (!queue.isEmpty()) {
-      TreeNode removed = queue.poll();
-      if (removed == null) {
-        end = true;
-      } else {
-        if (end) {
-          return false;
+    public boolean isCompleteTree(TreeNode root) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        boolean isEnd = false;
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            TreeNode removed = queue.remove();
+            if (removed == null) {
+                isEnd = true;
+            } 
+            if (removed != null) {
+                if (isEnd) {
+                    return false;
+                }
+                queue.add(removed.left);
+                queue.add(removed.right);
+            }
         }
-        queue.add(removed.left);
-        queue.add(removed.right);
-      }
+        return true;
     }
-    return true;
-  }
 }
diff --git a/Medium/Check If Array Pairs Are Divisible by k.java b/Medium/Check If Array Pairs Are Divisible by k.java
new file mode 100644
index 00000000..d942915f
--- /dev/null
+++ b/Medium/Check If Array Pairs Are Divisible by k.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public boolean canArrange(int[] arr, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : arr) {
+            int remainder = ((num % k) + k) % k;
+            map.put(remainder, map.getOrDefault(remainder, 0) + 1);
+        }
+        for (int num : arr) {
+            int remainder = ((num % k) + k) % k;
+            if (remainder == 0) {
+                if (map.get(remainder) % 2 == 1) {
+                    return false;
+                }
+            } else if (!map.get(remainder).equals(map.get(k - remainder))) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/Medium/Check if Strings Can be Made Equal With Operations II.java b/Medium/Check if Strings Can be Made Equal With Operations II.java
new file mode 100644
index 00000000..7507b140
--- /dev/null
+++ b/Medium/Check if Strings Can be Made Equal With Operations II.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public boolean checkStrings(String s1, String s2) {
+        int[] odd = new int[26];
+        int[] even = new int[26];
+        for (int i = 0; i < s1.length(); i++) {
+            if (i % 2 == 0) {
+                even[s1.charAt(i) - 'a']++;
+                even[s2.charAt(i) - 'a']--;
+            } else {
+                odd[s1.charAt(i) - 'a']++;
+                odd[s2.charAt(i) - 'a']--;
+            }
+        }
+        for (int i = 0; i < 26; i++) {
+            if (odd[i] != 0 || even[i] != 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/Medium/Check if a Parentheses String Can Be Valid.java b/Medium/Check if a Parentheses String Can Be Valid.java
new file mode 100644
index 00000000..c240176d
--- /dev/null
+++ b/Medium/Check if a Parentheses String Can Be Valid.java	
@@ -0,0 +1,30 @@
+class Solution {
+    public boolean canBeValid(String s, String locked) {
+        if (s.length() % 2 != 0) {
+            return false;
+        }
+        Stack<Integer> openBrackets = new Stack<>();
+        Stack<Integer> unlocked = new Stack<>();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (locked.charAt(i) == '0') {
+                unlocked.push(i);
+            } else if (c == '(') {
+                openBrackets.push(i);
+            } else if (c == ')') {
+                if (!openBrackets.isEmpty()) {
+                    openBrackets.pop();
+                } else if (!unlocked.isEmpty()) {
+                    unlocked.pop();
+                } else {
+                    return false;
+                }
+            }
+        }
+        while (!openBrackets.isEmpty() && !unlocked.isEmpty() && openBrackets.peek() < unlocked.peek()) {
+            openBrackets.pop();
+            unlocked.pop();
+        }
+        return openBrackets.isEmpty();
+    }
+}
diff --git a/Medium/Clone Binary Tree With Random Pointer.java b/Medium/Clone Binary Tree With Random Pointer.java
index 323b1b6e..cf43c71a 100644
--- a/Medium/Clone Binary Tree With Random Pointer.java	
+++ b/Medium/Clone Binary Tree With Random Pointer.java	
@@ -17,44 +17,43 @@
  */
 
 class Solution {
-  public NodeCopy copyRandomBinaryTree(Node root) {
-    if (root == null) {
-      return null;
-    }
-    Queue<Node> queue = new LinkedList<>();
-    Map<Node, NodeCopy> map = new HashMap<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        Node removed = queue.remove();
-        map.put(removed, new NodeCopy(removed.val));
-        if (removed.left != null) {
-          queue.add(removed.left);
-        }
-        if (removed.right != null) {
-          queue.add(removed.right);
+    public NodeCopy copyRandomBinaryTree(Node root) {
+        if (root == null) {
+            return null;
         }
-      }
+        Map<Node, NodeCopy> map = new HashMap<>();
+        copyOnlyNode(root, map);
+        copyNodePointers(root, map);
+        return map.get(root);
     }
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        Node removed = queue.remove();
-        if (removed.left != null) {
-          queue.add(removed.left);
-          map.get(removed).left = map.get(removed.left);
+    
+    private void copyNodePointers(Node root, Map<Node, NodeCopy> map) {
+        Queue<Node> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            Node removed = queue.remove();
+            NodeCopy copied = map.get(removed);
+            if (removed.left != null) {
+                queue.add(removed.left);
+                copied.left = map.get(removed.left);
+            }
+            if (removed.right != null) {
+                queue.add(removed.right);
+                copied.right = map.get(removed.right);
+            }
+            if (removed.random != null) {
+                copied.random = map.get(removed.random);
+            }
         }
-        if (removed.right != null) {
-          queue.add(removed.right);
-          map.get(removed).right = map.get(removed.right);
-        }
-        if (removed.random != null) {
-          map.get(removed).random = map.get(removed.random);
+    }
+    
+    private void copyOnlyNode(Node root, Map<Node, NodeCopy> map) {
+        if (root == null) {
+            return;
         }
-      }
+        NodeCopy copiedNode = new NodeCopy(root.val);
+        map.put(root, copiedNode);
+        copyOnlyNode(root.left, map);
+        copyOnlyNode(root.right, map);
     }
-    return map.get(root);
-  }
 }
diff --git a/Medium/Clone Graph.java b/Medium/Clone Graph.java
index 47a4ba95..cddb7b81 100644
--- a/Medium/Clone Graph.java	
+++ b/Medium/Clone Graph.java	
@@ -3,17 +3,14 @@
 class Node {
     public int val;
     public List<Node> neighbors;
-    
     public Node() {
         val = 0;
         neighbors = new ArrayList<Node>();
     }
-    
     public Node(int _val) {
         val = _val;
         neighbors = new ArrayList<Node>();
     }
-    
     public Node(int _val, ArrayList<Node> _neighbors) {
         val = _val;
         neighbors = _neighbors;
@@ -22,24 +19,24 @@ public Node(int _val, ArrayList<Node> _neighbors) {
 */
 
 class Solution {
-  public Node cloneGraph(Node node) {
-    if (node == null) {
-      return null;
-    }
-    Map<Node, Node> map = new HashMap<>();
-    Queue<Node> queue = new LinkedList<>();
-    queue.add(node);
-    map.put(node, new Node(node.val));
-    while (!queue.isEmpty()) {
-      Node removed = queue.remove();
-      for (Node neighbor : removed.neighbors) {
-        if (!map.containsKey(neighbor)) {
-          map.put(neighbor, new Node(neighbor.val));
-          queue.add(neighbor);
+    public Node cloneGraph(Node node) {
+        if (node == null) {
+            return null;
+        }
+        Map<Node, Node> map = new HashMap();
+        Queue<Node> queue = new LinkedList<>();
+        queue.add(node);
+        map.put(node, new Node(node.val));
+        while (!queue.isEmpty()) {
+            Node removed = queue.remove();
+            for (Node neighbor : removed.neighbors) {
+                if (!map.containsKey(neighbor)) {
+                    map.put(neighbor, new Node(neighbor.val));
+                    queue.add(neighbor);
+                }
+                map.get(removed).neighbors.add(map.get(neighbor));
+            }
         }
-        map.get(removed).neighbors.add(map.get(neighbor));
-      }
+        return map.get(node);
     }
-    return map.get(node);
-  }
 }
diff --git a/Medium/Combination Sum IV.java b/Medium/Combination Sum IV.java
index bc8c1924..3a0eb51e 100644
--- a/Medium/Combination Sum IV.java	
+++ b/Medium/Combination Sum IV.java	
@@ -1,25 +1,22 @@
 class Solution {
-  public int combinationSum4(int[] nums, int target) {
-    Integer[] dp = new Integer[target + 1];
-    return getCount(target, nums, dp);
-  }
-  
-  public int getCount(int target, int[] nums, Integer[] dp) {
-    if (dp[target] != null) {
-      return dp[target];
+    public int combinationSum4(int[] nums, int target) {
+        Integer[] dp = new Integer[target + 1];
+        return helper(nums, target, dp);
     }
-    if (target == 0) {
-      return 1;
+
+    private int helper(int[] nums, int target, Integer[] dp) {
+        if (dp[target] != null) {
+            return dp[target];
+        }
+        if (target == 0) {
+            return 1;
+        }
+        int count = 0;
+        for (int num : nums) {
+            if (target >= num) {
+                count += helper(nums, target - num, dp);
+            }
+        }
+        return dp[target] = count;
     }
-    if (target < 0) {
-      return 0;
-    }
-    int total = 0;
-    for (int num : nums) {
-      if (target >= num) {
-        total += getCount(target - num, nums, dp);
-      }
-    }
-    return dp[target] = total;
-  }
 }
diff --git a/Medium/Combination Sum.java b/Medium/Combination Sum.java
index de3b3740..6d9e8f77 100644
--- a/Medium/Combination Sum.java	
+++ b/Medium/Combination Sum.java	
@@ -1,21 +1,22 @@
 class Solution {
-  public List<List<Integer>> combinationSum(int[] candidates, int target) {
-    List<List<Integer>> result = new ArrayList<>();
-    helper(candidates, 0, target, new ArrayList<>(), result);
-    return result;
-  }
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> result = new ArrayList<>();
+        helper(candidates, target, new ArrayList<>(), result, 0);
+        return result;
+    }
 
-  private void helper(int[] candidates, int idx, int target, List<Integer> currCombination,
-      List<List<Integer>> result) {
-    if (target == 0) {
-      result.add(new ArrayList<>(currCombination));
-    } 
-    if (target > 0 && idx < candidates.length) {
-      for (int i = idx; i < candidates.length; i++) {
-        currCombination.add(candidates[i]);
-        helper(candidates, i, target - candidates[i], currCombination, result);
-        currCombination.remove(currCombination.size() - 1);
-      }
+    private void helper(int[] candidates, int target, List<Integer> combination, List<List<Integer>> result, int idx) {
+        if (target < 0 || idx == candidates.length) {
+            return;
+        }
+        if (target == 0) {
+            result.add(combination);
+            return;
+        }
+        for (int i = idx; i < candidates.length; i++) {
+            combination.add(candidates[i]);
+            helper(candidates, target - candidates[i], new ArrayList<>(combination), result, i);
+            combination.remove(combination.size() - 1);
+        }
     }
-  }
 }
diff --git a/Medium/Combinations.java b/Medium/Combinations.java
index f5d99e2b..425b44ff 100644
--- a/Medium/Combinations.java
+++ b/Medium/Combinations.java
@@ -1,26 +1,22 @@
 class Solution {
-  public List<List<Integer>> combine(int n, int k) {
-    List<List<Integer>> ans = new ArrayList<>();
-    List<Integer> curr = new ArrayList<>();
-    helper(ans, curr, new boolean[n], k, 0);
-    return ans;
-  }
-  
-  private void helper(List<List<Integer>> ans, List<Integer> curr, boolean[] visited, int k, int idx) {
-    if (curr.size() == k) {
-      ans.add(new ArrayList<>(curr));
+    public List<List<Integer>> combine(int n, int k) {
+        List<List<Integer>> result = new ArrayList<>();
+        helper(result, n, k, new ArrayList<>(), 1);
+        return result;
     }
-    else {
-      for (int i = idx; i < visited.length; i++) {
-        if (visited[i]) {
-          continue;
+
+    private void helper(List<List<Integer>> result, int n, int k, List<Integer> curr, int currValue) {
+        if (curr.size() == k) {
+            result.add(new ArrayList<>(curr));
+            return;
+        }
+        for (int i = currValue; i <= n; i++) {
+            if (!curr.isEmpty() && curr.get(curr.size() - 1) >= i) {
+                continue;
+            }
+            curr.add(i);
+            helper(result, n, k, curr, currValue + 1);
+            curr.remove(curr.size() - 1);
         }
-        curr.add(i + 1);
-        visited[i] = true;
-        helper(ans, curr, visited, k, i + 1);
-        curr.remove(curr.size() - 1);
-        visited[i] = false;
-      }
     }
-  }
 }
diff --git a/Medium/Construct Binary Tree from Preorder and Postorder Traversal.java b/Medium/Construct Binary Tree from Preorder and Postorder Traversal.java
new file mode 100644
index 00000000..ca7aa35d
--- /dev/null
+++ b/Medium/Construct Binary Tree from Preorder and Postorder Traversal.java	
@@ -0,0 +1,40 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode constructFromPrePost(int[] preorder, int[] postorder) {
+        int n = preorder.length;
+        Map<Integer, Integer> postorderIndex = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            postorderIndex.put(postorder[i], i);
+        }
+        return constructTree(0, n - 1, 0, preorder, postorderIndex);
+    }
+
+    private TreeNode constructTree(int preStart, int preEnd, int postStart, int[] preorder, Map<Integer, Integer> postorderIndex) {
+        if (preStart > preEnd) {
+            return null;
+        }
+        if (preStart == preEnd) {
+            return new TreeNode(preorder[preStart]);
+        }
+        int leftRoot = preorder[preStart + 1];
+        int leftCount = postorderIndex.get(leftRoot) - postStart + 1;
+        TreeNode root = new TreeNode(preorder[preStart]);
+        root.left = constructTree(preStart + 1, preStart + leftCount, postStart, preorder, postorderIndex);
+        root.right = constructTree(preStart + leftCount + 1, preEnd, postStart + leftCount, preorder, postorderIndex);
+        return root;
+    }
+}
diff --git a/Medium/Construct Smallest Number From DI String.java b/Medium/Construct Smallest Number From DI String.java
new file mode 100644
index 00000000..64e39262
--- /dev/null
+++ b/Medium/Construct Smallest Number From DI String.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public String smallestNumber(String pattern) {
+        StringBuilder result = new StringBuilder();
+        Stack<Integer> stack = new Stack<>();
+        for (int i = 0; i <= pattern.length(); i++) {
+            stack.push(i + 1);
+            if (i == pattern.length() || pattern.charAt(i) == 'I') {
+                while (!stack.isEmpty()) {
+                    result.append(stack.pop());
+                }
+            }
+        }
+        return result.toString();
+    }
+}
diff --git a/Medium/Convert Sorted List to Binary Search Tree.java b/Medium/Convert Sorted List to Binary Search Tree.java
index 5b49c0f3..c1258059 100644
--- a/Medium/Convert Sorted List to Binary Search Tree.java	
+++ b/Medium/Convert Sorted List to Binary Search Tree.java	
@@ -3,7 +3,9 @@
  * public class ListNode {
  *     int val;
  *     ListNode next;
- *     ListNode(int x) { val = x; }
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
  */
 /**
@@ -12,35 +14,33 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    ListNode curr;
-    
-    public TreeNode sortedListToBST(ListNode head) {        
-        curr = head;
-        return generate(count(head));
-    }
-    
-    public int count(ListNode node) {
-        int n = 0;
-        while (node != null) {
-            node = node.next;
-            ++n;
+    public TreeNode sortedListToBST(ListNode head) {
+        List<Integer> list = new ArrayList<>();
+        while (head != null) {
+            list.add(head.val);
+            head = head.next;
         }
-        return n;
+        return helper(list, 0, list.size() - 1);
     }
     
-    public TreeNode generate(int n) {
-        if (n==0) return null;
-        
-        TreeNode node = new TreeNode(0);
-        node.left = generate(n/2);
-        node.val = curr.val;
-        curr = curr.next;
-        node.right = generate(n-(n/2)-1);
-        
-        return node;
+    private TreeNode helper(List<Integer> list, int start, int end) {
+        if (start > end) {
+            return null;
+        }
+        int mid = (start + end) / 2;
+        TreeNode root = new TreeNode(list.get(mid));
+        root.left = helper(list, start, mid - 1);
+        root.right = helper(list, mid + 1, end);
+        return root;
     }
 }
diff --git a/Medium/Convert an Array Into a 2D Array With Conditions.java b/Medium/Convert an Array Into a 2D Array With Conditions.java
new file mode 100644
index 00000000..c774bda6
--- /dev/null
+++ b/Medium/Convert an Array Into a 2D Array With Conditions.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public List<List<Integer>> findMatrix(int[] nums) {
+        Map<Integer, Integer> frequencyMap = new HashMap<>();
+        for (int num : nums) {
+            frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        queue.addAll(frequencyMap.keySet());
+        List<List<Integer>> result = new ArrayList<>();
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            List<Integer> row = new ArrayList<>();
+            while (size-- > 0) {
+                int removed = queue.remove();
+                row.add(removed);
+                if (frequencyMap.get(removed) > 1) {
+                    frequencyMap.put(removed, frequencyMap.get(removed) - 1);
+                    queue.add(removed);
+                }
+            }
+            result.add(row);
+        }
+        return result;
+    }
+}
diff --git a/Medium/Count Complete Substrings.java b/Medium/Count Complete Substrings.java
new file mode 100644
index 00000000..995cf4b0
--- /dev/null
+++ b/Medium/Count Complete Substrings.java	
@@ -0,0 +1,54 @@
+class Solution {
+    public int countCompleteSubstrings(String word, int k) {
+        int count = 0;
+        StringBuilder sb = new StringBuilder();
+        int n = word.length();
+        for (int i = 0; i < n; i++) {
+            sb.append(word.charAt(i));
+            if (i < n - 1 && Math.abs(word.charAt(i) - word.charAt(i + 1)) > 2) {
+                count += calculateSubstrings(sb.toString(), k);
+                sb.setLength(0);
+            }
+        }
+        count += calculateSubstrings(sb.toString(), k);
+        return count;
+    }
+
+    private int calculateSubstrings(String s, int k) {
+        int count = 0;
+        int n = s.length();
+        for (int i = 1; i <= 26; i++) {
+            int len = k * i;
+            int[] freq = new int[26];
+            if (len > n) {
+                break;
+            }
+            for (int j = 0; j < len; j++) {
+                freq[s.charAt(j) - 'a']++;
+            }
+            if (check(freq, i, k)) {
+                count++;
+            }
+            for (int j = len; j < n; j++) {
+                freq[s.charAt(j - len) - 'a']--;
+                freq[s.charAt(j) - 'a']++;
+                if (check(freq, i, k)) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+
+    private boolean check(int[] freq, int i, int k) {
+        for (int value : freq) {
+            if (value == 0) {
+                continue;
+            }
+            if (value != k) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/Medium/Count Days Without Meetings.java b/Medium/Count Days Without Meetings.java
new file mode 100644
index 00000000..1630e6df
--- /dev/null
+++ b/Medium/Count Days Without Meetings.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int countDays(int days, int[][] meetings) {
+        Arrays.sort(meetings, (o1, o2) -> {
+            int c = Integer.compare(o1[0], o2[0]);
+            if (c != 0) {
+                return c;
+            }
+            return Integer.compare(o2[1], o1[1]);
+        });
+        int meetingDays = 0;
+        int idx = 0;
+        while (idx < meetings.length) {
+            int start = meetings[idx][0];
+            int end = meetings[idx][1];
+            idx++;
+            while (idx < meetings.length && meetings[idx][0] <= end) {
+                end = Math.max(end, meetings[idx][1]);
+                idx++;
+            }
+            meetingDays += (end - start + 1);
+        }
+        return days - meetingDays;
+    }
+}
diff --git a/Medium/Count Mentions Per User.java b/Medium/Count Mentions Per User.java
new file mode 100644
index 00000000..7fa42668
--- /dev/null
+++ b/Medium/Count Mentions Per User.java	
@@ -0,0 +1,61 @@
+class Solution {
+    public int[] countMentions(int numberOfUsers, List<List<String>> eventLog) {
+        List<Event> events = eventLog.stream()
+            .map(Event::buildEvent)
+            .sorted()
+            .collect(Collectors.toList());
+        Map<Integer, Integer> offlineUsers = new HashMap<>();
+        int[] mentions = new int[numberOfUsers];
+        for (Event event : events) {
+            if (event.message().equals("OFFLINE")) {
+                offlineUsers.put(Integer.parseInt(event.mentionString()), event.timestamp());
+            } else {
+                int timestamp = event.timestamp();
+                List<Integer> onlineUsers = offlineUsers.entrySet()
+                    .stream()
+                    .filter(t -> timestamp - t.getValue() >= 60)
+                    .map(Map.Entry::getKey)
+                    .collect(Collectors.toList());
+                onlineUsers.forEach(offlineUsers::remove);
+                String mentionString = event.mentionString();
+                if (mentionString.equals("ALL")) {
+                    for (int i = 0; i < numberOfUsers; i++) {
+                        mentions[i]++;
+                    }
+                } else if (mentionString.equals("HERE")) {
+                    for (int i = 0; i < numberOfUsers; i++) {
+                        if (!offlineUsers.containsKey(i)) {
+                            mentions[i]++;
+                        }
+                    }
+                } else {
+                    String[] usersMentioned = mentionString.split(" ");
+                    for (String user : usersMentioned) {
+                        int userId = Integer.parseInt(user.substring(2));
+                        mentions[userId]++;
+                    }
+                }
+            }
+        }
+        return mentions;
+    }
+
+    private record Event(String message, int timestamp, String mentionString) implements Comparable<Event> {
+
+        public static Event buildEvent(List<String> event) {
+            String message = event.get(0);
+            int timestamp = Integer.parseInt(event.get(1));
+            String mentionString = event.get(2);
+            return new Event(message, timestamp, mentionString);
+        }
+
+        @Override
+        public int compareTo(Event o) {
+            int c = this.timestamp - o.timestamp;
+            if (c != 0) {
+                return c;
+            }
+            return o.message().compareTo(this.message());
+        }
+    }
+}
diff --git a/Medium/Count Nodes Equal to Average of Subtree.java b/Medium/Count Nodes Equal to Average of Subtree.java
index a642fc31..5a6d2d75 100644
--- a/Medium/Count Nodes Equal to Average of Subtree.java	
+++ b/Medium/Count Nodes Equal to Average of Subtree.java	
@@ -14,24 +14,23 @@
  * }
  */
 class Solution {
-  public int averageOfSubtree(TreeNode root) {
-    int[] result = {0};
-    helper(root, result);
-    return result[0];
-  }
-  
-  private int[] helper(TreeNode root, int[] result) {
-    if (root == null) {
-      return new int[]{0, 0};
+    public int averageOfSubtree(TreeNode root) {
+        int[] result = {0};
+        recurse(root, result);
+        return result[0];
     }
-    int[] left = helper(root.left, result);
-    int[] right = helper(root.right, result);
-    int sum = left[0] + right[0] + root.val;
-    int numOfNodes = left[1] + right[1] + 1;
-    int average = sum / numOfNodes;
-    if (root.val == average) {
-      result[0]++;
+
+    private int[] recurse(TreeNode root, int[] result) {
+        if (root == null) {
+            return new int[]{0, 0};
+        }
+        int[] left = recurse(root.left, result);
+        int[] right = recurse(root.right, result);
+        int sum = left[0] + right[0] + root.val;
+        int count = left[1] + right[1] + 1;
+        if (count != 0 && sum / count == root.val) {
+            result[0]++;
+        }
+        return new int[]{sum, count};
     }
-    return new int[]{sum, numOfNodes};
-  }
 }
diff --git a/Medium/Count Number of Homogenous Substrings.java b/Medium/Count Number of Homogenous Substrings.java
index 64dd8610..4a543690 100644
--- a/Medium/Count Number of Homogenous Substrings.java	
+++ b/Medium/Count Number of Homogenous Substrings.java	
@@ -1,18 +1,18 @@
 class Solution {
-  private final int MOD = 1000000007;
-  public int countHomogenous(String s) {
-    int count = 0;
-    int start = 0;
-    int end = 0;
-    int n = s.length();
-    while (end < n) {
-      if (s.charAt(start) == s.charAt(end)) {
-        count = (count + (end - start + 1)) % MOD;
-        end++;
-      } else {
-        start++;
-      }
+
+    private static final int MOD = 1_000_000_007;
+
+    public int countHomogenous(String s) {
+        int result = 0;
+        int streak = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (i == 0 || s.charAt(i) == s.charAt(i - 1)) {
+                streak++;
+            } else {
+                streak = 1;
+            }
+            result = (result + streak) % MOD;
+        }
+        return result;
     }
-    return count;
-  }
 }
diff --git a/Medium/Count Number of Maximum Bitwise-OR Subsets.java b/Medium/Count Number of Maximum Bitwise-OR Subsets.java
new file mode 100644
index 00000000..973e1818
--- /dev/null
+++ b/Medium/Count Number of Maximum Bitwise-OR Subsets.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public int countMaxOrSubsets(int[] nums) {
+        int n = nums.length;
+        int maxValue = 0;
+        for (int num : nums) {
+            maxValue |= num;
+        }
+        Integer[][] dp = new Integer[n][maxValue + 1];
+        return countMaxOrSubsets(nums, 0, 0, maxValue, dp);
+    }
+
+    private int countMaxOrSubsets(int[] nums, int idx, int current, int maxValue, Integer[][] dp) {
+        if (idx == nums.length) {
+            return (current == maxValue) ? 1 : 0;
+        }
+        if (dp[idx][current] != null) {
+            return dp[idx][current];
+        }
+        int countWithout = countMaxOrSubsets(nums, idx + 1, current, maxValue, dp);
+        int countWith = countMaxOrSubsets(nums, idx + 1, current | nums[idx], maxValue, dp);
+        return dp[idx][current] = countWith + countWithout;
+    }
+}
diff --git a/Medium/Count Number of Nice Subarrays.java b/Medium/Count Number of Nice Subarrays.java
new file mode 100644
index 00000000..e2648bd3
--- /dev/null
+++ b/Medium/Count Number of Nice Subarrays.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int numberOfSubarrays(int[] nums, int k) {
+        int sum = 0;
+        int count = 0;
+        Map<Integer, Integer> map = new HashMap<>();
+        map.put(sum, 1);
+        for (int i = 0; i < nums.length; i++) {
+            sum += nums[i] % 2;
+            count += map.getOrDefault(sum - k, 0);
+            map.put(sum, map.getOrDefault(sum, 0) + 1);
+        }
+        return count;
+    }
+}
diff --git a/Medium/Count Subarrays Where Max Element Appears at Least K Times.java b/Medium/Count Subarrays Where Max Element Appears at Least K Times.java
new file mode 100644
index 00000000..d917693d
--- /dev/null
+++ b/Medium/Count Subarrays Where Max Element Appears at Least K Times.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        int maxElement = 0;
+        for (int num : nums) {
+            maxElement = Math.max(maxElement, num);
+        }
+        long result = 0;
+        int start = 0;
+        int maxElementsInWindow = 0;
+        for (int end = 0; end < nums.length; end++) {
+            if (nums[end] == maxElement) {
+                maxElementsInWindow++;
+            }
+            while (k == maxElementsInWindow) {
+                if (nums[start] == maxElement) {
+                    maxElementsInWindow--;
+                }
+                start++;
+            }
+            result += start;
+        }
+        return result;
+    }
+}
diff --git a/Medium/Count Substrings Without Repeating Character.java b/Medium/Count Substrings Without Repeating Character.java
new file mode 100644
index 00000000..6ffcf7cd
--- /dev/null
+++ b/Medium/Count Substrings Without Repeating Character.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int numberOfSpecialSubstrings(String s) {
+        int start = 0;
+        int end = 0;
+        int n = s.length();
+        int result = 0;
+        Map<Character, Integer> map = new HashMap<>();
+        while (end < n) {
+            map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
+            while (start < end && map.get(s.charAt(end)) > 1) {
+                map.put(s.charAt(start), map.get(s.charAt(start)) - 1);
+                start++;
+            }
+            end++;
+            result += end - start;
+        }
+        return result;
+    }
+}
diff --git a/Medium/Count Total Number of Colored Cells.java b/Medium/Count Total Number of Colored Cells.java
new file mode 100644
index 00000000..81c10a8c
--- /dev/null
+++ b/Medium/Count Total Number of Colored Cells.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public long coloredCells(int n) {
+        long count = 1;
+        int increment = 4;
+        while (n-- > 1) {
+            count += increment;
+            increment += 4;
+        }
+        return count;
+    }
+}
diff --git a/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java b/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java
index b8f9bb09..4b927bce 100644
--- a/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java	
+++ b/Medium/Count Unreachable Pairs of Nodes in an Undirected Graph.java	
@@ -1,29 +1,36 @@
 class Solution {
-  public long countPairs(int n, int[][] edges) {
-    Map<Integer, List<Integer>> graph = new HashMap<>();
-    for (int[] edge : edges) {
-      graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
-      graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+    public long countPairs(int n, int[][] edges) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+            graph.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+        }
+        boolean[] visited = new boolean[n];
+        long unreachableNodeCount = (((long) n) * (n - 1)) / 2;
+        for (int i = 0; i < n; i++) {
+            if (!visited[i]) {
+                long reachCount = traverseHelper(i, graph, visited);
+                unreachableNodeCount -= (reachCount * (reachCount - 1)) / 2;
+            }
+        }
+        return unreachableNodeCount;
     }
-    long unreachableNodes = (((long) n) * (n - 1)) / 2;
-    boolean[] visited = new boolean[n];
-    for (int i = 0; i < n; i++) {
-      if (!visited[i]) {
-        long[] reachCount = {0};
-        dfs(graph, i, reachCount, visited);
-        unreachableNodes -= (reachCount[0] * (reachCount[0] - 1)) / 2;
-      }      
+
+    private long traverseHelper(int node, Map<Integer, Set<Integer>> graph, boolean[] visited) {
+        Queue<Integer> queue = new LinkedList<>();
+        long count = 0;
+        queue.add(node);
+        visited[node] = true;
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            count++;
+            for (Integer conn : graph.getOrDefault(removed, new HashSet<>())) {
+                if (!visited[conn]) {
+                    visited[conn] = true;
+                    queue.add(conn);
+                }
+            }
+        }
+        return count;
     }
-    return unreachableNodes;
-  }
-  
-  private void dfs(Map<Integer, List<Integer>> graph, int node, long[] reachCount, boolean[] visited) {
-    visited[node] = true;
-    reachCount[0]++;
-    for (Integer conn : graph.getOrDefault(node, new ArrayList<>())) {
-      if (!visited[conn]) {
-        dfs(graph, conn, reachCount, visited);
-      }
-    }
-  }
 }
diff --git a/Medium/Count Vowel Strings in Ranges.java b/Medium/Count Vowel Strings in Ranges.java
new file mode 100644
index 00000000..8f836610
--- /dev/null
+++ b/Medium/Count Vowel Strings in Ranges.java	
@@ -0,0 +1,26 @@
+class Solution {
+    
+    public int[] vowelStrings(String[] words, int[][] queries) {
+        int[] counter = new int[words.length];
+        int currCounter = 0;
+        for (int i = 0; i < words.length; i++) {
+            String word = words[i];
+            if (isVowel(word.charAt(0)) && isVowel(word.charAt(word.length() - 1))) {
+                currCounter++;
+            }
+            counter[i] = currCounter;
+        }
+        int[] result = new int[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            int left = queries[i][0];
+            int right = queries[i][1];
+            result[i] = counter[right];
+            result[i] -= left == 0 ? 0 : counter[left - 1];
+        }
+        return result;
+    }
+    
+    private static boolean isVowel(char c) {
+        return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
+    }
+}
diff --git a/Medium/Count Ways To Build Good Strings.java b/Medium/Count Ways To Build Good Strings.java
new file mode 100644
index 00000000..16991f0c
--- /dev/null
+++ b/Medium/Count Ways To Build Good Strings.java	
@@ -0,0 +1,23 @@
+class Solution {
+    
+    private static final int MOD = 1000_000_007;
+    
+    public int countGoodStrings(int low, int high, int zero, int one) {
+        int[] dp = new int[high + 1];
+        dp[0] = 1;
+        for (int i = 1; i <= high; i++) {
+            if (i >= zero) {
+                dp[i] += dp[i - zero];
+            } 
+            if (i >= one) {
+                dp[i] += dp[i - one];
+            }
+            dp[i] %= MOD;
+        }
+        int result = 0;
+        for (int i = low; i <= high; i++) {
+            result = (result + dp[i]) % MOD;
+        }
+        return result;
+    }
+}
diff --git a/Medium/Count the Number of Complete Components.java b/Medium/Count the Number of Complete Components.java
new file mode 100644
index 00000000..d198b0b2
--- /dev/null
+++ b/Medium/Count the Number of Complete Components.java	
@@ -0,0 +1,38 @@
+class Solution {
+    public int countCompleteComponents(int n, int[][] edges) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            int nodeOne = edge[0];
+            int nodeTwo = edge[1];
+            graph.computeIfAbsent(nodeOne, k -> new HashSet<>()).add(nodeTwo);
+            graph.computeIfAbsent(nodeTwo, k -> new HashSet<>()).add(nodeOne);
+        }
+        int count = 0;
+        Set<Integer> visited = new HashSet<>();
+        for (int i = 0; i < n; i++) {
+            if (visited.add(i)) {
+                int[] componentInfo = new int[2];
+                dfs(i, graph, visited, componentInfo);
+                if (componentInfo[0] * (componentInfo[0] - 1) == componentInfo[1]) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+
+    private void dfs(
+        int node, 
+        Map<Integer, Set<Integer>> graph, 
+        Set<Integer> visited, 
+        int[] componentInfo) {
+        componentInfo[0]++;
+        Set<Integer> connections = graph.getOrDefault(node, new HashSet<>());
+        componentInfo[1] += connections.size();
+        for (Integer conn : connections) {
+            if (visited.add(conn)) {
+                dfs(conn, graph, visited, componentInfo);
+            }
+        }
+    }
+}
diff --git a/Medium/Count the Number of Good Nodes.java b/Medium/Count the Number of Good Nodes.java
new file mode 100644
index 00000000..d100513d
--- /dev/null
+++ b/Medium/Count the Number of Good Nodes.java	
@@ -0,0 +1,34 @@
+class Solution {
+    public int countGoodNodes(int[][] edges) {
+        Map<Integer, Set<Integer>> map = new HashMap<>();
+        for (int[] edge : edges) {
+            map.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+            map.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+        }        
+        int[] result = {0};
+        recurse(map, result, 0, -1);
+        return result[0];
+    }
+
+    private int recurse(Map<Integer, Set<Integer>> map, int[] result, int node, int prevNode) {
+        int count = -1;
+        int total = 1;
+        boolean flag = true;
+        for (Integer conn : map.getOrDefault(node, new HashSet<>())) {
+            if (conn == prevNode) {
+                continue;
+            }
+            int temp = recurse(map, result, conn, node);
+            total += temp;
+            if (count == -1) {
+                count = temp;
+            } else if (count != temp) {
+                flag = false;
+            }
+        }
+        if (flag) {
+            result[0]++;
+        }
+        return total;
+    }
+}
diff --git a/Medium/Course Schedule II.java b/Medium/Course Schedule II.java
index 78fb8e08..ce957faf 100644
--- a/Medium/Course Schedule II.java	
+++ b/Medium/Course Schedule II.java	
@@ -1,30 +1,32 @@
 class Solution {
-  public int[] findOrder(int numCourses, int[][] prerequisites) {
-    Map<Integer, List<Integer>> prerequisiteToCourseDependency = new HashMap<>();
-    int[] prerequisiteCount = new int[numCourses];
-    for (int[] prerequisite : prerequisites) {
-      prerequisiteToCourseDependency.computeIfAbsent(prerequisite[1], k -> new ArrayList<>())
-        .add(prerequisite[0]);
-      prerequisiteCount[prerequisite[0]]++;
-    }
-    Queue<Integer> queue = new LinkedList<>();
-    for (int i = 0; i < numCourses; i++) {
-      if (prerequisiteCount[i] == 0) {
-        queue.add(i);
-      }
-    }
-    int[] courseOrder = new int[numCourses];
-    int courseOrderIdx = 0;
-    while (!queue.isEmpty()) {
-      int course = queue.remove();
-      courseOrder[courseOrderIdx++] = course;
-      for (Integer dependentCourse : prerequisiteToCourseDependency.getOrDefault(course, new ArrayList<>())) {
-        prerequisiteCount[dependentCourse]--;
-        if (prerequisiteCount[dependentCourse] == 0) {
-          queue.add(dependentCourse);
+    public int[] findOrder(int numCourses, int[][] prerequisites) {
+        Map<Integer, Set<Integer>> map = new HashMap<>();
+        int[] indegree = new int[numCourses];
+        for (int[] prerequisite : prerequisites) {
+            int course = prerequisite[0];
+            int dependency = prerequisite[1];
+            map.computeIfAbsent(dependency, k -> new HashSet<>()).add(course);
+            indegree[course]++;
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        int[] result = new int[numCourses];
+        int resultIdx = 0;
+        Set<Integer> taken = new HashSet<>();
+        for (int i = 0; i < numCourses; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i);
+            }
+        }
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            result[resultIdx++] = removed;
+            for (Integer dependent : map.getOrDefault(removed, new HashSet<>())) {
+                indegree[dependent]--;
+                if (indegree[dependent] == 0) {
+                    queue.add(dependent);
+                }
+            }
         }
-      }
+        return resultIdx == numCourses ? result : new int[0];
     }
-    return courseOrderIdx == numCourses ? courseOrder : new int[]{};
-  }
 }
diff --git a/Medium/Course Schedule.java b/Medium/Course Schedule.java
index bea1a964..1f8c0693 100644
--- a/Medium/Course Schedule.java	
+++ b/Medium/Course Schedule.java	
@@ -1,29 +1,31 @@
 class Solution {
-  public boolean canFinish(int numCourses, int[][] prerequisites) {
-    Map<Integer, Set<Integer>> map = new HashMap<>();
-    int[] indegree = new int[numCourses];
-    for (int[] prerequisite : prerequisites) {
-      map.computeIfAbsent(prerequisite[1], k -> new HashSet<>()).add(prerequisite[0]);
-      indegree[prerequisite[0]]++;
-    }
-    Queue<Integer> queue = new LinkedList<>();
-    Set<Integer> taken = new HashSet<>();
-    for (int i = 0; i < numCourses; i++) {
-      if (indegree[i] == 0) {
-        queue.add(i);
-        taken.add(i);
-      }
-    }
-    while (!queue.isEmpty()) {
-      int removed = queue.remove();
-      for (Integer dependentCourse : map.getOrDefault(removed, new HashSet<>())) {
-        indegree[dependentCourse]--;
-        if (indegree[dependentCourse] == 0) {
-          taken.add(dependentCourse);
-          queue.add(dependentCourse);
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        int[] indegree = new int[numCourses];
+        Map<Integer, Set<Integer>> map = new HashMap<>();
+        for (int[] prerequisite : prerequisites) {
+            int course = prerequisite[0];
+            int prereq = prerequisite[1];
+            indegree[course]++;
+            map.computeIfAbsent(prereq, k -> new HashSet<>()).add(course);
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        Set<Integer> visited = new HashSet<>();
+        for (int i = 0; i < numCourses; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i);
+                visited.add(i);
+            }            
+        }
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            for (Integer conn : map.getOrDefault(removed, new HashSet<>())) {
+                indegree[conn]--;
+                if (indegree[conn] == 0) {
+                    queue.add(conn);
+                    visited.add(conn);
+                }
+            }
         }
-      }
+        return visited.size() == numCourses;
     }
-    return taken.size() == numCourses;
-  }
 }
diff --git a/Medium/Cousins in Binary Tree II.java b/Medium/Cousins in Binary Tree II.java
new file mode 100644
index 00000000..ee1b4b21
--- /dev/null
+++ b/Medium/Cousins in Binary Tree II.java	
@@ -0,0 +1,44 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode replaceValueInTree(TreeNode root) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        int prevLevelSum = root.val;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            int levelSum = 0;
+            for (int i = 0; i < size; i++) {
+                TreeNode node = queue.remove();
+                node.val = prevLevelSum - node.val;
+                int siblingSum = (node.left != null ? node.left.val : 0) + 
+                    (node.right != null ? node.right.val : 0); 
+                if (node.left != null) {
+                    levelSum += node.left.val;
+                    node.left.val = siblingSum;
+                    queue.add(node.left);
+                }
+                if (node.right != null) {
+                    levelSum += node.right.val;
+                    node.right.val = siblingSum;
+                    queue.add(node.right);
+                }
+            }
+            prevLevelSum = levelSum;
+        }
+        return root;
+    }
+}
diff --git a/Medium/Daily Temperatures.java b/Medium/Daily Temperatures.java
index ce3bdca3..5189f7ee 100644
--- a/Medium/Daily Temperatures.java	
+++ b/Medium/Daily Temperatures.java	
@@ -1,14 +1,15 @@
 class Solution {
-  public int[] dailyTemperatures(int[] T) {
-    Stack<Integer> stack = new Stack<>();
-    int[] ans = new int[T.length];
-    for (int i = T.length - 1; i >= 0; i--) {
-      while (!stack.isEmpty() && T[stack.peek()] <= T[i]) {
-        stack.pop();
-      }
-      ans[i] = stack.isEmpty() ? 0 : (stack.peek() - i);
-      stack.push(i);
+    public int[] dailyTemperatures(int[] temperatures) {
+        int n = temperatures.length;
+        int[] result = new int[n];
+        Stack<Integer> stack = new Stack<>();
+        for (int i = n - 1; i >= 0; i--) {
+            while (!stack.isEmpty() && temperatures[i] >= temperatures[stack.peek()]) {
+                stack.pop();
+            }
+            result[i] = stack.isEmpty() ? 0 : stack.peek() - i;
+            stack.push(i);
+        }
+        return result;
     }
-    return ans;
-  }
 }
diff --git a/Medium/Decoded String at Index.java b/Medium/Decoded String at Index.java
new file mode 100644
index 00000000..a0c94968
--- /dev/null
+++ b/Medium/Decoded String at Index.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public String decodeAtIndex(String s, int k) {
+        long size = 0;
+        int n = s.length();
+        for (int i = 0; i < n; i++) {
+            char c = s.charAt(i);
+            if (Character.isDigit(c)) {
+                size *= (c - '0');
+            } else {
+                size++;
+            }
+        }
+        for (int i = n - 1; i >= 0; i--) {
+            char c = s.charAt(i);
+            k %= size;
+            if (k == 0 && Character.isLetter(c)) {
+                return Character.toString(c);
+            }
+            if (Character.isDigit(c)) {
+                size /= (c - '0');
+            } else {
+                size--;
+            }
+        }
+        return "";
+    }
+}
diff --git a/Medium/Delete Nodes And Return Forest.java b/Medium/Delete Nodes And Return Forest.java
index c3ec8f1b..344770b5 100644
--- a/Medium/Delete Nodes And Return Forest.java	
+++ b/Medium/Delete Nodes And Return Forest.java	
@@ -14,33 +14,34 @@
  * }
  */
 class Solution {
-  public List<TreeNode> delNodes(TreeNode root, int[] to_delete) {
-    List<TreeNode> result = new ArrayList<>();
-    Set<Integer> deleteSet = Arrays.stream(to_delete).boxed().collect(Collectors.toSet());
-    helper(root, deleteSet, result, null);
-    return result;
-  }
-  
-  private void helper(TreeNode node, Set<Integer> deleteSet, List<TreeNode> result, TreeNode parent) {
-    if (node == null) {
-      return;
+    public List<TreeNode> delNodes(TreeNode root, int[] toDelete) {
+        Set<Integer> set = new HashSet<>();
+        for (int val : toDelete) {
+            set.add(val);
+        }
+        List<TreeNode> result = new ArrayList<>();
+        recurse(root, result, set, null);
+        return result;
     }
-    TreeNode nextParent = null;
-    if (deleteSet.contains(node.val)) {
-      if (parent != null) {
-        if (parent.left == node) {
-          parent.left = null;
-        } else {
-          parent.right = null;
+
+    private void recurse(TreeNode root, List<TreeNode> result, Set<Integer> set, TreeNode parent) {
+        if (root == null) {
+            return;
+        }
+        if (set.contains(root.val)) {
+            if (parent != null && parent.left == root) {
+                parent.left = null;
+            } else if (parent != null && parent.right == root) {
+                parent.right = null;
+            }
+            recurse(root.left, result, set, null);
+            recurse(root.right, result, set, null);
+            return;
+        }
+        if (parent == null) {
+            result.add(root);
         }
-      }
-    } else {
-      if (parent == null) {
-        result.add(node); 
-      }
-      nextParent = node;
+        recurse(root.left, result, set, root);
+        recurse(root.right, result, set, root);
     }
-    helper(node.left, deleteSet, result, nextParent);
-    helper(node.right, deleteSet, result, nextParent);
-  }
 }
diff --git a/Medium/Delete Nodes From Linked List Present in Array.java b/Medium/Delete Nodes From Linked List Present in Array.java
new file mode 100644
index 00000000..ff184902
--- /dev/null
+++ b/Medium/Delete Nodes From Linked List Present in Array.java	
@@ -0,0 +1,31 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode modifiedList(int[] nums, ListNode head) {
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            set.add(num);
+        }
+        while (head != null && set.contains(head.val)) {
+            head = head.next;
+        }
+        ListNode newHead = head;
+        ListNode curr = head;
+        while (curr.next != null) {
+            if (set.contains(curr.next.val)) {
+                curr.next = curr.next.next;
+            } else {
+                curr = curr.next;
+            }
+        }
+        return newHead;
+    }
+}
diff --git a/Medium/Design Add and Search Words Data Structure.java b/Medium/Design Add and Search Words Data Structure.java
index 45fc78fd..17814eb0 100644
--- a/Medium/Design Add and Search Words Data Structure.java	
+++ b/Medium/Design Add and Search Words Data Structure.java	
@@ -1,54 +1,53 @@
 class WordDictionary {
-  
-  private Node root;
-  
-  public WordDictionary() {
-    this.root = new Node();
-  }
-
-  public void addWord(String word) {
-    Node curr = root;
-    for (char c : word.toCharArray()) {
-      if (curr.children[c - 'a'] == null) {
-        curr.children[c - 'a'] = new Node();
-      }
-      curr = curr.children[c - 'a'];
+
+    private final TrieNode root;
+
+    public WordDictionary() {
+        this.root = new TrieNode();
     }
-    curr.isWord = true;
-  }
-
-  public boolean search(String word) {
-    Node curr = root;
-    return searchHelper(word, 0, curr);
-  }
-  
-  private boolean searchHelper(String word, int idx, Node curr) {
-    if (idx == word.length()) {
-      return curr.isWord;
+
+    public void addWord(String word) {
+        TrieNode curr = root;
+        for (char c : word.toCharArray()) {
+            if (!curr.children.containsKey(c)) {
+                curr.children.put(c, new TrieNode());
+            }
+            curr = curr.children.get(c);
+        }
+        curr.isWord = true;
     }
-    if (word.charAt(idx) != '.' && curr.children[word.charAt(idx) - 'a'] == null) {
-      return false;
+
+    public boolean search(String word) {
+        return searchHelper(word, 0, root);
     }
-    if (word.charAt(idx) == '.') {
-      for (Node child : curr.children) {
-        if (child != null && searchHelper(word, idx + 1, child)) {
-          return true;
+
+    private boolean searchHelper(String word, int idx, TrieNode node) {
+        if (idx == word.length()) {
+            return node.isWord;
         }
-      }
-      return false;
+        if (node.children.containsKey(word.charAt(idx))) {
+            return searchHelper(word, idx + 1, node.children.get(word.charAt(idx)));
+        }
+        if (word.charAt(idx) == '.') {
+            for (TrieNode child : node.children.values()) {
+                if (searchHelper(word, idx + 1, child)) {
+                    return true;
+                }
+            }
+        }
+        return false;
     }
-    return searchHelper(word, idx + 1, curr.children[word.charAt(idx) - 'a']);
-  }
-  
-  private static class Node {
-    Node[] children;
-    boolean isWord;
-    
-    public Node() {
-      this.children = new Node[26];
-      this.isWord = false;
+
+
+    static class TrieNode {
+        private final Map<Character, TrieNode> children;
+        private boolean isWord;
+
+        public TrieNode() {
+            this.children = new HashMap<>();
+            this.isWord = false;
+        }
     }
-  }
 }
 
 /**
diff --git a/Medium/Design Browser History.java b/Medium/Design Browser History.java
index 8aa9f71f..63799e9d 100644
--- a/Medium/Design Browser History.java	
+++ b/Medium/Design Browser History.java	
@@ -1,32 +1,32 @@
 class BrowserHistory {
+    
+    private final Stack<String> history;
+    private final Stack<String> future;
 
-  private Stack<String> history;
-  private Stack<String> future;
-
-  public BrowserHistory(String homepage) {
-    this.history = new Stack<>();
-    this.history.push(homepage);
-    this.future = new Stack<>();
-  }
-
-  public void visit(String url) {
-    this.future.removeAllElements();
-    this.history.push(url);
-  }
-
-  public String back(int steps) {
-    while (steps-- > 0 && this.history.size() > 1) {
-      this.future.push(this.history.pop());
+    public BrowserHistory(String homepage) {
+        this.history = new Stack<>();
+        this.future = new Stack<>();
+        this.history.push(homepage);
     }
-    return this.history.peek();
-  }
-
-  public String forward(int steps) {
-    while (steps-- > 0 && !this.future.isEmpty()) {
-      this.history.push(this.future.pop());
+    
+    public void visit(String url) {
+        future.removeAllElements();
+        history.push(url);
+    }
+    
+    public String back(int steps) {
+        while (steps-- > 0 && history.size() > 1) {
+            future.push(history.pop());
+        }
+        return history.peek();
+    }
+    
+    public String forward(int steps) {
+        while (steps-- > 0 && !future.isEmpty()) {
+            history.push(future.pop());
+        }
+        return history.peek();
     }
-    return this.history.peek();
-  }
 }
 
 /**
diff --git a/Medium/Design Circular Deque.java b/Medium/Design Circular Deque.java
index 86949d4a..66667ed5 100644
--- a/Medium/Design Circular Deque.java	
+++ b/Medium/Design Circular Deque.java	
@@ -1,104 +1,90 @@
 class MyCircularDeque {
-  
-  private Node head;
-  private Node tail;
-  private int k;
-  private int currSize;
 
-  public MyCircularDeque(int k) {
-    this.k = k;
-    this.currSize = 0;
-    this.head = new Node(-1);
-    this.tail = new Node(-1);
-    this.head.next = this.tail;
-    this.tail.prev = this.head;
-  }
+    private final Node head;
+    private final Node tail;
+    private final int capacity;
+    private int size;
 
-  public boolean insertFront(int value) {
-    if (isFull()) {
-      return false;
+    public MyCircularDeque(int k) {
+        head = new Node(-1);
+        tail = new Node(-1);
+        head.next = tail;
+        tail.prev = head;
+        capacity = k;
+        size = 0;
     }
-    Node node = new Node(value);
-    Node nextToHead = head.next;
-    head.next = node;
-    node.prev = head;
-    node.next = nextToHead;
-    nextToHead.prev = node;
-    currSize++;
-    return true;
-  }
 
-  public boolean insertLast(int value) {
-    if (isFull()) {
-      return false;
+    public boolean insertFront(int value) {
+        if (size == capacity) {
+            return false;
+        }
+        Node node = new Node(value);
+        node.next = head.next;
+        node.prev = head;
+        head.next.prev = node;
+        head.next = node;
+        size++;
+        return true;
     }
-    Node node = new Node(value);
-    Node prevToTail = tail.prev;
-    tail.prev = node;
-    node.next = tail;
-    prevToTail.next = node;
-    node.prev = prevToTail;
-    currSize++;
-    return true;
-  }
 
-  public boolean deleteFront() {
-    if (isEmpty()) {
-      return false;
+    public boolean insertLast(int value) {
+        if (size == capacity) {
+            return false;
+        }
+        Node node = new Node(value);
+        node.prev = tail.prev;
+        node.next = tail;
+        tail.prev.next = node;
+        tail.prev = node;
+        size++;
+        return true;
     }
-    Node toDelete = head.next;
-    deleteNode(toDelete);
-    return true;
-  }
 
-  public boolean deleteLast() {
-    if (isEmpty()) {
-      return false;
+    public boolean deleteFront() {
+        if (size == 0) {
+            return false;
+        }
+        head.next.next.prev = head;
+        head.next = head.next.next;
+        size--;
+        return true;
     }
-    Node toDelete = tail.prev;
-    deleteNode(toDelete);
-    return true;
-  }
 
-  public int getFront() {
-    if (isEmpty()) {
-      return -1;
+    public boolean deleteLast() {
+        if (size == 0) {
+            return false;
+        }
+        tail.prev.prev.next = tail;
+        tail.prev = tail.prev.prev;
+        size--;
+        return true;
     }
-    return head.next.val;
-  }
 
-  public int getRear() {
-    if (isEmpty()) {
-      return -1;
+    public int getFront() {
+        return head.next.value;
     }
-    return tail.prev.val;
-  }
 
-  public boolean isEmpty() {
-    return currSize == 0;
-  }
+    public int getRear() {
+        return tail.prev.value;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    public boolean isFull() {
+        return size == capacity;
+    }
+
+    static class Node {
+        int value;
+        Node next;
+        Node prev;
 
-  public boolean isFull() {
-    return currSize == k;
-  }
-  
-  private void deleteNode(Node node) {
-    Node prevToNode = node.prev;
-    Node nextToNode = node.next;
-    prevToNode.next = nextToNode;
-    nextToNode.prev = prevToNode;
-    currSize--;
-  }
-  
-  private static class Node {
-    int val;
-    Node next;
-    Node prev;
-    
-    public Node(int val) {
-      this.val = val;
+        Node(int value) {
+            this.value = value;
+        }
     }
-  }
 }
 
 /**
diff --git a/Medium/Design SQL.java b/Medium/Design SQL.java
new file mode 100644
index 00000000..644009b1
--- /dev/null
+++ b/Medium/Design SQL.java	
@@ -0,0 +1,47 @@
+class SQL {
+    
+    private final Map<String, Map<Integer, List<String>>> database;
+    private final Map<String, Integer> tableIdMap;
+
+    public SQL(List<String> tableNames, List<Integer> columns) {
+        this.database = new HashMap<>();
+        this.tableIdMap = new HashMap<>();
+        for (String name : tableNames) {
+            database.put(name, new HashMap<>());
+            tableIdMap.put(name, 1);
+        }
+    }
+    
+    public void insertRow(String tableName, List<String> row) {
+        // Select the table
+        Map<Integer, List<String>> table = this.database.get(tableName);
+        // Insert row in the table
+        table.put(tableIdMap.get(tableName), row);
+        // Increment rowId for the table
+        tableIdMap.put(tableName, tableIdMap.get(tableName) + 1);
+    }
+    
+    public void deleteRow(String tableName, int rowId) {
+        // Select the table
+        Map<Integer, List<String>> table = this.database.get(tableName);
+        // Delete the row against the rowId
+        table.remove(rowId);
+    }
+    
+    public String selectCell(String tableName, int rowId, int columnId) {
+        // Select the table
+        Map<Integer, List<String>> table = this.database.get(tableName);
+        // Select row
+        List<String> row = table.get(rowId);
+        // Select column
+        return row.get(columnId - 1);
+    }
+}
+
+/**
+ * Your SQL object will be instantiated and called as such:
+ * SQL obj = new SQL(names, columns);
+ * obj.insertRow(name,row);
+ * obj.deleteRow(name,rowId);
+ * String param_3 = obj.selectCell(name,rowId,columnId);
+ */
diff --git a/Medium/Design Snake Game.java b/Medium/Design Snake Game.java
index e4185474..dd645d15 100644
--- a/Medium/Design Snake Game.java	
+++ b/Medium/Design Snake Game.java	
@@ -1,87 +1,74 @@
 class SnakeGame {
-  
-  private final int width;
-  private final int height;
-  private final Set<Pair<Integer, Integer>> body;
-  private final Deque<Pair<Integer, Integer>> bodyQueue;
-  private final Queue<Pair<Integer, Integer>> foodQueue;
-  private int foodPoint;
-
-  public SnakeGame(int width, int height, int[][] food) {
-    this.width = width;
-    this.height = height;
-    this.body = new HashSet<>();
-    this.bodyQueue = new LinkedList<>();
-    this.body.add(new Pair<Integer, Integer>(0, 0));
-    this.bodyQueue.add(new Pair<Integer, Integer>(0, 0));
     
-    this.foodQueue = new LinkedList<>();
-    for (int[] fd : food) {
-      foodQueue.add(new Pair<Integer, Integer>(fd[0], fd[1]));
+    private final Deque<int[]> snake;
+    private final Queue<int[]> foodQueue;
+    private final Set<String> snakeBody;
+    private final int width;
+    private final int height;
+    private int score;
+    
+    public SnakeGame(int width, int height, int[][] food) {
+        this.snake = new ArrayDeque<>();
+        this.snake.addFirst(new int[]{0, 0});
+        this.foodQueue = new LinkedList<>();
+        this.foodQueue.addAll(Arrays.asList(food));
+        this.snakeBody = new HashSet<>();
+        this.snakeBody.add(0 + "|" + 0);
+        this.width = width;
+        this.height = height;
+        this.score = 0;
     }
-    this.foodPoint = 0;
-  }
-
-  public int move(String direction) {
-    Pair<Integer, Integer> currPosition = bodyQueue.peekLast();
-    Pair<Integer, Integer> nextPosition = move(currPosition, direction);
-    if (!isSnakeAlive(nextPosition)) {
-      return -1;
+    
+    public int move(String direction) {
+        int[] nextMove = getNextMove(direction);
+        if (!isMoveWithInBound(nextMove)) {
+            return -1;
+        }
+        moveSnake(nextMove);
+        if (isBitingItself(nextMove)) {
+            return -1;
+        }
+        this.snakeBody.add(nextMove[0] + "|" + nextMove[1]);
+        return score;
     }
-    if (!snakeAteFood(nextPosition)) {
-      body.remove(bodyQueue.pollFirst());
-      bodyQueue.addLast(nextPosition);
-      body.add(nextPosition);
+    
+    private int[] getNextMove(String direction) {
+        int[] nextMove = Arrays.copyOf(this.snake.peekFirst(), 2);
+        switch (direction) {
+            case "L" -> nextMove[1]--;
+            case "R" -> nextMove[1]++;
+            case "U" -> nextMove[0]--;
+            case "D" -> nextMove[0]++;
+            default -> {}
+        }
+        return nextMove;
     }
-    return foodPoint;
-  }
-  
-  private Pair<Integer, Integer> move(Pair<Integer, Integer> currPosition, String direction) {
-    int row = currPosition.getKey();
-    int col = currPosition.getValue();
-    switch (direction) {
-      case "U":
-        row--;
-        break;
-      case "D":
-        row++;
-        break;
-      case "L":
-        col--;
-        break;
-      case "R":
-        col++;
-        break;
-      default:
-        break;
+    
+    private boolean isMoveWithInBound(int[] move) {
+        int x = move[0];
+        int y = move[1];
+        return x >= 0 && y >= 0 && x < this.height && y < this.width;
     }
-    return new Pair<Integer, Integer>(row, col);
-  }
-  
-  private boolean isSnakeAlive(Pair<Integer, Integer> position) {
-    int row = position.getKey();
-    int col = position.getValue();
-    // Snake touched the boundary
-    if (!(row >= 0 && col >= 0 && row < height && col < width)) {
-      return false;
+    
+    private void moveSnake(int[] move) {
+        this.snake.addFirst(move);
+        if (snakeEatsFood(move)) {
+            this.foodQueue.remove();
+            this.score++;
+        } else {
+            int[] tail = this.snake.removeLast();
+            this.snakeBody.remove(tail[0] + "|" + tail[1]);
+        }
     }
-    // Snake bit somewhere in middle of the body
-    if (!position.equals(this.bodyQueue.peekFirst()) && this.body.contains(position)) {
-      return false;
+    
+    private boolean snakeEatsFood(int[] move) {
+        return !this.foodQueue.isEmpty() && move[0] == this.foodQueue.peek()[0] && move[1] == this.foodQueue.peek()[1];
     }
-    return true;
-  }
-  
-  private boolean snakeAteFood(Pair<Integer, Integer> position) {
-    if (!foodQueue.isEmpty() && position.equals(foodQueue.peek())) {
-      bodyQueue.addLast(position);
-      body.add(position);
-      foodQueue.poll();
-      foodPoint++;
-      return true;
+    
+    private boolean isBitingItself(int[] move) {
+        String key = move[0] + "|" + move[1];
+        return this.snakeBody.contains(key);
     }
-    return false;
-  }
 }
 
 /**
diff --git a/Medium/Design Spreadsheet.java b/Medium/Design Spreadsheet.java
new file mode 100644
index 00000000..e41fc142
--- /dev/null
+++ b/Medium/Design Spreadsheet.java	
@@ -0,0 +1,47 @@
+class Spreadsheet {
+
+    private final Map<Character, Map<Integer, Integer>> sheet;
+
+    public Spreadsheet(int rows) {
+        sheet = new HashMap<>();
+        for (char c = 'A'; c <= 'Z'; c++) {
+            sheet.put(c, new HashMap<>());
+        }
+    }
+    
+    public void setCell(String cell, int value) {
+        char column = cell.charAt(0);
+        int rowNumber = Integer.parseInt(cell.substring(1));
+        Map<Integer, Integer> row = sheet.get(column);
+        row.put(rowNumber, value);
+    }
+    
+    public void resetCell(String cell) {
+        setCell(cell, 0);
+    }
+    
+    public int getValue(String formula) {
+        String[] split = formula.split("\\+");
+        String cellOne = split[0].substring(1);
+        String cellTwo = split[1];
+        return getCellValue(cellOne) + getCellValue(cellTwo);
+    }
+
+    private int getCellValue(String cell) {
+        if (!Character.isLetter(cell.charAt(0))) {
+            return Integer.parseInt(cell);
+        }
+        char column = cell.charAt(0);
+        int rowNumber = Integer.parseInt(cell.substring(1));
+        Map<Integer, Integer> row = sheet.get(column);
+        return row.getOrDefault(rowNumber, 0);
+    }
+}
+
+/**
+ * Your Spreadsheet object will be instantiated and called as such:
+ * Spreadsheet obj = new Spreadsheet(rows);
+ * obj.setCell(cell,value);
+ * obj.resetCell(cell);
+ * int param_3 = obj.getValue(formula);
+ */
diff --git a/Medium/Design Underground System.java b/Medium/Design Underground System.java
index 51aa492a..6297656a 100644
--- a/Medium/Design Underground System.java	
+++ b/Medium/Design Underground System.java	
@@ -1,33 +1,37 @@
 class UndergroundSystem {
-  
-  private Map<String, Integer> totalTimeFromStartToEndStation;
-  private Map<String, Integer> numberOfCustomersFromStartToEndStation;
-  private Map<Integer, Integer> customerIdToStartTime;
-  private Map<Integer, String> customerIdToStartStation;
-  
-  public UndergroundSystem() {
-    this.totalTimeFromStartToEndStation = new HashMap<>();
-    this.numberOfCustomersFromStartToEndStation = new HashMap<>();
-    this.customerIdToStartTime = new HashMap<>();
-    this.customerIdToStartStation = new HashMap<>();
-  }
+    
+    private final Map<Integer, StationTimePair> customerToCheckInMapping;
+    private final Map<String, Integer> startEndStationTotalTimeMapping;
+    private final Map<String, Integer> startEndStationCountMapping;
 
-  public void checkIn(int id, String stationName, int t) {
-    this.customerIdToStartTime.put(id, t);
-    this.customerIdToStartStation.put(id, stationName);
-  }
-
-  public void checkOut(int id, String stationName, int t) {
-    int totalTime = t - this.customerIdToStartTime.get(id);
-    String key = this.customerIdToStartStation.get(id) + "|" + stationName;
-    this.totalTimeFromStartToEndStation.put(key, this.totalTimeFromStartToEndStation.getOrDefault(key, 0) + totalTime);
-    this.numberOfCustomersFromStartToEndStation.put(key, this.numberOfCustomersFromStartToEndStation.getOrDefault(key, 0) + 1);
-  }
-
-  public double getAverageTime(String startStation, String endStation) {
-    String key = startStation + "|" + endStation;
-    return this.totalTimeFromStartToEndStation.get(key) / (double) (this.numberOfCustomersFromStartToEndStation.get(key));
-   }
+    public UndergroundSystem() {
+        this.customerToCheckInMapping = new HashMap<>();
+        this.startEndStationTotalTimeMapping = new HashMap<>();
+        this.startEndStationCountMapping = new HashMap<>();
+    }
+    
+    public void checkIn(int id, String stationName, int t) {
+        StationTimePair pair = new StationTimePair(stationName, t);
+        customerToCheckInMapping.put(id, pair);
+    }
+    
+    public void checkOut(int id, String stationName, int t) {
+        StationTimePair pair = customerToCheckInMapping.get(id);
+        String key = pair.station() + "|" + stationName;
+        int totalTime = t - pair.time();
+        startEndStationTotalTimeMapping.put(key, startEndStationTotalTimeMapping.getOrDefault(key, 0) + totalTime);
+        startEndStationCountMapping.put(key, startEndStationCountMapping.getOrDefault(key, 0) + 1);
+    }
+    
+    public double getAverageTime(String startStation, String endStation) {
+        String key = startStation + "|" + endStation;
+        if (!startEndStationTotalTimeMapping.containsKey(key)) {
+            return 0.0;
+        }
+        return ((double) startEndStationTotalTimeMapping.get(key)) / startEndStationCountMapping.get(key);
+    }
+    
+    static record StationTimePair(String station, int time) {}
 }
 
 /**
diff --git a/Medium/Design a File Sharing System.java b/Medium/Design a File Sharing System.java
index 2f6c3de7..b5bba82b 100644
--- a/Medium/Design a File Sharing System.java	
+++ b/Medium/Design a File Sharing System.java	
@@ -1,57 +1,50 @@
 class FileSharing {
-  Map<Integer, Set<Integer>> chunkToUserMap;
-  Map<Integer, Set<Integer>> userToChunkMap;
-  int id;
-  PriorityQueue<Integer> availableIds;
-  public FileSharing(int m) {
-    id = 1;
-    chunkToUserMap = new HashMap<>();
-    userToChunkMap = new HashMap<>();
-    for (int i = 1; i <= m; i++) {
-      chunkToUserMap.put(i, new HashSet<>());
-    }
-    availableIds = new PriorityQueue<>();
-  }
 
-  public int join(List<Integer> ownedChunks) {
-    int userId = getUserId();
-    userToChunkMap.put(userId, new HashSet<>(ownedChunks));
-    for (Integer chunk : ownedChunks) {
-      chunkToUserMap.get(chunk).add(userId);
-    }
-    return userId;
-  }
-  
-  private int getUserId() {
-    if (availableIds.isEmpty()) {
-      return id++;
+    private final PriorityQueue<Integer> userIdsInSystem;
+    private final Map<Integer, Set<Integer>> chunkToUserIdMapping;
+    private final Map<Integer, Set<Integer>> userIdToChunkMapping;
+
+    public FileSharing(int m) {
+        this.userIdsInSystem = new PriorityQueue<>();
+        this.userIdsInSystem.add(1);
+        this.chunkToUserIdMapping = new HashMap<>();
+        for (int i = 1; i <= m; i++) {
+            chunkToUserIdMapping.put(i, new HashSet<>());
+        }
+        this.userIdToChunkMapping = new HashMap<>();
     }
-    return availableIds.poll();
-  }
 
-  public void leave(int userID) {
-    Set<Integer> chunksOwned = userToChunkMap.get(userID);
-    userToChunkMap.remove(userID);
-    for (Integer chunk : chunksOwned) {
-      chunkToUserMap.get(chunk).remove(userID);
+    public int join(List<Integer> ownedChunks) {
+        int currUserId = this.userIdsInSystem.poll();
+        if (this.userIdsInSystem.isEmpty()) {
+            this.userIdsInSystem.add(currUserId + 1);
+        }
+        this.userIdToChunkMapping.computeIfAbsent(currUserId, k -> new HashSet<>());
+        for (Integer chunk : ownedChunks) {
+            this.chunkToUserIdMapping.get(chunk).add(currUserId);
+            this.userIdToChunkMapping.get(currUserId).add(chunk);
+        }
+        return currUserId;
     }
-    availableIds.add(userID);
-  }
 
-  public List<Integer> request(int userID, int chunkID) {
-    Set<Integer> usersOwningChunk = chunkToUserMap.get(chunkID);
-    Iterator<Integer> iterator = usersOwningChunk.iterator();
-    List<Integer> users = new ArrayList<>();
-    while (iterator.hasNext()) {
-      users.add(iterator.next());
+    public void leave(int userID) {
+        this.userIdsInSystem.add(userID);
+        Set<Integer> chunksOwned = this.userIdToChunkMapping.get(userID);
+        this.userIdToChunkMapping.remove(userID);
+        for (Integer chunk : chunksOwned) {
+            this.chunkToUserIdMapping.get(chunk).remove(userID);
+        }
     }
-    if (!usersOwningChunk.contains(userID) && usersOwningChunk.size() > 0) {
-      userToChunkMap.get(userID).add(chunkID);
-      chunkToUserMap.get(chunkID).add(userID);
+
+    public List<Integer> request(int userID, int chunkID) {
+        if (this.chunkToUserIdMapping.get(chunkID).isEmpty()) {
+            return new ArrayList<>();
+        }
+        List<Integer> usersOwningChunk = this.chunkToUserIdMapping.get(chunkID).stream().sorted().toList();
+        this.userIdToChunkMapping.get(userID).add(chunkID);
+        this.chunkToUserIdMapping.get(chunkID).add(userID);
+        return usersOwningChunk;
     }
-    Collections.sort(users);
-    return users;
-  }
 }
 
 /**
diff --git a/Medium/Design a Food Rating System.java b/Medium/Design a Food Rating System.java
new file mode 100644
index 00000000..71c55477
--- /dev/null
+++ b/Medium/Design a Food Rating System.java	
@@ -0,0 +1,53 @@
+class FoodRatings {
+
+    private final Map<String, Integer> foodToRating;
+
+    private final Map<String, String> foodToCuisine;
+
+    private final Map<String, PriorityQueue<Food>> cuisineToFood;
+
+    public FoodRatings(String[] foods, String[] cuisines, int[] ratings) {
+        this.foodToRating = new HashMap<>();
+        this.foodToCuisine = new HashMap<>();
+        this.cuisineToFood = new HashMap<>();
+        for (int i = 0; i < foods.length; i++) {
+            String food = foods[i];
+            String cuisine = cuisines[i];
+            int rating = ratings[i];
+            foodToRating.put(food, rating);
+            foodToCuisine.put(food, cuisine);
+            cuisineToFood.computeIfAbsent(cuisine, k -> new PriorityQueue<>()).add(new Food(food, rating));
+        }
+    }
+
+    public void changeRating(String food, int newRating) {
+        this.foodToRating.put(food, newRating);
+        String cuisine = foodToCuisine.get(food);
+        cuisineToFood.get(cuisine).add(new Food(food, newRating));
+    }
+
+    public String highestRated(String cuisine) {
+        Food highestRatedFood = cuisineToFood.get(cuisine).peek();
+        while (foodToRating.get(highestRatedFood.name) != highestRatedFood.rating) {
+            cuisineToFood.get(cuisine).poll();
+            highestRatedFood = cuisineToFood.get(cuisine).peek();
+        }
+        return highestRatedFood.name;
+    }
+
+    private record Food(String name, int rating) implements Comparable<Food> {
+        @Override
+        public int compareTo(Food o) {
+            int c = o.rating - rating;
+            return c == 0 ? name.compareTo(o.name) : c;
+        }
+    }
+}
+
+
+/**
+ * Your FoodRatings object will be instantiated and called as such:
+ * FoodRatings obj = new FoodRatings(foods, cuisines, ratings);
+ * obj.changeRating(food,newRating);
+ * String param_2 = obj.highestRated(cuisine);
+ */
diff --git a/Medium/Design a Number Container System.java b/Medium/Design a Number Container System.java
new file mode 100644
index 00000000..26a3e843
--- /dev/null
+++ b/Medium/Design a Number Container System.java	
@@ -0,0 +1,34 @@
+class NumberContainers {
+
+    private final Map<Integer, TreeSet<Integer>> numberToIndex;
+    private final Map<Integer, Integer> indexToNumber;
+
+    public NumberContainers() {
+        this.numberToIndex = new HashMap<>();  
+        this.indexToNumber = new HashMap<>();      
+    }
+    
+    public void change(int index, int number) {
+        if (indexToNumber.containsKey(index)) {
+            int prevNumber = indexToNumber.get(index);
+            numberToIndex.get(prevNumber).remove(index);
+        }
+        indexToNumber.put(index, number);
+        numberToIndex.computeIfAbsent(number, k -> new TreeSet<>()).add(index);
+    }
+    
+    public int find(int number) {
+        TreeSet<Integer> indices = numberToIndex.getOrDefault(number, new TreeSet<>());
+        if (indices.isEmpty()) {
+            return -1;
+        }
+        return indices.first();
+    }
+}
+
+/**
+ * Your NumberContainers object will be instantiated and called as such:
+ * NumberContainers obj = new NumberContainers();
+ * obj.change(index,number);
+ * int param_2 = obj.find(number);
+ */
diff --git a/Medium/Design a Stack With Increment Operation.java b/Medium/Design a Stack With Increment Operation.java
index 9164401b..9e4ec3a3 100644
--- a/Medium/Design a Stack With Increment Operation.java	
+++ b/Medium/Design a Stack With Increment Operation.java	
@@ -1,40 +1,40 @@
 class CustomStack {
-  
-  private Stack<Integer> stack;
-  private int[] incrementArray;
-  private int maxSize;
-  
-  public CustomStack(int maxSize) {
-    this.stack = new Stack<>();
-    this.incrementArray = new int[maxSize];
-    this.maxSize = maxSize;
-  }
 
-  public void push(int x) {
-    if (this.stack.size() < this.maxSize) {
-      this.stack.push(x);
-    }
-  }
+    private final int maxSize;
+    private final Stack<Integer> stack;
+    private int[] increment;
 
-  public int pop() {
-    int idx = this.stack.size() - 1;
-    if (idx < 0) {
-      return -1;
+    public CustomStack(int maxSize) {
+        this.maxSize = maxSize;
+        this.stack = new Stack<>();
+        this.increment = new int[maxSize];
     }
-    if (idx > 0) {
-      this.incrementArray[idx - 1] += this.incrementArray[idx];
+    
+    public void push(int x) {
+        if (stack.size() < maxSize) {
+            stack.push(x);
+        }
     }
-    int result = this.stack.pop() + this.incrementArray[idx];
-    this.incrementArray[idx] = 0;
-    return result;
-  }
-
-  public void increment(int k, int val) {
-    int idx = Math.min(k, this.stack.size()) - 1;
-    if (idx >= 0) {
-      this.incrementArray[idx] += val;
+    
+    public int pop() {
+        int idx = stack.size() - 1;
+        if (idx < 0) {
+            return -1;
+        }
+        if (idx > 0) {
+            increment[idx - 1] += increment[idx];
+        }
+        int result = stack.pop() + increment[idx];
+        increment[idx] = 0;
+        return result;
+    }
+    
+    public void increment(int k, int val) {
+        int idx = Math.min(k, stack.size()) - 1;
+        if (idx >= 0) {
+            increment[idx] += val;
+        }
     }
-  }
 }
 
 /**
diff --git a/Medium/Design an Expression Tree With Evaluate Function.java b/Medium/Design an Expression Tree With Evaluate Function.java
index 123e21df..e01eb49f 100644
--- a/Medium/Design an Expression Tree With Evaluate Function.java	
+++ b/Medium/Design an Expression Tree With Evaluate Function.java	
@@ -4,50 +4,56 @@
  */
 
 abstract class Node {
-  public abstract int evaluate();
-  // define your fields here
+    public abstract int evaluate();
+    // define your fields here
 };
 
+
 class NumericNode extends Node {
-  
-  private int val;
-  
-  public NumericNode(int val) {
-    this.val = val;  
-  }
-  
-  public int evaluate() {
-    return this.val;
-  }
+    private int val;
+    
+    public NumericNode(int val) {
+        this.val = val;
+    }
+    
+    @Override
+    public int evaluate() {
+        return this.val;
+    }
 }
 
+
 class OperatorNode extends Node {
-  private char operator;
-  private Node leftNode;
-  private Node rightNode;
-  
-  public OperatorNode(char operator, Node leftNode, Node rightNode) {
-    this.operator = operator;
-    this.leftNode = leftNode;
-    this.rightNode = rightNode;
-  }
-  
-  public int evaluate() {
-    int leftValue = this.leftNode == null ? 0 : this.leftNode.evaluate();
-    int rightValue = this.rightNode == null ? 0 : this.rightNode.evaluate();
-    if (this.operator == '+') {
-      return leftValue + rightValue;
-    } else if (this.operator == '-') {
-      return leftValue - rightValue;
-    } else if (this.operator == '*') {
-      return leftValue * rightValue;
-    } else {
-      return leftValue / rightValue;
+    private char operator;
+    private Node left;
+    private Node right;
+    
+    public OperatorNode(char operator) {
+        this.operator = operator;
+        this.left = null;
+        this.right = null;
+    }
+    
+    @Override
+    public int evaluate() {
+        return switch(operator) {
+            case '+' -> left.evaluate() + right.evaluate();
+            case '-' -> left.evaluate() - right.evaluate();
+            case '*' -> left.evaluate() * right.evaluate();
+            case '/' -> left.evaluate() / right.evaluate();
+            default -> 0;
+        };
+    }
+    
+    public void setRightNode(Node right) {
+        this.right = right;
+    }
+    
+    public void setLeftNode(Node left) {
+        this.left = left;
     }
-  }
 }
 
-
 /**
  * This is the TreeBuilder class.
  * You can treat it as the driver code that takes the postinfix input 
@@ -55,19 +61,27 @@ public int evaluate() {
  */
 
 class TreeBuilder {
-  Node buildTree(String[] postfix) {
-    Stack<Node> stack = new Stack<>();
-    for(String token: postfix){
-      if (token.equals("*") || token.equals("+") || token.equals("-") || token.equals("/")) {
-        Node o2 = stack.pop();
-        Node o1 = stack.pop();
-        stack.push(new OperatorNode(token.charAt(0), o1, o2));
-      } else{
-        stack.push(new NumericNode(Integer.parseInt(token)));
-      }
+    private static final Set<String> OPERATORS = Set.of("+", "-", "/", "*");
+    
+    Node buildTree(String[] postfix) {
+        int[] idx = {postfix.length - 1};
+        return buildTree(postfix, idx);
+    }
+    
+    private Node buildTree(String[] postfix, int[] idx) {
+        if (idx[0] < 0) {
+            return null;
+        }
+        String val = postfix[idx[0]--];
+        if (OPERATORS.contains(val)) {
+            OperatorNode node = new OperatorNode(val.charAt(0));
+            node.setRightNode(buildTree(postfix, idx));
+            node.setLeftNode(buildTree(postfix, idx));
+            return node;
+        }
+        NumericNode node = new NumericNode(Integer.parseInt(val));
+        return node;
     }
-    return stack.pop();
-  }
 };
 
 
diff --git a/Medium/Determine if Two Strings Are Close.java b/Medium/Determine if Two Strings Are Close.java
index 96a5181a..3a43fd6a 100644
--- a/Medium/Determine if Two Strings Are Close.java	
+++ b/Medium/Determine if Two Strings Are Close.java	
@@ -1,30 +1,30 @@
 class Solution {
-  public boolean closeStrings(String word1, String word2) {
-    if (word1.length() != word2.length()) {
-      return false;
+    public boolean closeStrings(String word1, String word2) {
+        if (word1.length() != word2.length()) {
+            return false;
+        }
+        int[] frequencyOne = getFrequencyArray(word1);
+        int[] frequencyTwo = getFrequencyArray(word2);
+        for (int i = 0; i < 26; i++) {
+            if (frequencyOne[i] == 0 && frequencyTwo[i] != 0) {
+                return false;
+            }
+        }
+        Arrays.sort(frequencyOne);
+        Arrays.sort(frequencyTwo);
+        for (int i = 0; i < 26; i++) {
+            if (frequencyOne[i] != frequencyTwo[i]) {
+                return false;
+            }
+        }
+        return true;
     }
-    int[] frequencyOne = getFrequencyArray(word1);
-    int[] frequencyTwo = getFrequencyArray(word2);
-    for (int i = 0; i < frequencyOne.length; i++) {
-      if (frequencyOne[i] == 0 && frequencyTwo[i] != 0) {
-        return false;
-      }
+
+    private static int[] getFrequencyArray(String s) {
+        int[] frequency = new int[26];
+        for (int i = 0; i < s.length(); i++) {
+            frequency[s.charAt(i) - 'a']++;
+        }
+        return frequency;
     }
-    Arrays.sort(frequencyOne);
-    Arrays.sort(frequencyTwo);
-    for (int i = 0; i < frequencyOne.length; i++) {
-      if (frequencyOne[i] != frequencyTwo[i]) {
-        return false;
-      }
-    }
-    return true;
-  }
-  
-  private int[] getFrequencyArray(String s) {
-    int[] frequency = new int[26];
-    for (char c : s.toCharArray()) {
-      frequency[c - 'a']++;
-    }
-    return frequency;
-  }
 }
diff --git a/Medium/Determine if a Cell Is Reachable at a Given Time.java b/Medium/Determine if a Cell Is Reachable at a Given Time.java
new file mode 100644
index 00000000..37878fa8
--- /dev/null
+++ b/Medium/Determine if a Cell Is Reachable at a Given Time.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public boolean isReachableAtTime(int sx, int sy, int fx, int fy, int t) {
+        int xDiff = Math.abs(sx - fx);
+        int yDiff = Math.abs(sy - fy);
+        if (xDiff == 0 && yDiff == 0 && t == 1) {
+            return false;
+        }
+        return (Math.min(xDiff, yDiff) + Math.abs(xDiff - yDiff)) <= t; 
+    }
+}
diff --git a/Medium/Determine the Minimum Sum of a k-avoiding Array.java b/Medium/Determine the Minimum Sum of a k-avoiding Array.java
new file mode 100644
index 00000000..3eab331f
--- /dev/null
+++ b/Medium/Determine the Minimum Sum of a k-avoiding Array.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int minimumSum(int n, int k) {
+        Set<Integer> set = new HashSet<>();
+        set.add(1);
+        int sum = 1;
+        int next = 2;
+        while (n > 1) {
+            if (set.contains(k - next)) {
+                next++;
+                continue;
+            }
+            set.add(next);
+            sum += next++;
+            n--;
+        }
+        return sum;
+    }
+}
diff --git a/Medium/Detonate the Maximum Bombs.java b/Medium/Detonate the Maximum Bombs.java
new file mode 100644
index 00000000..2dbecdc0
--- /dev/null
+++ b/Medium/Detonate the Maximum Bombs.java	
@@ -0,0 +1,37 @@
+class Solution {
+    public int maximumDetonation(int[][] bombs) {
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        int n = bombs.length;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i == j) {
+                    continue;
+                }
+                int x1 = bombs[i][0];
+                int y1 = bombs[i][1];
+                int r = bombs[i][2];
+                int x2 = bombs[j][0];
+                int y2 = bombs[j][1];
+                if ((long) r * r >= (long) (x1 - x2) * (x1 - x2) + (long) (y1 - y2) * (y1 - y2)) {
+                    graph.computeIfAbsent(i, k -> new ArrayList<>()).add(j);
+                }
+            }
+        }
+        int result = 0;
+        for (int i = 0; i < n; i++) {
+            result = Math.max(result, dfs(i, new HashSet<>(), graph));
+        }
+        return result;
+    }
+    
+    private int dfs(int curr, Set<Integer> visited, Map<Integer, List<Integer>> graph) {
+        visited.add(curr);
+        int count = 1;
+        for (Integer neighbor : graph.getOrDefault(curr, new ArrayList<>())) {
+            if (!visited.contains(neighbor)) {
+                count += dfs(neighbor, visited, graph);
+            }
+        }
+        return count;
+    }
+}
diff --git a/Medium/Diagonal Traverse II.java b/Medium/Diagonal Traverse II.java
new file mode 100644
index 00000000..dabfc5ef
--- /dev/null
+++ b/Medium/Diagonal Traverse II.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int[] findDiagonalOrder(List<List<Integer>> nums) {
+        Queue<int[]> queue = new LinkedList<>();
+        List<Integer> result = new ArrayList<>();
+        queue.add(new int[]{0, 0});
+        while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            int x = removed[0];
+            int y = removed[1];
+            result.add(nums.get(x).get(y));
+            // move down in column first
+            if (y == 0 && x + 1 < nums.size()) {
+                queue.add(new int[]{x + 1, y});
+            }
+            // then pick the next element in row
+            if (y + 1 < nums.get(x).size()) {
+                queue.add(new int[]{x, y + 1});
+            }
+        }
+        int[] ans = new int[result.size()];
+        for (int i = 0; i < result.size(); i++) {
+            ans[i] = result.get(i);
+        }
+        return ans;
+    }
+}
diff --git a/Medium/Difference Between Ones and Zeros in Row and Column.java b/Medium/Difference Between Ones and Zeros in Row and Column.java
new file mode 100644
index 00000000..641b0b38
--- /dev/null
+++ b/Medium/Difference Between Ones and Zeros in Row and Column.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public int[][] onesMinusZeros(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        int[][] rowCount = new int[rows][2];
+        int[][] colCount = new int[cols][2];
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                rowCount[i][0] += grid[i][j] == 1 ? 1 : 0;
+                rowCount[i][1] += grid[i][j] != 1 ? 1 : 0;
+                colCount[j][0] += grid[i][j] == 1 ? 1 : 0;
+                colCount[j][1] += grid[i][j] != 1 ? 1 : 0;
+            }
+        }
+        int[][] result = new int[rows][cols];
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                result[i][j] = rowCount[i][0] + colCount[j][0] - rowCount[i][1] - colCount[j][1];
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Different Ways to Add Parentheses.java b/Medium/Different Ways to Add Parentheses.java
new file mode 100644
index 00000000..706fcf6c
--- /dev/null
+++ b/Medium/Different Ways to Add Parentheses.java	
@@ -0,0 +1,42 @@
+class Solution {
+    public List<Integer> diffWaysToCompute(String expression) {
+        List<Integer> result = new ArrayList<>();
+        if (expression.length() == 0) {
+            return result;
+        }
+        if (expression.length() == 1) {
+            result.add(Integer.parseInt(expression));
+            return result;
+        }
+        if (expression.length() == 2 && Character.isDigit(expression.charAt(0))) {
+            result.add(Integer.parseInt(expression));
+            return result;
+        }
+        for (int i = 0; i < expression.length(); i++) {
+            char c = expression.charAt(i);
+            if (Character.isDigit(c)) {
+                continue;
+            }
+            List<Integer> leftResult = diffWaysToCompute(expression.substring(0, i));
+            List<Integer> rightResult = diffWaysToCompute(expression.substring(i + 1));
+            for (int leftVal : leftResult) {
+                for (int rightVal : rightResult) {
+                    int value = 0;
+                    switch(c) {
+                        case '+':
+                            value = leftVal + rightVal;
+                            break;
+                        case '-':
+                            value = leftVal - rightVal;
+                            break;
+                        case '*':
+                            value = leftVal * rightVal;
+                            break;
+                    }
+                    result.add(value);
+                }
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Distribute Candies Among Children II.java b/Medium/Distribute Candies Among Children II.java
new file mode 100644
index 00000000..aa9648f2
--- /dev/null
+++ b/Medium/Distribute Candies Among Children II.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public long distributeCandies(int n, int limit) {
+        long result = 0;
+        for (int i = 0; i <= Math.min(limit, n); i++) {
+            // distribution not possible as we will have to allocate at least one child with 
+            // more than limit candies
+            if (n - i > 2 * limit) {
+                continue;
+            }
+            result += Math.min(n - i, limit) - Math.max(0, n - i - limit) + 1;
+        }
+        return result;
+    }
+}
diff --git a/Medium/Divide Array Into Arrays With Max Difference.java b/Medium/Divide Array Into Arrays With Max Difference.java
new file mode 100644
index 00000000..77959768
--- /dev/null
+++ b/Medium/Divide Array Into Arrays With Max Difference.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int[][] divideArray(int[] nums, int k) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        int[][] result = new int[n / 3][3];
+        int idx = 0;
+        for (int i = 2; i < nums.length; i += 3) {
+            if (nums[i] - nums[i - 2] > k) {
+                return new int[][]{};
+            }
+            result[idx++] = new int[]{nums[i - 2], nums[i - 1], nums[i]};
+        }
+        return result;
+    }
+}
diff --git a/Medium/Divide Intervals Into Minimum Number of Groups.java b/Medium/Divide Intervals Into Minimum Number of Groups.java
new file mode 100644
index 00000000..b58d0dcb
--- /dev/null
+++ b/Medium/Divide Intervals Into Minimum Number of Groups.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int minGroups(int[][] intervals) {
+        Arrays.sort(intervals, (o1, o2) -> {
+            int c = Integer.compare(o1[0], o2[0]);
+            if (c == 0) {
+                return Integer.compare(o1[1], o2[1]);
+            }
+            return c;
+        });
+        int max = 0;
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        for (int[] interval : intervals) {
+            while (!pq.isEmpty() && pq.peek() < interval[0]) {
+                pq.poll();
+            }
+            pq.add(interval[1]);
+            max = Math.max(max, pq.size());
+        }
+        return max;
+    }
+}
diff --git a/Medium/Divide Players Into Teams of Equal Skill.java b/Medium/Divide Players Into Teams of Equal Skill.java
new file mode 100644
index 00000000..41a5f1f7
--- /dev/null
+++ b/Medium/Divide Players Into Teams of Equal Skill.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public long dividePlayers(int[] skill) {
+        int n = skill.length;
+        int totalSkill = 0;
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int s : skill) {
+            totalSkill += s;
+            map.put(s, map.getOrDefault(s, 0) + 1);
+        }
+        if (totalSkill % (n / 2) != 0) {
+            return -1;
+        }
+        int targetSkill = totalSkill / (n / 2);
+        long totalChemistry = 0;
+        for (int currSkill : map.keySet()) {
+            int partnerSkill = targetSkill - currSkill;
+            int currSkillFreq = map.get(currSkill);
+            if (!map.containsKey(partnerSkill) || currSkillFreq != map.get(partnerSkill)) {
+                return -1;
+            }
+            totalChemistry += (long) currSkill * (long) partnerSkill * (long) currSkillFreq;
+        }
+        return totalChemistry / 2;
+    }
+}
diff --git a/Medium/Dota2 Senate.java b/Medium/Dota2 Senate.java
new file mode 100644
index 00000000..56465cb4
--- /dev/null
+++ b/Medium/Dota2 Senate.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public String predictPartyVictory(String senate) {
+        int n = senate.length();
+        Queue<Integer> rValid = new LinkedList<>();
+        Queue<Integer> dValid = new LinkedList<>();
+        for (int i = 0; i < n; i++) {
+            if (senate.charAt(i) == 'R') {
+                rValid.add(i);
+            } else {
+                dValid.add(i);
+            }
+        }
+        while (!rValid.isEmpty() && !dValid.isEmpty()) {
+            int rTurn = rValid.remove();
+            int dTurn = dValid.remove();
+            if (dTurn < rTurn) {
+                dValid.add(dTurn + n);
+            } else {
+                rValid.add(rTurn + n);
+            }
+        }
+        return rValid.isEmpty() ? "Dire" : "Radiant";
+    }
+}
diff --git a/Medium/Double Modular Exponentiation.java b/Medium/Double Modular Exponentiation.java
new file mode 100644
index 00000000..6dada495
--- /dev/null
+++ b/Medium/Double Modular Exponentiation.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public List<Integer> getGoodIndices(int[][] variables, int target) {
+        List<Integer> result = new ArrayList<>();
+        for (int i = 0; i < variables.length; i++) {
+            int a = variables[i][0];
+            int b = variables[i][1];
+            int c = variables[i][2];
+            int m = variables[i][3];
+            int base = 1;
+            for (int j = 0; j < b; j++) {
+                base = (base * a) % 10;
+            }
+            int value = 1;
+            for (int j = 0; j < c; j++) {
+                value = (value * base) % m;
+            }
+            if (value == target) {
+                result.add(i);
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Double a Number Represented as a Linked List.java b/Medium/Double a Number Represented as a Linked List.java
new file mode 100644
index 00000000..9e2bcbaa
--- /dev/null
+++ b/Medium/Double a Number Represented as a Linked List.java	
@@ -0,0 +1,40 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode doubleIt(ListNode head) {
+        ListNode rev = reverse(head);
+        ListNode curr = rev;
+        int carry = 0;
+        while (curr != null) {
+            int val = curr.val * 2 + carry;
+            carry = val / 10;
+            curr.val = val % 10;
+            if (curr.next == null && carry != 0) {
+                curr.next = new ListNode(carry);
+                break;
+            }
+            curr = curr.next;
+        }
+        return reverse(rev);
+    }
+
+    private ListNode reverse(ListNode curr) {
+        ListNode next = null;
+        ListNode prev = null;
+        while (curr != null) {
+            next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
+    }
+}
diff --git a/Medium/Equal Row and Column Pairs.java b/Medium/Equal Row and Column Pairs.java
index 7c31eb66..515fb2db 100644
--- a/Medium/Equal Row and Column Pairs.java	
+++ b/Medium/Equal Row and Column Pairs.java	
@@ -1,25 +1,23 @@
 class Solution {
-  public int equalPairs(int[][] grid) {
-    Map<String, Integer> map = new HashMap<>();
-    int rows = grid.length;
-    int cols = grid[0].length;
-    for (int i = 0; i < rows; i++) {
-      StringBuilder sb = new StringBuilder();
-      for (int j = 0; j < cols; j++) {
-        sb.append(grid[i][j]).append("|");
-      }
-      String key = sb.toString();
-      map.put(key, map.getOrDefault(key, 0) + 1);
+    public int equalPairs(int[][] grid) {
+        Map<String, Integer> rowMap = new HashMap<>();
+        for (int[] value : grid) {
+            StringBuilder sb = new StringBuilder();
+            for (int j = 0; j < grid[0].length; j++) {
+                sb.append(value[j]).append("|");
+            }
+            String key = sb.toString();
+            rowMap.put(key, rowMap.getOrDefault(key, 0) + 1);
+        }
+        int count = 0;
+        for (int i = 0; i < grid[0].length; i++) {
+            StringBuilder sb = new StringBuilder();
+            for (int[] ints : grid) {
+                sb.append(ints[i]).append("|");
+            }
+            String key = sb.toString();
+            count += rowMap.getOrDefault(key, 0);
+        }
+        return count;
     }
-    int count = 0;
-    for (int i = 0; i < cols; i++) {
-      StringBuilder sb = new StringBuilder();
-      for (int j = 0; j < rows; j++) {
-        sb.append(grid[j][i]).append("|");
-      }
-      String key = sb.toString();
-      count += map.getOrDefault(key, 0);
-    }
-    return count;
-  }
 }
diff --git a/Medium/Evaluate Reverse Polish Notation.java b/Medium/Evaluate Reverse Polish Notation.java
index 483049db..17b3a709 100644
--- a/Medium/Evaluate Reverse Polish Notation.java	
+++ b/Medium/Evaluate Reverse Polish Notation.java	
@@ -1,27 +1,26 @@
 class Solution {
-  public int evalRPN(String[] tokens) {
-    Stack<Integer> stack = new Stack<>();
-    String operations = "+-/*";
-    for (String token : tokens) {
-      stack.push(operations.contains(token) ? Objects
-          .requireNonNull(performOperation(stack.pop(), stack.pop(), token))
-          : Integer.parseInt(token));
+    
+    private static final Set<String> OPERATIONS = Set.of("*", "+", "/", "-");
+    
+    public int evalRPN(String[] tokens) {
+        Stack<Integer> stack = new Stack<>();
+        for (String token : tokens) {
+            if (OPERATIONS.contains(token)) {
+                stack.push(performOperation(stack.pop(), stack.pop(), token));
+            } else {
+                stack.push(Integer.parseInt(token));
+            }
+        }
+        return stack.pop();
     }
-    return stack.pop();
-  }
-
-  private Integer performOperation(Integer secondOperand, Integer firstOperand, String operation) {
-    switch (operation) {
-      case "+":
-        return firstOperand + secondOperand;
-      case "-":
-        return firstOperand - secondOperand;
-      case "*":
-        return firstOperand * secondOperand;
-      case "/":
-        return firstOperand / secondOperand;
-      default:
-        return null;
+    
+    private static int performOperation(int num2, int num1, String operation) throws UnsupportedOperationException {
+        return switch(operation) {
+            case "+" -> num1 + num2;
+            case "-" -> num1 - num2;
+            case "*" -> num1 * num2;
+            case "/" -> num1 / num2;
+            default -> throw new UnsupportedOperationException("Operation not supported");
+        };
     }
-  }
 }
diff --git a/Medium/Even Odd Tree.java b/Medium/Even Odd Tree.java
index 0d3a4886..574ddf6b 100644
--- a/Medium/Even Odd Tree.java	
+++ b/Medium/Even Odd Tree.java	
@@ -14,36 +14,31 @@
  * }
  */
 class Solution {
-  public boolean isEvenOddTree(TreeNode root) {
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    int remainderExpected = 1;
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      Integer prev = null;
-      while (size-- > 0) {
-        TreeNode removed = queue.remove();
-        if (removed.val % 2 != remainderExpected) {
-          return false;
+    public boolean isEvenOddTree(TreeNode root) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        boolean even = true;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            int prev = even ? Integer.MIN_VALUE : Integer.MAX_VALUE;
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                if ((even && removed.val % 2 == 0) || (!even && removed.val % 2 != 0)) {
+                    return false;
+                }
+                if ((even && removed.val <= prev) || (!even && removed.val >= prev)) {
+                    return false;
+                }
+                prev = removed.val;
+                if (removed.left != null) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null) {
+                    queue.add(removed.right);
+                }
+            }
+            even = !even;
         }
-        if (prev != null) {
-          if (remainderExpected == 1 && removed.val <= prev) {
-            return false;
-          } 
-          if (remainderExpected == 0 && removed.val >= prev) {
-            return false;
-          } 
-        }
-        prev = removed.val;
-        if (removed.left != null) {
-          queue.add(removed.left);
-        }
-        if (removed.right != null) {
-          queue.add(removed.right);
-        }
-      }
-      remainderExpected = remainderExpected == 1 ? 0 : 1;
+        return true;
     }
-    return true;
-  }
 }
diff --git a/Medium/Exclusive Time of Functions.java b/Medium/Exclusive Time of Functions.java
index 8212e0c0..cd85e84c 100644
--- a/Medium/Exclusive Time of Functions.java	
+++ b/Medium/Exclusive Time of Functions.java	
@@ -1,33 +1,25 @@
 class Solution {
-  public int[] exclusiveTime(int n, List<String> logs) {
-    int[] result = new int[n];
-    Stack<Log> stack = new Stack<>();
-    for (String log : logs) {
-      Log currentLog = new Log(log);
-      if (currentLog.isStart) {
-        stack.push(currentLog);
-      } else {
-        Log topLog = stack.pop();
-        result[topLog.id] += currentLog.time - topLog.time + 1 - topLog.overLappingTime;
-        if (!stack.isEmpty()) {
-          stack.peek().overLappingTime += currentLog.time - topLog.time + 1;
+    public int[] exclusiveTime(int n, List<String> logs) {
+        Stack<Integer> stack = new Stack<>();
+        int[] result = new int[n];
+        int lastTimestamp = 0;
+        for (String log : logs) {
+            String[] split = log.split(":");
+            int id = Integer.parseInt(split[0]);
+            int timestamp = Integer.parseInt(split[2]);
+            if (split[1].equals("start")) {
+                // We consider timestamp as part of current computation 
+                if (!stack.isEmpty()) {
+                    result[stack.peek()] += timestamp - lastTimestamp;
+                }
+                stack.push(id);
+                lastTimestamp = timestamp;
+            } else {
+                // We consider timestamp as part of previous computation
+                result[stack.pop()] += timestamp - lastTimestamp + 1;
+                lastTimestamp = timestamp + 1;
+            }
         }
-      }
+        return result;
     }
-    return result;
-  }
-
-  private static class Log {
-    public int id;
-    public boolean isStart;
-    public int time;
-    public int overLappingTime;
-
-    public Log(String log) {
-      String[] split = log.split(":");
-      this.id = Integer.parseInt(split[0]);
-      this.isStart = split[1].equals("start");
-      this.time = Integer.parseInt(split[2]);
-    }
-  }
 }
diff --git a/Medium/Extra Characters in a String.java b/Medium/Extra Characters in a String.java
new file mode 100644
index 00000000..4d43cc5c
--- /dev/null
+++ b/Medium/Extra Characters in a String.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int minExtraChar(String s, String[] dictionary) {
+        Integer[] dp = new Integer[s.length() + 1];
+        return helper(0, s, Arrays.stream(dictionary).collect(Collectors.toSet()), dp);
+    }
+
+    private int helper(int idx, String s, Set<String> set, Integer[] dp) {
+        if (idx == s.length()) {
+            return 0;
+        }
+        if (dp[idx] != null) {
+            return dp[idx];
+        }
+        int result = Integer.MAX_VALUE;
+        for (int i = idx; i < s.length(); i++) {
+            String sub = s.substring(idx, i + 1);
+            if (set.contains(sub)) {
+                result = Math.min(result, helper(i + 1, s, set, dp));
+            } else {
+                result = Math.min(result, i - idx + 1 + helper(i + 1, s, set, dp));
+            }
+        }
+        return dp[idx] = result;
+    }
+}
diff --git a/Medium/Find All Anagrams in a String.java b/Medium/Find All Anagrams in a String.java
index 1edba8c7..e18917da 100644
--- a/Medium/Find All Anagrams in a String.java	
+++ b/Medium/Find All Anagrams in a String.java	
@@ -1,30 +1,24 @@
 class Solution {
-  public List<Integer> findAnagrams(String s, String p) {
-    List<Integer> list = new ArrayList<>();
-    if (s.length() < p.length()) {
-      return list;
+    public List<Integer> findAnagrams(String s, String p) {
+        if (s.length() < p.length()) {
+            return new ArrayList<>();
+        }
+        List<Integer> result = new ArrayList<>();
+        int[] patternCounter = new int[26];
+        for (char c : p.toCharArray()) {
+            patternCounter[c - 'a']++;
+        }
+        int[] counter = new int[26];
+        int start = 0;
+        for (int i = 0; i < s.length(); i++) {
+            counter[s.charAt(i) - 'a']++;
+            if (i >= p.length() - 1) {
+                if (Arrays.equals(patternCounter, counter)) {
+                    result.add(start);
+                }
+                counter[s.charAt(start++) - 'a']--;
+            }
+        }
+        return result;
     }
-    int[] pArr = new int[26];
-    for (char c : p.toCharArray()) {
-      pArr[c - 'a']++;
-    }
-    String pStr = Arrays.toString(pArr);
-    int start = 0;
-    int end = 0;
-    int n = s.length();
-    int[] sArr = new int[26];
-    while (end < (p.length() - 1)) {
-      sArr[s.charAt(end) - 'a']++;
-      end++;
-    }
-    while (end < n) {
-      sArr[s.charAt(end) - 'a']++;
-      end++;
-      if (Arrays.toString(sArr).equals(pStr)) {
-        list.add(start);
-      }
-      sArr[s.charAt(start++) - 'a']--;
-    }
-    return list;
-  }
 }
diff --git a/Medium/Find All Groups of Farmland.java b/Medium/Find All Groups of Farmland.java
new file mode 100644
index 00000000..130db6a1
--- /dev/null
+++ b/Medium/Find All Groups of Farmland.java	
@@ -0,0 +1,49 @@
+class Solution {
+
+    private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+
+    public int[][] findFarmland(int[][] land) {
+        int rows = land.length;
+        int cols = land[0].length;
+        boolean[][] visited = new boolean[rows][cols];
+        List<int[]> result = new ArrayList<>();
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (land[i][j] == 1 && !visited[i][j]) {
+                    traverse(land, i, j, visited, result);
+                }
+            }
+        }
+        return result.stream()
+                .map(int[]::clone)
+                .toArray(int[][]::new);
+    }
+
+    private static void traverse(int[][] land, int i, int j, boolean[][] visited, List<int[]> result) {
+        int rows = land.length;
+        int cols = land[0].length;
+        Queue<int[]> queue = new LinkedList<>();
+        int[] leftMost = {i, j};
+        int[] rightMost = {i, j};
+        queue.add(new int[]{i, j});
+        visited[i][j] = true;
+        while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            int x = removed[0];
+            int y = removed[1];
+            leftMost[0] = Math.min(leftMost[0], x);
+            leftMost[1] = Math.min(leftMost[1], y);
+            rightMost[0] = Math.max(rightMost[0], x);
+            rightMost[1] = Math.max(rightMost[1], y);
+            for (int[] dir : DIRS) {
+                int newX = x + dir[0];
+                int newY = y + dir[1];
+                if (newX >= 0 && newY >= 0 && newX < rows && newY < cols && !visited[newX][newY] && land[newX][newY] == 1) {
+                    queue.add(new int[]{newX, newY});
+                    visited[newX][newY] = true;
+                }
+            }
+        }
+        result.add(new int[]{leftMost[0], leftMost[1], rightMost[0], rightMost[1]});
+    }
+}
diff --git a/Medium/Find Center of Star Graph.java b/Medium/Find Center of Star Graph.java
index f3f6de5a..8270ad2d 100644
--- a/Medium/Find Center of Star Graph.java	
+++ b/Medium/Find Center of Star Graph.java	
@@ -1,13 +1,16 @@
-import java.util.Map.Entry;
-
 class Solution {
-  public int findCenter(int[][] edges) {
-    Map<Integer, Set<Integer>> map = new HashMap<>();
-    for (int[] edge : edges) {
-      map.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
-      map.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+    public int findCenter(int[][] edges) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int n = edges.length;
+        for (int[] edge : edges) {
+            map.put(edge[0], map.getOrDefault(edge[0], 0) + 1);
+            map.put(edge[1], map.getOrDefault(edge[1], 0) + 1);
+        }
+        for (Integer key : map.keySet()) {
+            if (map.get(key) == n) {
+                return key;
+            }
+        }
+        return -1;
     }
-    return map.entrySet().stream().filter(entry -> entry.getValue().size() == edges.length).map(
-        Entry::getKey).findFirst().orElse(-1);
-  }
 }
diff --git a/Medium/Find Closest Node to Given Two Nodes.java b/Medium/Find Closest Node to Given Two Nodes.java
new file mode 100644
index 00000000..4c68c333
--- /dev/null
+++ b/Medium/Find Closest Node to Given Two Nodes.java	
@@ -0,0 +1,40 @@
+class Solution {
+    public int closestMeetingNode(int[] edges, int node1, int node2) {
+        int n = edges.length;
+        int[] distance1 = new int[n];
+        int[] distance2 = new int[n];
+        Arrays.fill(distance1, Integer.MAX_VALUE);
+        Arrays.fill(distance2, Integer.MAX_VALUE);
+        bfs(node1, edges, distance1);
+        bfs(node2, edges, distance2);
+        int minDistanceNode = -1;
+        int currMinDistance = Integer.MAX_VALUE;
+        for (int i = 0; i < n; i++) {
+            if (currMinDistance > Math.max(distance1[i], distance2[i])) {
+                minDistanceNode = i;
+                currMinDistance = Math.max(distance1[i], distance2[i]);
+            }
+        }
+        return minDistanceNode;
+    }
+    
+    private void bfs(int startNode, int[] edges, int[] distance) {
+        int n = edges.length;
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(startNode);
+        boolean[] visited = new boolean[n];
+        distance[startNode] = 0;
+        while (!queue.isEmpty()) {
+            int node = queue.remove();
+            if (visited[node]) {
+                continue;
+            }
+            visited[node] = true;
+            int neighbor = edges[node];
+            if (neighbor != -1 && !visited[neighbor]) {
+                distance[neighbor] = 1 + distance[node];
+                queue.add(neighbor);
+            }
+        }
+    }
+}
diff --git a/Medium/Find Consecutive Integers from a Data Stream.java b/Medium/Find Consecutive Integers from a Data Stream.java
new file mode 100644
index 00000000..7f57b28d
--- /dev/null
+++ b/Medium/Find Consecutive Integers from a Data Stream.java	
@@ -0,0 +1,23 @@
+class DataStream {
+    
+    private int k;
+    private int value;
+    private int counter;
+
+    public DataStream(int value, int k) {
+        this.k = k;
+        this.value = value;
+        this.counter = 0;
+    }
+    
+    public boolean consec(int num) {
+        counter = value == num ? (counter + 1) : 0;
+        return counter >= k;
+    }
+}
+
+/**
+ * Your DataStream object will be instantiated and called as such:
+ * DataStream obj = new DataStream(value, k);
+ * boolean param_1 = obj.consec(num);
+ */
diff --git a/Medium/Find Duplicate Subtrees.java b/Medium/Find Duplicate Subtrees.java
index b81a4bec..4800644b 100644
--- a/Medium/Find Duplicate Subtrees.java	
+++ b/Medium/Find Duplicate Subtrees.java	
@@ -4,35 +4,32 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-    Map<String, TreeNode> map;
-    
     public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
-        map = new HashMap<>();
-        List<TreeNode> ans = new ArrayList<>();
-        
-        helper(root);
-        
-        for (TreeNode node : map.values()) {
-            if (node != null) {
-                ans.add(node);
-            }
-        }
-        
-        return ans;
+        List<TreeNode> result = new LinkedList<>();
+        traverse(root, new HashMap<>(), result);
+        return result;
     }
-
-    private String helper(TreeNode root) {
-        if (root == null) {
-            return "#";
+    
+    private String traverse(TreeNode node, Map<String, Integer> frequencyMap, List<TreeNode> result) {
+        if (node == null) {
+            return "";
+        }
+        String key = ("(" + traverse(node.left, frequencyMap, result) + ")" + node.val + 
+                      "(" + traverse(node.right, frequencyMap, result) + ")");
+        frequencyMap.put(key, frequencyMap.getOrDefault(key, 0) + 1);
+        if (frequencyMap.get(key) == 2) {
+            result.add(node);
         }
-        
-        String path = root.val + "|" + helper(root.left) + "|" + helper(root.right);
-        map.put(path, map.containsKey(path) ? root : null);
-        
-        return path;
+        return key;
     }
 }
diff --git a/Medium/Find Eventual Safe States.java b/Medium/Find Eventual Safe States.java
new file mode 100644
index 00000000..2948587d
--- /dev/null
+++ b/Medium/Find Eventual Safe States.java	
@@ -0,0 +1,35 @@
+class Solution {
+    public List<Integer> eventualSafeNodes(int[][] graph) {
+        int n = graph.length;
+        Map<Integer, Set<Integer>> map = new HashMap<>();
+        int[] indegree = new int[n];
+        for (int i = 0; i < n; i++) {
+            for (Integer conn : graph[i]) {
+                indegree[i]++;
+                map.computeIfAbsent(conn, k -> new HashSet<>()).add(i);
+            }
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        for (int i = 0; i < n; i++) {    
+            if (indegree[i] == 0) {
+                queue.add(i);
+            }
+        }
+        List<Integer> result = new ArrayList<>();
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int removed = queue.remove();
+                result.add(removed);
+                for (Integer conn : map.getOrDefault(removed, new HashSet<>())) {
+                    indegree[conn]--;
+                    if (indegree[conn] == 0) {
+                        queue.add(conn);
+                    }
+                }
+            }
+        }
+        Collections.sort(result);
+        return result;
+    }
+}
diff --git a/Medium/Find First and Last Position of Element in Sorted Array.java b/Medium/Find First and Last Position of Element in Sorted Array.java
index a61bd0dc..64e4ecec 100644
--- a/Medium/Find First and Last Position of Element in Sorted Array.java	
+++ b/Medium/Find First and Last Position of Element in Sorted Array.java	
@@ -1,27 +1,35 @@
 class Solution {
-  public int[] searchRange(int[] nums, int target) {
-    return new int[]{binarySearchHelper(nums, target, -1), binarySearchHelper(nums, target, 1)};
-  }
-  
-  private int binarySearchHelper(int[] nums, int target, int direction) {
-    int idx = -1;
-    int start = 0;
-    int end = nums.length - 1;
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (nums[mid] == target) {
-        idx = idx == -1 ? mid : (direction == -1 ? Math.min(mid, idx) : Math.max(mid, idx));
-        if (direction == -1) {
-          end = mid - 1;
-        } else {
-          start = mid + 1;
+
+    private static enum Position {
+        FIRST, LAST;
+    }
+
+    public int[] searchRange(int[] nums, int target) {
+        return new int[]{
+            search(nums, target, Position.FIRST),
+            search(nums, target, Position.LAST)
+        };
+    }
+
+    private static int search(int[] nums, int target, Position position) {
+        int left = 0;
+        int right = nums.length - 1;
+        int idx = -1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[mid] == target) {
+                idx = mid;
+                if (position == Position.FIRST) {
+                    right = mid - 1;
+                } else {
+                    left = mid + 1;
+                }
+            } else if (nums[mid] > target) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
         }
-      } else if (nums[mid] > target) {
-        end = mid - 1;
-      } else {
-        start = mid + 1;
-      }
+        return idx;
     }
-    return idx;
-  }
 }
diff --git a/Medium/Find K Pairs with Smallest Sums.java b/Medium/Find K Pairs with Smallest Sums.java
index 894ca10d..f29f5c15 100644
--- a/Medium/Find K Pairs with Smallest Sums.java	
+++ b/Medium/Find K Pairs with Smallest Sums.java	
@@ -1,54 +1,26 @@
-class Solution {
-    public List<int[]> kSmallestPairs(int[] nums1, int[] nums2, int k) {
-        List<int[]> ans = new ArrayList<>();
-
-        if (nums1.length == 0 || nums2.length == 0 || k == 0) {
-            return ans;
-        }
-
-        PriorityQueue<Element> pq = new PriorityQueue<>(new Comparator<Element>() {
-            @Override
-            public int compare(Element o1, Element o2) {
-                return (o1.x + o1.y) - (o2.x + o2.y);
-            }
-        });
-
-        for (int i=0; i<nums2.length && i < k; i++) {
-            pq.offer(new Element(0, nums2[i], nums1[0]));
-        }
-
+class Solution {
+    public List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
+        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[2] - b[2]);
+        List<List<Integer>> result = new ArrayList<>();
+        Set<Pair<Integer, Integer>> visited = new HashSet<>();
+        pq.add(new int[]{0, 0, nums1[0] + nums2[0]});
+        visited.add(new Pair<Integer, Integer>(0, 0));
         while (k-- > 0 && !pq.isEmpty()) {
-            Element temp = pq.poll();
-            ans.add(new int[]{temp.y, temp.x});
-
-            if (temp.idx >= nums1.length-1) {
-                continue;
+            int[] removed = pq.poll();
+            int i = removed[0];
+            int j = removed[1];
+            result.add(List.of(nums1[i], nums2[j]));
+            Pair<Integer, Integer> nums1Pair = new Pair<Integer, Integer>(i + 1, j);
+            Pair<Integer, Integer> nums2Pair = new Pair<Integer, Integer>(i, j + 1);
+            if (i + 1 < nums1.length && !visited.contains(nums1Pair)) {
+                pq.add(new int[]{i + 1, j, nums1[i + 1] + nums2[j]});
+                visited.add(nums1Pair);
+            }
+            if (j + 1 < nums2.length && !visited.contains(nums2Pair)) {
+                pq.add(new int[]{i, j + 1, nums1[i] + nums2[j + 1]});
+                visited.add(nums2Pair);
             }
-
-            pq.offer(new Element(temp.idx+1, temp.x, nums1[temp.idx+1]));
-        }
-
-        return ans;
-    }
-
-    class Element {
-        int idx;
-        int x;
-        int y;
-
-        public Element(int val, int x, int y) {
-            this.idx = val;
-            this.x = x;
-            this.y = y;
-        }
-
-        @Override
-        public String toString() {
-            return "Element{" +
-                    "idx=" + idx +
-                    ", x=" + x +
-                    ", y=" + y +
-                    '}';
         }
+        return result;
     }
 }
diff --git a/Medium/Find Kth Bit in Nth Binary String.java b/Medium/Find Kth Bit in Nth Binary String.java
new file mode 100644
index 00000000..e98b29c7
--- /dev/null
+++ b/Medium/Find Kth Bit in Nth Binary String.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public char findKthBit(int n, int k) {
+        return nthString(n).charAt(k - 1);
+    }
+
+    private String nthString(int n) {
+        if (n == 1) {
+            return "0";
+        }
+        String prevString = nthString(n - 1);
+        return prevString + "1" + reverseAndInvert(prevString);
+    }
+
+    private String reverseAndInvert(String s) {
+        char[] chars = s.toCharArray();
+        for (int i = 0; i < s.length(); i++) {
+            chars[i] = chars[i] == '1' ? '0' : '1';
+        }
+        StringBuilder sb = new StringBuilder(String.valueOf(chars));
+        return sb.reverse().toString();
+    }
+}
diff --git a/Medium/Find Largest Value in Each Tree Row.java b/Medium/Find Largest Value in Each Tree Row.java
index 49aeca0e..2f0c7883 100644
--- a/Medium/Find Largest Value in Each Tree Row.java	
+++ b/Medium/Find Largest Value in Each Tree Row.java	
@@ -4,32 +4,38 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  public List<Integer> largestValues(TreeNode root) {
-    List<Integer> list = new ArrayList<>();
-    if (root == null) {
-      return list;
-    }
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int maxVal = Integer.MIN_VALUE;
-      int size = queue.size();
-      while (size-- > 0) {
-        TreeNode removed = queue.remove();
-        maxVal = Math.max(maxVal, removed.val);
-        if (removed.left != null) {
-          queue.add(removed.left);
+    public List<Integer> largestValues(TreeNode root) {
+        if (root == null) {
+            return new ArrayList<>();
         }
-        if (removed.right != null) {
-          queue.add(removed.right);
+        List<Integer> result = new ArrayList<>();
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            int maxValue = queue.peek().val;
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                maxValue = Math.max(maxValue, removed.val);
+                if (removed.left != null) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null) {
+                    queue.add(removed.right);
+                }
+            }
+            result.add(maxValue);
         }
-      }
-      list.add(maxVal);
+        return result;
     }
-    return list;
-  }
 }
diff --git a/Medium/Find Minimum Time to Reach Last Room I.java b/Medium/Find Minimum Time to Reach Last Room I.java
new file mode 100644
index 00000000..0247baa4
--- /dev/null
+++ b/Medium/Find Minimum Time to Reach Last Room I.java	
@@ -0,0 +1,36 @@
+class Solution {
+
+    private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+
+    public int minTimeToReach(int[][] moveTime) {
+        int n = moveTime.length;
+        int m = moveTime[0].length;
+        boolean[][] visited = new boolean[n][m];
+        Integer[][] minTime = new Integer[n][m];
+        minTime[0][0] = 0;
+        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[2] - b[2]);
+        pq.add(new int[]{0, 0, 0});
+        while (!pq.isEmpty()) {
+            int[] removed = pq.remove();
+            int x = removed[0];
+            int y = removed[1];
+            if (visited[x][y]) {
+                continue;
+            }
+            visited[x][y] = true;
+            for (int[] dir : DIRS) {
+                int newX = x + dir[0];
+                int newY = y + dir[1];
+                if (newX >= 0 && newY >= 0 && newX < n && newY < m) {
+                    int distance = Math.max(minTime[x][y], moveTime[newX][newY]) + 1;
+                    int currMinTime = minTime[newX][newY] == null ? Integer.MAX_VALUE : minTime[newX][newY];
+                    if (currMinTime > distance) {
+                        minTime[newX][newY] = distance;
+                        pq.add(new int[]{newX, newY, distance});
+                    }
+                }
+            }
+        }
+        return minTime[n - 1][m - 1];
+    }
+}
diff --git a/Medium/Find Minimum in Rotated Sorted Array.java b/Medium/Find Minimum in Rotated Sorted Array.java
index 8c18f17b..79ae6e51 100644
--- a/Medium/Find Minimum in Rotated Sorted Array.java	
+++ b/Medium/Find Minimum in Rotated Sorted Array.java	
@@ -1,30 +1,17 @@
 class Solution {
-  public int findMin(int[] nums) {
-    if (nums.length == 1) {
-      return nums[0];
+    public int findMin(int[] nums) {
+        int start = 0;
+        int end = nums.length - 1;
+        int minValue = 5001;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            minValue = Math.min(minValue, nums[mid]);
+            if (nums[end] > nums[mid]) {
+                end = mid - 1;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return minValue;
     }
-    int left = 0;
-    int right = nums.length - 1;
-    // Sorted but not rotated
-    if (nums[right] > nums[left]) {
-      return nums[left];
-    }
-    while (left <= right) {
-      int mid = (left + right) / 2;
-      // mid + 1 is point of rotation
-      if (nums[mid] > nums[mid + 1]) {
-        return nums[mid + 1];
-      }
-      // mid is point of rotation
-      if (nums[mid - 1] > nums[mid]) {
-        return nums[mid];
-      }
-      if (nums[mid] > nums[0]) {
-        left = mid + 1;
-      } else {
-        right = mid - 1;
-      }
-    }
-    return Integer.MAX_VALUE;
-  }
 }
diff --git a/Medium/Find Missing Observations.java b/Medium/Find Missing Observations.java
index 7b738edc..fe724572 100644
--- a/Medium/Find Missing Observations.java	
+++ b/Medium/Find Missing Observations.java	
@@ -1,17 +1,21 @@
 class Solution {
-  public int[] missingRolls(int[] rolls, int mean, int n) {
-    int currSum = Arrays.stream(rolls).sum();
-    int missingSum = mean * (n + rolls.length) - currSum;
-    if (missingSum > n * 6 || missingSum < n) {
-      return new int[]{};
+    public int[] missingRolls(int[] rolls, int mean, int n) {
+        int m = rolls.length;
+        int sum = 0;
+        for (int roll : rolls) {
+            sum += roll;
+        }
+        int expectedSum = mean * (n + m);
+        int remaining = expectedSum - sum;
+        if (remaining > 6 * n || remaining < n) {
+            return new int[]{};
+        }
+        int[] result = new int[n];
+        Arrays.fill(result, remaining / n);
+        remaining = remaining % n;
+        for (int i = 0; i < remaining; i++) {
+            result[i]++;
+        }        
+        return result;
     }
-    int[] ans = new int[n];
-    int part = missingSum / n;
-    int remainder = missingSum % n;
-    Arrays.fill(ans, part);
-    for (int i = 0; i < remainder; i++) {
-      ans[i]++;
-    }
-    return ans;
-  }
 }
diff --git a/Medium/Find Players With Zero or One Losses.java b/Medium/Find Players With Zero or One Losses.java
index f3f14ff5..1692f1e5 100644
--- a/Medium/Find Players With Zero or One Losses.java	
+++ b/Medium/Find Players With Zero or One Losses.java	
@@ -1,24 +1,22 @@
 class Solution {
-  public List<List<Integer>> findWinners(int[][] matches) {
-    Map<Integer, Integer> lossCount = new HashMap<>();
-    Set<Integer> players = new HashSet<>();
-    for (int[] match : matches) {
-      lossCount.put(match[1], lossCount.getOrDefault(match[1], 0) + 1);
-      players.add(match[0]);
-      players.add(match[1]);
+    public List<List<Integer>> findWinners(int[][] matches) {
+        Map<Integer, Integer> playerToLossCount = new HashMap<>();
+        for (int[] match : matches) {
+            int winner = match[0];
+            int loser = match[1];
+            playerToLossCount.putIfAbsent(winner, 0);
+            playerToLossCount.put(loser, playerToLossCount.getOrDefault(loser, 0) + 1);
+        }
+        List<List<Integer>> result = new ArrayList<>(
+            Arrays.asList(new ArrayList<>(), new ArrayList<>())
+        );
+        for (Map.Entry<Integer, Integer> entry : playerToLossCount.entrySet()) {
+            if (entry.getValue() <= 1) {
+                result.get(entry.getValue()).add(entry.getKey());
+            }
+        }
+        Collections.sort(result.get(0));
+        Collections.sort(result.get(1));
+        return result;
     }
-    List<Integer> noLoss = new ArrayList<>();
-    List<Integer> exactlyOneLoss = new ArrayList<>();
-    for (Integer player : players) {
-      if (!lossCount.containsKey(player)) {
-        noLoss.add(player);
-      }
-      if (lossCount.getOrDefault(player, 0) == 1) {
-        exactlyOneLoss.add(player);
-      }
-    }
-    Collections.sort(noLoss);
-    Collections.sort(exactlyOneLoss);
-    return Arrays.asList(noLoss, exactlyOneLoss);
-  }
 }
diff --git a/Medium/Find Polygon With the Largest Perimeter.java b/Medium/Find Polygon With the Largest Perimeter.java
new file mode 100644
index 00000000..8b368cb2
--- /dev/null
+++ b/Medium/Find Polygon With the Largest Perimeter.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public long largestPerimeter(int[] nums) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        long prefixSum = 0;
+        long result = -1;
+        for (int i = 0; i < n; i++) {
+            if (i >= 2 && nums[i] < prefixSum) {
+                result = nums[i] + prefixSum;
+            }
+            prefixSum += nums[i];
+        }
+        return result;
+    }
+}
diff --git a/Medium/Find The First Player to win K Games in a Row.java b/Medium/Find The First Player to win K Games in a Row.java
new file mode 100644
index 00000000..fe26c684
--- /dev/null
+++ b/Medium/Find The First Player to win K Games in a Row.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int findWinningPlayer(int[] skills, int k) {
+        Map<Integer, Integer> indexMap = new HashMap<>();
+        for (int i = 0; i < skills.length; i++) {
+            indexMap.put(skills[i], i);
+        }
+        Map<Integer, Integer> winCountMap = new HashMap<>();
+        Deque<Integer> deque = new ArrayDeque<>();
+        for (int num : skills) {
+            deque.addFirst(num);
+        }
+        while (deque.size() > 1) {
+            int first = deque.pollLast();
+            int second = deque.pollLast();
+            int winner = Math.max(first, second);
+            winCountMap.put(winner, winCountMap.getOrDefault(winner, 0) + 1);
+            deque.addLast(winner);
+            if (winCountMap.get(winner) == k) {
+                return indexMap.get(winner);
+            }
+        }
+        return indexMap.get(deque.poll());
+    }
+}
diff --git a/Medium/Find The Original Array of Prefix Xor.java b/Medium/Find The Original Array of Prefix Xor.java
index 97baa6e7..46732ae1 100644
--- a/Medium/Find The Original Array of Prefix Xor.java	
+++ b/Medium/Find The Original Array of Prefix Xor.java	
@@ -1,11 +1,11 @@
 class Solution {
-  public int[] findArray(int[] pref) {
-    int n = pref.length;
-    int[] result = new int[n];
-    result[0] = pref[0];
-    for (int i = 1; i < n; i++) {
-      result[i] = pref[i] ^ pref[i - 1];
+    public int[] findArray(int[] pref) {
+        int n = pref.length;
+        int[] result = new int[n];
+        result[0] = pref[0];
+        for (int i = 1; i < n; i++) {
+            result[i] = pref[i - 1] ^ pref[i];
+        }
+        return result;
     }
-    return result;
-  }
 }
diff --git a/Medium/Find Unique Binary String.java b/Medium/Find Unique Binary String.java
new file mode 100644
index 00000000..80cdfa9e
--- /dev/null
+++ b/Medium/Find Unique Binary String.java	
@@ -0,0 +1,25 @@
+class Solution {
+
+    private static final char[] BINARY_CHARS = {'1', '0'};
+
+    public String findDifferentBinaryString(String[] nums) {
+        int n = nums.length;
+        Set<String> binaryStrings = new HashSet<>();
+        backtrack(new StringBuilder(), n, binaryStrings);
+        Set<String> binaryStringsPresent = Arrays.stream(nums).collect(Collectors.toSet());
+        binaryStrings.removeAll(binaryStringsPresent);
+        return binaryStrings.isEmpty() ? "" : binaryStrings.iterator().next();
+    }
+
+    private void backtrack(StringBuilder sb, int n, Set<String> binaryStrings) {
+        if (sb.length() == n) {
+            binaryStrings.add(sb.toString());
+            return;
+        }
+        for (char c : BINARY_CHARS) {
+            sb.append(c);
+            backtrack(sb, n, binaryStrings);
+            sb.deleteCharAt(sb.length() - 1);
+        }
+    }
+}
diff --git a/Medium/Find if Array Can Be Sorted.java b/Medium/Find if Array Can Be Sorted.java
new file mode 100644
index 00000000..8b08e457
--- /dev/null
+++ b/Medium/Find if Array Can Be Sorted.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public boolean canSortArray(int[] nums) {
+        int lastGroupHighest = 0;
+        int highest = nums[0];
+        boolean bitChange = false;
+        for (int i = 1; i < nums.length; i++) {
+            bitChange = Integer.bitCount(highest) != Integer.bitCount(nums[i]);
+            if (bitChange) {
+                lastGroupHighest = highest;
+            }
+            highest = Math.max(nums[i], highest);
+            if (nums[i] < lastGroupHighest) {
+                return false;
+            }
+        } 
+        return true;
+    }
+}
diff --git a/Medium/Find the Duplicate Number.java b/Medium/Find the Duplicate Number.java
index c4f5a541..bfd8908b 100644
--- a/Medium/Find the Duplicate Number.java	
+++ b/Medium/Find the Duplicate Number.java	
@@ -1,16 +1,20 @@
 class Solution {
-  public int findDuplicate(int[] nums) {
-    int slow = nums[0];
-    int fast = nums[0];
-    do {
-      slow = nums[slow];
-      fast = nums[nums[fast]];
-    } while (slow != fast);
-    slow = nums[0];
-    while (slow != fast) {
-      slow = nums[slow];
-      fast = nums[fast];
+    public int findDuplicate(int[] nums) {
+        int slow = nums[0];
+        int fast = nums[0];
+        while (true) {
+            slow = nums[slow];
+            fast = nums[nums[fast]];
+            if (slow == fast) {
+                break;
+            }
+        }
+        int idxOne = nums[0];
+        int idxTwo = slow;
+        while (idxOne != idxTwo) {
+            idxOne = nums[idxOne];
+            idxTwo = nums[idxTwo];
+        }
+        return idxOne;
     }
-    return fast;
-  }
 }
diff --git a/Medium/Find the Index of the First Occurrence in a String.java b/Medium/Find the Index of the First Occurrence in a String.java
new file mode 100644
index 00000000..4156d0ba
--- /dev/null
+++ b/Medium/Find the Index of the First Occurrence in a String.java	
@@ -0,0 +1,10 @@
+class Solution {
+    public int strStr(String haystack, String needle) {
+        for (int i = 0; i <= haystack.length() - needle.length(); i++) {
+            if (haystack.substring(i, i + needle.length()).equals(needle)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
diff --git a/Medium/Find the Length of the Longest Common Prefix.java b/Medium/Find the Length of the Longest Common Prefix.java
new file mode 100644
index 00000000..a626cd3a
--- /dev/null
+++ b/Medium/Find the Length of the Longest Common Prefix.java	
@@ -0,0 +1,52 @@
+class Solution {
+    public int longestCommonPrefix(int[] arr1, int[] arr2) {
+        TrieNodeManager nodeManager = new TrieNodeManager();
+        for (int num : arr1) {
+            nodeManager.index(String.valueOf(num));
+        }
+        int maxLength = 0;
+        for (int num : arr2) {
+            int length = nodeManager.find(String.valueOf(num));
+            maxLength = Math.max(maxLength, length);
+        }
+        return maxLength;
+    }
+    
+    private static class TrieNodeManager {
+        
+        private Node root;
+        
+        public TrieNodeManager() {
+            this.root = new Node();
+        }
+        
+        public void index(String s) {
+            Node curr = root;
+            for (char c : s.toCharArray()) {
+                if (!curr.children.containsKey(c)) {
+                    curr.children.put(c, new Node());
+                }
+                curr = curr.children.get(c);
+            }
+        }
+        
+        public int find(String s) {
+            Node curr = root;
+            for (int i = 0; i < s.length(); i++) {
+                if (!curr.children.containsKey(s.charAt(i))) {
+                    return i;
+                }
+                curr = curr.children.get(s.charAt(i));
+            }
+            return s.length();
+        }
+        
+        class Node {
+            Map<Character, Node> children;
+            
+            public Node() {
+                this.children = new HashMap<>();
+            }
+        }
+    }
+}
diff --git a/Medium/Find the Lexicographically Largest String From the Box I.java b/Medium/Find the Lexicographically Largest String From the Box I.java
new file mode 100644
index 00000000..1133cb93
--- /dev/null
+++ b/Medium/Find the Lexicographically Largest String From the Box I.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public String answerString(String word, int numFriends) {
+        if (numFriends == 1) {
+            return word;
+        }
+        int n = word.length();
+        String result = "";
+        for (int i = 0; i < n; i++) {
+            String curr = word.substring(i, Math.min(i + n - numFriends + 1, n));
+            if (result.compareTo(curr) <= 0) {
+                result = curr;
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Find the Longest Semi-Repetitive Substring.java b/Medium/Find the Longest Semi-Repetitive Substring.java
new file mode 100644
index 00000000..f6743a56
--- /dev/null
+++ b/Medium/Find the Longest Semi-Repetitive Substring.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int longestSemiRepetitiveSubstring(String s) {
+        int start = 0;
+        int end = 0;
+        int maxLength = 1;
+        int consecutiveCount = 0;
+        while (end < s.length() - 1) {
+            if (s.charAt(end) == s.charAt(end + 1)) {
+                consecutiveCount++;
+            }
+            end++;
+            while (start < end && consecutiveCount > 1) {
+                if (s.charAt(start) == s.charAt(start + 1)) {
+                    consecutiveCount--;
+                }
+                start++;
+            }
+            maxLength = Math.max(maxLength, end - start + 1);
+        }
+        return maxLength;
+    }
+}
diff --git a/Medium/Find the Longest Substring Containing Vowels in Even Counts.java b/Medium/Find the Longest Substring Containing Vowels in Even Counts.java
new file mode 100644
index 00000000..66e33ef9
--- /dev/null
+++ b/Medium/Find the Longest Substring Containing Vowels in Even Counts.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int findTheLongestSubstring(String s) {
+        int prefixXor = 0;
+        char[] frequency = new char[26];
+        frequency['a' - 'a'] = 1;
+        frequency['e' - 'a'] = 2;
+        frequency['i' - 'a'] = 4;
+        frequency['o' - 'a'] = 8;
+        frequency['u' - 'a'] = 16;
+        int[] indexMap = new int[32];
+        Arrays.fill(indexMap, -1);
+        int result = 0;
+        for (int i = 0; i < s.length(); i++) {
+            prefixXor ^= frequency[s.charAt(i) - 'a'];
+            if (indexMap[prefixXor] == -1 && prefixXor != 0) {
+                indexMap[prefixXor] = i;
+            }
+            result = Math.max(result, i - indexMap[prefixXor]);
+        }
+        return result;
+    }
+}
diff --git a/Medium/Find the Maximum Divisibility Score.java b/Medium/Find the Maximum Divisibility Score.java
new file mode 100644
index 00000000..2e33ee9a
--- /dev/null
+++ b/Medium/Find the Maximum Divisibility Score.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maxDivScore(int[] nums, int[] divisors) {
+        int maxScore = -1;
+        int maxScoreCandidate = -1;
+        for (int divisor : divisors) {
+            int currScore = 0;
+            for (int num : nums) {
+                currScore += num % divisor == 0 ? 1 : 0;
+            }
+            if (currScore > maxScore) {
+                maxScore = currScore;
+                maxScoreCandidate = divisor;
+            } else if (currScore == maxScore) {
+                maxScoreCandidate = Math.min(maxScoreCandidate, divisor);
+            }
+        }
+        return maxScoreCandidate;
+    }
+}
diff --git a/Medium/Find the Maximum Number of Elements in Subset.java b/Medium/Find the Maximum Number of Elements in Subset.java
new file mode 100644
index 00000000..4c419cbc
--- /dev/null
+++ b/Medium/Find the Maximum Number of Elements in Subset.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maximumLength(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        int result = map.containsKey(1) ? (map.get(1) % 2 == 0 ? map.get(1) - 1 : map.get(1)) : 1;
+        for (int num : nums) {
+            int count = 0;
+            while (map.containsKey(num) && map.get(num) >= 2 && num != 1) {
+                count += 2;
+                num *= num;
+            }
+            count += map.containsKey(num) ? 1 : -1;
+            result = Math.max(result, count);
+        }
+        return result;
+    }
+}
diff --git a/Medium/Find the Minimum Area to Cover All Ones I.java b/Medium/Find the Minimum Area to Cover All Ones I.java
new file mode 100644
index 00000000..538bf894
--- /dev/null
+++ b/Medium/Find the Minimum Area to Cover All Ones I.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int minimumArea(int[][] grid) {
+        int minRow = Integer.MAX_VALUE;
+        int minCol = Integer.MAX_VALUE;
+        int maxRow = Integer.MIN_VALUE;
+        int maxCol = Integer.MIN_VALUE;
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 1) {
+                    minRow = Math.min(minRow, i);
+                    minCol = Math.min(minCol, j);
+                    maxRow = Math.max(maxRow, i);
+                    maxCol = Math.max(maxCol, j);
+                }
+            }
+        }
+        if (minRow == Integer.MAX_VALUE) {
+            return 0;
+        }
+        int length = maxRow - minRow + 1;
+        int breadth = maxCol - minCol + 1;
+        return length * breadth;
+    }
+}
diff --git a/Medium/Find the N-th Value After K Seconds.java b/Medium/Find the N-th Value After K Seconds.java
new file mode 100644
index 00000000..e457d0eb
--- /dev/null
+++ b/Medium/Find the N-th Value After K Seconds.java	
@@ -0,0 +1,15 @@
+class Solution {
+
+    private final int MOD = 1000_000_007;
+
+    public int valueAfterKSeconds(int n, int k) {
+        int[] arr = new int[n];
+        Arrays.fill(arr, 1);
+        while (k-- > 0) {
+            for (int i = 1; i < n; i++) {
+                arr[i] = (arr[i] + arr[i - 1]) % MOD;
+            }
+        }
+        return arr[n - 1];
+    }
+}
diff --git a/Medium/Find the Number of Distinct Colors Among the Balls.java b/Medium/Find the Number of Distinct Colors Among the Balls.java
new file mode 100644
index 00000000..428e5406
--- /dev/null
+++ b/Medium/Find the Number of Distinct Colors Among the Balls.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public int[] queryResults(int limit, int[][] queries) {
+        Map<Integer, Integer> ballToColor = new HashMap<>();
+        Map<Integer, Integer> colorToBallCount = new HashMap<>();
+        int n = queries.length;
+        int[] result = new int[n];
+        for (int i = 0; i < queries.length; i++) {
+            int ball = queries[i][0];
+            int color = queries[i][1];
+            if (ballToColor.containsKey(ball)) {
+                int prevColor = ballToColor.get(ball);
+                colorToBallCount.put(prevColor, colorToBallCount.get(prevColor) - 1);
+                if (colorToBallCount.get(prevColor) == 0) {
+                    colorToBallCount.remove(prevColor);
+                }
+            }
+            ballToColor.put(ball, color);
+            colorToBallCount.put(color, colorToBallCount.getOrDefault(color, 0) + 1);
+            result[i] = colorToBallCount.size();
+        }
+        return result;
+    }
+}
diff --git a/Medium/Find the Prefix Common Array of Two Arrays.java b/Medium/Find the Prefix Common Array of Two Arrays.java
new file mode 100644
index 00000000..e6312a17
--- /dev/null
+++ b/Medium/Find the Prefix Common Array of Two Arrays.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int[] findThePrefixCommonArray(int[] A, int[] B) {
+        int count = 0;
+        int n = A.length;
+        int[] result = new int[n];
+        int[] frequency = new int[n + 1];
+        for (int i = 0; i < n; i++) {
+            frequency[A[i]]++;
+            if (frequency[A[i]] == 2) {
+                count++;
+            }
+            frequency[B[i]]++;
+            if (frequency[B[i]] == 2) {
+                count++;
+            }
+            result[i] = count;
+        }
+        return result;
+    }
+}
diff --git a/Medium/Find the Score of All Prefixes of an Array.java b/Medium/Find the Score of All Prefixes of an Array.java
new file mode 100644
index 00000000..ff88ca98
--- /dev/null
+++ b/Medium/Find the Score of All Prefixes of an Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public long[] findPrefixScore(int[] nums) {
+        int[] conver = new int[nums.length];
+        int max = nums[0];
+        for (int i = 0; i < nums.length; i++) {
+            max = Math.max(max, nums[i]);
+            conver[i] = nums[i] + max;
+        }
+        long[] result = new long[nums.length];
+        long score = 0;
+        for (int i = 0; i < nums.length; i++) {
+            score += conver[i];
+            result[i] = score;
+        }
+        return result;
+    }
+}
diff --git a/Medium/Find the Student that Will Replace the Chalk.java b/Medium/Find the Student that Will Replace the Chalk.java
index 8ee73065..bdf79d9a 100644
--- a/Medium/Find the Student that Will Replace the Chalk.java	
+++ b/Medium/Find the Student that Will Replace the Chalk.java	
@@ -1,17 +1,23 @@
 class Solution {
-  public int chalkReplacer(int[] chalk, int k) {
-    int initialResult = chalkReplacerHelper(chalk, k);
-    return initialResult != -1 ? initialResult
-        : chalkReplacerHelper(chalk, k % Arrays.stream(chalk).sum());
-  }
-
-  private int chalkReplacerHelper(int[] chalk, int k) {
-    for (int i = 0; i < chalk.length; i++) {
-      if (k - chalk[i] < 0) {
-        return i;
-      }
-      k -= chalk[i];
+    public int chalkReplacer(int[] chalk, int k) {
+        int n = chalk.length;
+        long[] prefixSum = new long[n];
+        prefixSum[0] = chalk[0];
+        for (int i = 1; i < n; i++) {
+            prefixSum[i] = chalk[i] + prefixSum[i - 1]; 
+        }
+        long total = prefixSum[n - 1];
+        long remaining = k % total;
+        int left = 0;
+        int right = n - 1;
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (prefixSum[mid] <= remaining) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        return right;
     }
-    return -1;
-  }
 }
diff --git a/Medium/Find the Substring With Maximum Cost.java b/Medium/Find the Substring With Maximum Cost.java
new file mode 100644
index 00000000..24e00548
--- /dev/null
+++ b/Medium/Find the Substring With Maximum Cost.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int maximumCostSubstring(String s, String chars, int[] vals) {
+        Map<Character, Integer> valueMap = new HashMap<>();
+        for (int i = 0; i < chars.length(); i++) {
+            valueMap.put(chars.charAt(i), vals[i]);
+        }
+        int maxCost = 0;
+        int currCost = 0;
+        for (char c : s.toCharArray()) {
+            int currCharCost = valueMap.containsKey(c) ? valueMap.get(c) : (c - 'a' + 1);
+            currCost = Math.max(currCharCost, currCost + currCharCost);
+            maxCost = Math.max(currCost, maxCost);
+        }
+        return maxCost;
+    }
+}
diff --git a/Medium/Find the Winner of an Array Game.java b/Medium/Find the Winner of an Array Game.java
index 0c7130f4..98932a1e 100644
--- a/Medium/Find the Winner of an Array Game.java	
+++ b/Medium/Find the Winner of an Array Game.java	
@@ -1,17 +1,16 @@
 class Solution {
-  public int getWinner(int[] arr, int k) {
-    int currentElement = arr[0];
-    int n = arr.length;
-    int currentWinCount = 0;
-    for (int i = 1; i < n; i++) {
-      if (arr[i] > currentElement) {
-        currentElement = arr[i];
-        currentWinCount = 0;
-      }
-      if (++currentWinCount == k) {
-        break;
-      }
+    public int getWinner(int[] arr, int k) {
+        int curr = arr[0];
+        int streak = 0;
+        for (int i = 1; i < arr.length; i++) {
+            if (curr < arr[i]) {
+                curr = arr[i];
+                streak = 0;
+            } 
+            if (++streak == k) {
+                break;
+            }
+        }
+        return curr;
     }
-    return currentElement;
-  }
 }
diff --git a/Medium/Find the Winner of the Circular Game.java b/Medium/Find the Winner of the Circular Game.java
new file mode 100644
index 00000000..816b3aa4
--- /dev/null
+++ b/Medium/Find the Winner of the Circular Game.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int findTheWinner(int n, int k) {
+        Queue<Integer> circle = new LinkedList<>();
+        for (int i = 1; i <= n; i++) {
+            circle.add(i);
+        }
+        while (circle.size() > 1) {
+            for (int i = 0; i < k - 1; i++) {
+                circle.add(circle.remove());
+            }
+            circle.remove();
+        }
+        return circle.peek();
+    }
+}
diff --git a/Medium/First Unique Number.java b/Medium/First Unique Number.java
index d5406335..6affb411 100644
--- a/Medium/First Unique Number.java	
+++ b/Medium/First Unique Number.java	
@@ -1,68 +1,27 @@
 class FirstUnique {
-  
-  private Node head;
-  private Node tail;
-  private Map<Integer, Node> map;
-  
-  public FirstUnique(int[] nums) {
-    this.head = new Node(-1);
-    this.tail = new Node(-1);
-    this.head.next = this.tail;
-    this.tail.prev = this.head;
-    this.map = new HashMap<>();
-    for (int num : nums) {
-      if (map.containsKey(num)) {
-        deleteNode(map.get(num));
-      } else {
-        Node node = new Node(num);
-        map.put(num, node);
-        addToTail(node);
-      }
-    }
-  }
 
-  public int showFirstUnique() {
-    return this.head.next.val;
-  }
+    private Map<Integer, Integer> map;
+    private Queue<Integer> queue;
 
-  public void add(int value) {
-    if (map.containsKey(value)) {
-      deleteNode(map.get(value));
-      return;
+    public FirstUnique(int[] nums) {
+        map = new HashMap<>();
+        queue = new LinkedList<>();
+        for (int num : nums) {
+            add(num);
+        }
     }
-    Node node = new Node(value);
-    map.put(value, node);
-    addToTail(node);
-  }
-  
-  private void addToTail(Node node) {
-    Node prevToTail = this.tail.prev;
-    prevToTail.next = node;
-    node.next = this.tail;
-    node.prev = prevToTail;
-    this.tail.prev = node;
-  }
-  
-  private void deleteNode(Node node) {
-    if (node == null) {
-      return;
+    
+    public int showFirstUnique() {
+        while (!queue.isEmpty() && map.get(queue.peek()) > 1) {
+            queue.remove();
+        }
+        return queue.isEmpty() ? -1 : queue.peek();
     }
-    map.put(node.val, null);
-    Node prevToNode = node.prev;
-    Node nextToNode = node.next;
-    prevToNode.next = nextToNode;
-    nextToNode.prev = prevToNode;
-  }
-  
-  private static class Node {
-    int val;
-    Node next;
-    Node prev;
     
-    public Node(int val) {
-      this.val = val;
+    public void add(int value) {
+        queue.add(value);
+        map.put(value, map.getOrDefault(value, 0) + 1);
     }
-  }
 }
 
 /**
diff --git a/Medium/Flatten Nested List Iterator.java b/Medium/Flatten Nested List Iterator.java
index 5081ee2e..087bc1ef 100644
--- a/Medium/Flatten Nested List Iterator.java	
+++ b/Medium/Flatten Nested List Iterator.java	
@@ -17,31 +17,34 @@
  */
 public class NestedIterator implements Iterator<Integer> {
 
-  private Stack<NestedInteger> stack;
-  
-  public NestedIterator(List<NestedInteger> nestedList) {
-    this.stack = new Stack<>();
-    for (int i = nestedList.size() - 1; i >= 0; i--) {
-      this.stack.push(nestedList.get(i));
+    private Stack<NestedInteger> stack;
+
+    public NestedIterator(List<NestedInteger> nestedList) {
+        this.stack = new Stack<>();
+        for (int i = nestedList.size() - 1; i >= 0; i--) {
+            this.stack.push(nestedList.get(i));
+        }
     }
-  }
 
-  @Override
-  public Integer next() {
-    int value = this.stack.pop().getInteger();
-    return value;
-  }
+    @Override
+    public Integer next() {
+        return stack.pop().getInteger();
+    }
 
-  @Override
-  public boolean hasNext() {
-    while (!this.stack.isEmpty() && !this.stack.peek().isInteger()) {
-      List<NestedInteger> ni = this.stack.pop().getList();
-      for (int i = ni.size() - 1; i >= 0; i--) {
-        this.stack.push(ni.get(i));
-      }
+    @Override
+    public boolean hasNext() {
+        while (!stack.isEmpty() && !stack.peek().isInteger()) {
+            NestedInteger popped = stack.pop();
+            if (popped == null) {
+                continue;
+            }
+            List<NestedInteger> list = popped.getList();
+            for (int i = list.size() - 1; i >= 0; i--) {
+                stack.push(list.get(i));
+            }
+        }
+        return !stack.isEmpty();
     }
-    return !this.stack.isEmpty();
-  }
 }
 
 /**
diff --git a/Medium/Flip Equivalent Binary Trees.java b/Medium/Flip Equivalent Binary Trees.java
index 7829ff4d..8590505e 100644
--- a/Medium/Flip Equivalent Binary Trees.java	
+++ b/Medium/Flip Equivalent Binary Trees.java	
@@ -1,31 +1,31 @@
-i/**
+/**
  * Definition for a binary tree node.
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  public boolean flipEquiv(TreeNode root1, TreeNode root2) {
-    if (root1 == null && root2 == null) {
-      return true;
+    public boolean flipEquiv(TreeNode root1, TreeNode root2) {
+        if (root1 == null && root2 == null) {
+            return true;
+        }
+        if (root1 == null || root2 == null) {
+            return false;
+        }
+        if (root1.val != root2.val) {
+            return false;
+        }
+        boolean noSwap = flipEquiv(root1.left, root2.left) && flipEquiv(root1.right, root2.right);
+        boolean swap = flipEquiv(root1.left, root2.right) && flipEquiv(root1.right, root2.left);
+        return noSwap || swap;
     }
-    if (root1 == null || root2 == null) {
-      return false;
-    }
-    if (root1.val != root2.val) {
-      return false;
-    }
-    return (
-        (
-          flipEquiv(root1.left, root2.left) && flipEquiv(root1.right, root2.right)
-        ) || 
-        (
-          flipEquiv(root1.left, root2.right) && 
-          flipEquiv(root1.right, root2.left)
-        )
-      );
-  }
 }
diff --git a/Medium/Fraction Addition and Subtraction.java b/Medium/Fraction Addition and Subtraction.java
new file mode 100644
index 00000000..3d26da63
--- /dev/null
+++ b/Medium/Fraction Addition and Subtraction.java	
@@ -0,0 +1,42 @@
+class Solution {
+    public String fractionAddition(String expression) {
+        int numerator = 0;
+        int denominator = 1;
+        int idx = 0;
+        int n = expression.length();
+        while (idx < n) {
+            int currNumerator = 0;
+            int currDenominator = 0;
+            boolean negative = false;
+            if (expression.charAt(idx) == '-' || expression.charAt(idx) == '+') {
+                negative = expression.charAt(idx) == '-' ? true : false;
+                idx++;
+            }
+            while (Character.isDigit(expression.charAt(idx))) {
+                currNumerator = currNumerator * 10 + Character.getNumericValue(expression.charAt(idx));
+                idx++;
+            }
+            if (negative) {
+                currNumerator *= -1;
+            }
+            idx++;
+            while (idx < n && Character.isDigit(expression.charAt(idx))) {
+                currDenominator = currDenominator * 10 + Character.getNumericValue(expression.charAt(idx));
+                idx++;
+            }
+            numerator = numerator * currDenominator + currNumerator * denominator;
+            denominator = denominator * currDenominator;
+        }
+        int gcd = Math.abs(gcd(numerator, denominator));
+        numerator /= gcd;
+        denominator /= gcd;
+        return numerator + "/" + denominator;
+    }
+
+    private int gcd(int a, int b) {
+        if (a == 0) {
+            return b;
+        }
+        return gcd(b % a, a);
+    }
+}
diff --git a/Medium/Frequency Tracker.java b/Medium/Frequency Tracker.java
new file mode 100644
index 00000000..e5e83453
--- /dev/null
+++ b/Medium/Frequency Tracker.java	
@@ -0,0 +1,48 @@
+class FrequencyTracker {
+
+    private final Map<Integer, Integer> numToFrequencyMapping;
+    private final Map<Integer, Set<Integer>> frequencyToNumMapping;
+
+    public FrequencyTracker() {
+        this.numToFrequencyMapping = new HashMap<>();
+        this.frequencyToNumMapping = new HashMap<>();
+    }
+
+    public void add(int number) {
+        int prevFrequency = this.numToFrequencyMapping.getOrDefault(number, 0);
+        int newFrequency = prevFrequency + 1;
+        this.numToFrequencyMapping.put(number, newFrequency);
+        updateFreqToNumMapping(number, prevFrequency, newFrequency);
+    }
+
+    public void deleteOne(int number) {
+        int prevFrequency = this.numToFrequencyMapping.getOrDefault(number, 0);
+        if (prevFrequency == 0) {
+            return;
+        }
+        int newFrequency = prevFrequency - 1;
+        this.numToFrequencyMapping.put(number, newFrequency);
+        updateFreqToNumMapping(number, prevFrequency, newFrequency);
+    }
+
+    public boolean hasFrequency(int frequency) {
+        return this.frequencyToNumMapping.getOrDefault(frequency, new HashSet<>()).size() > 0;
+    }
+
+    private void updateFreqToNumMapping(int number, int prevFrequency, int newFrequency) {
+        if (prevFrequency != 0) {
+            this.frequencyToNumMapping.get(prevFrequency).remove(number);
+        }
+        if (newFrequency != 0) {
+            this.frequencyToNumMapping.computeIfAbsent(newFrequency, k -> new HashSet<>()).add(number);
+        }
+    }
+}
+
+/**
+ * Your FrequencyTracker object will be instantiated and called as such:
+ * FrequencyTracker obj = new FrequencyTracker();
+ * obj.add(number);
+ * obj.deleteOne(number);
+ * boolean param_3 = obj.hasFrequency(frequency);
+ */
diff --git a/Medium/Fruit Into Baskets.java b/Medium/Fruit Into Baskets.java
index 79889371..937fbbe9 100644
--- a/Medium/Fruit Into Baskets.java	
+++ b/Medium/Fruit Into Baskets.java	
@@ -1,21 +1,21 @@
 class Solution {
-  public int totalFruit(int[] fruits) {
-    Map<Integer, Integer> map = new HashMap<>();
-    int startIdx = 0;
-    int endIdx = 0;
-    int n = fruits.length;
-    int maxPickedCount = 0;
-    while (endIdx < n) {
-      map.put(fruits[endIdx], map.getOrDefault(fruits[endIdx++], 0) + 1);
-      while (startIdx < endIdx && map.size() > 2) {
-        map.put(fruits[startIdx], map.get(fruits[startIdx]) - 1);
-        if (map.get(fruits[startIdx]) == 0) {
-          map.remove(fruits[startIdx]);
+    public int totalFruit(int[] fruits) {
+        int maximumFruits = 0;
+        Map<Integer, Integer> map = new HashMap<>();
+        int start = 0;
+        int end = 0;
+        while (end < fruits.length) {
+            map.put(fruits[end], map.getOrDefault(fruits[end], 0) + 1);
+            end++;
+            while (start < end && map.size() > 2) {
+                map.put(fruits[start], map.get(fruits[start]) - 1);
+                if (map.get(fruits[start]) == 0) {
+                    map.remove(fruits[start]);
+                }
+                start++;
+            }
+            maximumFruits = Math.max(maximumFruits, end - start);
         }
-        startIdx++;
-      }
-      maxPickedCount = Math.max(maxPickedCount, endIdx - startIdx);
+        return maximumFruits;
     }
-    return maxPickedCount;
-  }   
 }
diff --git a/Medium/Furthest Building You Can Reach.java b/Medium/Furthest Building You Can Reach.java
index 2c901072..1e110678 100644
--- a/Medium/Furthest Building You Can Reach.java	
+++ b/Medium/Furthest Building You Can Reach.java	
@@ -1,18 +1,20 @@
 class Solution {
-  public int furthestBuilding(int[] heights, int bricks, int ladders) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>();
-    for (int i = 1; i < heights.length; i++) {
-      int diff = heights[i] - heights[i - 1];
-      if (diff > 0) {
-        pq.add(diff);
-        if (pq.size() > ladders) {
-          bricks -= pq.poll();
+    public int furthestBuilding(int[] heights, int bricks, int ladders) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        for (int i = 1; i < heights.length; i++) {
+            int diff = heights[i] - heights[i - 1];
+            if (diff > 0) {
+                pq.add(diff);
+                bricks -= diff;
+                if (bricks < 0) {
+                    if (ladders == 0) {
+                        return i - 1;
+                    }
+                    ladders--;
+                    bricks += pq.poll();
+                }
+            }
         }
-        if (bricks < 0) {
-          return i - 1;
-        }
-      }
+        return heights.length - 1;
     }
-    return heights.length - 1;
-  }
 }
diff --git a/Medium/Group the People Given the Group Size They Belong To.java b/Medium/Group the People Given the Group Size They Belong To.java
index 475cf0c6..095fb67f 100644
--- a/Medium/Group the People Given the Group Size They Belong To.java	
+++ b/Medium/Group the People Given the Group Size They Belong To.java	
@@ -1,20 +1,18 @@
 class Solution {
-  public List<List<Integer>> groupThePeople(int[] groupSizes) {
-    Map<Integer, Queue<Integer>> groupSizeToId = new HashMap<>();
-    for (int i = 0; i < groupSizes.length; i++) {
-      groupSizeToId.computeIfAbsent(groupSizes[i], k -> new LinkedList<>()).add(i);
-    }
-    List<List<Integer>> result = new ArrayList<>();
-    for (Integer groupSize : groupSizeToId.keySet()) {
-      Queue<Integer> ids = groupSizeToId.get(groupSize);
-      while (!ids.isEmpty()) {
-        List<Integer> group = new ArrayList<>(groupSize);
-        for (int i = 0; i< groupSize; i++) {
-          group.add(ids.remove());
+    public List<List<Integer>> groupThePeople(int[] groupSizes) {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        for (int i = 0; i < groupSizes.length; i++) {
+            map.computeIfAbsent(groupSizes[i], k -> new ArrayList<>()).add(i);
+        }
+        List<List<Integer>> result = new ArrayList<>();
+        for (Integer key : map.keySet()) {
+            List<Integer> candidates = map.get(key);
+            int idx = 0;
+            while (idx < candidates.size()) {
+                result.add(candidates.subList(idx, idx + key));
+                idx += key;
+            }
         }
-        result.add(group);
-      }
+        return result;
     }
-    return result;
-  }
 }
diff --git a/Medium/Hand of Straights.java b/Medium/Hand of Straights.java
index ceff444a..5f407cf0 100644
--- a/Medium/Hand of Straights.java	
+++ b/Medium/Hand of Straights.java	
@@ -1,29 +1,32 @@
 class Solution {
-  public boolean isNStraightHand(int[] hand, int W) {
-    if (hand.length % W != 0) {
-      return false;
-    }
-    Map<Integer, Integer> counterMap = new HashMap<>();
-    Set<Integer> set = new TreeSet<>();
-    for (int num : hand) {
-      counterMap.put(num, counterMap.getOrDefault(num, 0) + 1);
-      set.add(num);
-    }
-    Iterator<Integer> iter = set.iterator();
-    Integer curr = iter.next();
-    while (counterMap.get(curr) > 0) {
-      int temp = curr;
-      for (int i = 0; i < W; i++) {
-        if (counterMap.getOrDefault(temp, 0) == 0) {
-          return false;
+    public boolean isNStraightHand(int[] hand, int groupSize) {
+        if (hand.length % groupSize != 0) {
+            return false;
+        }
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : hand) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        PriorityQueue<Integer> pq = new PriorityQueue<>(map.keySet());
+        while (!pq.isEmpty()) {
+            List<Integer> temp = new ArrayList<>();
+            int prev = -1;
+            for (int i = 0; i < groupSize; i++) {
+                if (pq.isEmpty()) {
+                    return false;
+                }
+                int removed = pq.remove();
+                map.put(removed, map.get(removed) - 1);
+                if (map.get(removed) > 0) {
+                    temp.add(removed);
+                }
+                if (prev != -1 && removed != prev + 1) {
+                    return false;
+                }
+                prev = removed;
+            }
+            pq.addAll(temp);
         }
-        counterMap.put(temp, counterMap.get(temp) - 1);
-        temp++;
-      }
-      while (iter.hasNext() && counterMap.get(curr) == 0) {
-        curr = iter.next();
-      }
+        return true;
     }
-    return true;
-  }
 }
diff --git a/Medium/High-Access Employees.java b/Medium/High-Access Employees.java
new file mode 100644
index 00000000..8c881fc8
--- /dev/null
+++ b/Medium/High-Access Employees.java	
@@ -0,0 +1,43 @@
+class Solution {
+    public List<String> findHighAccessEmployees(List<List<String>> accessTimeEntries) {
+        Map<String, List<TimeRecord>> map = new HashMap<>();
+        for (List<String> entry : accessTimeEntries) {
+            String employee = entry.get(0);
+            String time = entry.get(1);
+            map.computeIfAbsent(employee, k -> new ArrayList<>()).add(TimeRecord.buildTimeRecord(time));
+        }
+        List<String> result = new ArrayList<>();
+        for (String key : map.keySet()) {
+            List<TimeRecord> entries = map.get(key);
+            if (entries.size() < 3) {
+                continue;
+            }
+            Collections.sort(entries);
+            for (int i = 0; i < entries.size() - 2; i++) {
+                if (TimeRecord.areWithinSameHour(entries.get(i), entries.get(i + 2))) {
+                    result.add(key);
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+
+    private record TimeRecord(int totalMinutes) implements Comparable<TimeRecord> {
+
+        public static TimeRecord buildTimeRecord(String entry) {
+            int hour = Integer.parseInt(entry.substring(0, 2));
+            int min = Integer.parseInt(entry.substring(2));
+            return new TimeRecord(hour * 60 + min);
+        }
+
+        public static boolean areWithinSameHour(TimeRecord startTime, TimeRecord endTime) {
+            return endTime.totalMinutes - startTime.totalMinutes < 60;
+        }
+
+        @Override
+        public int compareTo(TimeRecord o) {
+            return this.totalMinutes - o.totalMinutes;
+        }
+    }
+}
diff --git a/Medium/House Robber.java b/Medium/House Robber.java
index 8837a99d..3ebdc59b 100644
--- a/Medium/House Robber.java	
+++ b/Medium/House Robber.java	
@@ -1,14 +1,11 @@
 class Solution {
-  public int rob(int[] nums) {
-    if (nums.length == 1) {
-      return nums[0];
+    public int rob(int[] nums) {
+        int n = nums.length;
+        int[] dp = new int[n + 1];
+        dp[1] = nums[0];
+        for (int i = 1; i < n; i++) {
+            dp[i + 1] = Math.max(dp[i], dp[i - 1] + nums[i]);
+        }
+        return dp[n];
     }
-    int[] dp = new int[nums.length];
-    dp[0] = nums[0];
-    dp[1] = Math.max(nums[0], nums[1]);
-    for (int i = 2; i < nums.length; i++) {
-      dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
-    }
-    return dp[nums.length - 1];
-  }
 }
diff --git a/Medium/Implement Trie (Prefix Tree).java b/Medium/Implement Trie (Prefix Tree).java
index 8df3049a..353634fd 100644
--- a/Medium/Implement Trie (Prefix Tree).java	
+++ b/Medium/Implement Trie (Prefix Tree).java	
@@ -1,56 +1,61 @@
+import java.util.Optional;
+
 class Trie {
-  
-  private TrieNode root;
-  
-  public Trie() {
-    this.root = new TrieNode();
-  }
-
-  public void insert(String word) {
-    TrieNode curr = root;
-    for (char c : word.toCharArray()) {
-      if (!curr.children.containsKey(c)) {
-        curr.children.put(c, new TrieNode());
-      }
-      curr = curr.children.get(c);
+
+    private final TrieNode root;
+
+    public Trie() {
+        root = new TrieNode();
     }
-    curr.isWord = true;
-  }
-
-  public boolean search(String word) {
-    TrieNode searchNode = searchHelper(word);
-    return searchNode != null && searchNode.isWord;
-  }
-
-  public boolean startsWith(String prefix) {
-    return searchHelper(prefix) != null;
-  }
-  
-  private TrieNode searchHelper(String s) {
-    TrieNode curr = root;
-    for (char c : s.toCharArray()) {
-      if (!curr.children.containsKey(c)) {
-        return null;
-      }
-      curr = curr.children.get(c);
+
+    public void insert(String word) {
+        TrieNode curr = root;
+        for (char c : word.toCharArray()) {
+            if (!curr.children.containsKey(c)) {
+                curr.children.put(c, new TrieNode());
+            }
+            curr = curr.children.get(c);
+        }
+        curr.isWord = true;
+    }
+
+    public boolean search(String word) {
+        Optional<TrieNode> node = searchHelper(word);
+        return node.isPresent() && node.get().isWord;
+    }
+
+    public boolean startsWith(String prefix) {
+        Optional<TrieNode> node = searchHelper(prefix);
+        return node.isPresent();
     }
-    return curr;
-  }
-  
-  private class TrieNode {
-    Map<Character, TrieNode> children;
-    boolean isWord;
     
-    public TrieNode() {
-      this.children = new HashMap<>();
+    public Optional<TrieNode> searchHelper(String word) {
+        TrieNode curr = root;
+        for (char c : word.toCharArray()) {
+            if (!curr.children.containsKey(c)) {
+                return Optional.empty();
+            }
+            curr = curr.children.get(c);
+        }
+        return Optional.of(curr);
+    }
+
+    private static class TrieNode {
+        
+        private final Map<Character, TrieNode> children;
+        private boolean isWord;
+
+        private TrieNode() {
+            this.children = new HashMap<>();
+            this.isWord = false;
+        }
     }
-  }
 }
 
 /**
-* Your Trie object will be instantiated and called as such:
-* Trie obj = new Trie();
-* obj.insert(word);
-* boolean param_2 = obj.search(word);
-* boolean param_3 = obj.startsWith(prefix);
-*/
+ * Your Trie object will be instantiated and called as such:
+ * Trie obj = new Trie();
+ * obj.insert(word);
+ * boolean param_2 = obj.search(word);
+ * boolean param_3 = obj.startsWith(prefix);
+ */
diff --git a/Medium/Implement Trie II (Prefix Tree).java b/Medium/Implement Trie II (Prefix Tree).java
index e6bae27d..7c5b1a36 100644
--- a/Medium/Implement Trie II (Prefix Tree).java	
+++ b/Medium/Implement Trie II (Prefix Tree).java	
@@ -1,82 +1,69 @@
-class Trie {
+import java.util.Optional;
+
 
-  private Node head;
+class Trie {
 
-  public Trie() {
-    this.head = new Node('-');
-  }
+    private final Node root;
 
-  public void insert(String word) {
-    Node curr = this.head;
-    for (char c : word.toCharArray()) {
-      if (!curr.children.containsKey(c)) {
-        curr.children.put(c, new Node(c));
-      }
-      curr = curr.children.get(c);
+    public Trie() {
+        root = new Node();
     }
-    curr.wordToFrequency.put(word, curr.wordToFrequency.getOrDefault(word, 0) + 1);
-  }
 
-  public int countWordsEqualTo(String word) {
-    Node curr = this.head;
-    curr = traverseTrie(curr, word);
-    if (curr == null) {
-      return 0;
+    public void insert(String word) {
+        Node curr = root;
+        for (char c : word.toCharArray()) {
+            if (!curr.children.containsKey(c)) {
+                curr.children.put(c, new Node());
+            }
+            curr = curr.children.get(c);
+            curr.startingWordCount++;
+        }
+        curr.endingWordCount++;
     }
-    return curr.wordToFrequency.getOrDefault(word, 0);
-  }
 
-  public int countWordsStartingWith(String prefix) {
-    Node curr = this.head;
-    curr = traverseTrie(curr, prefix);
-    if (curr == null) {
-      return 0;
+    public int countWordsEqualTo(String word) {
+        Optional<Node> curr = search(word);
+        return curr.map(node -> node.endingWordCount).orElse(0);
     }
-    int count = 0;
-    Queue<Node> queue = new LinkedList<>();
-    queue.add(curr);
-    while (!queue.isEmpty()) {
-      Node removed = queue.remove();
-      for (String word : removed.wordToFrequency.keySet()) {
-        count += removed.wordToFrequency.get(word);
-      }
-      for (Character child : removed.children.keySet()) {
-        queue.add(removed.children.get(child));
-      }
+
+    public int countWordsStartingWith(String prefix) {
+        Optional<Node> curr = search(prefix);
+        return curr.map(node -> node.startingWordCount).orElse(0);
     }
-    return count;
-  }
 
-  public void erase(String word) {
-    Node curr = this.head;
-    curr = traverseTrie(curr, word);
-    if (curr == null || curr.wordToFrequency.getOrDefault(word, 0) == 0) {
-      return;
+    public void erase(String word) {
+        Node curr = root;
+        for (char c : word.toCharArray()) {
+            curr = curr.children.get(c);
+            curr.startingWordCount--;
+        }
+        curr.endingWordCount--;
     }
-    curr.wordToFrequency.put(word, curr.wordToFrequency.get(word) - 1);
-  }
 
-  private Node traverseTrie(Node curr, String word) {
-    for (char c : word.toCharArray()) {
-      if (!curr.children.containsKey(c)) {
-        return null;
-      }
-      curr = curr.children.get(c);
+    private Optional<Node> search(String word) {
+        Node curr = root;
+        for (char c : word.toCharArray()) {
+            if (!curr.children.containsKey(c)) {
+                return Optional.empty();
+            }
+            curr = curr.children.get(c);
+        }
+        return Optional.of(curr);
     }
-    return curr;
-  }
 
-  private static class Node {
-    char c;
-    Map<Character, Node> children;
-    Map<String, Integer> wordToFrequency;
+    private static class Node {
+
+        private int startingWordCount;
+        private int endingWordCount;
+
+        private final Map<Character, Node> children;
 
-    public Node(char c) {
-      this.c = c;
-      this.children = new HashMap<>();
-      this.wordToFrequency = new HashMap<>();
+        public Node() {
+            this.startingWordCount = 0;
+            this.endingWordCount = 0;
+            this.children = new HashMap<>();
+        }
     }
-  }
 }
 
 /**
diff --git a/Medium/Insert Delete GetRandom O(1).java b/Medium/Insert Delete GetRandom O(1).java
index 3b9b44ae..9ef0fc92 100644
--- a/Medium/Insert Delete GetRandom O(1).java	
+++ b/Medium/Insert Delete GetRandom O(1).java	
@@ -1,40 +1,41 @@
 class RandomizedSet {
 
-  private List<Integer> randomizedSet;
-  private Map<Integer, Integer> indexMap;
-  private int currSize;
-  
-  public RandomizedSet() {
-    this.randomizedSet = new ArrayList<>();
-    this.indexMap = new HashMap<>();
-    this.currSize = 0;
-  }
+    private final List<Integer> values;
+    private final Map<Integer, Integer> valToIndexMap;
 
-  public boolean insert(int val) {
-    if (this.indexMap.containsKey(val)) {
-      return false;
+    public RandomizedSet() {
+        this.values = new ArrayList<>();
+        this.valToIndexMap = new HashMap<>();
     }
-    this.randomizedSet.add(val);
-    this.indexMap.put(val, this.currSize++);
-    return true;
-  }
 
-  public boolean remove(int val) {
-    if (!this.indexMap.containsKey(val)) {
-      return false;
+    public boolean insert(int val) {
+        if (valToIndexMap.containsKey(val)) {
+            return false;
+        }
+        values.add(val);
+        valToIndexMap.put(val, values.size() - 1);
+        return true;
     }
-    int valIdx = this.indexMap.get(val);
-    this.indexMap.put(this.randomizedSet.get(this.currSize - 1), valIdx);
-    this.randomizedSet.set(valIdx, this.randomizedSet.get(this.currSize - 1));
-    this.randomizedSet.remove(this.currSize - 1);
-    this.indexMap.remove(val);
-    this.currSize--;
-    return true;
-  }
 
-  public int getRandom() {
-    return this.randomizedSet.get(new Random().nextInt(this.currSize));
-  }
+    public boolean remove(int val) {
+        if (!valToIndexMap.containsKey(val)) {
+            return false;
+        }
+        int valIdx = valToIndexMap.get(val);
+        int valAtLastIdx = values.get(values.size() - 1);
+        // update index for last element
+        values.set(valIdx, valAtLastIdx);
+        valToIndexMap.put(valAtLastIdx, valIdx);
+        // remove value
+        values.remove(values.size() - 1);
+        valToIndexMap.remove(val);
+        return true;
+    }
+
+    public int getRandom() {
+        int idx = new Random().nextInt(values.size());
+        return values.get(idx);
+    }
 }
 
 /**
diff --git a/Medium/Insert Greatest Common Divisors in Linked List.java b/Medium/Insert Greatest Common Divisors in Linked List.java
new file mode 100644
index 00000000..6dcf5fd0
--- /dev/null
+++ b/Medium/Insert Greatest Common Divisors in Linked List.java	
@@ -0,0 +1,29 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode insertGreatestCommonDivisors(ListNode head) {
+        ListNode curr = head;
+        while (curr != null && curr.next != null) {
+            ListNode gcdNode = new ListNode(findGcd(curr.val, curr.next.val));
+            gcdNode.next = curr.next;
+            curr.next = gcdNode;
+            curr = gcdNode.next;
+        }
+        return head;
+    }
+    
+    private static int findGcd(int numOne, int numTwo) {
+        if (numOne == numTwo) {
+            return numOne;
+        }
+        return numOne > numTwo ? findGcd(numOne - numTwo, numTwo) : findGcd(numOne, numTwo - numOne);
+    }
+}
diff --git a/Medium/Insert Interval.java b/Medium/Insert Interval.java
index a263b710..a90a6884 100644
--- a/Medium/Insert Interval.java	
+++ b/Medium/Insert Interval.java	
@@ -1,32 +1,19 @@
 class Solution {
-  public int[][] insert(int[][] intervals, int[] newInterval) {
-    List<int[]> result = new ArrayList<>();
-    int idx = 0;
-    int newStart = newInterval[0];
-    int newEnd = newInterval[1];
-    while (idx < intervals.length && newStart > intervals[idx][0]) {
-      result.add(intervals[idx++]);
+    public int[][] insert(int[][] intervals, int[] newInterval) {
+        List<int[]> result = new ArrayList<>();
+        int idx = 0;
+        while (idx < intervals.length && intervals[idx][1] < newInterval[0]) {
+            result.add(intervals[idx++]);
+        }
+        while (idx < intervals.length && newInterval[1] >= intervals[idx][0]) {
+            newInterval[0] = Math.min(newInterval[0], intervals[idx][0]);
+            newInterval[1] = Math.max(newInterval[1], intervals[idx][1]);
+            idx++;
+        }
+        result.add(newInterval);
+        while (idx < intervals.length) {
+            result.add(intervals[idx++]);
+        }
+        return result.toArray(new int[result.size()][]);
     }
-    int[] currInterval = new int[2];
-    if (result.isEmpty() || result.get(result.size() - 1)[1] < newStart) {
-      result.add(newInterval);
-    } else {
-      currInterval = result.remove(result.size() - 1);
-      currInterval[1] = Math.max(currInterval[1], newEnd);
-      result.add(currInterval);
-    }
-    while (idx < intervals.length) {
-      currInterval = intervals[idx++];
-      int start = currInterval[0];
-      int end = currInterval[1];
-      if (result.get(result.size() - 1)[1] < start) {
-        result.add(currInterval);
-      } else {
-        currInterval = result.remove(result.size() - 1);
-        currInterval[1] = Math.max(currInterval[1], end);
-        result.add(currInterval);
-      }
-    }
-    return result.toArray(new int[result.size()][2]);
-  }
 }
diff --git a/Medium/Integer Break.java b/Medium/Integer Break.java
new file mode 100644
index 00000000..10071c6f
--- /dev/null
+++ b/Medium/Integer Break.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int integerBreak(int n) {
+        if (n < 4) {
+            return n - 1;
+        }
+        int[] dp = new int[n + 1];
+        for (int i = 1; i <= 3; i++) {
+            dp[i] = i;
+        }
+        for (int i = 4; i <= n; i++) {
+            int result = i;
+            for (int j = 2; j < i; j++) {
+                result = Math.max(result, j * dp[i - j]);
+            }
+            dp[i] = result;
+        }
+        return dp[n];
+    }
+}
diff --git a/Medium/Is Graph Bipartite.java b/Medium/Is Graph Bipartite.java
index c77018dc..3a30604f 100644
--- a/Medium/Is Graph Bipartite.java	
+++ b/Medium/Is Graph Bipartite.java	
@@ -1,39 +1,38 @@
 class Solution {
-  public boolean isBipartite(int[][] graph) {
-    int n = graph.length;
-    int[] color = new int[n];
-    Arrays.fill(color, -1);
-    for (int i = 0; i < n; i++) {
-      if (color[i] == -1 && !bipartiteCheck(graph, i, color)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  
-  private boolean bipartiteCheck(int[][] graph, int node, int[] color) {
-    Queue<Integer> queue = new LinkedList<>();
-    queue.add(node);
-    int currColor = 0;
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int removed = queue.remove();
-        if (color[removed] != -1) {
-          if (color[removed] != currColor) {
-            return false;
-          }
-          continue;
+    public boolean isBipartite(int[][] graph) {
+        int n = graph.length;
+        int[] color = new int[n];
+        for (int i = 0; i < n; i++) {
+            if (color[i] == 0 && !isBipartite(graph, i, color)) {
+                return false;
+            }
         }
-        color[removed] = currColor;
-        for (int conn : graph[removed]) {
-          if (color[conn] == -1) {
-            queue.add(conn);
-          }
+        return true;
+    }
+    
+    private boolean isBipartite(int[][] graph, int node, int[] color) {
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(node);
+        int currColor = 1;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int removed = queue.remove();
+                if (color[removed] != 0) {
+                    if (color[removed] != currColor) {
+                        return false;
+                    }
+                } else {
+                    color[removed] = currColor;
+                    for (int conn : graph[removed]) {
+                        if (color[conn] == 0) {
+                            queue.add(conn);
+                        }
+                    }
+                }
+            }
+            currColor = currColor == 1 ? 2 : 1;
         }
-      }
-      currColor = currColor == 1 ? 0 : 1;
+        return true;
     }
-    return true;
-  }
 }
diff --git a/Medium/Jump Game II.java b/Medium/Jump Game II.java
new file mode 100644
index 00000000..0f3a792c
--- /dev/null
+++ b/Medium/Jump Game II.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int jump(int[] nums) {
+        int jumpCount = 0;
+        int left = 0;
+        int right = 0;
+        while (right < nums.length - 1) {
+            int farthest = 0;
+            for (int i = left; i <= right; i++) {
+                farthest = Math.max(farthest, i + nums[i]);
+            }
+            left = right + 1;
+            right = farthest;
+            jumpCount++;
+        }
+        return jumpCount;
+    }
+}
diff --git a/Medium/K-th Symbol in Grammar.java b/Medium/K-th Symbol in Grammar.java
new file mode 100644
index 00000000..da370f11
--- /dev/null
+++ b/Medium/K-th Symbol in Grammar.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int kthGrammar(int n, int k) {
+        return depthFirstSearch(n, k, 0);
+    }
+
+    private int depthFirstSearch(int n, int k, int root) {
+        if (n == 1) {
+            return root;
+        }
+        int nodeCount = (int) Math.pow(2, n - 1);
+        if (k > (nodeCount / 2)) {
+            int nextRoot = (root == 0) ? 1 : 0;
+            return depthFirstSearch(n - 1, k - (nodeCount / 2), nextRoot);
+        }
+        int nextRoot = (root == 0) ? 0 : 1;
+        return depthFirstSearch(n - 1, k, nextRoot);
+    }
+}
diff --git a/Medium/Keys and Rooms.java b/Medium/Keys and Rooms.java
index 6a2f8c3f..a4fd783a 100644
--- a/Medium/Keys and Rooms.java	
+++ b/Medium/Keys and Rooms.java	
@@ -1,19 +1,18 @@
 class Solution {
     public boolean canVisitAllRooms(List<List<Integer>> rooms) {
-        Stack<Integer> stack = new Stack<>();
-        Set<Integer> set = new HashSet<>();
-        set.add(0);
-        stack.add(0);
-        while (!stack.isEmpty()) {
-            int keyPopped = stack.pop();
-            List<Integer> keys = rooms.get(keyPopped);
-            for (Integer key : keys) {
-                if (!set.contains(key)) {
-                    stack.push(key);
-                    set.add(key);
+        Set<Integer> visited = new HashSet<>();
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(0);
+        visited.add(0);
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            for (Integer nextRoom : rooms.get(removed)) {
+                if (!visited.contains(nextRoom)) {
+                    queue.add(nextRoom);
+                    visited.add(nextRoom);
                 }
             }
         }
-        return set.size() == rooms.size();
+        return visited.size() == rooms.size();
     }
 }
diff --git a/Medium/Kth Largest Sum in a Binary Tree.java b/Medium/Kth Largest Sum in a Binary Tree.java
new file mode 100644
index 00000000..01955179
--- /dev/null
+++ b/Medium/Kth Largest Sum in a Binary Tree.java	
@@ -0,0 +1,41 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public long kthLargestLevelSum(TreeNode root, int k) {
+        PriorityQueue<Long> pq = new PriorityQueue<>();
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            long sum = 0l;
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                sum += removed.val;
+                if (removed.left != null) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null) {
+                    queue.add(removed.right);
+                }
+            }
+            pq.add(sum);
+            if (pq.size() > k) {
+                pq.poll();
+            }
+        }
+        return pq.size() < k ? -1 : pq.poll();
+    }
+}
diff --git a/Medium/LRU Cache.java b/Medium/LRU Cache.java
index e141637f..1e1b3ae6 100644
--- a/Medium/LRU Cache.java	
+++ b/Medium/LRU Cache.java	
@@ -1,69 +1,84 @@
 class LRUCache {
+    
+    private final Map<Integer, Node> map;
+    private final int capacity;
+    private final Node head;
+    private final Node tail;
+    
+    public LRUCache(int capacity) {
+        this.capacity = capacity;
+        this.map = new HashMap<>();
+        this.head = new Node(-1, -1);
+        this.tail = new Node(-1, -1);
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
+    }
+
+    public int get(int key) {
+        if (!map.containsKey(key)) {
+            return -1;
+        }
+        Node node = map.get(key);
+        removeNode(node);
+        addToFront(node);
+        return node.value;
+    }
 
-  private final Map<Integer, Node> map;
-  private final Node head;
-  private final Node tail;
-  private int capacity;
+    public void put(int key, int value) {
+        if (map.containsKey(key)) {
+            updateExistingKey(key, value);
+            return;
+        }
+        if (map.size() == this.capacity) {
+            Node leastUsed = tail.prev;
+            removeNode(leastUsed);
+            map.remove(leastUsed.key);
+        }
+        Node newNode = new Node(key, value);
+        addToFront(newNode);
+        map.put(key, newNode);
+    }
 
-  public LRUCache(int capacity) {
-    this.map = new HashMap<>();
-    this.head = new Node(-1, -1);
-    this.tail = new Node(-1, -1);
-    head.next = tail;
-    tail.prev = head;
-    this.capacity = capacity;
-  }
+    private void updateExistingKey(int key, int value) {
+        Node node = map.get(key);
+        Node updatedNode = new Node(key, value);
+        removeNode(node);
+        addToFront(updatedNode);
+        map.put(key, updatedNode);
+    }
 
-  public int get(int key) {
-    if (!this.map.containsKey(key)) {
-      return -1;
+    private void removeNode(Node node) {
+        Node prevToNode = node.prev;
+        Node nextToNode = node.next;
+        prevToNode.next = nextToNode;
+        nextToNode.prev = prevToNode;
     }
-    Node node = this.map.get(key);
-    removeNode(node);
-    addNode(node);
-    return this.map.get(key).val;
-  }
 
-  public void put(int key, int value) {
-    if (!map.containsKey(key)) {
-      if (capacity == 0) {
-        removeNode(tail.prev);
-      }
-    } else {
-      removeNode(this.map.get(key));
+    private void addToFront(Node node) {
+        Node nextToHead = head.next;
+        node.next = nextToHead;
+        nextToHead.prev = node;
+        node.prev = head;
+        head.next = node;
     }
-    addNode(new Node(key, value));
-  }
-  
-  private void addNode(Node node) {
-    Node nextToHead = head.next;
-    head.next = node;
-    node.next = nextToHead;
-    nextToHead.prev = node;
-    node.prev = head;
-    this.map.put(node.key, node);
-    this.capacity--;
-  }
-  
-  private void removeNode(Node node) {
-    Node nextNode = node.next;
-    node.prev.next = nextNode;
-    nextNode.prev = node.prev;
-    this.map.remove(node.key);
-    this.capacity++;
-  }
 
-  private static class Node {
-    Node next;
-    Node prev;
-    int key;
-    int val;
+    private static class Node {
 
-    public Node(int key, int val) {
-      this.key = key;
-      this.val = val;
-      this.next = null;
-      this.prev = null;
+        private final int key;
+        private final int value;
+        private Node next;
+        private Node prev;
+        
+        public Node(int key, int value) {
+            this.key = key;
+            this.value = value;
+        }
     }
-  }
 }
+
+/**
+ * Your LRUCache object will be instantiated and called as such:
+ * LRUCache obj = new LRUCache(capacity);
+ * int param_1 = obj.get(key);
+ * obj.put(key,value);
+ */
diff --git a/Medium/Largest BST Subtree.java b/Medium/Largest BST Subtree.java
index 45c83c6f..18ddfeaf 100644
--- a/Medium/Largest BST Subtree.java	
+++ b/Medium/Largest BST Subtree.java	
@@ -4,43 +4,41 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
     public int largestBSTSubtree(TreeNode root) {
-        return largestBSTSubtreeHelper(root);
-    }
-    
-    private int largestBSTSubtreeHelper(TreeNode root) {
-        if (isBST(root)) {
-            return getNodeCount(root);
-        }
-        
-        return Math.max(-1, Math.max(largestBSTSubtreeHelper(root.left), largestBSTSubtreeHelper(root.right)));
-    }
-    
-    private boolean isBST(TreeNode root) {
-        return isBSTHelper(root, Integer.MAX_VALUE, Integer.MIN_VALUE);
-    }
-    
-    private boolean isBSTHelper(TreeNode root, int max, int min) {
         if (root == null) {
-            return true;
+            return 0;
         }
-        
-        if (root.val >= max || root.val <= min) {
-            return false;
+        int[] isBstResult = isBst(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
+        if (isBstResult[0] == 1) {
+            return isBstResult[1];
         }
-        
-        return isBSTHelper(root.left, root.val, min) && isBSTHelper(root.right, max, root.val);
+        return Math.max(largestBSTSubtree(root.left), largestBSTSubtree(root.right));
     }
 
-    private int getNodeCount(TreeNode root) {
+    private int[] isBst(TreeNode root, int minValue, int maxValue) {
         if (root == null) {
-            return 0;
+            return new int[]{1, 0};
+        }
+        int[] result = new int[2];
+        if (!(root.val > minValue && root.val < maxValue)) {
+            return result;
+        }
+        int[] leftIsBst = isBst(root.left, minValue, root.val);
+        int[] rightIsBst = isBst(root.right, root.val, maxValue);
+        if (leftIsBst[0] == 1 && rightIsBst[0] == 1) {
+            result[0] = 1;
+            result[1] = 1 + leftIsBst[1] + rightIsBst[1];
         }
-        
-        return 1 + getNodeCount(root.left) + getNodeCount(root.right);
+        return result;
     }
 }
diff --git a/Medium/Largest Combination With Bitwise AND Greater Than Zero.java b/Medium/Largest Combination With Bitwise AND Greater Than Zero.java
new file mode 100644
index 00000000..1399f1bb
--- /dev/null
+++ b/Medium/Largest Combination With Bitwise AND Greater Than Zero.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int largestCombination(int[] candidates) {
+        int[] bitCount = new int[24];
+        for (int i = 0; i < 24; i++) {
+            for (int candidate : candidates) {
+                if ((candidate & (1 << i)) != 0) {
+                    bitCount[i]++;
+                }
+            }
+        }
+        int result = 0;
+        for (int count : bitCount) {
+            result = Math.max(count, result);
+        }
+        return result;
+    }
+}
diff --git a/Medium/Last Moment Before All Ants Fall Out of a Plank.java b/Medium/Last Moment Before All Ants Fall Out of a Plank.java
index 45e59801..e061b5d3 100644
--- a/Medium/Last Moment Before All Ants Fall Out of a Plank.java	
+++ b/Medium/Last Moment Before All Ants Fall Out of a Plank.java	
@@ -1,12 +1,12 @@
 class Solution {
-  public int getLastMoment(int n, int[] left, int[] right) {
-    int res = 0;
-    for (int ant : left) {
-      res = Math.max(res, ant);
+    public int getLastMoment(int n, int[] left, int[] right) {
+        int result = 0;
+        for (int num : left) {
+            result = Math.max(result, num);
+        }
+        for (int num : right) {
+            result = Math.max(result, n - num);
+        }
+        return result;
     }
-    for (int ant : right) {
-      res = Math.max(res, n - ant);
-    }
-    return res;
-  }
 }
diff --git a/Medium/Least Number of Unique Integers after K Removals.java b/Medium/Least Number of Unique Integers after K Removals.java
index 30b56fac..c6755d8e 100644
--- a/Medium/Least Number of Unique Integers after K Removals.java	
+++ b/Medium/Least Number of Unique Integers after K Removals.java	
@@ -1,28 +1,19 @@
 class Solution {
-  public int findLeastNumOfUniqueInts(int[] arr, int k) {
-    Map<Integer, Integer> map = new HashMap<>();
-    List<Integer> list = new ArrayList<>();
-    for (int num : arr) {
-      if (!map.containsKey(num)) {
-        list.add(num);
-      }
-      map.put(num, map.getOrDefault(num, 0) + 1);
+    public int findLeastNumOfUniqueInts(int[] arr, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : arr) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> map.get(a).compareTo(map.get(b)));
+        pq.addAll(map.keySet());
+        while (k > 0 && !pq.isEmpty()) {
+            int count = map.get(pq.peek());
+            if (count > k) {
+                break;
+            }
+            k -= count;
+            pq.poll();
+        }
+        return pq.size();
     }
-    Collections.sort(list, new Comparator<Integer>(){
-      public int compare(Integer o1, Integer o2) {
-        return map.get(o1) - map.get(o2);
-      }
-    });
-    for (Integer num : list) {
-      int count = map.get(num);
-      k -= count;
-      if (k >= 0) {
-        map.remove(num);
-      }
-      else {
-       break; 
-      }
-    }
-    return map.size();
-  }
 }
diff --git a/Medium/Length of Longest Subarray With at Most K Frequency.java b/Medium/Length of Longest Subarray With at Most K Frequency.java
new file mode 100644
index 00000000..82d8f62d
--- /dev/null
+++ b/Medium/Length of Longest Subarray With at Most K Frequency.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maxSubarrayLength(int[] nums, int k) {
+        int start = 0;
+        int end = 0;
+        int result = 0;
+        int n = nums.length;
+        Map<Integer, Integer> map = new HashMap<>();
+        while (end < n) {
+            map.put(nums[end], map.getOrDefault(nums[end], 0) + 1);
+            while (start < end && map.get(nums[end]) > k) {
+                map.put(nums[start], map.get(nums[start]) - 1);
+                start++;
+            }
+            end++;
+            result = Math.max(result, end - start);
+        }
+        return result;
+    }
+}
diff --git a/Medium/Letter Combinations of a Phone Number.java b/Medium/Letter Combinations of a Phone Number.java
index 2c3a8c23..b145954b 100644
--- a/Medium/Letter Combinations of a Phone Number.java	
+++ b/Medium/Letter Combinations of a Phone Number.java	
@@ -1,25 +1,32 @@
 class Solution {
-  
-  private final List<String> LETTER_MAPPING = Arrays.asList("abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz");
-  
-  public List<String> letterCombinations(String digits) {
-    List<String> result = new ArrayList<>();
-    helper(digits, 0, new StringBuilder(), result);
-    return result;
-  }
-  
-  private void helper(String digits, int idx, StringBuilder sb, List<String> result) {
-    if (idx == digits.length()) {
-      if (sb.length() > 0) {
-        result.add(new String(sb.toString()));
-      }
-      return;
-    } 
-    int mappingIdx = Character.getNumericValue(digits.charAt(idx)) - 2;
-    for (char c : LETTER_MAPPING.get(mappingIdx).toCharArray()) {
-      sb.append(c);
-      helper(digits, idx + 1, sb, result);
-      sb.deleteCharAt(sb.length() - 1);
+    private static final Map<Character, String> DIGIT_TO_CHAR_MAPPING = Map.of(
+            '2', "abc",
+            '3', "def",
+            '4', "ghi",
+            '5', "jkl",
+            '6', "mno",
+            '7', "pqrs",
+            '8', "tuv",
+            '9', "wxyz"
+    );
+
+    public List<String> letterCombinations(String digits) {
+        List<String> result = new ArrayList<>();
+        letterCombinations(digits, 0, new StringBuilder(), result);
+        return result;
+    }
+
+    private void letterCombinations(String digits, int idx, StringBuilder sb, List<String> result) {
+        if (idx == digits.length()) {
+            if (!sb.isEmpty()) {
+                result.add(sb.toString());
+            }
+            return;
+        }
+        for (char c : DIGIT_TO_CHAR_MAPPING.get(digits.charAt(idx)).toCharArray()) {
+            sb.append(c);
+            letterCombinations(digits, idx + 1, sb, result);
+            sb.deleteCharAt(sb.length() - 1);
+        }
     }
-  }
 }
diff --git a/Medium/Lexicographical Numbers.java b/Medium/Lexicographical Numbers.java
index c0ccab5e..4476017b 100644
--- a/Medium/Lexicographical Numbers.java	
+++ b/Medium/Lexicographical Numbers.java	
@@ -1,19 +1,18 @@
 class Solution {
-  public List<Integer> lexicalOrder(int n) {
-    List<Integer> result = new ArrayList<>();
-    for (int i = 1; i < 10; i++) {
-      dfs(i, n, result);
+    public List<Integer> lexicalOrder(int n) {
+        List<Integer> result = new ArrayList<>();
+        int curr = 1;
+        for (int i = 0; i < n; i++) {
+            result.add(curr);
+            if (curr * 10 <= n) {
+                curr *= 10;
+            } else {
+                while (curr % 10 == 9 || curr == n) {
+                    curr /= 10;
+                }
+                curr++;
+            }
+        }
+        return result;
     }
-    return result;
-  }
-  
-  private void dfs(int curr, int n, List<Integer> result) {
-    if (curr > n) {
-      return;
-    }
-    result.add(curr);
-    for (int i = 0; i < 10; i++) {
-      dfs(10 * curr + i, n, result);
-    }
-  }
 }
diff --git a/Medium/Lexicographically Minimum String After Removing Stars.java b/Medium/Lexicographically Minimum String After Removing Stars.java
new file mode 100644
index 00000000..794ee712
--- /dev/null
+++ b/Medium/Lexicographically Minimum String After Removing Stars.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public String clearStars(String s) {
+        Deque<Integer>[] count = new Deque[26];
+        for (int i = 0; i < 26; i++) {
+            count[i] = new ArrayDeque<>();
+        }
+        char[] letters = s.toCharArray();
+        for (int i = 0; i < letters.length; i++) {
+            if (letters[i] != '*') {
+                count[letters[i] - 'a'].push(i);
+            } else {
+                for (int j = 0; j < 26; j++) {
+                    if (!count[j].isEmpty()) {
+                        letters[count[j].pop()] = '*';
+                        break;
+                    }
+                }
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for (char c : letters) {
+            if (c != '*') {
+                sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+}
diff --git a/Medium/Lexicographically Smallest Equivalent String.java b/Medium/Lexicographically Smallest Equivalent String.java
index c5856615..f4d01c21 100644
--- a/Medium/Lexicographically Smallest Equivalent String.java	
+++ b/Medium/Lexicographically Smallest Equivalent String.java	
@@ -1,31 +1,46 @@
 class Solution {
-  public String smallestEquivalentString(String s1, String s2, String baseStr) {
-    int[] graph = new int[26];
-    for (int i = 0; i < 26; i++) {
-      graph[i] = i;
+    public String smallestEquivalentString(String s1, String s2, String baseStr) {
+        UnionFind unionFind = new UnionFind(26);
+        for (int i = 0; i < s1.length(); i++) {
+            char c1 = s1.charAt(i);
+            char c2 = s2.charAt(i);
+            unionFind.union(c1 - 'a', c2 - 'a');
+        }
+        StringBuilder result = new StringBuilder();
+        for (char c : baseStr.toCharArray()) {
+            result.append((char) (unionFind.find(c - 'a') + 'a'));
+        }
+        return result.toString();
     }
-    for (int i = 0; i < s1.length(); i++) {
-      int idxOne = s1.charAt(i) - 'a';
-      int idxTwo = s2.charAt(i) - 'a';
-      int parentOne = find(graph, idxOne);
-      int parentTwo = find(graph, idxTwo);
-      if(parentOne < parentTwo) {
-        graph[parentTwo] = parentOne;
-      } else {
-        graph[parentOne] = parentTwo;
-      }
+
+    class UnionFind {
+        private int[] parent;
+
+        public UnionFind(int n) {
+            parent = new int[n];
+            for (int i = 0; i < n; i++) {
+                parent[i] = i;
+            }
+        }
+
+        public int find(int node) {
+            if (parent[node] == node) {
+                return node;
+            }
+            parent[node] = find(parent[node]);
+            return parent[node];
+        }
+
+        public void union(int nodeOne, int nodeTwo) {
+            int parentOne = find(nodeOne);
+            int parentTwo = find(nodeTwo);
+            if (parentOne != parentTwo) {
+                if (parentOne < parentTwo) {
+                    parent[parentTwo] = parentOne;
+                } else {
+                    parent[parentOne] = parentTwo;
+                }
+            }
+        }
     }
-    StringBuilder sb = new StringBuilder();
-    for (char c : baseStr.toCharArray()) {
-      sb.append((char) ('a' + find(graph, c - 'a')));
-    }
-    return sb.toString();
-  }
-  
-  private int find(int[] graph, int idx) {
-    while(graph[idx] != idx) {
-      idx = graph[idx];
-    }
-    return idx;
-  }
 }
diff --git a/Medium/Lexicographically Smallest String After Substring Operation.java b/Medium/Lexicographically Smallest String After Substring Operation.java
new file mode 100644
index 00000000..e55990b7
--- /dev/null
+++ b/Medium/Lexicographically Smallest String After Substring Operation.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public String smallestString(String s) {
+        StringBuilder sb = new StringBuilder();
+        int idx = 0;
+        while (idx < s.length() && s.charAt(idx) == 'a') {
+            sb.append(s.charAt(idx++));
+        }
+        if (idx == s.length()) {
+            return s.substring(0, s.length() - 1) + 'z';
+        }
+        while (idx < s.length() && s.charAt(idx) != 'a') {
+            sb.append(getPreviousChar(s.charAt(idx++)));
+        }
+        return sb.append(s.substring(idx)).toString();
+    }
+    
+    private char getPreviousChar(char c) {
+        return (char) (c - 1);
+    }
+}
diff --git a/Medium/Linked List Cycle II.java b/Medium/Linked List Cycle II.java
index 42ba6ee8..2a88b1b4 100644
--- a/Medium/Linked List Cycle II.java	
+++ b/Medium/Linked List Cycle II.java	
@@ -10,24 +10,24 @@
  * }
  */
 public class Solution {
-  public ListNode detectCycle(ListNode head) {
-    ListNode fast = head;
-    ListNode slow = head;
-    while (fast != null && fast.next != null) {
-      slow = slow.next;
-      fast = fast.next.next;
-      if (slow == fast) {
-        break;
-      }
+    public ListNode detectCycle(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+            if (slow == fast) {
+                break;
+            }
+        }
+        if (fast == null || fast.next == null) {
+            return null;
+        }
+        ListNode curr = head;
+        while (curr != slow) {
+            curr = curr.next;
+            slow = slow.next;
+        }
+        return curr;
     }
-    if (fast == null || fast.next == null) {
-      return null;
-    }
-    slow = head;
-    while (slow != fast) {
-      slow = slow.next;
-      fast = fast.next;
-    }
-    return slow;
-  }
 }
diff --git a/Medium/Linked List Frequency.java b/Medium/Linked List Frequency.java
new file mode 100644
index 00000000..1c5a1739
--- /dev/null
+++ b/Medium/Linked List Frequency.java	
@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode frequenciesOfElements(ListNode head) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (ListNode curr = head; curr != null; curr = curr.next) {
+            map.put(curr.val, map.getOrDefault(curr.val, 0) + 1);
+        }
+        ListNode dummy = new ListNode(-1);
+        ListNode curr = dummy;
+        for (Integer key : map.keySet()) {
+            curr.next = new ListNode(map.get(key));
+            curr = curr.next;
+        }
+        return dummy.next;
+    }
+}
diff --git a/Medium/Longest Arithmetic Subsequence of Given Difference.java b/Medium/Longest Arithmetic Subsequence of Given Difference.java
new file mode 100644
index 00000000..ef48493e
--- /dev/null
+++ b/Medium/Longest Arithmetic Subsequence of Given Difference.java	
@@ -0,0 +1,12 @@
+class Solution {
+    public int longestSubsequence(int[] arr, int difference) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int maxValue = 0;
+        for (int num : arr) {
+            int endingSubLength = map.getOrDefault(num - difference, 0);
+            map.put(num, endingSubLength + 1);
+            maxValue = Math.max(maxValue, map.get(num));
+        }
+        return maxValue;
+    }
+}
diff --git a/Medium/Longest Arithmetic Subsequence.java b/Medium/Longest Arithmetic Subsequence.java
index 70544ee4..67a7fbb6 100644
--- a/Medium/Longest Arithmetic Subsequence.java	
+++ b/Medium/Longest Arithmetic Subsequence.java	
@@ -1,15 +1,15 @@
 class Solution {
-  public int longestArithSeqLength(int[] nums) {
-    int result = 2;
-    Map<Integer, Integer>[] dp = new HashMap[nums.length];
-    for (int i = 0; i < nums.length; i++) {
-      dp[i] = new HashMap<>();
-      for (int j = 0; j < i; j++) {
-        int diff = nums[i] - nums[j];
-        dp[i].put(diff, dp[j].getOrDefault(diff, 1) + 1);
-        result = Math.max(result, dp[i].get(diff));
-      }
+    public int longestArithSeqLength(int[] nums) {
+        int result = 0;
+        Map<Integer, Integer>[] dp = new HashMap[nums.length];
+        for (int i = 0; i < nums.length; i++) {
+            dp[i] = new HashMap<>();
+            for (int j = 0; j < i; j++) {
+                int diff = nums[j] - nums[i];
+                dp[i].put(diff, dp[j].getOrDefault(diff, 1) + 1);
+                result = Math.max(result, dp[i].get(diff));
+            }
+        }
+        return result;
     }
-    return result;
-  }
 }
diff --git a/Medium/Longest Common Subsequence Between Sorted Arrays.java b/Medium/Longest Common Subsequence Between Sorted Arrays.java
new file mode 100644
index 00000000..d050d3fd
--- /dev/null
+++ b/Medium/Longest Common Subsequence Between Sorted Arrays.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public List<Integer> longestCommonSubsequence(int[][] arrays) {
+        List<Integer> result = new ArrayList<>();
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int[] arr : arrays) {
+            for (int num : arr) {
+                map.put(num, map.getOrDefault(num, 0) + 1);
+                if (map.get(num) == arrays.length) {
+                    result.add(num);
+                }
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Longest Common Subsequence.java b/Medium/Longest Common Subsequence.java
new file mode 100644
index 00000000..43fc5464
--- /dev/null
+++ b/Medium/Longest Common Subsequence.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int longestCommonSubsequence(String text1, String text2) {
+        int n = text1.length();
+        int m = text2.length();
+        int[][] dp = new int[n + 1][m + 1];
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (text1.charAt(i) == text2.charAt(j)) {
+                    dp[i + 1][j + 1] = 1 + dp[i][j];
+                } else {
+                    dp[i + 1][j + 1] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+                }
+            }
+        }
+        return dp[n][m];
+    }
+}
diff --git a/Medium/Longest Happy String.java b/Medium/Longest Happy String.java
index 145fd638..4af8f747 100644
--- a/Medium/Longest Happy String.java	
+++ b/Medium/Longest Happy String.java	
@@ -1,42 +1,42 @@
 class Solution {
-  public String longestDiverseString(int a, int b, int c) {
-    PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((o1, o2) -> o2[1] - o1[1]);
-    if (a > 0) {
-      priorityQueue.add(new int[]{0, a});
-    }
-    if (b > 0) {
-      priorityQueue.add(new int[]{1, b});
-    }
-    if (c > 0) {
-      priorityQueue.add(new int[]{2, c});
-    }
-    StringBuilder sb = new StringBuilder("zz");
-    while (!priorityQueue.isEmpty()) {
-      int[] temp = {-1, -1};
-      char peekChar = (char) ('a' + priorityQueue.peek()[0]);
-      if (peekChar == sb.charAt(sb.length() - 1) && 
-          peekChar == sb.charAt(sb.length() - 2)) {
-        temp[0] = priorityQueue.peek()[0];
-        temp[1] = priorityQueue.peek()[1];
-        priorityQueue.poll();
-        if (priorityQueue.isEmpty()) {
-          break;
+    public String longestDiverseString(int a, int b, int c) {
+        PriorityQueue<LetterFrequencyPair> pq =
+                new PriorityQueue<>((p, q) -> q.frequency() - p.frequency());
+        if (a > 0) {
+            pq.add(new LetterFrequencyPair('a', a));
+        }
+        if (b > 0) {
+            pq.add(new LetterFrequencyPair('b', b));
+        }
+        if (c > 0) {
+            pq.add(new LetterFrequencyPair('c', c));
         }
-      }
-      peekChar = (char) ('a' + priorityQueue.peek()[0]);
-      if (peekChar != sb.charAt(sb.length() - 1) || 
-          peekChar != sb.charAt(sb.length() - 2)) {
-        int[] removed = priorityQueue.poll();
-        sb.append(peekChar);
-        removed[1]--;
-        if (removed[1] > 0) {
-          priorityQueue.add(removed);
+        StringBuilder sb = new StringBuilder();
+        while (!pq.isEmpty()) {
+            LetterFrequencyPair removed = pq.remove();
+            int frequency = removed.frequency();
+            int resultLength = sb.length();
+            if (resultLength >= 2 &&
+                    sb.charAt(resultLength - 1) == removed.letter() &&
+                    sb.charAt(resultLength - 2) == removed.letter()) {
+                if (pq.isEmpty()) {
+                    break;
+                }
+                LetterFrequencyPair temp = pq.remove();
+                sb.append(temp.letter());
+                if (temp.frequency() - 1 > 0) {
+                    pq.add(new LetterFrequencyPair(temp.letter(), temp.frequency() - 1));
+                }
+            } else {
+                sb.append(removed.letter());
+                frequency--;
+            }
+            if (frequency > 0) {
+                pq.add(new LetterFrequencyPair(removed.letter(), frequency));
+            }
         }
-      }
-      if (temp[0] != -1) {
-        priorityQueue.add(temp);
-      }
+        return sb.toString();
     }
-    return sb.substring(2).toString();
-  }
+
+    private record LetterFrequencyPair(char letter, int frequency) {}
 }
diff --git a/Medium/Longest Increasing Subsequence.java b/Medium/Longest Increasing Subsequence.java
index a4607634..b56c14ef 100644
--- a/Medium/Longest Increasing Subsequence.java	
+++ b/Medium/Longest Increasing Subsequence.java	
@@ -1,19 +1,18 @@
 class Solution {
-  public int lengthOfLIS(int[] nums) {
-    List<Integer> subsequence = new ArrayList<>();
-    subsequence.add(nums[0]);
-    for (int i = 1; i < nums.length; i++) {
-      int currNum = nums[i];
-      if (currNum > subsequence.get(subsequence.size() - 1)) {
-        subsequence.add(currNum);
-      } else {
-        int idx = 0;
-        while (currNum > subsequence.get(idx)) {
-          idx++;
+    public int lengthOfLIS(int[] nums) {
+        List<Integer> subsequence = new ArrayList<>();
+        subsequence.add(nums[0]);
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] > subsequence.get(subsequence.size() - 1)) {
+                subsequence.add(nums[i]);
+            } else {
+                int idx = 0;
+                while (nums[i] > subsequence.get(idx)) {
+                    idx++;
+                }
+                subsequence.set(idx, nums[i]);
+            }
         }
-        subsequence.set(idx, currNum);
-      }
+        return subsequence.size();
     }
-    return subsequence.size();
-  }
 }
diff --git a/Medium/Longest Palindromic Subsequence.java b/Medium/Longest Palindromic Subsequence.java
index 5d9d4dfd..85c6c5e7 100644
--- a/Medium/Longest Palindromic Subsequence.java	
+++ b/Medium/Longest Palindromic Subsequence.java	
@@ -1,34 +1,25 @@
 class Solution {
     public int longestPalindromeSubseq(String s) {
-        int[][] temp = new int[s.length()][s.length()];
-        for(int i=0;i<s.length();i++) {
-            temp[i][i] = 1;
+        int n = s.length();
+        int[][] dp = new int[n][n];
+        return helper(s, 0, n - 1, dp);
+    }
+    
+    private int helper(String s, int startIdx, int endIdx, int[][] dp) {
+        if (dp[startIdx][endIdx] != 0) {
+            return dp[startIdx][endIdx];
+        }
+        if (startIdx > endIdx) {
+            return 0;
         }
-        
-        int j;
-        
-        for (int cl=2;cl <= s.length();cl++) {
-            for (int i=0;i<s.length()-cl+1;i++) {
-                j = i + cl - 1;
-                if (s.charAt(i) == s.charAt(j) && cl == 2)
-                   temp[i][j] = 2;
-                else if (s.charAt(i) == s.charAt(j))
-                   temp[i][j] = temp[i+1][j-1] + 2;
-                else
-                   temp[i][j] = Math.max(temp[i][j-1], temp[i+1][j]);
-            }
+        if (startIdx == endIdx) {
+            return 1;
         }
-        
-        return temp[0][s.length()-1];
+        if (s.charAt(startIdx) == s.charAt(endIdx)) {
+            dp[startIdx][endIdx] = helper(s, startIdx + 1, endIdx - 1, dp) + 2;
+        } else {
+            dp[startIdx][endIdx] = Math.max(helper(s, startIdx + 1, endIdx, dp), helper(s, startIdx, endIdx - 1, dp));
+        }
+        return dp[startIdx][endIdx];
     }
-    
-//     public int longestPalindromeSubseq(String s, int l, int len) {
-//         if (len == 1) return 1;
-//         if (len == 0) return 0;
-        
-//         if (s.charAt(l) == s.charAt(l+len-1)) return 2 + longestPalindromeSubseq(s, l+1, len-2);
-//         else {
-//             return Math.max(longestPalindromeSubseq(s,l+1,len-1), longestPalindromeSubseq(s,l, len-1));
-//         }
-//     }
 }
diff --git a/Medium/Longest Palindromic Substring.java b/Medium/Longest Palindromic Substring.java
index c22fec2d..73732212 100644
--- a/Medium/Longest Palindromic Substring.java	
+++ b/Medium/Longest Palindromic Substring.java	
@@ -1,24 +1,28 @@
 class Solution {
-  public String longestPalindrome(String s) {
-    int start = 0;
-    int end = 0;
-    for (int i = 0; i < s.length(); i++) {
-      int lenOne = helper(s, i, i);
-      int lenTwo = helper(s, i, i + 1);
-      int maxLength = Math.max(lenOne, lenTwo);
-      if (maxLength > end - start) {
-        start = i - (maxLength - 1) / 2;
-        end = i + maxLength / 2;
-      }
+    public String longestPalindrome(String s) {
+        int n = s.length();
+        boolean[][] dp = new boolean[n][n];
+        int[] result = new int[]{0, 0};
+        for (int i = 0; i < n; i++) {
+            dp[i][i] = true;
+        }
+        for (int i = 0; i < n - 1; i++) {
+            if (s.charAt(i) == s.charAt(i + 1)) {
+                dp[i][i + 1] = true;
+                result[0] = i;
+                result[1] = i + 1;
+            }
+        }
+        for (int i = 2; i < n; i++) {
+            for (int j = 0; j < n - i; j++) {
+                int k = i + j;
+                if (s.charAt(j) == s.charAt(k) && dp[j + 1][k - 1]) {
+                    dp[j][k] = true;
+                    result[0] = j;
+                    result[1] = k;
+                }
+            }
+        }
+        return s.substring(result[0], result[1] + 1);
     }
-    return s.substring(start, end + 1);
-  }
-  
-  private int helper(String s, int left, int right) {
-    while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
-      left--;
-      right++;
-    }
-    return right - left - 1;
-  }
 }
diff --git a/Medium/Longest Square Streak in an Array.java b/Medium/Longest Square Streak in an Array.java
new file mode 100644
index 00000000..141abdee
--- /dev/null
+++ b/Medium/Longest Square Streak in an Array.java	
@@ -0,0 +1,25 @@
+class Solution {
+
+    private static final int LIMIT = 100_000;
+
+    public int longestSquareStreak(int[] nums) {
+        Set<Integer> uniqueNums = new HashSet<>();
+        for (int num : nums) {
+            uniqueNums.add(num);
+        }
+        int result = 0;
+        for (int num : nums) {
+            int currStreak = 0;
+            long curr = num;
+            while (uniqueNums.contains((int) curr)) {
+                currStreak++;
+                if (curr * curr > LIMIT) {
+                    break;
+                }
+                curr *= curr;
+            }
+            result = Math.max(result, currStreak);
+        }
+        return result < 2 ? -1 : result;
+    }
+}
diff --git a/Medium/Longest String Chain.java b/Medium/Longest String Chain.java
index 17d14f0c..5c36ef9d 100644
--- a/Medium/Longest String Chain.java	
+++ b/Medium/Longest String Chain.java	
@@ -1,29 +1,31 @@
 class Solution {
-  public int longestStrChain(String[] words) {
-    Map<String, Integer> dp = new HashMap<>();
-    Set<String> wordSet = Arrays.stream(words).collect(Collectors.toSet());
-    int maxLength = 0;
-    for (String word : words) {
-      maxLength = Math.max(maxLength, dfs(wordSet, dp, word));
+    public int longestStrChain(String[] words) {
+        Set<String> wordSet = Arrays.stream(words)
+        .collect(Collectors.toSet());
+        Map<String, Integer> memo = new HashMap<>();
+        int result = 0;
+        for (String word : words) {
+            result = Math.max(result, dfs(wordSet, memo, word));
+        }
+        return result;
     }
-    return maxLength;
-  }
-  
-  private int dfs(Set<String> wordSet, Map<String, Integer> dp, String currWord) {
-    if (dp.containsKey(currWord)) {
-      return dp.get(currWord);
+
+    private int dfs(Set<String> wordSet, Map<String, Integer> memo, String word) {
+        if (memo.containsKey(word)) {
+            return memo.get(word);
+        }
+        int maxLength = 1;
+        StringBuilder sb = new StringBuilder(word);
+        for (int i = 0; i < word.length(); i++) {
+            sb.deleteCharAt(i);
+            String newWord = sb.toString();
+            if (wordSet.contains(newWord)) {
+                int currLength = 1 + dfs(wordSet, memo, newWord);
+                maxLength = Math.max(maxLength, currLength);
+            }
+            sb.insert(i, word.charAt(i));
+        }
+        memo.put(word, maxLength);
+        return maxLength;
     }
-    int maxLength = 1;
-    StringBuilder sb = new StringBuilder(currWord);
-    for (int i = 0; i < currWord.length(); i++) {
-      sb.deleteCharAt(i);
-      String newWord = sb.toString();
-      if (wordSet.contains(newWord)) {
-        maxLength = Math.max(maxLength, 1 + dfs(wordSet, dp, newWord));
-      }
-      sb.insert(i, currWord.charAt(i));
-    }
-    dp.put(currWord, maxLength);
-    return dp.get(currWord);
-  }
 }
diff --git a/Medium/Longest Subarray With Maximum Bitwise AND.java b/Medium/Longest Subarray With Maximum Bitwise AND.java
new file mode 100644
index 00000000..63c1ca55
--- /dev/null
+++ b/Medium/Longest Subarray With Maximum Bitwise AND.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int longestSubarray(int[] nums) {
+        int result = 0;
+        int max = 0;
+        int count = 0;
+        for (int num : nums) {
+            if (max < num) {
+                max = num;
+                result = count = 0;
+            }
+            if (max == num) {
+                count++;
+            } else {
+                count = 0;
+            }
+            result = Math.max(result, count);
+        }
+        return result;
+    }
+}
diff --git a/Medium/Longest Subarray of 1's After Deleting One Element.java b/Medium/Longest Subarray of 1's After Deleting One Element.java
new file mode 100644
index 00000000..b10a1675
--- /dev/null
+++ b/Medium/Longest Subarray of 1's After Deleting One Element.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int longestSubarray(int[] nums) {
+        int zeroIdx = -1;
+        int windowSize = 0;
+        int startIdx = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] == 0) {
+                startIdx = zeroIdx + 1;
+                zeroIdx = i;
+            }
+            windowSize = Math.max(windowSize, i - startIdx);
+        }
+        return windowSize;
+    }
+}
diff --git a/Medium/Longest Substring with At Most K Distinct Characters.java b/Medium/Longest Substring with At Most K Distinct Characters.java
index 02936a53..a793b8c0 100644
--- a/Medium/Longest Substring with At Most K Distinct Characters.java	
+++ b/Medium/Longest Substring with At Most K Distinct Characters.java	
@@ -1,21 +1,21 @@
 class Solution {
-  public int lengthOfLongestSubstringKDistinct(String s, int k) {
-    Map<Character, Integer> map = new HashMap<>();
-    int startIdx = 0;
-    int endIdx = 0;
-    int maxLength = 0;
-    while (endIdx < s.length()) {
-      map.put(s.charAt(endIdx), map.getOrDefault(s.charAt(endIdx), 0) + 1);
-      endIdx++;
-      while (startIdx < endIdx && map.size() > k) {
-        map.put(s.charAt(startIdx), map.getOrDefault(s.charAt(startIdx), 0 ) - 1);
-        if (map.get(s.charAt(startIdx))  == 0) {
-          map.remove(s.charAt(startIdx));
+    public int lengthOfLongestSubstringKDistinct(String s, int k) {
+        Map<Character, Integer> map = new HashMap<>();
+        int start = 0;
+        int end = 0;
+        int maxLength = 0;
+        while (end < s.length()) {
+            map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
+            while (start <= end && map.size() > k) {
+                map.put(s.charAt(start), map.get(s.charAt(start)) - 1);
+                if (map.get(s.charAt(start)) == 0) {
+                    map.remove(s.charAt(start));
+                }
+                start++;
+            }
+            end++;
+            maxLength = Math.max(maxLength, end - start);
         }
-        startIdx++;
-      }
-      maxLength = Math.max(maxLength, endIdx - startIdx);
+        return maxLength;
     }
-    return maxLength;
-  }
 }
diff --git a/Medium/Longest Substring with At Most Two Distinct Characters.java b/Medium/Longest Substring with At Most Two Distinct Characters.java
index 2af3a613..04f60a83 100644
--- a/Medium/Longest Substring with At Most Two Distinct Characters.java	
+++ b/Medium/Longest Substring with At Most Two Distinct Characters.java	
@@ -1,22 +1,22 @@
 class Solution {
-  public int lengthOfLongestSubstringTwoDistinct(String s) {
-    Map<Character, Integer> map = new HashMap<>();
-    int startIdx = 0;
-    int endIdx = 0;
-    int n = s.length();
-    int maxLength = 0;
-    while (endIdx < n) {
-      map.put(s.charAt(endIdx), map.getOrDefault(s.charAt(endIdx), 0) + 1);
-      while (startIdx < endIdx && map.size() > 2) {
-        map.put(s.charAt(startIdx), map.getOrDefault(s.charAt(startIdx), 0) - 1);
-        if (map.get(s.charAt(startIdx)) <= 0) {
-          map.remove(s.charAt(startIdx));
+    public int lengthOfLongestSubstringTwoDistinct(String s) {
+        int max = 0;
+        int start = 0;
+        int end = 0;
+        int n = s.length();
+        Map<Character, Integer> map = new HashMap<>();
+        while (end < n) {
+            map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
+            end++;
+            while (start < end && map.size() > 2) {
+                map.put(s.charAt(start), map.getOrDefault(s.charAt(start), 0) - 1);
+                if (map.get(s.charAt(start)) == 0) {
+                    map.remove(s.charAt(start));
+                }
+                start++;
+            }
+            max = Math.max(max, end - start);
         }
-        startIdx++;
-      }
-      endIdx++;
-      maxLength = Math.max(endIdx - startIdx, maxLength);
+        return max;
     }
-    return maxLength;
-  }
 }
diff --git a/Medium/Longest Word With All Prefixes.java b/Medium/Longest Word With All Prefixes.java
index 567aea3a..a2a69a0f 100644
--- a/Medium/Longest Word With All Prefixes.java	
+++ b/Medium/Longest Word With All Prefixes.java	
@@ -1,53 +1,59 @@
 class Solution {
-  public String longestWord(String[] words) {
-    TrieNode root = new TrieNode();
-    root.isWord = true;
-    Map<Integer, PriorityQueue<String>> map = new TreeMap<>((o1, o2) -> o2 - o1);
-    for (String word : words) {
-      addToTrie(word, root);
-      map.computeIfAbsent(word.length(), k -> new PriorityQueue<>(String::compareTo)).add(word);
-    }
-    for (Integer key : map.keySet()) {
-      PriorityQueue<String> priorityQueue = map.get(key);
-      while (!priorityQueue.isEmpty()) {
-        String candidateWord = priorityQueue.poll();
-        if (wordContainAllPrefixes(candidateWord, root)) {
-          return candidateWord;
+    public String longestWord(String[] words) {
+        TrieNode root = new TrieNode();
+        for (String word : words) {
+            root.insert(word);
+        }
+        String longestValidWord = "";
+        for (String word : words) {
+            if (root.hasAllPrefixes(word)) {
+                if (word.length() > longestValidWord.length() || 
+                    (word.length() == longestValidWord.length() && word.compareTo(longestValidWord) < 0)) {
+                    longestValidWord = word;
+                }
+            }
         }
-      }
+        return longestValidWord;
     }
-    return "";
-  }
 
-  private boolean wordContainAllPrefixes(String word, TrieNode root) {
-    TrieNode curr = root;
-    for (int i = 0; i < word.length(); i++) {
-      if (!curr.isWord) {
-        return false;
-      }
-      curr = curr.children.get(word.charAt(i));
-    }
-    return curr.isWord;
-  }
+    static class TrieNode {
+        private final Map<Character, TrieNode> children;
+        private boolean isWord;
 
-  private void addToTrie(String word, TrieNode root) {
-    TrieNode curr = root;
-    for (int i = 0; i < word.length(); i++) {
-      if (!curr.children.containsKey(word.charAt(i))) {
-        curr.children.put(word.charAt(i), new TrieNode());
-      }
-      curr = curr.children.get(word.charAt(i));
-    }
-    curr.isWord = true;
-  }
+        public TrieNode() {
+            this.children = new HashMap<>();
+        }
 
-  private static class TrieNode {
-    Map<Character, TrieNode> children;
-    boolean isWord;
+        public void insert(String word) {
+            TrieNode curr = this;
+            for (char c : word.toCharArray()) {
+                curr = curr.getOrCreateChild(c);
+            }
+            curr.isWord = true;
+        }
+
+        public boolean hasAllPrefixes(String word) {
+            TrieNode curr = this;
+            for (char c : word.toCharArray()) {
+                TrieNode child = curr.children.getOrDefault(c, null);
+                if (child == null) {
+                    return false;
+                }       
+                if (!child.isWord) {
+                    return false;
+                }
+                curr = child;
+            }
+            return true;
+        }
 
-    public TrieNode() {
-      this.children = new HashMap<>();
-      this.isWord = false;
+        private TrieNode getOrCreateChild(char c) {
+            if (children.containsKey(c)) {
+                return children.get(c);
+            }
+            TrieNode node = new TrieNode();
+            children.put(c, node);
+            return node;
+        }
     }
-  }
 }
diff --git a/Medium/Longest ZigZag Path in a Binary Tree.java b/Medium/Longest ZigZag Path in a Binary Tree.java
index bdc3e8f9..71e32231 100644
--- a/Medium/Longest ZigZag Path in a Binary Tree.java	
+++ b/Medium/Longest ZigZag Path in a Binary Tree.java	
@@ -4,33 +4,39 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  int max;
-  public int longestZigZag(TreeNode root) {
-    if (root == null) {
-      return -1;
+    
+    private enum DIRECTION {
+        LEFT, RIGHT;
     }
-    max = 0;
-    helper(root.right, 1, true);
-    helper(root.left, 1, false);
-    return max;
-  } 
-  
-  private void helper(TreeNode root, int step, boolean isRight) {
-    if (root == null) {
-      return;
+    
+    public int longestZigZag(TreeNode root) {
+        int[] pathLength = {0};
+        dfs(root, DIRECTION.LEFT, 0, pathLength);
+        dfs(root, DIRECTION.RIGHT, 0, pathLength);
+        return pathLength[0];
     }
-    max = Math.max(max, step);
-    if (isRight) {
-      helper(root.left, step + 1, false);
-      helper(root.right, 1, true);
+    
+    private void dfs(TreeNode node, DIRECTION direction, int steps, int[] pathLength) {
+        if (node == null) {
+            return;
+        }
+        pathLength[0] = Math.max(pathLength[0], steps);
+        if (direction == DIRECTION.LEFT) {
+            dfs(node.left, DIRECTION.RIGHT, steps + 1, pathLength);
+            dfs(node.right, DIRECTION.LEFT, 1, pathLength);
+        } else {
+            dfs(node.left, DIRECTION.RIGHT, 1, pathLength);
+            dfs(node.right, DIRECTION.LEFT, steps + 1, pathLength);
+        }
     }
-    else {
-      helper(root.right, step + 1, true);
-      helper(root.left, 1, false);
-    }
-  }
 }
diff --git a/Medium/Lowest Common Ancestor of a Binary Tree II.java b/Medium/Lowest Common Ancestor of a Binary Tree II.java
new file mode 100644
index 00000000..be4c28d2
--- /dev/null
+++ b/Medium/Lowest Common Ancestor of a Binary Tree II.java	
@@ -0,0 +1,46 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        TreeNode result = lca(root, p, q);
+        if (result == p) {
+            return checkIfNodeExist(p, q) ? p : null;
+        }
+        if (result == q) {
+            return checkIfNodeExist(q, p) ? q : null;
+        }
+        return result;
+    }
+    
+    private boolean checkIfNodeExist(TreeNode root, TreeNode target) {
+        if (root == target) {
+            return true;
+        }
+        if (root == null) {
+            return false;
+        }
+        return checkIfNodeExist(root.left, target) || checkIfNodeExist(root.right, target);
+    }
+    
+    private TreeNode lca(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null) {
+            return root;
+        }
+        if (root == p || root == q) {
+            return root;
+        }
+        TreeNode left = lca(root.left, p, q);
+        TreeNode right = lca(root.right, p, q);
+        if (left != null && right != null) {
+            return root;
+        }
+        return left != null ? left : right;
+    }
+}
diff --git a/Medium/Lowest Common Ancestor of a Binary Tree III.java b/Medium/Lowest Common Ancestor of a Binary Tree III.java
index 26269fcc..098b0f86 100644
--- a/Medium/Lowest Common Ancestor of a Binary Tree III.java	
+++ b/Medium/Lowest Common Ancestor of a Binary Tree III.java	
@@ -9,30 +9,30 @@ class Node {
 */
 
 class Solution {
-  public Node lowestCommonAncestor(Node p, Node q) {
-    int pDepth = getDepth(p);
-    int qDepth = getDepth(q);
-    while (pDepth > qDepth) {
-      pDepth--;
-      p = p.parent;
+    public Node lowestCommonAncestor(Node p, Node q) {
+        int pDepth = getDepth(p);
+        int qDepth = getDepth(q);
+        while (pDepth > qDepth) {
+            pDepth--;
+            p = p.parent;
+        }
+        while (qDepth > pDepth) {
+            qDepth--;
+            q = q.parent;
+        }
+        while (p != q) {
+            p = p.parent;
+            q = q.parent;
+        }
+        return p;
     }
-    while (pDepth < qDepth) {
-      qDepth--;
-      q = q.parent;
-    }
-    while (p != q) {
-      p = p.parent;
-      q = q.parent;
-    }
-    return p;
-  }
-  
-  private int getDepth(Node node) {
-    int depth = 0;
-    while (node != null) {
-      depth++;
-      node = node.parent;
+
+    private int getDepth(Node node) {
+        int depth = 0;
+        while (node != null) {
+            depth++;
+            node = node.parent;
+        }
+        return depth;
     }
-    return depth;
-  }
 }
diff --git a/Medium/Lowest Common Ancestor of a Binary Tree.java b/Medium/Lowest Common Ancestor of a Binary Tree.java
index b49de19a..890c71e6 100644
--- a/Medium/Lowest Common Ancestor of a Binary Tree.java	
+++ b/Medium/Lowest Common Ancestor of a Binary Tree.java	
@@ -8,15 +8,21 @@
  * }
  */
 class Solution {
-  public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
-    if (root == null || root == p || root == q) {
-      return root;
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if (root == null) {
+            return null;
+        }
+        if (root == p || root == q) {
+            return root;
+        }
+        TreeNode left = lowestCommonAncestor(root.left, p, q);
+        TreeNode right = lowestCommonAncestor(root.right, p, q);
+        if (left != null && right != null) {
+            return root;
+        }
+        if (left != null || right != null) {
+            return left != null ? left : right;
+        }
+        return null;
     }
-    TreeNode leftRoot = lowestCommonAncestor(root.left, p, q);
-    TreeNode rightRoot = lowestCommonAncestor(root.right, p, q);
-    if (leftRoot != null && rightRoot != null) {
-      return root;
-    }
-    return leftRoot != null ? leftRoot : rightRoot;
-  }
 }
diff --git a/Medium/Magnetic Force Between Two Balls.java b/Medium/Magnetic Force Between Two Balls.java
new file mode 100644
index 00000000..9ca9708b
--- /dev/null
+++ b/Medium/Magnetic Force Between Two Balls.java	
@@ -0,0 +1,32 @@
+class Solution {
+    public int maxDistance(int[] position, int m) {
+        int result = 0;
+        int n = position.length;
+        Arrays.sort(position);
+        int left = 1;
+        int right = (int) Math.ceil(position[n - 1] / (m - 1.0));
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (isPossible(position, mid, m)) {
+                result = mid;
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return result;
+    }
+
+    private boolean isPossible(int[] position, int distance, int m) {
+        int prevBall = position[0];
+        int ballCount = 1;
+        for (int i = 1; i < position.length && ballCount < m; i++) {
+            int curr = position[i];
+            if (curr - prevBall >= distance) {
+                ballCount++;
+                prevBall = curr;
+            }
+        }
+        return ballCount == m;
+    }
+}
diff --git a/Medium/Majority Element II.java b/Medium/Majority Element II.java
index a44275b4..5b59752e 100644
--- a/Medium/Majority Element II.java	
+++ b/Medium/Majority Element II.java	
@@ -1,42 +1,43 @@
 class Solution {
-  public List<Integer> majorityElement(int[] nums) {
-    Integer majorityElementOne = null;
-    Integer majorityElementTwo = null;
-    int countOne = 0;
-    int countTwo = 0;
-    for (int num : nums) {
-      if (majorityElementOne != null && num == majorityElementOne) {
-        countOne++;
-      } else if (majorityElementTwo != null && num == majorityElementTwo) {
-        countTwo++;
-      } else if (countOne == 0) {
-        majorityElementOne = num;
-        countOne = 1;
-      } else if (countTwo == 0) {
-        majorityElementTwo = num;
-        countTwo = 1;
-      } else {
-        countOne--;
-        countTwo--;
-      }
+    public List<Integer> majorityElement(int[] nums) {
+        Integer candidateOne = null;
+        Integer candidateTwo = null;
+        int countOne = 0;
+        int countTwo = 0;
+        for (int num : nums) {
+            if (candidateOne != null && candidateOne == num) {
+                countOne++;
+            } else if (candidateTwo != null && candidateTwo == num) {
+                countTwo++;
+            } else if (countOne == 0) {
+                candidateOne = num;
+                countOne++;
+            } else if (countTwo == 0) {
+                candidateTwo = num;
+                countTwo++;
+            } else {
+                countOne--;
+                countTwo--;
+            }
+        }
+        countOne = 0;
+        countTwo = 0;
+        for (int num : nums) {
+            if (candidateOne != null && candidateOne == num) {
+                countOne++;
+            }
+            if (candidateTwo != null && candidateTwo == num) {
+                countTwo++;
+            }
+        }
+        int n = nums.length;
+        List<Integer> result = new ArrayList<>();
+        if (countOne > n / 3) {
+            result.add(candidateOne);
+        }
+        if (countTwo > n / 3) {
+            result.add(candidateTwo);
+        }
+        return result;
     }
-    List<Integer> result = new ArrayList<>();
-    countOne = 0;
-    countTwo = 0;
-    for (int num : nums) {
-      if (majorityElementOne != null && majorityElementOne == num) {
-        countOne++;
-      }
-      if (majorityElementTwo != null && majorityElementTwo == num) {
-        countTwo++;
-      }
-    }
-    if (countOne > nums.length / 3) {
-      result.add(majorityElementOne);
-    }
-    if (countTwo > nums.length / 3) {
-      result.add(majorityElementTwo);
-    }
-    return result;
-  }
 }
diff --git a/Medium/Make String a Subsequence Using Cyclic Increments.java b/Medium/Make String a Subsequence Using Cyclic Increments.java
new file mode 100644
index 00000000..1247a755
--- /dev/null
+++ b/Medium/Make String a Subsequence Using Cyclic Increments.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public boolean canMakeSubsequence(String str1, String str2) {
+        int idxOne = 0;
+        int idxTwo = 0;
+        while (idxOne < str1.length() && idxTwo < str2.length()) {
+            if (str1.charAt(idxOne) == str2.charAt(idxTwo) ||
+                nextCyclicChar(str1.charAt(idxOne)) == str2.charAt(idxTwo)) {
+                idxTwo++;
+            } 
+            idxOne++;
+        }
+        return idxTwo == str2.length();
+    }
+    
+    private static char nextCyclicChar(char c) {
+        return c == 'z' ? 'a' : (char) (c + 1);
+    }
+}
diff --git a/Medium/Make Sum Divisible by P.java b/Medium/Make Sum Divisible by P.java
new file mode 100644
index 00000000..ee94817a
--- /dev/null
+++ b/Medium/Make Sum Divisible by P.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int minSubarray(int[] nums, int p) {
+        int n = nums.length;
+        int sum = 0;
+        for (int num : nums) {
+            sum = (sum + num) % p;
+        }
+        int target = sum % p;
+        if (target == 0) {
+            return 0;
+        }
+        Map<Integer, Integer> map = new HashMap<>();
+        map.put(0, -1);
+        int currSum = 0;
+        int result = n; 
+        for (int i = 0; i < n; i++) {
+            currSum = (currSum + nums[i]) % p;
+            int needed = (currSum - target + p) % p;
+            if (map.containsKey(needed)) {
+                result = Math.min(result, i - map.get(needed));
+            }
+            map.put(currSum, i);
+        }
+        return result == n ? -1 : result;
+    }
+}
diff --git a/Medium/Max Consecutive Ones III.java b/Medium/Max Consecutive Ones III.java
new file mode 100644
index 00000000..cec14a87
--- /dev/null
+++ b/Medium/Max Consecutive Ones III.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public int longestOnes(int[] nums, int k) {
+        int start = 0;
+        int end = 0;
+        int flipped = 0;
+        int n = nums.length;
+        int max = 0;
+        while (end < nums.length) {
+            if (nums[end] == 0) {
+                flipped++;
+            }
+            end++;
+            while (start < end && flipped > k) {
+                if (nums[start] == 0) {
+                    flipped--;
+                }
+                start++;
+            }
+            max = Math.max(max, end - start);
+        }
+        return max;
+    }
+}
diff --git a/Medium/Max Sum of a Pair With Equal Sum of Digits.java b/Medium/Max Sum of a Pair With Equal Sum of Digits.java
index 597e0658..1d8d89ae 100644
--- a/Medium/Max Sum of a Pair With Equal Sum of Digits.java	
+++ b/Medium/Max Sum of a Pair With Equal Sum of Digits.java	
@@ -1,25 +1,25 @@
 class Solution {
-  public int maximumSum(int[] nums) {
-    int maxSum = -1;
-    Map<Integer, Integer> map = new HashMap<>();
-    for (int num : nums) {
-      int digitSum = getDigitSum(num);
-      if (map.containsKey(digitSum)) {
-        maxSum = Math.max(maxSum, map.get(digitSum) + num);
-        map.put(digitSum, Math.max(map.get(digitSum), num));
-      } else {
-        map.put(digitSum, num);
-      }
+    public int maximumSum(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int maxSum = -1;
+        for (int num : nums) {
+            int digitSum = calculateDigitSum(num);
+            if (map.containsKey(digitSum)) {
+                maxSum = Math.max(maxSum, map.get(digitSum) + num);
+                map.put(digitSum, Math.max(map.get(digitSum), num));
+            } else {
+                map.put(digitSum, num);
+            }
+        }
+        return maxSum;
     }
-    return maxSum;
-  }
-  
-  private int getDigitSum(int num) {
-    int sum = 0;
-    while (num > 0) {
-      sum += num % 10;
-      num /= 10;
+
+    private int calculateDigitSum(int num) {
+        int sum = 0;
+        while (num > 0) {
+            sum += num % 10;
+            num /= 10;
+        }
+        return sum;
     }
-    return sum;
-  }
 }
diff --git a/Medium/Maximal Network Rank.java b/Medium/Maximal Network Rank.java
index 211a7c8e..e5c3f20c 100644
--- a/Medium/Maximal Network Rank.java	
+++ b/Medium/Maximal Network Rank.java	
@@ -1,19 +1,21 @@
 class Solution {
-  public int maximalNetworkRank(int n, int[][] roads) {
-    boolean[][] connected = new boolean[n][n];
-    int[] count = new int[n];
-    for (int[] road : roads) {
-      count[road[0]]++;
-      count[road[1]]++;
-      connected[road[0]][road[1]] = true;
-      connected[road[1]][road[0]] = true;
+    public int maximalNetworkRank(int n, int[][] roads) {
+        Map<Integer, Set<Integer>> map = new HashMap<>();
+        for (int[] road : roads) {
+            map.computeIfAbsent(road[0], k -> new HashSet<>()).add(road[1]);
+            map.computeIfAbsent(road[1], k -> new HashSet<>()).add(road[0]);
+        }
+        int maximumRank = 0;
+        for (int i = 0; i < n; i++) {
+            int iRank = map.getOrDefault(i, new HashSet<>()).size();
+            for (int j = i + 1; j < n; j++) {
+                int combinedRank = iRank + map.getOrDefault(j, new HashSet<>()).size();
+                if (map.getOrDefault(j, new HashSet<>()).contains(i)) {
+                    combinedRank--;
+                }
+                maximumRank = Math.max(maximumRank, combinedRank);
+            }
+        }
+        return maximumRank;
     }
-    int maxCount = 0;
-    for (int i = 0; i < n; i++) {
-      for (int j = i + 1; j < n; j++) {
-        maxCount = Math.max(maxCount, count[i] + count[j] - (connected[i][j] ? 1 : 0));
-      }
-    }
-    return maxCount;
-  }
 }
diff --git a/Medium/Maximal Score After Applying K Operations.java b/Medium/Maximal Score After Applying K Operations.java
new file mode 100644
index 00000000..ca776caf
--- /dev/null
+++ b/Medium/Maximal Score After Applying K Operations.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public long maxKelements(int[] nums, int k) {
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        for (int num : nums) {
+            pq.add(num);
+        }
+        long sum = 0;
+        while (!pq.isEmpty() && k-- > 0) {
+            int removed = pq.poll();
+            sum += removed;
+            pq.add((int) Math.ceil(((double) removed) / 3));
+        }
+        return sum;
+    }
+}
diff --git a/Medium/Maximize Happiness of Selected Children.java b/Medium/Maximize Happiness of Selected Children.java
new file mode 100644
index 00000000..01e3aeff
--- /dev/null
+++ b/Medium/Maximize Happiness of Selected Children.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public long maximumHappinessSum(int[] happiness, int k) {
+        Arrays.sort(happiness);
+        int turnCount = 0;
+        long happinessSum = 0;
+        int idx = happiness.length - 1;
+        while (k-- > 0) {
+            int currentHappiness = Math.max(0, happiness[idx] - turnCount);
+            happinessSum += currentHappiness;
+            turnCount++;
+            idx--;
+        }
+        return happinessSum;
+    }
+}
diff --git a/Medium/Maximize the Confusion of an Exam.java b/Medium/Maximize the Confusion of an Exam.java
new file mode 100644
index 00000000..3e7e14d1
--- /dev/null
+++ b/Medium/Maximize the Confusion of an Exam.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maxConsecutiveAnswers(String answerKey, int k) {
+        int resultSize = k;
+        Map<Character, Integer> map = new HashMap<>();
+        for (int i = 0; i < k; i++) {
+            map.put(answerKey.charAt(i), map.getOrDefault(answerKey.charAt(i), 0) + 1);
+        }
+        int start = 0;
+        for (int i = k; i < answerKey.length(); i++) {
+            map.put(answerKey.charAt(i), map.getOrDefault(answerKey.charAt(i), 0) + 1);
+            while (Math.min(map.getOrDefault('T', 0), map.getOrDefault('F', 0)) > k) {
+                map.put(answerKey.charAt(start), map.get(answerKey.charAt(start)) - 1);
+                start++;
+            }
+            resultSize = Math.max(resultSize, i - start + 1);
+        }
+        return resultSize;
+    }
+}
diff --git a/Medium/Maximum Average Subtree.java b/Medium/Maximum Average Subtree.java
index 97c54cf6..873f4f01 100644
--- a/Medium/Maximum Average Subtree.java	
+++ b/Medium/Maximum Average Subtree.java	
@@ -4,28 +4,32 @@
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
- *     TreeNode(int x) { val = x; }
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
  * }
  */
 class Solution {
-  double maxAvg;
-  public double maximumAverageSubtree(TreeNode root) {
-    maxAvg = 0.0;
-    helper(root);
-    return maxAvg;
-  }
-  
-  private int[] helper(TreeNode root) {
-    int[] data = new int[2];
-    if (root == null) {
-      return data;
+    public double maximumAverageSubtree(TreeNode root) {
+        double[] result = {0.0};
+        traverse(root, result);
+        return result[0];
+    }
+
+    private double[] traverse(TreeNode root, double[] result) {
+        if (root == null) {
+            return new double[]{0.0, 0.0};
+        }
+        double[] leftValues = traverse(root.left, result);
+        double[] rightValues = traverse(root.right, result);
+        double sum = root.val + leftValues[0] + rightValues[0];
+        double count = 1 + leftValues[1] + rightValues[1];
+        double avg = sum / count;
+        result[0] = Math.max(result[0], avg);
+        return new double[]{sum, count};
     }
-    int[] dataLeft = helper(root.left);
-    int[] dataRight = helper(root.right);
-    data[0] += root.val + dataLeft[0] + dataRight[0];
-    data[1] += 1 + dataLeft[1] + dataRight[1];
-    double avg = ((double) data[0]) / data[1];
-    maxAvg = Math.max(maxAvg, avg);
-    return data;
-  }
 }
diff --git a/Medium/Maximum Coins Heroes Can Collect.java b/Medium/Maximum Coins Heroes Can Collect.java
new file mode 100644
index 00000000..1e98abf9
--- /dev/null
+++ b/Medium/Maximum Coins Heroes Can Collect.java	
@@ -0,0 +1,40 @@
+class Solution {
+    public long[] maximumCoins(int[] heroes, int[] monsters, int[] coins) {
+        List<MonsterEntity> monsterEntities = new ArrayList<>();
+        int n = monsters.length;
+        for (int i = 0; i < n; i++) {
+            monsterEntities.add(new MonsterEntity(monsters[i], coins[i]));
+        }
+        Collections.sort(monsterEntities, (a, b) -> (a.health() - b.health()));
+        long[] prefixCoinSum = new long[n];
+        for (int i = 0; i < n; i++) {
+            prefixCoinSum[i] = i == 0 ? 0 : prefixCoinSum[i - 1];
+            prefixCoinSum[i] += monsterEntities.get(i).coin();
+        }
+        int m = heroes.length;
+        long[] result = new long[m];
+        for (int i = 0; i < m; i++) {
+            int idx = binarySearch(monsterEntities, heroes[i]);
+            result[i] = idx != Integer.MIN_VALUE ? prefixCoinSum[idx] : 0;
+        }
+        return result;
+    }
+
+    private int binarySearch(List<MonsterEntity> monsterEntities, int heroHealth) {
+        int left = 0;
+        int right = monsterEntities.size() - 1;
+        int idx = Integer.MIN_VALUE;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (monsterEntities.get(mid).health() <= heroHealth) {
+                idx = Math.max(idx, mid);
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return idx;
+    }
+
+    private static record MonsterEntity(int health, int coin) {}
+}
diff --git a/Medium/Maximum Difference Between Node and Ancestor.java b/Medium/Maximum Difference Between Node and Ancestor.java
index 75d54cfa..b623f146 100644
--- a/Medium/Maximum Difference Between Node and Ancestor.java	
+++ b/Medium/Maximum Difference Between Node and Ancestor.java	
@@ -14,16 +14,38 @@
  * }
  */
 class Solution {
-  public int maxAncestorDiff(TreeNode root) {
-    return dfs(root, root.val, root.val);
-  }
-  
-  private int dfs(TreeNode root, int min, int max) {
-    if (root == null) {
-      return max - min;
+    public int maxAncestorDiff(TreeNode root) {
+        int maxDiff = 0;
+        Queue<NodeValuePair> queue = new LinkedList<>();
+        queue.add(new NodeValuePair(root, root.val, root.val));
+        while (!queue.isEmpty()) {
+            NodeValuePair removed = queue.remove();
+            TreeNode node = removed.node;
+            Integer minNodeValue = removed.minNodeValue;
+            Integer maxNodeValue = removed.maxNodeValue;
+            maxDiff = Math.max(maxDiff, Math.max(Math.abs(node.val - minNodeValue), Math.abs(node.val - maxNodeValue)));
+            Integer updatedMinNodeValue = Math.min(node.val, minNodeValue);
+            Integer updatedMaxNodeValue = Math.max(node.val, maxNodeValue);
+            if (node.left != null) {
+                queue.add(new NodeValuePair(node.left, updatedMinNodeValue, updatedMaxNodeValue));
+            }
+            if (node.right != null) {
+                queue.add(new NodeValuePair(node.right, updatedMinNodeValue, updatedMaxNodeValue));
+            }
+        }
+        return maxDiff;
+    }
+    
+    
+    private static class NodeValuePair {
+        private TreeNode node;
+        private Integer minNodeValue;
+        private Integer maxNodeValue;
+        
+        public NodeValuePair(TreeNode node, Integer minNodeValue, Integer maxNodeValue) {
+            this.node = node;
+            this.minNodeValue = minNodeValue;
+            this.maxNodeValue = maxNodeValue;
+        }
     }
-    max = Math.max(root.val, max);
-    min = Math.min(root.val, min);
-    return Math.max(dfs(root.left, min, max), dfs(root.right, min, max));
-  }
 }
diff --git a/Medium/Maximum Distance in Arrays.java b/Medium/Maximum Distance in Arrays.java
new file mode 100644
index 00000000..8205803e
--- /dev/null
+++ b/Medium/Maximum Distance in Arrays.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxDistance(List<List<Integer>> arrays) {
+        int result = 0;
+        int n = arrays.get(0).size();
+        int min = arrays.get(0).get(0);
+        int max = arrays.get(0).get(n - 1);
+        for (int i = 1; i < arrays.size(); i++) {
+            n = arrays.get(i).size();
+            result = Math.max(result, 
+                Math.max(Math.abs(arrays.get(i).get(n - 1) - min), 
+                        Math.abs(max - arrays.get(i).get(0))));
+            min = Math.min(min, arrays.get(i).get(0));
+            max = Math.max(max, arrays.get(i).get(n - 1));
+        }
+        return result;
+    }
+}
diff --git a/Medium/Maximum Ice Cream Bars.java b/Medium/Maximum Ice Cream Bars.java
index 75d34abf..d8faca38 100644
--- a/Medium/Maximum Ice Cream Bars.java	
+++ b/Medium/Maximum Ice Cream Bars.java	
@@ -1,12 +1,18 @@
 class Solution {
-  public int maxIceCream(int[] costs, int coins) {
-    PriorityQueue<Integer> pq = new PriorityQueue<>();
-    pq.addAll(Arrays.stream(costs).boxed().collect(Collectors.toList()));
-    int icecreamCount = 0;
-    while (!pq.isEmpty() && (coins - pq.peek()) >= 0) {
-      coins -= pq.poll();
-      icecreamCount++;
+    public int maxIceCream(int[] costs, int coins) {
+        int[] costFrequency = new int[1000_01];
+        for (int cost : costs) {
+            costFrequency[cost]++;
+        }
+        int numberOfIcecreams = 0;
+        for (int i = 1; i <= 1000_00 && coins >= i; i++) {
+            if (costFrequency[i] > 0) {
+                while (coins >= i && costFrequency[i]-- > 0) {
+                    numberOfIcecreams++;
+                    coins -= i;
+                }
+            }
+        }
+        return numberOfIcecreams;
     }
-    return icecreamCount;
-  }
 }
diff --git a/Medium/Maximum Length of Pair Chain.java b/Medium/Maximum Length of Pair Chain.java
index 1ad30427..cb98b670 100644
--- a/Medium/Maximum Length of Pair Chain.java	
+++ b/Medium/Maximum Length of Pair Chain.java	
@@ -1,22 +1,14 @@
 class Solution {
     public int findLongestChain(int[][] pairs) {
-        Arrays.sort(pairs, new Comparator<int[]>() {
-            @Override
-            public int compare(int[] o1, int[] o2) {
-                return o1[0] - o2[0];
-            }
-        });
-
-        int[] temp = new int[pairs.length];
-        Arrays.fill(temp, 1);
-        for (int i=1; i<pairs.length; i++) {
-            for (int j=0; j<i; j++) {
-                if (pairs[j][1] < pairs[i][0]) {
-                    temp[i] = Math.max(temp[i], temp[j] + 1);
-                }
+        Arrays.sort(pairs, Comparator.comparingInt(a -> a[1]));
+        int curr = Integer.MIN_VALUE;
+        int result = 0;
+        for (int[] pair : pairs) {
+            if (pair[0] > curr) {
+                result++;
+                curr = pair[1];
             }
         }
-
-        return Arrays.stream(temp).max().getAsInt();
+        return result;
     }
 }
diff --git a/Medium/Maximum Length of a Concatenated String with Unique Characters.java b/Medium/Maximum Length of a Concatenated String with Unique Characters.java
new file mode 100644
index 00000000..65ca06dc
--- /dev/null
+++ b/Medium/Maximum Length of a Concatenated String with Unique Characters.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int maxLength(List<String> arr) {
+        return backtrack(arr, 0, new HashMap<>());
+    }
+
+    private int backtrack(List<String> arr, int idx, Map<Character, Integer> map) {
+        if (map.values().stream().anyMatch(val -> val > 1)) {
+            return 0;
+        }
+        int result = map.size();
+        for (int i = idx; i < arr.size(); i++) {
+            char[] chars = arr.get(i).toCharArray();
+            for (char c : chars) {
+                map.put(c, map.getOrDefault(c, 0) + 1);
+            }
+            result = Math.max(result, backtrack(arr, i + 1, map));
+            for (char c : chars) {
+                map.put(c, map.get(c) - 1);
+                if (map.get(c) == 0) {
+                    map.remove(c);
+                }
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Maximum Level Sum of a Binary Tree.java b/Medium/Maximum Level Sum of a Binary Tree.java
index 8c1bdac6..74c62767 100644
--- a/Medium/Maximum Level Sum of a Binary Tree.java	
+++ b/Medium/Maximum Level Sum of a Binary Tree.java	
@@ -14,34 +14,31 @@
  * }
  */
 class Solution {
-  public int maxLevelSum(TreeNode root) {
-    if (root == null) {
-      return 0;
-    }
-    int currLevel = 1;
-    int maxSum = Integer.MIN_VALUE;
-    int maxSumLevel = 0;
-    Queue<TreeNode> queue = new LinkedList<>();
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      int currSum = 0;
-      while (size-- > 0) {
-        TreeNode removed = queue.remove();
-        currSum += removed.val;
-        if (removed.left != null) {
-          queue.add(removed.left);
-        }
-        if (removed.right != null) {
-          queue.add(removed.right);
+    public int maxLevelSum(TreeNode root) {
+        int maxSum = Integer.MIN_VALUE;
+        int maxSumLevel = 0;
+        int currLevel = 1;
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int levelSum = 0;
+            int size = queue.size();
+            while (size-- > 0) {
+                TreeNode removed = queue.remove();
+                levelSum += removed.val;
+                if (removed.left != null) {
+                    queue.add(removed.left);
+                }
+                if (removed.right != null) {
+                    queue.add(removed.right);
+                }
+            }
+            if (levelSum > maxSum) {
+                maxSum = levelSum;
+                maxSumLevel = currLevel;
+            }
+            currLevel++;
         }
-      }
-      if (maxSum < currSum) {
-        maxSum = currSum;
-        maxSumLevel = currLevel;
-      }
-      currLevel++;
+        return maxSumLevel;
     }
-    return maxSumLevel;
-  }
 }
diff --git a/Medium/Maximum Number of Integers to Choose From a Range I.java b/Medium/Maximum Number of Integers to Choose From a Range I.java
new file mode 100644
index 00000000..8f3ad2ee
--- /dev/null
+++ b/Medium/Maximum Number of Integers to Choose From a Range I.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int maxCount(int[] banned, int n, int maxSum) {
+        int count = 0;
+        Set<Integer> bannedSet = Arrays.stream(banned).boxed().collect(Collectors.toSet());
+        for (int i = 1; i <= n && count < n; i++) {
+            if (bannedSet.contains(i)) {
+                continue;
+            }
+            if (maxSum - i < 0) {
+                break;
+            }
+            count++;
+            maxSum -= i;
+        }
+        return count;
+    }
+}
diff --git a/Medium/Maximum Number of Moves in a Grid.java b/Medium/Maximum Number of Moves in a Grid.java
new file mode 100644
index 00000000..014425f8
--- /dev/null
+++ b/Medium/Maximum Number of Moves in a Grid.java	
@@ -0,0 +1,40 @@
+class Solution {
+
+    private static final int[] DIRS = {-1, 0, 1};
+
+    public int maxMoves(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        Queue<int[]> queue = new LinkedList<>();
+        boolean[][] visited = new boolean[rows][cols];
+        for (int i = 0; i < rows; i++) {
+            visited[i][0] = true;
+            queue.add(new int[]{i, 0, 0});
+        }
+        int result = 0; 
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] removed = queue.remove();
+                int row = removed[0];
+                int col = removed[1];
+                int count = removed[2];
+                result = Math.max(result, count);
+                for (int dir : DIRS) {
+                    int nextRow = row + dir;
+                    int nextCol = col + 1;
+                    if (nextRow >= 0 && 
+                        nextCol >= 0 && 
+                        nextRow < rows && 
+                        nextCol < cols && 
+                        !visited[nextRow][nextCol] &&
+                        grid[row][col] < grid[nextRow][nextCol]) {
+                            visited[nextRow][nextCol] = true;
+                            queue.add(new int[]{nextRow, nextCol, count + 1});
+                        }
+                }
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Maximum Number of Vowels in a Substring of Given Length.java b/Medium/Maximum Number of Vowels in a Substring of Given Length.java
index 5af78c54..0b27eda9 100644
--- a/Medium/Maximum Number of Vowels in a Substring of Given Length.java	
+++ b/Medium/Maximum Number of Vowels in a Substring of Given Length.java	
@@ -1,32 +1,23 @@
 class Solution {
-  public int maxVowels(String s, int k) {
-    Map<Character, Integer> map = new HashMap<>();
-    String vowels = "aeiou";
-    int count = 0;
-    int maxCount = 0;
-    int start = 0;
-    int end = 0;
-    int n = s.length();
-    while (end < (k - 1)) {
-      if (vowels.indexOf(s.charAt(end)) != -1) {
-        map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
-        count++;
-      }
-      end++;
+    public int maxVowels(String s, int k) {
+        int currCount = 0;
+        Set<Character> vowels = Set.of('a', 'e', 'i', 'o', 'u');
+        for (int i = 0; i < k - 1; i++) {
+            if (vowels.contains(s.charAt(i))) {
+                currCount++;
+            }
+        }
+        int maxCount = 0;
+        int start = 0;
+        for (int i = k - 1; i < s.length(); i++) {
+            if (vowels.contains(s.charAt(i))) {
+                currCount++;
+            }
+            maxCount = Math.max(maxCount, currCount);
+            if (vowels.contains(s.charAt(start++))) {
+                currCount--;
+            }
+        }
+        return maxCount;
     }
-    while (end < n) {
-       if (vowels.indexOf(s.charAt(end)) != -1) {
-        map.put(s.charAt(end), map.getOrDefault(s.charAt(end), 0) + 1);
-         count++;
-      }
-      end++;
-      maxCount = Math.max(maxCount, count);
-      if (vowels.indexOf(s.charAt(start)) != -1) {
-        map.put(s.charAt(start), map.getOrDefault(s.charAt(start), 0) - 1);
-        count--;
-      }
-      start++;
-    }
-    return maxCount;
-  }
 }
diff --git a/Medium/Maximum Points After Enemy Battles.java b/Medium/Maximum Points After Enemy Battles.java
new file mode 100644
index 00000000..2358cd8f
--- /dev/null
+++ b/Medium/Maximum Points After Enemy Battles.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public long maximumPoints(int[] enemyEnergies, int currentEnergy) {
+        long sum = 0;
+        int minimumEnergy = Integer.MAX_VALUE;
+        for (int energy : enemyEnergies) {
+            sum += energy;
+            minimumEnergy = Math.min(minimumEnergy, energy);
+        }
+        if (currentEnergy < minimumEnergy) {
+            return 0;
+        }
+        long totalEnergy = currentEnergy;
+        totalEnergy += sum - minimumEnergy;
+        return totalEnergy / minimumEnergy;
+    }
+}
diff --git a/Medium/Maximum Product of Splitted Binary Tree.java b/Medium/Maximum Product of Splitted Binary Tree.java
new file mode 100644
index 00000000..72a36750
--- /dev/null
+++ b/Medium/Maximum Product of Splitted Binary Tree.java	
@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int maxProduct(TreeNode root) {
+        List<Integer> allNodeSums = new ArrayList<>();
+        long totalSum = treeSum(root, allNodeSums);
+        long best = 0;
+        for (long sum : allNodeSums) {
+            best = Math.max(best, sum * (totalSum - sum));
+        }
+        return (int) (best % 1000_000_007);
+    }
+    
+    private int treeSum(TreeNode root, List<Integer> allNodeSums) {
+        if (root == null) {
+            return 0;
+        }
+        int leftSum = treeSum(root.left, allNodeSums);
+        int rightSum = treeSum(root.right, allNodeSums);
+        int totalSum = leftSum + rightSum + root.val;
+        allNodeSums.add(totalSum);
+        return totalSum;
+    }
+}
diff --git a/Medium/Maximum Score From Removing Substrings.java b/Medium/Maximum Score From Removing Substrings.java
new file mode 100644
index 00000000..0f7ccf87
--- /dev/null
+++ b/Medium/Maximum Score From Removing Substrings.java	
@@ -0,0 +1,29 @@
+class Solution {
+    public int maximumGain(String s, int x, int y) {
+        int score = 0;
+        String firstPass = removeSubstring(s, x > y ? "ab" : "ba");
+        int removeCount = (s.length() - firstPass.length()) / 2;
+        score += removeCount * Math.max(x, y);
+        String secondPass = removeSubstring(firstPass, x > y ? "ba" : "ab");
+        removeCount = (firstPass.length() - secondPass.length()) / 2;
+        score += removeCount * Math.min(x, y);
+        return score;
+    }
+
+    private String removeSubstring(String s, String target) {
+        Stack<Character> stack = new Stack<>();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c == target.charAt(1) && !stack.isEmpty() && stack.peek() == target.charAt(0)) {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        while (!stack.isEmpty()) {
+            sb.append(stack.pop());
+        }
+        return sb.reverse().toString();
+    }
+}
diff --git a/Medium/Maximum Size Subarray Sum Equals k.java b/Medium/Maximum Size Subarray Sum Equals k.java
index 97d37973..dce7007a 100644
--- a/Medium/Maximum Size Subarray Sum Equals k.java	
+++ b/Medium/Maximum Size Subarray Sum Equals k.java	
@@ -1,18 +1,17 @@
 class Solution {
-  public int maxSubArrayLen(int[] nums, int k) {
-    Map<Integer, Integer> map = new HashMap<>();
-    int res = 0;
-    int sum = 0;
-    for (int i = 0; i < nums.length; i++) {
-      sum += nums[i];
-      if (sum == k) {
-        res = i + 1;
-      }
-      else if (map.containsKey(sum - k)) {
-        res = Math.max(res, i - map.get(sum - k));
-      }
-      map.putIfAbsent(sum, i);
+    public int maxSubArrayLen(int[] nums, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        int prefixSum = 0;
+        int max = 0;
+        for (int i = 0; i < nums.length; i++) {
+            prefixSum += nums[i];
+            if (prefixSum == k) {
+                max = i + 1;
+            } else if (map.containsKey(prefixSum - k)) {
+                max = Math.max(max, i - map.get(prefixSum - k));
+            }
+            map.putIfAbsent(prefixSum, i);
+        }
+        return max;
     }
-    return res;
-  }
 }
diff --git a/Medium/Maximum Star Sum of a Graph.java b/Medium/Maximum Star Sum of a Graph.java
new file mode 100644
index 00000000..f54f2f83
--- /dev/null
+++ b/Medium/Maximum Star Sum of a Graph.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int maxStarSum(int[] vals, int[][] edges, int k) {
+        Map<Integer, PriorityQueue<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], node -> new PriorityQueue<>(Comparator.reverseOrder())).add(vals[edge[1]]);
+            graph.computeIfAbsent(edge[1], node -> new PriorityQueue<>(Comparator.reverseOrder())).add(vals[edge[0]]);
+        }
+        int maxSum = Integer.MIN_VALUE;
+        for (int i = 0; i < vals.length; i++) {
+            int currSum = vals[i];
+            PriorityQueue<Integer> pq = graph.getOrDefault(i, new PriorityQueue<>());
+            for (int j = 0; j < k && !pq.isEmpty(); j++){
+                currSum += Math.max(pq.poll(), 0);
+            }
+            maxSum = Math.max(maxSum, currSum);
+        }
+        return maxSum;
+    }
+}
diff --git a/Medium/Maximum Subarray.java b/Medium/Maximum Subarray.java
new file mode 100644
index 00000000..459a8733
--- /dev/null
+++ b/Medium/Maximum Subarray.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int currSum = 0;
+        int maxSum = Integer.MIN_VALUE;
+        for (int num : nums) {
+            currSum += num;
+            if (currSum < num) {
+                currSum = num;
+            }
+            maxSum = Math.max(maxSum, currSum);
+        }
+        return maxSum;
+    }
+}
diff --git a/Medium/Maximum Subsequence Score.java b/Medium/Maximum Subsequence Score.java
new file mode 100644
index 00000000..2598f5ed
--- /dev/null
+++ b/Medium/Maximum Subsequence Score.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public long maxScore(int[] nums1, int[] nums2, int k) {
+        int[][] combined = new int[nums1.length][2];
+        for (int i = 0; i < nums1.length; i++) {
+            combined[i] = new int[]{nums1[i], nums2[i]};
+        }
+        Arrays.sort(combined, (o1, o2) -> o2[1] - o1[1]);
+        long result = 0;
+        long total = 0;
+        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        for (int[] unit : combined) {
+            pq.add(unit[0]);
+            total += unit[0];
+            if (pq.size() > k) {
+                total -= pq.poll();
+            }
+            if (pq.size() == k) {
+                result = Math.max(result, total * unit[1]);
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Maximum Sum of Almost Unique Subarray.java b/Medium/Maximum Sum of Almost Unique Subarray.java
new file mode 100644
index 00000000..1d9facff
--- /dev/null
+++ b/Medium/Maximum Sum of Almost Unique Subarray.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public long maxSum(List<Integer> nums, int m, int k) {
+        long result = 0;
+        long currSum = 0;
+        Map<Integer, Integer> frequencyMap = new HashMap<>();
+        int uniqueCount = 0;
+        for (int i = 0; i < nums.size(); i++) {
+            int curr = nums.get(i);
+            frequencyMap.put(curr, frequencyMap.getOrDefault(curr, 0) + 1);
+            if (frequencyMap.get(curr) == 1) {
+                uniqueCount++;
+            }
+            currSum += curr;
+            if (i >= k - 1) {
+                if (uniqueCount >= m) {
+                    result = Math.max(result, currSum);
+                }
+                int temp = nums.get(i - k + 1);
+                frequencyMap.put(temp, frequencyMap.getOrDefault(temp, 0) - 1);
+                if (frequencyMap.get(temp) == 0) {
+                    uniqueCount--;
+                }
+                currSum -= temp;
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Maximum Swap.java b/Medium/Maximum Swap.java
index 5d30c780..c12fb12e 100644
--- a/Medium/Maximum Swap.java	
+++ b/Medium/Maximum Swap.java	
@@ -1,29 +1,20 @@
 class Solution {
-  public int maximumSwap(int num) {
-    String stringValue = Integer.toString(num);
-    Map<Integer, Integer> valToIndexMap = new HashMap<>();
-    int[] digits = new int[String.valueOf(num).length()];
-    for (int i = digits.length - 1; i >= 0; i--) {
-      int digit = num % 10;
-      num /= 10;
-      digits[i] = digit;
-      valToIndexMap.putIfAbsent(digit, i);
-    }
-    for (int i = 0; i < digits.length; i++) {
-      for (int k = 9; k > digits[i]; k--) {
-        if (valToIndexMap.getOrDefault(k, -1) > i) {
-          int swapIndex = valToIndexMap.get(k);
-          return Integer.parseInt(
-              stringValue.substring(0, i) // Digits before swap index
-                  + k // Swapped value
-                  + stringValue.substring(i + 1, swapIndex) // Digits after original index(i) and before swappedIndex
-                  + digits[i] // Digit at original index(i)
-                  + ((swapIndex + 1) != stringValue.length() // Check if swapIndex is last digit of num
-                      ? stringValue.substring(swapIndex + 1) // If not then add digits that come after the swapIndex
-                      : "")); // Else add an empty string
+    public int maximumSwap(int num) {
+        char[] digits = String.valueOf(num).toCharArray();
+        int n = digits.length;
+        int[] maxRightIdx = new int[n];
+        maxRightIdx[n - 1] = n - 1;
+        for (int i = n - 2; i >= 0; i--) {
+            maxRightIdx[i] = (digits[i] > digits[maxRightIdx[i + 1]]) ? i : maxRightIdx[i + 1];
+        }
+        for (int i = 0; i < n; i++) {
+            if (digits[i] < digits[maxRightIdx[i]]) {
+                char temp = digits[i];
+                digits[i] = digits[maxRightIdx[i]];
+                digits[maxRightIdx[i]] = temp;
+                return Integer.parseInt(String.valueOf(digits));
+            }
         }
-      }
+        return num;
     }
-    return Integer.parseInt(stringValue);
-  }
 }
diff --git a/Medium/Maximum Value at a Given Index in a Bounded Array.java b/Medium/Maximum Value at a Given Index in a Bounded Array.java
new file mode 100644
index 00000000..6a1a4966
--- /dev/null
+++ b/Medium/Maximum Value at a Given Index in a Bounded Array.java	
@@ -0,0 +1,30 @@
+class Solution {
+    public int maxValue(int n, int index, int maxSum) {
+        int start = 1;
+        int end = maxSum;
+        while (start < end) {
+            int mid = (start + end + 1) / 2;
+            if (findSum(index, mid, n) <= maxSum) {
+                start = mid;
+            } else {
+                end = mid - 1;
+            }
+        }
+        return start;
+    }
+    
+    private long findSum(int index, int targetIndex, int n) {
+        long count = 0;
+        if (targetIndex > index) {
+            count += (long) (2 * targetIndex - index) * (index + 1) / 2;
+        } else {
+            count += (long) (targetIndex + 1) * targetIndex / 2 + index - targetIndex + 1;
+        }
+        if (targetIndex >= n - index) {
+            count += (long) (targetIndex + targetIndex - n + 1 + index) * (n - index) / 2;
+        } else {
+            count += (long) (targetIndex + 1) * targetIndex / 2 + n - index - targetIndex;
+        }   
+        return count - targetIndex;
+    }
+}
diff --git a/Medium/Maximum Width Ramp.java b/Medium/Maximum Width Ramp.java
index 37eb1862..2463f02b 100644
--- a/Medium/Maximum Width Ramp.java	
+++ b/Medium/Maximum Width Ramp.java	
@@ -1,21 +1,18 @@
 class Solution {
-    public int maxWidthRamp(int[] A) {
+    public int maxWidthRamp(int[] nums) {
+        int n = nums.length;
         Stack<Integer> stack = new Stack<>();
-        int ans = 0;
-        int n = A.length;
-
-        for (int i=0; i<n; i++) {
-            if (stack.isEmpty() || A[stack.peek()] > A[i]) {
-                stack.add(i);
+        for (int i = 0; i < n; i++) {
+            if (stack.isEmpty() || nums[stack.peek()] > nums[i]) {
+                stack.push(i);
             }
         }
-
-        for (int i=n-1; i>=ans; i--) {
-            while (!stack.isEmpty() && A[stack.peek()] <= A[i]) {
-                ans = Math.max(ans, i - stack.pop());
+        int result = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            while (!stack.isEmpty() && nums[stack.peek()] <= nums[i]) {
+                result = Math.max(result, i - stack.pop());
             }
         }
-
-        return ans;
+        return result;
     }
 }
diff --git a/Medium/Maximum Width of Binary Tree.java b/Medium/Maximum Width of Binary Tree.java
index 3610e37d..d5edef7e 100644
--- a/Medium/Maximum Width of Binary Tree.java	
+++ b/Medium/Maximum Width of Binary Tree.java	
@@ -14,35 +14,30 @@
  * }
  */
 class Solution {
-  public int widthOfBinaryTree(TreeNode root) {
-    int maxWidth = 0;
-    Queue<TreeNode> queue = new LinkedList<>();
-    Map<TreeNode, Integer> map = new HashMap<>();
-    map.put(root, 1);
-    queue.add(root);
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      int start = 0;
-      int end = 0;
-      for (int i = 0; i < size; i++) {
-        TreeNode node = queue.poll();
-        if (i == 0) {
-          start = map.get(node);
+    public int widthOfBinaryTree(TreeNode root) {
+        if (root == null) {
+            return 0;
         }
-        if (i == size - 1) {
-          end = map.get(node);
+        Queue<NodeColIndex> queue = new LinkedList<>();
+        queue.add(new NodeColIndex(root, 0));
+        int maxWidth = 0;
+        while (!queue.isEmpty()) {
+            NodeColIndex head = queue.peek();
+            int levelSize = queue.size();
+            for (int i = 0; i < levelSize; i++) {
+                NodeColIndex removed = queue.remove();
+                TreeNode node = removed.node;
+                if (node.left != null) {
+                    queue.add(new NodeColIndex(node.left, 2 * removed.colIdx));
+                }
+                if (node.right != null) {
+                    queue.add(new NodeColIndex(node.right, 2 * removed.colIdx + 1));
+                }
+                maxWidth = Math.max(maxWidth, removed.colIdx - head.colIdx + 1);
+            }
         }
-        if (node.left != null) {
-          map.put(node.left, map.get(node) * 2);
-          queue.add(node.left);
-        }
-        if (node.right != null) {
-          map.put(node.right, map.get(node) * 2 + 1);
-          queue.add(node.right);
-        }
-      }
-      maxWidth = Math.max(maxWidth, end - start + 1);
+        return maxWidth;
     }
-    return maxWidth;
-  }
+    
+    private record NodeColIndex(TreeNode node, int colIdx) {}
 }
diff --git a/Medium/Meeting Rooms II.java b/Medium/Meeting Rooms II.java
index d43eab4e..ff594c8a 100644
--- a/Medium/Meeting Rooms II.java	
+++ b/Medium/Meeting Rooms II.java	
@@ -1,16 +1,15 @@
 class Solution {
-  public int minMeetingRooms(int[][] intervals) {
-    Arrays.sort(intervals, Comparator.comparingInt((a) -> a[0]));
-    PriorityQueue<int[]> meetingsInProgress = new PriorityQueue<>(
-        Comparator.comparingInt((a) -> a[1]));
-    int result = 0;
-    for (int[] interval : intervals) {
-      while (!meetingsInProgress.isEmpty() && meetingsInProgress.peek()[1] <= interval[0]) {
-        meetingsInProgress.poll();
-      }
-      meetingsInProgress.add(interval);
-      result = Math.max(result, meetingsInProgress.size());
+    public int minMeetingRooms(int[][] intervals) {
+        Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[0]));
+        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[1]));
+        int meetingRooms = 0;
+        for (int[] interval : intervals) {
+            while (!pq.isEmpty() && pq.peek()[1] <= interval[0]) {
+                pq.poll();
+            }
+            pq.add(interval);
+            meetingRooms = Math.max(meetingRooms, pq.size());
+        }
+        return meetingRooms;
     }
-    return result;
-  }
 }
diff --git a/Medium/Meeting Scheduler.java b/Medium/Meeting Scheduler.java
index d5bf6b16..aeb5d8e9 100644
--- a/Medium/Meeting Scheduler.java	
+++ b/Medium/Meeting Scheduler.java	
@@ -1,21 +1,22 @@
 class Solution {
-  public List<Integer> minAvailableDuration(int[][] slots1, int[][] slots2, int duration) {
-    Arrays.sort(slots1, Comparator.comparingInt(o -> o[0]));
-    Arrays.sort(slots2, Comparator.comparingInt(o -> o[0]));
-    int idxOne = 0;
-    int idxTwo = 0;
-    while (idxOne < slots1.length && idxTwo < slots2.length) {
-      int maxStart = Math.max(slots1[idxOne][0], slots2[idxTwo][0]);
-      int minEnd = Math.min(slots1[idxOne][1], slots2[idxTwo][1]);
-      if (minEnd - maxStart >= duration) {
-        return Arrays.asList(maxStart, maxStart + duration);
-      }
-      if (slots1[idxOne][1] > slots2[idxTwo][1]) {
-        idxTwo++;
-      } else {
-        idxOne++;
-      }
+    public List<Integer> minAvailableDuration(int[][] slots1, int[][] slots2, int duration) {
+        Arrays.sort(slots1, Comparator.comparingInt(o -> o[0]));
+        Arrays.sort(slots2, Comparator.comparingInt(o -> o[0]));
+        int idxOne = 0;
+        int idxTwo = 0;
+        while (idxOne < slots1.length && idxTwo < slots2.length) {
+            int maxStart = Math.max(slots1[idxOne][0], slots2[idxTwo][0]);
+            int minEnd = Math.min(slots1[idxOne][1], slots2[idxTwo][1]);
+            if (minEnd - maxStart >= duration) {
+                return List.of(maxStart, maxStart + duration);
+            }
+            if (minEnd == slots1[idxOne][1]) {
+                idxOne++;
+            }
+            if (minEnd == slots2[idxTwo][1]) {
+                idxTwo++;
+            }
+        }
+        return Collections.emptyList();
     }
-    return new ArrayList<>();
-  }
 }
diff --git a/Medium/Merge In Between Linked Lists.java b/Medium/Merge In Between Linked Lists.java
index 5e3b814a..9f36b5a8 100644
--- a/Medium/Merge In Between Linked Lists.java	
+++ b/Medium/Merge In Between Linked Lists.java	
@@ -9,27 +9,22 @@
  * }
  */
 class Solution {
-  public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
-    ListNode currList1 = list1;
-    // Stop just before a and record the pointer
-    for (int i = 0; i < a - 1; i++) {
-      currList1 = currList1.next;
+    public ListNode mergeInBetween(ListNode list1, int a, int b, ListNode list2) {
+        ListNode curr = list1;
+        for (int i = 1; i < a; i++) {
+            curr = curr.next;
+        }
+        ListNode start = curr;
+        for (int i = a - 1; i <= b; i++) {
+            curr = curr.next;
+        }
+        ListNode end = curr;
+        start.next = list2;
+        curr = list2;
+        while (curr.next != null) {
+            curr = curr.next;
+        }
+        curr.next = end;
+        return list1;
     }
-    ListNode currCopy = currList1;
-    // Cover a to b
-    for (int i = a; i <= b; i++) {
-      currList1 = currList1.next;
-    } 
-    // Record what is remaining after b
-    ListNode remaining = currList1.next;
-    // Find end of list2
-    ListNode list2End = list2;
-    while (list2End != null && list2End.next != null) {
-      list2End = list2End.next;
-    }
-    // Pointer manipulation
-    currCopy.next = list2;
-    list2End.next = remaining;
-    return list1;
-  }
 }
diff --git a/Medium/Merge Intervals.java b/Medium/Merge Intervals.java
index c4b49872..cb0a90cf 100644
--- a/Medium/Merge Intervals.java	
+++ b/Medium/Merge Intervals.java	
@@ -1,22 +1,18 @@
 class Solution {
-  public int[][] merge(int[][] intervals) {
-    Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[0]).thenComparingInt(o -> o[1]));
-    List<int[]> mergedIntervals = new ArrayList<>();
-    int idx = 0;
-    while (idx < intervals.length) {
-      int currentStart = intervals[idx][0];
-      int currentEnd = intervals[idx][1];
-      idx++;
-      while (idx < intervals.length && intervals[idx][0] <= currentEnd) {
-        currentEnd = Math.max(intervals[idx][1], currentEnd);
-        idx++;
-      }
-      mergedIntervals.add(new int[]{currentStart, currentEnd});
+    public int[][] merge(int[][] intervals) {
+        Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[0])
+                .thenComparingInt(o -> o[1]));
+        int idx = 0;
+        List<int[]> result = new ArrayList<>();
+        while (idx < intervals.length) {
+            int start = intervals[idx][0];
+            int end = intervals[idx][1];
+            idx++;
+            while (idx < intervals.length && intervals[idx][0] <= end) {
+                end = Math.max(end, intervals[idx++][1]);
+            }
+            result.add(new int[]{start, end});
+        }
+        return result.toArray(new int[][]{});
     }
-    int[][] result = new int[mergedIntervals.size()][2];
-    for (int i = 0; i < mergedIntervals.size(); i++) {
-      result[i] = mergedIntervals.get(i);
-    }
-    return result;
-  }
 }
diff --git a/Medium/Min Cost to Connect All Points.java b/Medium/Min Cost to Connect All Points.java
index 15cc689b..168142ca 100644
--- a/Medium/Min Cost to Connect All Points.java	
+++ b/Medium/Min Cost to Connect All Points.java	
@@ -1,80 +1,64 @@
 class Solution {
-  public int minCostConnectPoints(int[][] points) {
-    int n = points.length;
-    PriorityQueue<Edge> priorityQueue = new PriorityQueue<>((x, y) -> x.cost - y.cost);
-    UnionFind unionFind = new UnionFind(n);
-    for (int i = 0; i < n; i++) {
-      int[] coordinate = points[i];
-      for (int j = i + 1; j < n; j++) {
-        int[] secondCoordinate = points[j];
-        int cost = Math.abs(coordinate[0] - secondCoordinate[0]) + Math.abs(coordinate[1] - secondCoordinate[1]);
-        Edge edge = new Edge(i, j, cost);
-        priorityQueue.add(edge);
-      }
-    }
-    int minimumCost = 0;
-    int totalEdges = n - 1;
-    while (!priorityQueue.isEmpty() && totalEdges > 0) {
-      Edge edge = priorityQueue.poll();
-      if (!unionFind.connected(edge.pointOne, edge.pointTwo)) {
-        unionFind.union(edge.pointOne, edge.pointTwo);
-        minimumCost += edge.cost;
-        totalEdges--;
-      }
-    }
-    return minimumCost;
-  }
-
-  private static class Edge {
-    int pointOne;
-    int pointTwo;
-    int cost;
-
-    public Edge(int pointOne, int pointTwo, int cost) {
-      this.pointOne = pointOne;
-      this.pointTwo = pointTwo;
-      this.cost = cost;
+    public int minCostConnectPoints(int[][] points) {
+        int n = points.length;
+        List<int[]> edges = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                int weight = Math.abs(points[i][0] - points[j][0]) + Math.abs(points[i][1] - points[j][1]);
+                int[] curr = {weight, i, j};
+                edges.add(curr);
+            }
+        }
+        Collections.sort(edges, Comparator.comparingInt(a -> a[0]));
+        UnionFind unionFind = new UnionFind(n);
+        int minCost = 0;
+        int edgeUsedCount = 0;
+        for (int i = 0; i < edges.size() && edgeUsedCount < n - 1; i++) {
+            int nodeOne = edges.get(i)[1];
+            int nodeTwo = edges.get(i)[2];
+            int weight = edges.get(i)[0];
+            if (unionFind.union(nodeOne, nodeTwo)) {
+                minCost += weight;
+                edgeUsedCount++;
+            }
+        }
+        return minCost;
     }
-  }
-
-  private static class UnionFind {
 
-    private final int[] root;
-    private final int[] rank;
+    private static class UnionFind {
+        private final int[] group;
+        private final int[] rank;
 
-    public UnionFind(int size) {
-      this.root = new int[size];
-      this.rank = new int[size];
-      for (int i = 0; i < size; i++) {
-        this.root[i] = i;
-        this.rank[i] = 1;
-      }
-    }
-
-    public void union(int nodeOne, int nodeTwo) {
-      int rootOne = find(nodeOne);
-      int rootTwo = find(nodeTwo);
-      if (rootOne != rootTwo) {
-        if (this.rank[rootOne] > this.rank[rootTwo]) {
-          this.root[rootTwo] = rootOne;
-        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
-          this.root[rootOne] = rootTwo;
-        } else {
-          this.root[rootTwo] = rootOne;
-          this.rank[rootOne]++;
+        public UnionFind(int n) {
+            this.group = new int[n];
+            this.rank = new int[n];
+            for (int i = 0; i < n; i++) {
+                this.group[i] = i;
+            }
         }
-      }
-    }
 
-    public int find(int node) {
-      if (node == root[node]) {
-        return node;
-      }
-      return root[node] = find(root[node]);
-    }
+        public int find(int node) {
+            if (group[node] != node) {
+                group[node] = find(group[node]);
+            }
+            return group[node];
+        }
 
-    public boolean connected(int nodeOne, int nodeTwo) {
-      return find(nodeOne) == find(nodeTwo);
+        public boolean union(int nodeOne, int nodeTwo) {
+            int groupOne = find(nodeOne);
+            int groupTwo = find(nodeTwo);
+            if (groupOne == groupTwo) {
+                return false;
+            }
+            if (rank[groupOne] > rank[groupTwo]) {
+                group[groupTwo] = groupOne;
+            } else if (rank[groupOne] < rank[groupTwo]) {
+                group[groupOne] = groupTwo;
+            } else {
+                group[groupOne] = groupTwo;
+                rank[groupTwo]++;
+            }
+            return true;
+        }
     }
-  }
 }
diff --git a/Medium/Minimize Maximum of Array.java b/Medium/Minimize Maximum of Array.java
new file mode 100644
index 00000000..79d5ee9b
--- /dev/null
+++ b/Medium/Minimize Maximum of Array.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int minimizeArrayValue(int[] nums) {
+        long prefixSum = 0L;
+        long result = 0L;
+        for (int i = 0; i < nums.length; i++) {
+            prefixSum += nums[i];
+            result = Math.max(result, (prefixSum + i) / (i + 1));
+        }
+        return (int) result;
+    }
+}
diff --git a/Medium/Minimize Product Sum of Two Arrays.java b/Medium/Minimize Product Sum of Two Arrays.java
index 4f8e184b..8302c68e 100644
--- a/Medium/Minimize Product Sum of Two Arrays.java	
+++ b/Medium/Minimize Product Sum of Two Arrays.java	
@@ -1,29 +1,25 @@
 class Solution {
-  public int minProductSum(int[] nums1, int[] nums2) {
-    int[] frequencyOne = new int[101];
-    int[] frequencyTwo = new int[101];
-    for (int i = 0; i < nums1.length; i++) {
-      frequencyOne[nums1[i]]++;
-      frequencyTwo[nums2[i]]++;
+    public int minProductSum(int[] nums1, int[] nums2) {
+        int[] frequencyOne = new int[101];
+        int[] frequencyTwo = new int[101];
+        for (int i = 0; i < nums1.length; i++) {
+            frequencyOne[nums1[i]]++;
+            frequencyTwo[nums2[i]]++;
+        }
+        int productSum = 0;
+        int idxOne = 1;
+        int idxTwo = 100;
+        while (idxOne < 101 && idxTwo > 0) {
+            if (frequencyOne[idxOne] == 0) {
+                idxOne++;
+            } else if (frequencyTwo[idxTwo] == 0) {
+                idxTwo--;
+            } else {
+                productSum += idxOne * idxTwo;
+                frequencyOne[idxOne]--;
+                frequencyTwo[idxTwo]--;
+            }
+        }
+        return productSum;
     }
-    int idxOne = 0;
-    int idxTwo = 100;
-    int sum = 0;
-    while (idxOne < 101 && idxTwo >= 0) {
-      while (idxOne < 101 && frequencyOne[idxOne] == 0) {
-        idxOne++;
-      }
-      while (idxTwo >= 0 && frequencyTwo[idxTwo] == 0) {
-        idxTwo--;
-      }
-      if (idxOne == 101 || idxTwo == -1) {
-        break;
-      }
-      int counter = Math.min(frequencyOne[idxOne], frequencyTwo[idxTwo]);
-      sum += counter * idxOne * idxTwo;
-      frequencyOne[idxOne] -= counter;
-      frequencyTwo[idxTwo] -= counter;
-    }
-    return sum;
-  }   
 }
diff --git a/Medium/Minimize XOR.java b/Medium/Minimize XOR.java
new file mode 100644
index 00000000..cc5e87a3
--- /dev/null
+++ b/Medium/Minimize XOR.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int minimizeXor(int num1, int num2) {
+        int result = 0;
+        int targetSetBitCount = Integer.bitCount(num2);
+        int setBitCount = 0;
+        int currBit = 31;
+        while (setBitCount < targetSetBitCount) {
+            if (isSet(num1, currBit) || (targetSetBitCount - setBitCount > currBit)) {
+                result = setBit(result, currBit);
+                setBitCount++;
+            }
+            currBit--;
+        }
+        return result;
+    }
+
+    private boolean isSet(int x, int bit) {
+        return (x & (1 << bit)) != 0;
+    }
+
+    private int setBit(int x, int bit) {
+        return x | (1 << bit);
+    }
+}
diff --git a/Medium/Minimize the Maximum Difference of Pairs.java b/Medium/Minimize the Maximum Difference of Pairs.java
new file mode 100644
index 00000000..5ec67591
--- /dev/null
+++ b/Medium/Minimize the Maximum Difference of Pairs.java	
@@ -0,0 +1,30 @@
+class Solution {
+    public int minimizeMax(int[] nums, int p) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        int start = 0;
+        int end = nums[n - 1] - nums[0];
+        while (start < end) {
+            int mid = (start + end) / 2;
+            if (countValidPairs(nums, mid) >= p) {
+                end = mid;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return start;
+    }
+    
+    private static int countValidPairs(int[] nums, int limit) {
+        int idx = 0;
+        int count = 0;
+        while (idx < nums.length - 1) {
+            if (nums[idx + 1] - nums[idx] <= limit) {
+                count++;
+                idx++;
+            }
+            idx++;
+        }
+        return count;
+    }
+}
diff --git a/Medium/Minimized Maximum of Products Distributed to Any Store.java b/Medium/Minimized Maximum of Products Distributed to Any Store.java
new file mode 100644
index 00000000..70a46016
--- /dev/null
+++ b/Medium/Minimized Maximum of Products Distributed to Any Store.java	
@@ -0,0 +1,36 @@
+class Solution {
+    public int minimizedMaximum(int n, int[] quantities) {
+        int left = 0;
+        int right = 0;
+        for (int quantity : quantities) {
+            right = Math.max(right, quantity);
+        }
+        while (left < right) {
+            int mid = (left + right) / 2;
+            if (isPossible(n, mid, quantities)) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+
+    private boolean isPossible(int n, int min, int[] quantities) {
+        int idx = 0;
+        int remaining = quantities[idx];
+        for (int i = 0; i < n; i++) {
+            if (remaining <= min) {
+                idx++;
+                if (idx == quantities.length) {
+                    return true;
+                } else {
+                    remaining = quantities[idx];
+                }
+            } else {
+                remaining -= min;
+            }
+        }
+        return false;
+    }
+}
diff --git a/Medium/Minimum Add to Make Parentheses Valid.java b/Medium/Minimum Add to Make Parentheses Valid.java
index f119bfe7..7fcfc88d 100644
--- a/Medium/Minimum Add to Make Parentheses Valid.java	
+++ b/Medium/Minimum Add to Make Parentheses Valid.java	
@@ -1,18 +1,14 @@
 class Solution {
-  public int minAddToMakeValid(String s) {
-    int count = 0;
-    Stack<Character> stack = new Stack<>();
-    for (char c : s.toCharArray()) {
-      if (c == '(') {
-        stack.push(c);
-      } else {
-        if (stack.isEmpty()) {
-          count++;
-        } else {
-          stack.pop();
+    public int minAddToMakeValid(String s) {
+        int open = 0;
+        int count = 0;
+        for (char c : s.toCharArray()) {
+            open += c == '(' ? 1 : -1;
+            if (open < 0) {
+                count += Math.abs(open);
+                open = 0;
+            }
         }
-      }
+        return count + open;
     }
-    return count + stack.size();
-  }
 }
diff --git a/Medium/Minimum Amount of Time to Collect Garbage.java b/Medium/Minimum Amount of Time to Collect Garbage.java
index b0ac91ff..ace2125d 100644
--- a/Medium/Minimum Amount of Time to Collect Garbage.java	
+++ b/Medium/Minimum Amount of Time to Collect Garbage.java	
@@ -1,34 +1,25 @@
 class Solution {
-  public int garbageCollection(String[] garbage, int[] travel) {
-    int[] lastIdx = {-1, -1, -1};
-    Map<Integer, int[]> garbageCount = new HashMap<>();
-    for (int i = 0; i < garbage.length; i++) {
-      garbageCount.put(i, new int[3]);
-      for (char c : garbage[i].toCharArray()) {
-        if (c == 'M') {
-          lastIdx[0] = i;
-          garbageCount.get(i)[0]++;
+    public int garbageCollection(String[] garbage, int[] travel) {
+        Map<Character, Integer> lastIdx = new HashMap<>();
+        for (int i = garbage.length - 1; i >= 0; i--) {
+            if (garbage[i].indexOf('M') != -1) {
+                lastIdx.putIfAbsent('M', i);
+            }
+            if (garbage[i].indexOf('G') != -1) {
+                lastIdx.putIfAbsent('G', i);
+            }
+            if (garbage[i].indexOf('P') != -1) {
+                lastIdx.putIfAbsent('P', i);
+            }
         }
-        if (c == 'P') {
-          lastIdx[1] = i;
-          garbageCount.get(i)[1]++;
+        int totalTime = 0;
+        for (int i = 0; i < garbage.length; i++) {
+            int travelTime = i == 0 ? 0 : travel[i - 1];
+            totalTime += garbage[i].length();
+            totalTime += lastIdx.getOrDefault('P', -1) >= i ? travelTime : 0;
+            totalTime += lastIdx.getOrDefault('M', -1) >= i ? travelTime : 0;
+            totalTime += lastIdx.getOrDefault('G', -1) >= i ? travelTime : 0;
         }
-        if (c == 'G') {
-          lastIdx[2] = i;
-          garbageCount.get(i)[2]++;
-        }
-      }
-    }
-    int time = 0;
-    for (int i = 0; i < 3; i++) {
-      for (int j = 0; j < garbage.length; j++) {
-        if (lastIdx[i] < j) {
-          break;
-        }
-        time += j == 0 ? 0 : travel[j - 1];
-        time += garbageCount.get(j)[i];
-      }
+        return totalTime;
     }
-    return time;
-  }
 }
diff --git a/Medium/Minimum Cost For Tickets.java b/Medium/Minimum Cost For Tickets.java
new file mode 100644
index 00000000..8867660b
--- /dev/null
+++ b/Medium/Minimum Cost For Tickets.java	
@@ -0,0 +1,29 @@
+class Solution {
+    public int mincostTickets(int[] days, int[] costs) {
+        Set<Integer> daySet = new HashSet<>();
+        for (int day : days) {
+            daySet.add(day);
+        }
+        int[] dp = new int[days[days.length - 1]];
+        return helper(days[days.length - 1], daySet, costs, dp);
+    }
+    
+    private int helper(int currDay, Set<Integer> daySet, int[] costs, int[] dp) {
+        if (currDay <= 0) {
+            return 0;
+        }
+        if (dp[currDay - 1] != 0) {
+            return dp[currDay - 1];
+        }
+        int result = 0;
+        if (daySet.contains(currDay)) {
+            int one = helper(currDay - 1, daySet, costs, dp) + costs[0];
+            int seven = helper(currDay - 7, daySet, costs, dp) + costs[1];
+            int thirty = helper(currDay - 30, daySet, costs, dp) + costs[2];
+            result = Math.min(one, Math.min(seven, thirty));
+        } else {
+            result = helper(currDay - 1, daySet, costs, dp);
+        }
+        return dp[currDay - 1] = result;
+    }
+}
diff --git a/Medium/Minimum Deletions to Make Character Frequencies Unique.java b/Medium/Minimum Deletions to Make Character Frequencies Unique.java
index f98fa559..2d57dc68 100644
--- a/Medium/Minimum Deletions to Make Character Frequencies Unique.java	
+++ b/Medium/Minimum Deletions to Make Character Frequencies Unique.java	
@@ -1,25 +1,25 @@
 class Solution {
-  public int minDeletions(String s) {
-    int[] frequency = new int[26];
-    for (char c : s.toCharArray()) {
-      frequency[c - 'a']++;
-    }
-    PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
-    for (int freq : frequency) {
-      if (freq > 0) {
-        pq.add(freq);
-      }
-    }
-    int numOfDeletions = 0;
-    while (!pq.isEmpty()) {
-      int removedFreq = pq.poll();
-      if (!pq.isEmpty() && pq.peek() == removedFreq) {
-        numOfDeletions++;
-        if (removedFreq > 1) {
-          pq.add(removedFreq - 1);
+    public int minDeletions(String s) {
+        int[] frequency = new int[26];
+        for (char c : s.toCharArray()) {
+            frequency[c - 'a']++;
+        }
+        Arrays.sort(frequency);
+        int numOfDeletions = 0;
+        int expectedFrequency = frequency[25];
+        for (int i = 25; i >= 0; i--) {
+            if (frequency[i] == 0) {
+                break;
+            }
+            if (frequency[i] > expectedFrequency) {
+                numOfDeletions += frequency[i] - expectedFrequency;
+            } else {
+                expectedFrequency = frequency[i];
+            }
+            if (expectedFrequency > 0) {
+                expectedFrequency--;
+            }
         }
-      }
+        return numOfDeletions;
     }
-    return numOfDeletions;
-  }
 }
diff --git a/Medium/Minimum Difference Between Largest and Smallest Value in Three Moves.java b/Medium/Minimum Difference Between Largest and Smallest Value in Three Moves.java
new file mode 100644
index 00000000..2722191a
--- /dev/null
+++ b/Medium/Minimum Difference Between Largest and Smallest Value in Three Moves.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int minDifference(int[] nums) {
+        int n = nums.length;
+        if (n <= 4) {
+            return 0;
+        }
+        Arrays.sort(nums);
+        int minDiff = Integer.MAX_VALUE;
+        int left = 0;
+        int right = n - 4;
+        while (left < 4) {
+            minDiff = Math.min(minDiff, nums[right++] - nums[left++]);
+        }
+        return minDiff;
+    }
+}
diff --git a/Medium/Minimum Falling Path Sum.java b/Medium/Minimum Falling Path Sum.java
index 040759bf..255081b9 100644
--- a/Medium/Minimum Falling Path Sum.java	
+++ b/Medium/Minimum Falling Path Sum.java	
@@ -1,27 +1,33 @@
 class Solution {
-  public int minFallingPathSum(int[][] matrix) {
-    int minFallingSum = Integer.MAX_VALUE;
-    Integer[][] dp = new Integer[matrix.length][matrix[0].length];
-    for (int i = 0; i < matrix.length; i++) {
-      minFallingSum = Math.min(minFallingSum, findMinFallingPathSumHelper(matrix, 0, i, dp));
+    private static final int[][] DIRS = {{1, -1}, {1, 0}, {1, 1}};
+
+    public int minFallingPathSum(int[][] matrix) {
+        int rows = matrix.length;
+        int cols = matrix[0].length;
+        Integer[][] dp = new Integer[rows + 1][cols + 1];
+        int result = Integer.MAX_VALUE;
+        for (int i = 0; i < cols; i++) {
+            result = Math.min(result, recurse(matrix, 0, i, rows, cols, dp));
+        }
+        return result;
     }
-    return minFallingSum;
-  }
-  
-  private int findMinFallingPathSumHelper(int[][] matrix, int row, int col, Integer[][] dp) {
-    if (col < 0 || col == matrix.length) {
-      return Integer.MAX_VALUE;
+
+    private int recurse(int[][] matrix, int row, int col, int rows, int cols, Integer[][] dp) {
+        if (row == rows - 1) {
+            return matrix[row][col];
+        }
+        if (dp[row][col] != null) {
+            return dp[row][col];
+        }
+        int result = Integer.MAX_VALUE;
+        for (int[] dir : DIRS) {
+            int newRow = row + dir[0];
+            int newCol = col + dir[1];
+            if (newRow < 0 || newCol < 0 || newRow >= rows || newCol >= cols) {
+                continue;
+            }
+            result = Math.min(result, matrix[row][col] + recurse(matrix, newRow, newCol, rows, cols, dp));
+        }
+        return dp[row][col] = result;
     }
-    if (row == matrix.length - 1) {
-      return matrix[row][col];
-    }
-    if (dp[row][col] != null) {
-      return dp[row][col];
-    }
-    int leftSum = findMinFallingPathSumHelper(matrix, row + 1, col, dp);
-    int middleSum = findMinFallingPathSumHelper(matrix, row + 1, col + 1, dp);
-    int rightSum = findMinFallingPathSumHelper(matrix, row + 1, col - 1, dp);
-    dp[row][col] = Math.min(leftSum, Math.min(middleSum, rightSum)) + matrix[row][col];
-    return dp[row][col];
-  }
 }
diff --git a/Medium/Minimum Flips to Make a OR b Equal to c.java b/Medium/Minimum Flips to Make a OR b Equal to c.java
new file mode 100644
index 00000000..91963256
--- /dev/null
+++ b/Medium/Minimum Flips to Make a OR b Equal to c.java	
@@ -0,0 +1,5 @@
+class Solution {
+    public int minFlips(int a, int b, int c) {
+        return Integer.bitCount((a | b) ^ c) + Integer.bitCount(a & b & ((a | b) ^ c)); 
+    }
+}
diff --git a/Medium/Minimum Fuel Cost to Report to the Capital.java b/Medium/Minimum Fuel Cost to Report to the Capital.java
new file mode 100644
index 00000000..ee48239f
--- /dev/null
+++ b/Medium/Minimum Fuel Cost to Report to the Capital.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public long minimumFuelCost(int[][] roads, int seats) {
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        for (int[] road : roads) {
+            graph.computeIfAbsent(road[0], k -> new ArrayList<>()).add(road[1]);
+            graph.computeIfAbsent(road[1], k -> new ArrayList<>()).add(road[0]);
+        }
+        long[] fuel = {0l};
+        dfs(0, -1, graph, seats, fuel);
+        return fuel[0];
+    }
+    
+    private long dfs(int node, int parent, Map<Integer, List<Integer>> graph, int seats, long[] fuel) {
+        int representativeCount = 1;
+        if (!graph.containsKey(node)) {
+            return representativeCount;
+        }
+        for (int child : graph.get(node)) {
+            if (child != parent) {
+                representativeCount += dfs(child, node, graph, seats, fuel);
+            }
+        }
+        if (node != 0) {
+            fuel[0] += Math.ceil((double) representativeCount / seats); 
+        }
+        return representativeCount;
+    }
+}
diff --git a/Medium/Minimum Health to Beat Game.java b/Medium/Minimum Health to Beat Game.java
new file mode 100644
index 00000000..9b93099e
--- /dev/null
+++ b/Medium/Minimum Health to Beat Game.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public long minimumHealth(int[] damage, int armor) {
+        int maxDamage = 0;
+        long totalDamage = 0;
+        for (int d : damage) {
+            totalDamage += d;
+            maxDamage = Math.max(maxDamage, d);
+        }
+        return totalDamage - Math.min(armor, maxDamage) + 1;
+    }
+}
diff --git a/Medium/Minimum Increment to Make Array Unique.java b/Medium/Minimum Increment to Make Array Unique.java
new file mode 100644
index 00000000..7be5a583
--- /dev/null
+++ b/Medium/Minimum Increment to Make Array Unique.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int minIncrementForUnique(int[] nums) {
+        Arrays.sort(nums);
+        int increments = 0;
+        for (int i = 1; i < nums.length; i++) {
+            if (nums[i] <= nums[i - 1]) {
+                increments += nums[i - 1] + 1 - nums[i];
+                nums[i] = nums[i - 1] + 1;
+            }
+        }
+        return increments;
+    }
+}
diff --git a/Medium/Minimum Knight Moves.java b/Medium/Minimum Knight Moves.java
index e1352ac4..35759df8 100644
--- a/Medium/Minimum Knight Moves.java	
+++ b/Medium/Minimum Knight Moves.java	
@@ -1,30 +1,30 @@
 class Solution {
-  private final int[][] DIRS = {{1, 2}, {2, 1}, {1, -2}, {-2, 1}, {2, -1}, {-2, -1}, {-1, -2}, {-1, 2}};
-  
-  public int minKnightMoves(int x, int y) {
-    int numOfSteps = 0;
-    boolean[][] visited = new boolean[607][607];
-    Queue<int[]> queue = new LinkedList<>();
-    queue.add(new int[]{0, 0});
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int[] removed = queue.remove();
-        if (removed[0] == x && removed[1] == y) {
-          return numOfSteps;
+
+    private static final int[][] MOVES = {{1, 2}, {2, 1}, {2, -1}, {1, -2}, {-1, -2}, {-2, -1}, {-2, 1}, {-1, 2}};
+
+    public int minKnightMoves(int x, int y) {
+        boolean[][] visited = new boolean[607][607];
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{0, 0});
+        int steps = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] removed = queue.remove();
+                if (removed[0] == x && removed[1] == y) {
+                    return steps;
+                }
+                for (int[] move : MOVES) {
+                    int newX = removed[0] + move[0];
+                    int newY = removed[1] + move[1];
+                    if (!visited[newX + 302][newY + 302]) {
+                        visited[newX + 302][newY + 302] = true;
+                        queue.add(new int[]{newX, newY});
+                    }
+                }
+            }
+            steps++;
         }
-        for (int[] dir : DIRS) {
-          int newX = removed[0] + dir[0];
-          int newY = removed[1] + dir[1];
-          if (visited[newX + 302][newY + 302]) {
-            continue;
-          }
-          visited[newX + 302][newY + 302] = true;
-          queue.add(new int[]{newX, newY});
-        }
-      }
-      numOfSteps++;
+        return steps;
     }
-    return numOfSteps;
-  }
 }
diff --git a/Medium/Minimum Length of String After Deleting Similar Ends.java b/Medium/Minimum Length of String After Deleting Similar Ends.java
new file mode 100644
index 00000000..bc1c6c89
--- /dev/null
+++ b/Medium/Minimum Length of String After Deleting Similar Ends.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int minimumLength(String s) {
+        int start = 0;
+        int end = s.length() - 1;
+        while (start < end && s.charAt(start) == s.charAt(end)) {
+            char startChar = s.charAt(start);
+            char endChar = s.charAt(end);
+            while (start <= end && s.charAt(start) == startChar) {
+                start++;
+            }
+            while (end > start && s.charAt(end) == endChar) {
+                end--;
+            }
+        }
+        return end - start + 1;
+    }
+}
diff --git a/Medium/Minimum Levels to Gain More Points.java b/Medium/Minimum Levels to Gain More Points.java
new file mode 100644
index 00000000..c7fd7222
--- /dev/null
+++ b/Medium/Minimum Levels to Gain More Points.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int minimumLevels(int[] possible) {
+        int n = possible.length;
+        int totalScore = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            totalScore += possible[i] == 1 ? 1 : -1;
+        }
+        int score = 0;
+        for (int i = 0; i < n - 1; i++) {
+            score += possible[i] == 1 ? 1 : -1;
+            if (score > totalScore - score) {
+                return i + 1;
+            }
+        }
+        return -1;
+    }
+}
diff --git a/Medium/Minimum Number of Days to Make m Bouquets.java b/Medium/Minimum Number of Days to Make m Bouquets.java
new file mode 100644
index 00000000..83578712
--- /dev/null
+++ b/Medium/Minimum Number of Days to Make m Bouquets.java	
@@ -0,0 +1,37 @@
+class Solution {
+    public int minDays(int[] bloomDay, int m, int k) {
+        int left = 0;
+        int right = 0;
+        for (int day : bloomDay) {
+            right = Math.max(right, day);
+        }
+        int days = -1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (numberOfBouquet(bloomDay, mid, k) >= m) {
+                days = mid;
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return days;
+    }
+
+    private int numberOfBouquet(int[] bloomDay, int mid, int k) {
+        int bouquetCount = 0;
+        int count = 0;
+        for (int i = 0; i < bloomDay.length; i++) {
+            if (bloomDay[i] <= mid) {
+                count++;
+            } else {
+                count = 0;
+            }
+            if (count == k) {
+                bouquetCount++;
+                count = 0;
+            }
+        }
+        return bouquetCount;
+    }
+}
diff --git a/Medium/Minimum Number of Operations to Make Array Empty.java b/Medium/Minimum Number of Operations to Make Array Empty.java
new file mode 100644
index 00000000..69754a8d
--- /dev/null
+++ b/Medium/Minimum Number of Operations to Make Array Empty.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int minOperations(int[] nums) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int num : nums) {
+            map.put(num, map.getOrDefault(num, 0) + 1);
+        }
+        int operations = 0;
+        for (Integer value : map.values()) {
+            if (value == 1) {
+                return -1;
+            }
+            operations += value / 3 + (value % 3 == 0 ? 0 : 1);
+        }
+        return operations;
+    }
+}
diff --git a/Medium/Minimum Number of Pushes to Type Word II.java b/Medium/Minimum Number of Pushes to Type Word II.java
new file mode 100644
index 00000000..71ec90f6
--- /dev/null
+++ b/Medium/Minimum Number of Pushes to Type Word II.java	
@@ -0,0 +1,23 @@
+class Solution {
+    public int minimumPushes(String word) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : word.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+        PriorityQueue<Character> pq = new PriorityQueue<>((a, b) -> map.get(b).compareTo(map.get(a)));
+        pq.addAll(map.keySet());
+        int count = 0;
+        int typeMultiple = 1;
+        int counter = 0;
+        while (!pq.isEmpty()) {
+            char removed = pq.poll();
+            count += typeMultiple * map.get(removed);
+            counter++;
+            if (counter == 8) {
+                counter = 0;
+                typeMultiple++;
+            }
+        }
+        return count;
+    }
+}
diff --git a/Medium/Minimum Number of Swaps to Make the String Balanced.java b/Medium/Minimum Number of Swaps to Make the String Balanced.java
new file mode 100644
index 00000000..79935f13
--- /dev/null
+++ b/Medium/Minimum Number of Swaps to Make the String Balanced.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int minSwaps(String s) {
+        char[] chars = s.toCharArray();
+        Stack<Integer> openBrackets = new Stack<>();
+        for (int i = 0; i < chars.length; i++) {
+            if (chars[i] == '[') {
+                openBrackets.push(i);
+            }
+        }
+        int open = 0;
+        int swaps = 0;
+        for (int i = 0; i < chars.length; i++) {
+            open += chars[i] == '[' ? 1 : -1;
+            if (open < 0) {
+                swaps++;
+                int endIdx = openBrackets.pop();
+                chars[endIdx] = ']';
+                chars[i] = '[';
+                open += 2;
+            }
+        }
+        return swaps;
+    }
+}
diff --git a/Medium/Minimum Number of Vertices to Reach All Nodes.java b/Medium/Minimum Number of Vertices to Reach All Nodes.java
index 6c0688b6..6459877d 100644
--- a/Medium/Minimum Number of Vertices to Reach All Nodes.java	
+++ b/Medium/Minimum Number of Vertices to Reach All Nodes.java	
@@ -1,15 +1,15 @@
 class Solution {
-  public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {
-    int[] indegree = new int[n];
-    for (List<Integer> edge : edges) {
-      indegree[edge.get(1)]++;
+    public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {
+        int[] indegree = new int[n];
+        for (List<Integer> edge : edges) {
+            indegree[edge.get(1)]++;
+        }
+        List<Integer> zeroIndegree = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (indegree[i] == 0) {
+                zeroIndegree.add(i);
+            }
+        }
+        return zeroIndegree;
     }
-    List<Integer> ans = new ArrayList<>();
-    for (int i = 0; i < n; i++) {
-      if (indegree[i] == 0) {
-        ans.add(i);
-      }
-    }
-    return ans;
-  }
 }
diff --git a/Medium/Minimum Operations to Exceed Threshold Value II.java b/Medium/Minimum Operations to Exceed Threshold Value II.java
new file mode 100644
index 00000000..9a6c2b09
--- /dev/null
+++ b/Medium/Minimum Operations to Exceed Threshold Value II.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int minOperations(int[] nums, int k) {
+        PriorityQueue<Long> pq = new PriorityQueue<>();
+        for (int num : nums) {
+            pq.add((long) num);
+        }
+        int operations = 0;
+        while (pq.peek() < k) {
+            long smallest = pq.poll();
+            long secondSmallest = pq.poll();
+            long newValue = Math.min(smallest, secondSmallest) * 2 + Math.max(smallest, secondSmallest);
+            pq.add(newValue);
+            operations++;
+        }
+        return operations;
+    }
+}
diff --git a/Medium/Minimum Operations to Make Binary Array Elements Equal to One I.java b/Medium/Minimum Operations to Make Binary Array Elements Equal to One I.java
new file mode 100644
index 00000000..4b5b20a1
--- /dev/null
+++ b/Medium/Minimum Operations to Make Binary Array Elements Equal to One I.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public int minOperations(int[] nums) {
+        int count = 0;
+        for (int i = 0; i <= nums.length - 3; i++) {
+            if (nums[i] == 0) {
+                nums[i] = nums[i] == 0 ? 1 : 0;
+                nums[i + 1] = nums[i + 1] == 0 ? 1 : 0;
+                nums[i + 2] = nums[i + 2] == 0 ? 1 : 0;
+                count++;
+            }
+        }
+        for (int i = nums.length - 3; i < nums.length; i++) {
+            if (nums[i] == 0) {
+                return -1;
+            } 
+        }
+        return count;
+    }
+}
diff --git a/Medium/Minimum Operations to Make a Special Number.java b/Medium/Minimum Operations to Make a Special Number.java
new file mode 100644
index 00000000..20f250fc
--- /dev/null
+++ b/Medium/Minimum Operations to Make a Special Number.java	
@@ -0,0 +1,25 @@
+class Solution {
+    
+    private final int NOT_FOUND_VALUE = 100_000;
+    
+    public int minimumOperations(String num) {
+        Integer[][] dp = new Integer[100][25];
+        return helper(num, 0, 0, dp);
+    }
+    
+    private int helper(String num, int idx, int mod, Integer[][] dp) {
+        if (idx == num.length()) {
+            if (mod == 0) {
+                return 0;
+            }
+            return NOT_FOUND_VALUE;
+        }
+        if (dp[idx][mod] != null) {
+            return dp[idx][mod];
+        }
+        int take = helper(num, idx + 1, (mod * 10 + (num.charAt(idx) - '0')) % 25, dp);
+        int remove = 1 + helper(num, idx + 1, mod, dp);
+        dp[idx][mod] = Math.min(take, remove);
+        return dp[idx][mod];
+    }
+}
diff --git a/Medium/Minimum Operations to Reduce X to Zero.java b/Medium/Minimum Operations to Reduce X to Zero.java
index 3e202cb6..f2f2a99b 100644
--- a/Medium/Minimum Operations to Reduce X to Zero.java	
+++ b/Medium/Minimum Operations to Reduce X to Zero.java	
@@ -1,21 +1,22 @@
 class Solution {
-  public int minOperations(int[] nums, int x) {
-    int totalSum = 0;
-    for (int num : nums) {
-      totalSum += num;
+    public int minOperations(int[] nums, int x) {
+        int sum = 0;
+        for (int num : nums) {
+            sum += num;
+        }
+        int max = -1;
+        int left = 0;
+        int curr = 0;
+        int n = nums.length;
+        for (int right = 0; right < n; right++) {
+            curr += nums[right];
+            while (curr > sum - x && left <= right) {
+                curr -= nums[left++];
+            }
+            if (curr == sum - x) {
+                max = Math.max(max, right - left + 1);
+            }
+        }
+        return max != -1 ? n - max : -1;
     }
-    int max = -1;
-    int left = 0;
-    int current = 0;
-    for (int right = 0; right < nums.length; right++) {
-      current += nums[right];
-      while (current > totalSum - x && left <= right) {
-        current -= nums[left++];
-      }
-      if (current == totalSum - x) {
-        max = Math.max(max, right - left + 1);
-      }
-    }
-    return max != -1 ? nums.length - max : -1;
-  }
 }
diff --git a/Medium/Minimum Path Sum.java b/Medium/Minimum Path Sum.java
index 2100ec3a..0565b7b0 100644
--- a/Medium/Minimum Path Sum.java	
+++ b/Medium/Minimum Path Sum.java	
@@ -1,18 +1,18 @@
 class Solution {
-  public int minPathSum(int[][] grid) {
-    int[][] dp = new int[grid.length][grid[0].length];
-    for (int i = 0; i < dp.length; i++) {
-      for (int j = 0; j < dp[i].length; j++) {
-        dp[i][j] += grid[i][j];
-        if (i > 0 && j > 0) {
-          dp[i][j] += Math.min(dp[i - 1][j], dp[i][j - 1]);
-        } else if (i > 0) {
-          dp[i][j] += dp[i - 1][j];
-        } else if (j > 0) {
-          dp[i][j] += dp[i][j - 1];
+    public int minPathSum(int[][] grid) {
+        int[][] dp = new int[grid.length][grid[0].length];
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                dp[i][j] = grid[i][j];
+                if (i > 0 && j > 0) {
+                    dp[i][j] += Math.min(dp[i - 1][j], dp[i][j - 1]);
+                } else if (i > 0) {
+                    dp[i][j] += dp[i - 1][j];
+                } else if (j > 0) {
+                    dp[i][j] += dp[i][j - 1];
+                }
+            }
         }
-      }
+        return dp[grid.length - 1][grid[0].length - 1];
     }
-    return dp[grid.length - 1][grid[0].length - 1];
-  }
 }
diff --git a/Medium/Minimum Penalty for a Shop.java b/Medium/Minimum Penalty for a Shop.java
new file mode 100644
index 00000000..e5c5eaa9
--- /dev/null
+++ b/Medium/Minimum Penalty for a Shop.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int bestClosingTime(String customers) {
+        int n = customers.length();
+        int minPenalty = 0;
+        int currPenalty = 0;
+        int minPenaltyHour = 0;
+        for (int i = 0; i < n; i++) {
+            currPenalty += customers.charAt(i) == 'Y' ? -1 : 1;
+            if (currPenalty < minPenalty) {
+                minPenaltyHour = i + 1;
+                minPenalty = currPenalty;
+            }
+        }
+        return minPenaltyHour;
+    }
+}
diff --git a/Medium/Minimum Processing Time.java b/Medium/Minimum Processing Time.java
new file mode 100644
index 00000000..ec9b75e6
--- /dev/null
+++ b/Medium/Minimum Processing Time.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int minProcessingTime(List<Integer> processorTime, List<Integer> tasks) {
+        PriorityQueue<Integer> taskQueue = new PriorityQueue<>();
+        PriorityQueue<Integer> processorQueue = new PriorityQueue<>((a, b) -> b - a);
+        taskQueue.addAll(tasks);
+        processorQueue.addAll(processorTime);
+        int totalTime = Integer.MIN_VALUE;
+        while (!processorQueue.isEmpty()) {
+            int startTime = processorQueue.remove();
+            int currTime = Integer.MIN_VALUE;
+            for (int i = 0; i < 4; i++) {
+                currTime = Math.max(currTime, startTime + taskQueue.remove());
+            }
+            totalTime = Math.max(totalTime, currTime);
+        }
+        return totalTime;
+    }
+}
diff --git a/Medium/Minimum Remove to Make Valid Parentheses.java b/Medium/Minimum Remove to Make Valid Parentheses.java
index 45734d11..7d5be988 100644
--- a/Medium/Minimum Remove to Make Valid Parentheses.java	
+++ b/Medium/Minimum Remove to Make Valid Parentheses.java	
@@ -1,27 +1,28 @@
 class Solution {
-  public String minRemoveToMakeValid(String s) {
-    Stack<Integer> stack = new Stack<>();
-    Set<Integer> validIndexes = new HashSet<>();
-    for (int i = 0; i < s.length(); i++) {
-      if (s.charAt(i) == '(') {
-        stack.add(i);
-      } else if (s.charAt(i) == ')') {
-        if (!stack.isEmpty()) {
-          validIndexes.add(stack.pop());
-          validIndexes.add(i);
+    public String minRemoveToMakeValid(String s) {
+        char[] letters = s.toCharArray();
+        Stack<Integer> stack = new Stack<>();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c == '(') {
+                stack.push(i);
+            } else if (c == ')') {
+                if (stack.isEmpty()) {
+                    letters[i] = '-';
+                } else {
+                    stack.pop();
+                }
+            }
         }
-      }
-    }
-    StringBuilder sb = new StringBuilder();
-    for (int i = 0; i < s.length(); i++) {
-      if (s.charAt(i) == '(' || s.charAt(i) == ')') {
-        if (validIndexes.contains(i)) {
-          sb.append(s.charAt(i));
+        while (!stack.isEmpty()) {
+            letters[stack.pop()] = '-';
+        }
+        StringBuilder sb = new StringBuilder();
+        for (char c : letters) {
+            if (c != '-') {
+                sb.append(c);
+            }
         }
-      } else {
-        sb.append(s.charAt(i));
-      }
+        return sb.toString();
     }
-    return sb.toString();
-  }
 }
diff --git a/Medium/Minimum Rounds to Complete All Tasks.java b/Medium/Minimum Rounds to Complete All Tasks.java
new file mode 100644
index 00000000..309810a0
--- /dev/null
+++ b/Medium/Minimum Rounds to Complete All Tasks.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public int minimumRounds(int[] tasks) {
+        Map<Integer, Long> frequencyMap = Arrays.stream(tasks)
+            .boxed()
+            .collect(Collectors.groupingBy(
+                Function.identity(), 
+                HashMap::new, 
+                Collectors.counting()));
+        int rounds = 0;
+        for (Long occurrences : frequencyMap.values()) {
+            if (occurrences == 1) {
+                return -1;
+            }
+            if (occurrences % 3 == 0) {
+                rounds += (int) (occurrences / 3);
+            } else {
+                rounds += (int) (occurrences / 3 + 1);
+            }
+        }
+        return rounds;
+    }
+}
diff --git a/Medium/Minimum Score of a Path Between Two Cities.java b/Medium/Minimum Score of a Path Between Two Cities.java
new file mode 100644
index 00000000..28b7ed1b
--- /dev/null
+++ b/Medium/Minimum Score of a Path Between Two Cities.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public int minScore(int n, int[][] roads) {
+        Map<Integer, List<List<Integer>>> graph = new HashMap<>();
+        for (int[] road : roads) {
+            graph.computeIfAbsent(road[0], k -> new ArrayList<>())
+                .add(List.of(road[1], road[2]));
+            graph.computeIfAbsent(road[1], k -> new ArrayList<>())
+                .add(List.of(road[0], road[2]));
+        }
+        return bfs(n, graph);
+    }
+    
+    private int bfs(int n , Map<Integer, List<List<Integer>>> graph) {
+        boolean[] visited = new boolean[n + 1];
+        Queue<Integer> queue = new LinkedList<>();
+        int result = Integer.MAX_VALUE;
+        queue.add(1);
+        visited[1] = true;
+        while (!queue.isEmpty()) {
+            int node = queue.remove();
+            for (List<Integer> edge : graph.getOrDefault(node, new ArrayList<>())) {
+                result = Math.min(result, edge.get(1));
+                if (!visited[edge.get(0)]) {
+                    visited[edge.get(0)] = true;
+                    queue.add(edge.get(0));
+                }
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Minimum Size Subarray Sum.java b/Medium/Minimum Size Subarray Sum.java
index 4d41780e..5bafe959 100644
--- a/Medium/Minimum Size Subarray Sum.java	
+++ b/Medium/Minimum Size Subarray Sum.java	
@@ -1,30 +1,18 @@
 class Solution {
-    public int minSubArrayLen(int s, int[] nums) {
-        int sum = 0;
-        int slow = 0;
-        int fast = 0;
-        int n = nums.length;
-        int minLen = Integer.MAX_VALUE;
-        
-        while (fast < n) {
-            sum += nums[fast];
-            
-            if (sum >= s) {
-                while (slow <= fast) {
-                    minLen = Math.min(minLen, fast - slow + 1);
-                    if (sum - nums[slow] >= s) {
-                        sum -= nums[slow];
-                        slow++;
-                    }
-                    else {
-                        break;
-                    }
-                }   
+    public int minSubArrayLen(int target, int[] nums) {
+        int start = 0;
+        int end = 0;
+        int currSum = 0;
+        int minLength = Integer.MAX_VALUE;
+        while (end < nums.length) {
+            currSum += nums[end++];
+            while (start < end && currSum - nums[start] >= target) {
+                currSum -= nums[start++];
+            }
+            if (currSum >= target) {
+                minLength = Math.min(minLength, end - start);
             }
-            
-            fast++;
         }
-        
-        return minLen == Integer.MAX_VALUE ? 0 : minLen;
+        return minLength == Integer.MAX_VALUE ? 0 : minLength;
     }
 }
diff --git a/Medium/Minimum Speed to Arrive on Time.java b/Medium/Minimum Speed to Arrive on Time.java
new file mode 100644
index 00000000..c5751902
--- /dev/null
+++ b/Medium/Minimum Speed to Arrive on Time.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int minSpeedOnTime(int[] dist, double hour) {
+        int start = 1;
+        int end = 1000_000_0;
+        int minSpeed = -1;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            if (isPossible(dist, mid, hour)) {
+                minSpeed = mid;
+                end = mid - 1;
+            } else {
+                start = mid + 1;
+            }
+        }
+        return minSpeed;
+    }
+    
+    private boolean isPossible(int[] dist, int speed, double hour) {
+        double totalTime = 0.0;
+        for (int i = 0; i < dist.length; i++) {
+            double time = (double) dist[i] / (double) speed;
+            totalTime += (i == dist.length - 1 ? time : Math.ceil(time));
+        }
+        return totalTime <= hour;
+    }
+}
diff --git a/Medium/Minimum Time to Collect All Apples in a Tree.java b/Medium/Minimum Time to Collect All Apples in a Tree.java
index 24feb762..0e54b3ec 100644
--- a/Medium/Minimum Time to Collect All Apples in a Tree.java	
+++ b/Medium/Minimum Time to Collect All Apples in a Tree.java	
@@ -1,25 +1,27 @@
 class Solution {
-  public int minTime(int n, int[][] edges, List<Boolean> hasApple) {
-    Map<Integer, Set<Integer>> tree = new HashMap<>();
-    for (int[] edge : edges) {
-      tree.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
-      tree.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
+    public int minTime(int n, int[][] edges, List<Boolean> hasApple) {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        for (int[] edge : edges) {
+            map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+            map.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+        }
+        return recurse(0, -1, map, hasApple);
     }
-    Set<Integer> visited = new HashSet<>();
-    return dfs(0, hasApple, visited, tree);
-  }
-  
-  private int dfs(int node, List<Boolean> hasApple, Set<Integer> visited, Map<Integer, Set<Integer>> tree) {
-    visited.add(node);
-    int result = 0;
-    for (Integer child : tree.getOrDefault(node, new HashSet<>())) {
-      if (!visited.contains(child)) {
-        result += dfs(child, hasApple, visited, tree);
-      }
+
+    private int recurse(int node, int parent, Map<Integer, List<Integer>> graph, List<Boolean> hasApple) {
+        if (!graph.containsKey(node)) {
+            return 0;
+        }
+        int time = 0;
+        for (Integer conn: graph.get(node)) {
+            if (conn == parent) {
+                continue;
+            }
+            int connTime = recurse(conn, node, graph, hasApple);
+            if (connTime > 0 || hasApple.get(conn)) {
+                time += connTime + 2;
+            }
+        }
+        return time;
     }
-    if ((result > 0 || hasApple.get(node)) && node != 0) {
-      result += 2;
-    }
-    return result;
-  }
 }
diff --git a/Medium/Minimum Time to Complete Trips.java b/Medium/Minimum Time to Complete Trips.java
index 901a3e57..f6fa3539 100644
--- a/Medium/Minimum Time to Complete Trips.java	
+++ b/Medium/Minimum Time to Complete Trips.java	
@@ -1,27 +1,27 @@
 class Solution {
-  public long minimumTime(int[] time, int totalTrips) {
-    long minTime = 1;
-    long fastestBus = time[0];
-    for (int t : time) {
-      fastestBus = Math.min(fastestBus, t);
+    public long minimumTime(int[] time, int totalTrips) {
+        int maxTime = 1;
+        for (int t : time) {
+            maxTime = Math.max(maxTime, t);
+        }
+        long left = 1;
+        long right = (long) maxTime * totalTrips;
+        while (left < right) {
+            long mid = (left + right) / 2;
+            if (isPossible(time, mid, totalTrips)) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
     }
-    long maxTime = fastestBus * totalTrips;
-    while (minTime < maxTime) {
-      long midTime = minTime + (maxTime - minTime) / 2;
-      if (getNumberOfTripsWithTime(time, midTime) >= totalTrips) {
-        maxTime = midTime;
-      } else {
-        minTime = midTime + 1;
-      }
+    
+    private boolean isPossible(int[] time, long totalTime, int totalTrips) {
+        long actualTrips = 0;
+        for (int t : time) {
+            actualTrips += totalTime / t;
+        }
+        return actualTrips >= totalTrips;
     }
-    return minTime;
-  }
-  
-  private long getNumberOfTripsWithTime(int[] time, long currentTime) {
-    long totalTrips = 0;
-    for (int t : time) {
-      totalTrips += currentTime / t;
-    }
-    return totalTrips;
-  }
 }
diff --git a/Medium/Minimum Time to Make Rope Colorful.java b/Medium/Minimum Time to Make Rope Colorful.java
index 97cc34e1..3fdc7e26 100644
--- a/Medium/Minimum Time to Make Rope Colorful.java	
+++ b/Medium/Minimum Time to Make Rope Colorful.java	
@@ -1,19 +1,19 @@
 class Solution {
-  public int minCost(String colors, int[] neededTime) {
-    int totalTime = 0;
-    int left = 0;
-    int right = 0;
-    while (right < colors.length()) {
-      int currTotal = 0;
-      int currMax = 0;
-      while (left < neededTime.length && colors.charAt(right) == colors.charAt(left)) {
-        currTotal += neededTime[left];
-        currMax = Math.max(currMax, neededTime[left]);
-        left++;
-      }
-      totalTime += currTotal - currMax;
-      right = left;
+    public int minCost(String colors, int[] neededTime) {
+        Stack<Integer> stack = new Stack<>();
+        int cost = 0;
+        for (int i = 0; i < colors.length(); i++) {
+            if (stack.isEmpty() || colors.charAt(i) != colors.charAt(stack.peek())) {
+                stack.push(i);
+                continue;
+            }
+            if (neededTime[i] > neededTime[stack.peek()]) {
+                cost += neededTime[stack.pop()];
+                stack.push(i);
+            } else {
+                cost += neededTime[i]; 
+            }
+        }
+        return cost;
     }
-    return totalTime;
-  }
 }
diff --git a/Medium/Most Beautiful Item for Each Query.java b/Medium/Most Beautiful Item for Each Query.java
new file mode 100644
index 00000000..5d2f75db
--- /dev/null
+++ b/Medium/Most Beautiful Item for Each Query.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int[] maximumBeauty(int[][] items, int[] queries) {
+        Arrays.sort(items, (a, b) -> (a[0] - b[0]));
+        TreeMap<Integer, Integer> map = new TreeMap<>();
+        map.put(0, 0);
+        int currMax = 0;
+        for (int[] item : items) {
+            currMax = Math.max(currMax, item[1]);
+            map.put(item[0], currMax);
+        }
+        int[] result = new int[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            result[i] = map.floorEntry(queries[i]).getValue();
+        }
+        return result;
+    }
+}
diff --git a/Medium/Neighboring Bitwise XOR.java b/Medium/Neighboring Bitwise XOR.java
new file mode 100644
index 00000000..6e46025c
--- /dev/null
+++ b/Medium/Neighboring Bitwise XOR.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public boolean doesValidArrayExist(int[] derived) {
+        int n = derived.length;
+        int[] original = new int[n + 1];
+        for (int i = 0; i < derived.length; i++) {
+            original[i + 1] = derived[i] ^ original[i];
+        }
+        boolean checkForZero = (original[0] == original[n]);
+        original[0] = 1;
+        for (int i = 0; i < n; i++) {
+            original[i + 1] = derived[i] ^ original[i];
+        }
+        boolean checkForOne = (original[0] == original[n]);
+        return checkForZero || checkForOne;
+    }
+}
diff --git a/Medium/New 21 Game.java b/Medium/New 21 Game.java
new file mode 100644
index 00000000..26c88d90
--- /dev/null
+++ b/Medium/New 21 Game.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public double new21Game(int n, int k, int maxPts) {
+        double[] dp = new double[n + 1];
+        dp[0] = 1;
+        double s = k > 0 ? 1 : 0;
+        for (int i = 1; i <= n; i++) {
+            dp[i] = s / maxPts;
+            if (i < k) {
+                s += dp[i];
+            }
+            if (i - maxPts >= 0 && i - maxPts < k) {
+                s -= dp[i - maxPts];
+            }
+        }
+        double result = 0;
+        for (int i = k; i <= n; i++) {
+            result += dp[i];
+        }
+        return result;
+    }
+}
diff --git a/Medium/Next Permutation.java b/Medium/Next Permutation.java
index 7b808969..b08a0001 100644
--- a/Medium/Next Permutation.java	
+++ b/Medium/Next Permutation.java	
@@ -1,31 +1,31 @@
 class Solution {
-  public void nextPermutation(int[] nums) {
-    int idx = nums.length - 2;
-    while (idx >= 0 && nums[idx + 1] <= nums[idx]) {
-      idx--;
+    public void nextPermutation(int[] nums) {
+        int n = nums.length;
+        int pivot = n - 1;
+        // Find the first value where decreasing order doesn't holds
+        while (pivot > 0 && nums[pivot] <= nums[pivot - 1]) {
+            pivot--;
+        }
+        if (pivot != 0) {
+            int i = n - 1;
+            // Find the first value from right to left which is greater than element at
+            // pivot - 1
+            while (nums[i] <= nums[pivot - 1]) {
+                i--;
+            }
+            swap(nums, pivot - 1, i);
+        }
+        // Reverse the complete array
+        int left = pivot;
+        int right = n - 1;
+        while (left < right) {
+            swap(nums, left++, right--);
+        }
     }
-    if (idx >= 0) {
-      int endIdx = nums.length - 1;
-      while (nums[endIdx] <= nums[idx]) {
-        endIdx--;
-      }
-      swap(nums, idx, endIdx);
+
+    private void swap(int[] nums, int idxOne, int idxTwo) {
+        int temp = nums[idxOne];
+        nums[idxOne] = nums[idxTwo];
+        nums[idxTwo] = temp;
     }
-    reverse(nums, idx + 1);
-  }
-  
-  private void reverse(int[] nums, int startIdx) {
-    int endIdx = nums.length - 1;
-    while (startIdx < endIdx) {
-      swap(nums, startIdx, endIdx);
-      startIdx++;
-      endIdx--;
-    }
-  }
-  
-  private void swap(int[] nums, int i, int j) {
-    int temp = nums[i];
-    nums[i] = nums[j];
-    nums[j] = temp;
-  }
 }
diff --git a/Medium/Non Overlapping Intervals.java b/Medium/Non Overlapping Intervals.java
deleted file mode 100644
index cbdae574..00000000
--- a/Medium/Non Overlapping Intervals.java	
+++ /dev/null
@@ -1,17 +0,0 @@
-class Solution {
-  public int eraseOverlapIntervals(int[][] intervals) {
-    if (intervals.length == 0) {
-      return 0;
-    }
-    Arrays.sort(intervals, Comparator.comparingInt(o -> o[1]));
-    int notRemoved = 1;
-    int end = intervals[0][1];
-    for (int i = 1; i < intervals.length; i++) {
-      if (intervals[i][0] >= end) {
-        notRemoved++;
-        end = intervals[i][1];
-      }
-    }
-    return intervals.length - notRemoved;
-  }
-}
diff --git a/Medium/Non-overlapping Intervals.java b/Medium/Non-overlapping Intervals.java
new file mode 100644
index 00000000..c403b5ed
--- /dev/null
+++ b/Medium/Non-overlapping Intervals.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        Arrays.sort(intervals, Comparator.comparingInt((int[] o) -> o[1]));
+        int result = 0;
+        int minEndTime = Integer.MIN_VALUE;
+        for (int i = 0; i < intervals.length; i++) {
+            int start = intervals[i][0];
+            int end = intervals[i][1];
+            if (start >= minEndTime) {
+                minEndTime = end;
+            } else {
+                result++;
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Number of Closed Islands.java b/Medium/Number of Closed Islands.java
index 201b30a3..bc8a9a9e 100644
--- a/Medium/Number of Closed Islands.java	
+++ b/Medium/Number of Closed Islands.java	
@@ -1,40 +1,38 @@
 class Solution {
-  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-  
-  public int closedIsland(int[][] grid) {
-    int closedIslandCount = 0;
-    for (int i = 0; i < grid.length; i++) {
-      for (int j = 0; j < grid[0].length; j++) {
-        if (grid[i][j] == 0 && isSurroundedSuccessfully(grid, i, j)) {
-          closedIslandCount++;
+
+    private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+
+    public int closedIsland(int[][] grid) {
+        int count = 0;
+        boolean[][] visited = new boolean[grid.length][grid[0].length];
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 0 && !visited[i][j] && isClosed(grid, i, j, visited)) {
+                    count++;
+                }
+            }
         }
-      }
+        return count;
     }
-    return closedIslandCount;
-  }
-  
-  private boolean isSurroundedSuccessfully(int[][] grid, int i, int j) {
-    Queue<int[]> queue = new LinkedList<>();
-    queue.add(new int[]{i, j});
-    boolean surroundingCheck = true;
-    while (!queue.isEmpty()) {
-      int[] removed = queue.remove();
-      int x = removed[0];
-      int y = removed[1];
-      if (x < 0 || y < 0 || x >= grid.length || y >= grid[0].length) {
-        surroundingCheck = false;
-        continue;
-      }
-      if (grid[x][y] == 1) {
-        continue;
-      }
-      grid[x][y] = 1;
-      for (int[] dir : DIRS) {
-        int newX = x + dir[0];
-        int newY = y + dir[1];
-        queue.add(new int[]{newX, newY});
-      }
+
+    private boolean isClosed(int[][] grid, int i, int j, boolean[][] visited) {
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{i, j});
+        visited[i][j] = true;
+        boolean closed = true;
+        while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            for (int[] dir : DIRS) {
+                int newX = removed[0] + dir[0];
+                int newY = removed[1] + dir[1];
+                if (newX < 0 || newY < 0 || newX >= grid.length || newY >= grid[0].length) {
+                    closed = false;
+                } else if (grid[newX][newY] == 0 && !visited[newX][newY]) {
+                    queue.add(new int[]{newX, newY});
+                    visited[newX][newY] = true;
+                }
+            }
+        }
+        return closed;
     }
-    return surroundingCheck;
-  }
 }
diff --git a/Medium/Number of Connected Components in an Undirected Graph.java b/Medium/Number of Connected Components in an Undirected Graph.java
index e794deea..59e0be29 100644
--- a/Medium/Number of Connected Components in an Undirected Graph.java	
+++ b/Medium/Number of Connected Components in an Undirected Graph.java	
@@ -1,51 +1,29 @@
 class Solution {
-  public int countComponents(int n, int[][] edges) {
-    DisjointSet disjointSet = new DisjointSet(n);
-    for (int[] edge : edges) {
-      disjointSet.union(edge[0], edge[1]);
-    }
-    Set<Integer> rootSet = new HashSet<>();
-    for (int i = 0; i < n; i++) {
-      rootSet.add(disjointSet.find(i));
-    }
-    return rootSet.size();
-  }
-
-  private static class DisjointSet {
-
-    private final int[] root;
-    private final int[] rank;
-
-    public DisjointSet(int size) {
-      this.root = new int[size];
-      this.rank = new int[size];
-      for (int i = 0; i < size; i++) {
-        this.root[i] = i;
-        this.rank[i] = 1;
-      }
-    }
-
-    public void union(int nodeOne, int nodeTwo) {
-      int rootOne = find(nodeOne);
-      int rootTwo = find(nodeTwo);
-      if (rootOne != rootTwo) {
-        if (this.rank[rootOne] > this.rank[rootTwo]) {
-          this.root[rootTwo] = rootOne;
-        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
-          this.root[rootOne] = rootTwo;
-        } else {
-          this.root[rootTwo] = rootOne;
-          this.rank[rootOne]++;
+    public int countComponents(int n, int[][] edges) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new HashSet<>()).add(edge[1]);
+            graph.computeIfAbsent(edge[1], k -> new HashSet<>()).add(edge[0]);
         }
-      }
-    }
-
-
-    public int find(int node) {
-      if (node == root[node]) {
-        return node;
-      }
-      return root[node] = find(root[node]);
+        int connectedComponentCount = 0;
+        Set<Integer> visited = new HashSet<>();
+        for (int i = 0; i < n; i++) {
+            if (!visited.contains(i)) {
+                Queue<Integer> queue = new LinkedList<>();
+                visited.add(i);
+                queue.add(i);
+                while (!queue.isEmpty()) {
+                    int removed = queue.remove();
+                    for (Integer neighbor : graph.getOrDefault(removed, new HashSet<>())) {
+                        if (!visited.contains(neighbor)) {
+                            queue.add(neighbor);
+                            visited.add(neighbor);
+                        }
+                    }
+                }
+                connectedComponentCount++;
+            }
+        }
+        return connectedComponentCount;
     }
-  }
 }
diff --git a/Medium/Number of Dice Rolls With Target Sum.java b/Medium/Number of Dice Rolls With Target Sum.java
index 6e600168..e192518a 100644
--- a/Medium/Number of Dice Rolls With Target Sum.java	
+++ b/Medium/Number of Dice Rolls With Target Sum.java	
@@ -1,27 +1,31 @@
 class Solution {
-  Map<String, Integer> map = new HashMap<>();
-  final int MODULO = 1000000007;
-  public int numRollsToTarget(int d, int f, int target) {
-    if (d == 0 && target == 0) {
-      return 1;
+
+    private static final int MOD = 1000_000_007;
+
+    public int numRollsToTarget(int n, int k, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+        return helper(n, k, target, map);
     }
-    if (d == 0 || target == 0) {
-      return 0;
+
+    private int helper(int n, int k, int target, Map<Integer, Integer> map) {
+        if (n == 0 && target == 0) {
+            return 1;
+        }
+        if (n == 0 || target == 0) {
+            return 0;
+        }
+        int key = n * 1000 + target;
+        if (map.containsKey(key)) {
+            return map.get(key);
+        }
+        int result = 0;
+        for (int i = 1; i <= k; i++) {
+            if (target < i) {
+                break;
+            }
+            result = (result + helper(n - 1, k, target - i, map)) % MOD;
+        }
+        map.put(key, result);
+        return result;
     }
-    String key = d + "|" + target;
-    if (map.containsKey(key)) {
-      return map.get(key);
-    }
-    int res = 0;
-    for (int i = 1; i <= f; i++) {
-      if (target >= i) {
-        res = (res + numRollsToTarget(d - 1, f, target - i)) % MODULO;
-      }
-      else {
-        break;
-      }
-    }
-    map.put(key, res);
-    return map.get(key);
-  }
 }
diff --git a/Medium/Number of Enclaves.java b/Medium/Number of Enclaves.java
index 105942a1..afacc77a 100644
--- a/Medium/Number of Enclaves.java	
+++ b/Medium/Number of Enclaves.java	
@@ -1,30 +1,40 @@
 class Solution {
-  private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
-
-  public int numEnclaves(int[][] grid) {
-    Queue<int[]> queue = new LinkedList<>();
-    int result = 0;
-    for (int i = 0; i < grid.length; i++) {
-      for (int j = 0; j < grid[0].length; j++) {
-        result += grid[i][j];
-        if (i * j == 0 || i == grid.length - 1 || j == grid[i].length - 1) {
-          queue.add(new int[]{i, j});
+    
+    private static final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
+    
+    public int numEnclaves(int[][] grid) {
+        int count = 0;
+        boolean[][] visited = new boolean[grid.length][grid[0].length];
+        for (int i = 0; i < grid.length; i++) {
+            for (int j = 0; j < grid[0].length; j++) {
+                if (grid[i][j] == 1 && !visited[i][j]) {
+                    count += getClosedEnclaveCount(grid, i, j, visited);
+                }
+            }
         }
-      }
+        return count;
     }
-    while (!queue.isEmpty()) {
-      int[] removed = queue.remove();
-      int x = removed[0];
-      int y = removed[1];
-      if (x < 0 || y < 0 || x == grid.length || y == grid[0].length || grid[x][y] != 1) {
-        continue;
-      }
-      grid[x][y] = 0;
-      result--;
-      for (int[] dir : DIRS) {
-        queue.add(new int[]{x + dir[0], y + dir[1]});
-      }
+    
+    private int getClosedEnclaveCount(int[][] grid, int i, int j, boolean[][] visited) {
+        boolean isClosed = true;
+        int enclaveCount = 0;
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{i, j});
+        visited[i][j] = true;
+        while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            enclaveCount++;
+            for (int[] dir : DIRS) {
+                int newX = removed[0] + dir[0];
+                int newY = removed[1] + dir[1];
+                if (newX < 0 || newY < 0 || newX >= grid.length || newY >= grid[0].length) {
+                    isClosed = false;
+                } else if (grid[newX][newY] == 1 && !visited[newX][newY]) {
+                    visited[newX][newY] = true;
+                    queue.add(new int[]{newX, newY});
+                }
+            }
+        }
+        return isClosed ? enclaveCount : 0;
     }
-    return result;
-  }
 }
diff --git a/Medium/Number of Good Leaf Nodes Pairs.java b/Medium/Number of Good Leaf Nodes Pairs.java
new file mode 100644
index 00000000..c54d967f
--- /dev/null
+++ b/Medium/Number of Good Leaf Nodes Pairs.java	
@@ -0,0 +1,59 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int countPairs(TreeNode root, int distance) {
+        Map<TreeNode, List<TreeNode>> graph = new HashMap<>();
+        Set<TreeNode> leaves = new HashSet<>();
+        traverse(root, null, graph, leaves);
+        int result = 0;
+        for (TreeNode leaf : leaves) {
+            Queue<TreeNode> queue = new LinkedList<>();
+            Set<TreeNode> visited = new HashSet<>();
+            queue.add(leaf);
+            visited.add(leaf);
+            for (int i = 0; i <= distance; i++) {
+                int size = queue.size();
+                while (size-- > 0) {
+                    TreeNode curr = queue.remove();
+                    if (leaves.contains(curr) && curr != leaf) {
+                        result++;
+                    }
+                    for (TreeNode neighbor : graph.getOrDefault(curr, new ArrayList<>())) {
+                        if (visited.add(neighbor)) {
+                            queue.add(neighbor);
+                        }
+                    }
+                }
+            }
+        }
+        return result / 2;
+    }
+
+    private void traverse(TreeNode node, TreeNode parent, Map<TreeNode, List<TreeNode>> graph, Set<TreeNode> leaves) {
+        if (node == null) {
+            return;
+        }
+        if (node.left == null && node.right == null) {
+            leaves.add(node);
+        }
+        if (parent != null) {
+            graph.computeIfAbsent(parent, k -> new ArrayList<>()).add(node);
+            graph.computeIfAbsent(node, k -> new ArrayList<>()).add(parent);
+        }
+        traverse(node.left, node, graph, leaves);
+        traverse(node.right, node, graph, leaves);
+    }
+}
diff --git a/Medium/Number of Laser Beams in a Bank.java b/Medium/Number of Laser Beams in a Bank.java
index 9a03ad92..ce39e8bd 100644
--- a/Medium/Number of Laser Beams in a Bank.java	
+++ b/Medium/Number of Laser Beams in a Bank.java	
@@ -1,15 +1,17 @@
 class Solution {
-  public int numberOfBeams(String[] bank) {
-    int prevLaserCount = 0;
-    int totalNumberOfBeams = 0;
-    for (String beam : bank) {
-      if (beam.indexOf('1') != -1) {
-        int currentBeamCount = (int) beam.chars().mapToObj(c -> (char) c).filter(c -> c == '1')
-            .count();
-        totalNumberOfBeams += prevLaserCount * currentBeamCount;
-        prevLaserCount = currentBeamCount;
-      }
+    public int numberOfBeams(String[] bank) {
+        int beamCount = 0;
+        int prevLaserCount = 0;
+        for (String row : bank) {
+            int count = 0;
+            for (char c : row.toCharArray()) {
+                count += c == '1' ? 1 : 0;
+            }
+            if (count > 0) {
+                beamCount += prevLaserCount * count;
+                prevLaserCount = count;
+            }
+        }
+        return beamCount;
     }
-    return totalNumberOfBeams;
-  }
 }
diff --git a/Medium/Number of Nodes in the Sub-Tree With the Same Label.java b/Medium/Number of Nodes in the Sub-Tree With the Same Label.java
index 473b9052..1798a058 100644
--- a/Medium/Number of Nodes in the Sub-Tree With the Same Label.java	
+++ b/Medium/Number of Nodes in the Sub-Tree With the Same Label.java	
@@ -1,30 +1,28 @@
 class Solution {
-  public int[] countSubTrees(int n, int[][] edges, String labels) {
-    Map<Integer, List<Integer>> map = new HashMap<>();
-    for (int[] edge : edges) {
-      map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
-      map.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
-    }
-    int[] count = new int[n];
-    Set<Integer> set = new HashSet<>();
-    dfs(map, 0, labels, count, set);
-    return count;
-  }
-  
-  private int[] dfs(Map<Integer, List<Integer>> map, int curr, String labels, int[] count, Set<Integer> set) {
-    int[] cnt = new int[26];
-    if (set.add(curr)) {
-      char c = labels.charAt(curr);
-      for (Integer child : map.getOrDefault(curr, new ArrayList<>())) {
-        int[] temp = dfs(map, child, labels, count, set);
-        for (int i = 0; i < 26; i++) {
-          cnt[i] += temp[i];
+    public int[] countSubTrees(int n, int[][] edges, String labels) {
+        Map<Integer, List<Integer>> tree = new HashMap<>();
+        for (int[] edge : edges) {
+            tree.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+            tree.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+        }
+        int[] result = new int[n];
+        Set<Integer> visited = new HashSet<>();
+        bfs(tree, 0, labels, result, visited);
+        return result;
+    } 
+    
+    private int[] bfs(Map<Integer, List<Integer>> tree, int currNode, String labels, int[] result, Set<Integer> visited) {
+        int[] labelCount = new int[26];
+        if (visited.add(currNode)) {
+            labelCount[labels.charAt(currNode) - 'a']++;
+            for (Integer child : tree.getOrDefault(currNode, new ArrayList<>())) {
+                int[] childLabelCount = bfs(tree, child, labels, result, visited);
+                for (int i = 0; i < 26; i++) {
+                    labelCount[i] += childLabelCount[i];
+                }
+            }
+            result[currNode] += labelCount[labels.charAt(currNode) - 'a'];
         }
-      }
-      cnt[c - 'a']++;
-      count[curr] = cnt[c - 'a'];
+        return labelCount;
     }
-    return cnt;
-  }
 }
-
diff --git a/Medium/Number of Operations to Make Network Connected.java b/Medium/Number of Operations to Make Network Connected.java
new file mode 100644
index 00000000..c44c17d8
--- /dev/null
+++ b/Medium/Number of Operations to Make Network Connected.java	
@@ -0,0 +1,36 @@
+class Solution {
+    public int makeConnected(int n, int[][] connections) {
+        if (connections.length < n - 1) {
+            return -1;
+        }
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int[] conn : connections) {
+            graph.computeIfAbsent(conn[0], k -> new HashSet<>()).add(conn[1]);
+            graph.computeIfAbsent(conn[1], k -> new HashSet<>()).add(conn[0]);
+        }
+        int count = 0;
+        boolean[] visited = new boolean[n];
+        for (int i = 0; i < n; i++) {
+            if (!visited[i]) {
+                bfs(graph, i, visited);
+                count++;
+            }
+        }
+        return count - 1;
+    }
+    
+    private void bfs(Map<Integer, Set<Integer>> graph, int start, boolean[] visited) {
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(start);
+        visited[start] = true;
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            for (Integer node : graph.getOrDefault(removed, new HashSet<>())) {
+                if (!visited[node]) {
+                    visited[node] = true;
+                    queue.add(node);
+                }
+            }
+        }
+    }
+}
diff --git a/Medium/Number of Provinces.java b/Medium/Number of Provinces.java
index 4f485f0d..03338dd8 100644
--- a/Medium/Number of Provinces.java	
+++ b/Medium/Number of Provinces.java	
@@ -1,34 +1,37 @@
 class Solution {
-  public int findCircleNum(int[][] isConnected) {
-    int n = isConnected.length;
-    Map<Integer, Set<Integer>> map = new HashMap<>();
-    for (int i = 0; i < n; i++) {
-      for (int j = 0; j < n; j++) {
-        if (i != j && isConnected[i][j] == 1) {
-          map.computeIfAbsent(i, k -> new HashSet<>()).add(j);
-          map.computeIfAbsent(j, k -> new HashSet<>()).add(i);
+    public int findCircleNum(int[][] isConnected) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int i = 0; i < isConnected.length; i++) {
+            for (int j = 0; j < isConnected[i].length; j++) {
+                if (i != j && isConnected[i][j] == 1) {
+                    graph.computeIfAbsent(i, k -> new HashSet<>()).add(j);
+                    graph.computeIfAbsent(j, k -> new HashSet<>()).add(i);
+                }
+            }
+        }
+        Set<Integer> visited = new HashSet<>();
+        int provinces = 0;
+        for (int i = 0; i < isConnected.length; i++) {
+            if (!visited.contains(i)) {
+                traverse(graph, i, visited);
+                provinces++;
+            }
         }
-      }
+        return provinces;
     }
-    Set<Integer> visited = new HashSet<>();
-    int provinceCount = 0;
-    for (int i = 0; i < n; i++) {
-      if (!visited.contains(i)) {
+    
+    private void traverse(Map<Integer, Set<Integer>> graph, int city, Set<Integer> visited) {
         Queue<Integer> queue = new LinkedList<>();
-        queue.add(i);
-        visited.add(i);
+        queue.add(city);
+        visited.add(city);
         while (!queue.isEmpty()) {
-          int removed = queue.remove();
-          for (Integer connection : map.getOrDefault(removed, new HashSet<>())) {
-            if (!visited.contains(connection)) {
-              queue.add(connection);
-              visited.add(connection);
+            int removed = queue.remove();
+            for (Integer conn : graph.getOrDefault(removed, new HashSet<>())) {
+                if (!visited.contains(conn)) {
+                    queue.add(conn);
+                    visited.add(conn);
+                }
             }
-          }
         }
-        provinceCount++;
-      }
     }
-    return provinceCount;
-  }
 }
diff --git a/Medium/Number of Same-End Substrings.java b/Medium/Number of Same-End Substrings.java
new file mode 100644
index 00000000..4003737d
--- /dev/null
+++ b/Medium/Number of Same-End Substrings.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public int[] sameEndSubstringCount(String s, int[][] queries) {
+        int n = s.length();
+        int[][] prefixSum = new int[26][n];
+        for (int i = 0; i < n; i++) {
+            prefixSum[s.charAt(i) - 'a'][i]++;
+        }
+        for (int i = 0; i < 26; i++) {
+            for (int j = 1; j < n; j++) {
+                prefixSum[i][j] += prefixSum[i][j - 1];
+            }
+        }
+        int[] result = new int[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            int left = queries[i][0];
+            int right = queries[i][1];
+            int count = 0;
+            for (int c = 0; c < 26; c++) {
+                int leftFreq = left == 0 ? 0 : prefixSum[c][left - 1];
+                int rightFreq = prefixSum[c][right];
+                int freqInRange = rightFreq - leftFreq;
+                count += (freqInRange * (freqInRange + 1)) / 2;
+            }
+            result[i] = count;
+        }
+        return result;
+    }
+}
diff --git a/Medium/Number of Steps to Reduce a Number in Binary Representation to One.java b/Medium/Number of Steps to Reduce a Number in Binary Representation to One.java
new file mode 100644
index 00000000..00a8296a
--- /dev/null
+++ b/Medium/Number of Steps to Reduce a Number in Binary Representation to One.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public int numSteps(String s) {
+        int operations = 0;
+        StringBuilder sb = new StringBuilder(s);
+        while (sb.length() > 1) {
+            int n = sb.length();
+            if (sb.charAt(n - 1) == '0') {
+                // divide by 2
+                sb.deleteCharAt(n - 1);
+            } else {
+                // add 1 
+                int idx = n - 1;
+                while (idx >= 0 && sb.charAt(idx) != '0') {
+                    sb.setCharAt(idx, '0');
+                    idx--;
+                }
+                if (idx < 0) {
+                    sb.insert(0, '1');
+                } else {
+                    sb.setCharAt(idx, '1');
+                }
+            }
+            operations++;
+        }
+        return operations;
+    }
+}
diff --git a/Medium/Number of Subsequences That Satisfy the Given Sum Condition.java b/Medium/Number of Subsequences That Satisfy the Given Sum Condition.java
new file mode 100644
index 00000000..9a40ee6b
--- /dev/null
+++ b/Medium/Number of Subsequences That Satisfy the Given Sum Condition.java	
@@ -0,0 +1,26 @@
+class Solution {
+    
+    private static final int MOD = 1000_000_007;
+    
+    public int numSubseq(int[] nums, int target) {
+        int n = nums.length;
+        Arrays.sort(nums);
+        int[] power = new int[n];
+        power[0] = 1;
+        for (int i = 1; i < n; i++) {
+            power[i] = (power[i - 1] * 2) % MOD;
+        }
+        int result = 0;
+        int left = 0;
+        int right = n - 1;
+        while (left <= right) {
+            if (nums[left] + nums[right] <= target) {
+                result = (result + power[right - left]) % MOD;
+                left++;
+            } else {
+                right--;
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Number of Zero-Filled Subarrays.java b/Medium/Number of Zero-Filled Subarrays.java
index af77e188..b7c17309 100644
--- a/Medium/Number of Zero-Filled Subarrays.java	
+++ b/Medium/Number of Zero-Filled Subarrays.java	
@@ -1,14 +1,16 @@
 class Solution {
-  public long zeroFilledSubarray(int[] nums) {
-    long count = 0;
-    long subarrayLength = 0;
-    for (int i = 0; i < nums.length; i++) {
-      if (nums[i] == 0) {
-        count += ++subarrayLength;
-      } else {
-        subarrayLength = 0;
-      }
+    public long zeroFilledSubarray(int[] nums) {
+        long subarrayCount = 0L;
+        int idx = 0;
+        while (idx < nums.length) {
+            long count = 0L;
+            while (idx < nums.length && nums[idx] == 0) {
+                idx++;
+                count++;
+            }
+            subarrayCount += (count * (count + 1)) / 2;
+            idx++;
+        }
+        return subarrayCount;
     }
-    return count;
-  }
 }
diff --git a/Medium/One Edit Distance.java b/Medium/One Edit Distance.java
index dc32eede..662a41d1 100644
--- a/Medium/One Edit Distance.java	
+++ b/Medium/One Edit Distance.java	
@@ -1,39 +1,28 @@
 class Solution {
-  public boolean isOneEditDistance(String s, String t) {
-    int lengthDiff = Math.abs(s.length() - t.length());
-    if (s.equals(t) || lengthDiff > 1) {
-      return false;
-    }
-    if (s.length() == 0 || t.length() == 0) {
-      return true;
-    }
-    int idxOne = 0;
-    int idxTwo = 0;
-    boolean changeDone = false;
-    while (idxOne < s.length() && idxTwo < t.length()) {
-      if (s.charAt(idxOne) == t.charAt(idxTwo)) {
-        idxOne++;
-        idxTwo++;
-        continue;
-      }
-      if (changeDone) {
-        return false;
-      }
-      if (lengthDiff != 0) {
-        if (s.length() > t.length()) {
-          idxOne++;
-        } else {
-          idxTwo++;
+    public boolean isOneEditDistance(String s, String t) {
+        int diff = Math.abs(s.length() - t.length());
+        if (s.equals(t) || diff > 1) {
+            return false;
         }
-      } else {
-        idxOne++;
-        idxTwo++;
-      }
-      changeDone = true;
-    }
-    if (changeDone && (idxOne != s.length() || idxTwo != t.length())) {
-      return false;
+        int idx = 0;
+        while (idx < s.length() && idx < t.length()) {
+            if (s.charAt(idx) != t.charAt(idx)) {
+                // Replace character
+                if (s.substring(idx + 1).equals(t.substring(idx + 1))) {
+                    return true;
+                }
+                // Delete 1 character from s
+                if (s.substring(idx + 1).equals(t.substring(idx))) {
+                    return true;
+                }
+                // Delete 1 character from t
+                if (s.substring(idx).equals(t.substring(idx + 1))) {
+                    return true;
+                }
+                return false;
+            }
+            idx++;
+        }
+        return true;
     }
-    return true;
-  }
 }
diff --git a/Medium/Open The Lock.java b/Medium/Open The Lock.java
index 926e8521..f692f0ba 100644
--- a/Medium/Open The Lock.java	
+++ b/Medium/Open The Lock.java	
@@ -1,40 +1,38 @@
 class Solution {
     public int openLock(String[] deadends, String target) {
         Set<String> deadEndSet = new HashSet<>(Arrays.asList(deadends));
-        if (deadEndSet.contains(target) || deadEndSet.contains("0000")) {
+        String startingPoint = "0000";
+        if (deadEndSet.contains(startingPoint)) {
             return -1;
         }
         Queue<String> queue = new LinkedList<>();
-        Set<String> seen = new HashSet<>();
-        queue.add("0000");
-        seen.add("0000");
-        int steps = 0;
+        Set<String> visited = new HashSet<>();
+        queue.add(startingPoint);
+        visited.add(startingPoint);
+        int attempts = 0;
         int[] rotations = {-1, 1};
         while (!queue.isEmpty()) {
             int size = queue.size();
             for (int i = 0; i < size; i++) {
                 String removed = queue.remove();
                 if (removed.equals(target)) {
-                    return steps;
+                    return attempts;
                 }
                 if (deadEndSet.contains(removed)) {
                     continue;
                 }
                 for (int j = 0; j < 4; j++) {
                     for (int rotation : rotations) {
-                        int changedVal = ((removed.charAt(j) - '0') + rotation + 10) % 10;
-                        String newRotation = new StringBuilder()
-                                                    .append(removed.substring(0,j))                                                                                         .append(changedVal)
-                                                    .append(removed.substring(j + 1))
-                                                    .toString();
-                        if (!seen.contains(newRotation)) {
-                            seen.add(newRotation);
+                        int newValue = ((removed.charAt(j) - '0') + rotation + 10) % 10;
+                        String newRotation = removed.substring(0, j) + newValue + removed.substring(j + 1);
+                        if (!visited.contains(newRotation)) {
+                            visited.add(newRotation);
                             queue.add(newRotation);
                         }
                     }
                 }
             }
-            steps++;
+            attempts++;
         }
         return -1;
     }
diff --git a/Medium/Optimal Partition of String.java b/Medium/Optimal Partition of String.java
index 2c42afa6..68b01d59 100644
--- a/Medium/Optimal Partition of String.java	
+++ b/Medium/Optimal Partition of String.java	
@@ -1,14 +1,14 @@
 class Solution {
-  public int partitionString(String s) {
-    int idx = 0;
-    int count = 0;
-    while (idx < s.length()) {
-      Set<Character> set = new HashSet<>();
-      while (idx < s.length() && set.add(s.charAt(idx))) {
-        idx++;
-      }
-      count++;
+    public int partitionString(String s) {
+        int count = 0;
+        int idx = 0;
+        while (idx < s.length()) {
+            Set<Character> set = new HashSet<>();
+            while (idx < s.length() && set.add(s.charAt(idx))) {
+                idx++;
+            }
+            count++;
+        }
+        return count;
     }
-    return count;
-  }
 }
diff --git a/Medium/Out of Boundary Paths.java b/Medium/Out of Boundary Paths.java
index 7179a63c..fc7e9a26 100644
--- a/Medium/Out of Boundary Paths.java	
+++ b/Medium/Out of Boundary Paths.java	
@@ -1,34 +1,26 @@
 class Solution {
-  private final int MODULUS = 1000000000 + 7;
-  
-  public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
-    int dp[][] = new int[m][n];
-    dp[startRow][startColumn] = 1;
-    int count = 0;
-    for (int currMove = 1; currMove <= maxMove; currMove++) {
-      int[][] temp = new int[m][n];
-      for (int i = 0; i < m; i++) {
-        for (int j = 0; j < n; j++) {
-          if (i == m - 1) {
-            count = (count + dp[i][j]) % MODULUS;
-          }
-          if (j == n - 1) {
-            count = (count + dp[i][j]) % MODULUS;
-          }
-          if (i == 0) {
-            count = (count + dp[i][j]) % MODULUS;
-          }
-          if (j == 0) {
-            count = (count + dp[i][j]) % MODULUS;
-          }
-          temp[i][j] = (
-              ((i > 0 ? dp[i - 1][j] : 0) + (i < m - 1 ? dp[i + 1][j] : 0)) % MODULUS +
-              ((j > 0 ? dp[i][j - 1] : 0) + (j < n - 1 ? dp[i][j + 1] : 0)) % MODULUS
-          ) % MODULUS;
+
+    private static final int MOD = 1000_000_007;
+
+    public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {
+        Integer[][][] dp = new Integer[m][n][maxMove + 1];
+        return findPaths(m, n, maxMove, startRow, startColumn, dp);
+    }
+
+    public int findPaths(int m, int n, int maxMove, int startRow, int startColumn, Integer[][][] dp) {
+        if (startRow == m || startColumn == n || startRow < 0 || startColumn < 0) {
+            return 1;
+        }
+        if (maxMove == 0) {
+            return 0;
+        }
+        if (dp[startRow][startColumn][maxMove] != null) {
+            return dp[startRow][startColumn][maxMove];
         }
-      }
-      dp = temp;
+        return dp[startRow][startColumn][maxMove] = (
+            (findPaths(m, n, maxMove - 1, startRow - 1, startColumn, dp) +
+            findPaths(m, n, maxMove - 1, startRow + 1, startColumn, dp)) % MOD +
+            (findPaths(m, n, maxMove - 1, startRow, startColumn - 1, dp) +
+            findPaths(m, n, maxMove - 1, startRow, startColumn + 1, dp)) % MOD) % MOD; 
     }
-    return count;
-  }
 }
diff --git a/Medium/Paint Fence.java b/Medium/Paint Fence.java
new file mode 100644
index 00000000..39c72ffa
--- /dev/null
+++ b/Medium/Paint Fence.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int numWays(int n, int k) {
+        Map<Integer, Integer> map = new HashMap<>();
+        return numWays(n, k, map);
+    }
+
+    private int numWays(int n, int k, Map<Integer, Integer> map) {
+        if (n == 1) {
+            return k;
+        }
+        if (n == 2) {
+            return k * k;
+        }
+        if (map.containsKey(n)) {
+            return map.get(n);
+        }
+        map.put(n, (k - 1) * (numWays(n - 1, k, map) + numWays(n - 2, k, map)));
+        return map.get(n);
+    }
+}
diff --git a/Medium/Paint House.java b/Medium/Paint House.java
new file mode 100644
index 00000000..27b1a502
--- /dev/null
+++ b/Medium/Paint House.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int minCost(int[][] costs) {
+        int n = costs.length;
+        int[][] dp = new int[n][3];
+        dp[0][0] = costs[0][0];
+        dp[0][1] = costs[0][1];
+        dp[0][2] = costs[0][2];
+        for (int i = 1; i < n; i++) {
+            dp[i][0] = Math.min(dp[i - 1][1], dp[i - 1][2]) + costs[i][0];
+            dp[i][1] = Math.min(dp[i - 1][0], dp[i - 1][2]) + costs[i][1];
+            dp[i][2] = Math.min(dp[i - 1][0], dp[i - 1][1]) + costs[i][2];
+        }
+        return Math.min(dp[n - 1][0], Math.min(dp[n - 1][1], dp[n - 1][2]));
+    }
+}
diff --git a/Medium/Palindrome Partitioning.java b/Medium/Palindrome Partitioning.java
index 1171f009..de89ed16 100644
--- a/Medium/Palindrome Partitioning.java	
+++ b/Medium/Palindrome Partitioning.java	
@@ -1,27 +1,31 @@
 class Solution {
-    public List<List<String>> partition(String a) {
-        List<List<String>> ans = new ArrayList<>();
-        helper(ans, new ArrayList<String>(), a, 0);
-        return ans;
+    public List<List<String>> partition(String s) {
+        List<List<String>> result = new ArrayList<>();
+        backtrack(result, new ArrayList<>(), s, 0);
+        return result;
     }
- 
-    private void helper(List<List<String>> ans, List<String> temp, String a, int idx) {
-        if (idx == a.length()) {
-            ans.add(new ArrayList<>(temp));
+
+    private void backtrack(List<List<String>> result, List<String> currentList,
+                           String s, int idx) {
+        if (idx == s.length()) {
+            result.add(new ArrayList<>(currentList));
             return;
         }
-        for (int i=idx; i<a.length(); i++) {
-            String sb = a.substring(idx, i+1);
- 
-            if (isPalindrome(sb)) {
-                temp.add(sb);
-                helper(ans, temp, a, i+1);
-                temp.remove(temp.size()-1);
+        for (int i = idx; i < s.length(); i++) {
+            if (isPalindrome(s, idx, i)) {
+                currentList.add(s.substring(idx, i + 1));
+                backtrack(result, currentList, s, i + 1);
+                currentList.removeLast();
             }
         }
     }
- 
-    private boolean isPalindrome(String s) {
-        return new StringBuilder(s).reverse().toString().equals(s);
+
+    private boolean isPalindrome(String s, int startIdx, int endIdx) {
+        while (startIdx < endIdx) {
+            if (s.charAt(startIdx++) != s.charAt(endIdx--)) {
+                return false;
+            }
+        }
+        return true;
     }
 }
diff --git a/Medium/Parallel Courses.java b/Medium/Parallel Courses.java
index a3843f23..797e3b58 100644
--- a/Medium/Parallel Courses.java	
+++ b/Medium/Parallel Courses.java	
@@ -1,33 +1,35 @@
 class Solution {
-  public int minimumSemesters(int n, int[][] relations) {
-    Map<Integer, List<Integer>> graph = new HashMap<>();
-    int[] indegree = new int[n + 1];
-    for (int[] relation : relations) {
-      graph.computeIfAbsent(relation[0], k -> new ArrayList<>()).add(relation[1]);
-      indegree[relation[1]]++;
-    }
-    Queue<Integer> queue = new LinkedList<>();
-    int numOfSemesters = 0;
-    Set<Integer> coursesTaken = new HashSet<>();
-    for (int i = 1; i <= n; i++) {
-      if (indegree[i] == 0) {
-        queue.add(i);
-      }
-    }
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int course = queue.remove();
-        coursesTaken.add(course);
-        for (int dependentCourse : graph.getOrDefault(course, new ArrayList<>())) {
-          indegree[dependentCourse]--;
-          if (indegree[dependentCourse] <= 0 && !coursesTaken.contains(dependentCourse)) {
-            queue.add(dependentCourse);
-          }
+    public int minimumSemesters(int n, int[][] relations) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        int[] indegree = new int[n];
+        for (int[] relation : relations) {
+            int course = relation[0];
+            int dependency = relation[1];
+            indegree[course - 1]++;
+            graph.computeIfAbsent(dependency, k -> new HashSet<>()).add(course);
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        int numOfSemesters = 0;
+        int coursesTaken = 0;
+        for (int i = 0; i < n; i++) {
+            if (indegree[i] == 0) {
+                queue.add(i + 1);
+            }
+        }
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int removed = queue.remove();
+                coursesTaken++;
+                for (Integer dependent : graph.getOrDefault(removed, new HashSet<>())) {
+                    indegree[dependent - 1]--;
+                    if (indegree[dependent - 1] == 0) {
+                        queue.add(dependent);
+                    }
+                }
+            }
+            numOfSemesters++;
         }
-      }
-      numOfSemesters++;
+        return coursesTaken == n ? numOfSemesters : -1;
     }
-    return coursesTaken.size() == n ? numOfSemesters : -1;
-  }
 }
diff --git a/Medium/Partition Array for Maximum Sum.java b/Medium/Partition Array for Maximum Sum.java
new file mode 100644
index 00000000..4868c1c3
--- /dev/null
+++ b/Medium/Partition Array for Maximum Sum.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int maxSumAfterPartitioning(int[] arr, int k) {
+        Integer[] dp = new Integer[arr.length];
+        return maxSum(arr, k, dp, 0);
+    }
+
+    private int maxSum(int[] arr, int k, Integer[] dp, int start) {
+        int n = arr.length;
+        if (start >= n) {
+            return 0;
+        }
+        if (dp[start] != null) {
+            return dp[start];
+        }
+        int currMax = 0;
+        int result = 0;
+        int end = Math.min(n, start + k);
+        for (int i = start; i < end; i++) {
+            currMax = Math.max(currMax, arr[i]);
+            result = Math.max(result, 
+                currMax * (i - start + 1) + maxSum(arr, k, dp, i + 1));
+        }
+        return dp[start] = result;
+    }
+}
diff --git a/Medium/Partition Labels.java b/Medium/Partition Labels.java
index d8896c4a..e3157703 100644
--- a/Medium/Partition Labels.java	
+++ b/Medium/Partition Labels.java	
@@ -1,19 +1,19 @@
 class Solution {
-  public List<Integer> partitionLabels(String s) {
-    Map<Character, Integer> lastIndex = new HashMap<>();
-    for (int i = 0; i < s.length(); i++) {
-      lastIndex.put(s.charAt(i), i);
+    public List<Integer> partitionLabels(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (int i = 0; i < s.length(); i++) {
+            map.put(s.charAt(i), i);
+        }
+        List<Integer> result = new ArrayList<>();
+        int start = 0;
+        int maxIdx = Integer.MIN_VALUE;
+        for (int i = 0; i < s.length(); i++) {
+            maxIdx = Math.max(map.get(s.charAt(i)), maxIdx);
+            if (maxIdx == i) {
+                result.add(i - start + 1);
+                start = i + 1;
+            }
+        }
+        return result;
     }
-    List<Integer> partitionIndices = new ArrayList<>();
-    int currMaxIdx = -1;
-    int prevIdx = 0;
-    for (int i = 0; i < s.length(); i++) {
-      currMaxIdx = Math.max(currMaxIdx, lastIndex.get(s.charAt(i)));
-      if (i == currMaxIdx) {
-        partitionIndices.add(i - prevIdx + 1);
-        prevIdx = i + 1;
-      }
-    }
-    return partitionIndices;
-  }
 }
diff --git a/Medium/Partition List.java b/Medium/Partition List.java
index bb1f9dcf..a807608c 100644
--- a/Medium/Partition List.java	
+++ b/Medium/Partition List.java	
@@ -9,38 +9,35 @@
  * }
  */
 class Solution {
-  public ListNode partition(ListNode head, int x) {
-    ListNode lessThanHead = null;
-    ListNode lessThan = null;
-    ListNode greaterThan = null;
-    ListNode greaterThanHead = null;
-    while (head != null) {
-      ListNode nextNode = head.next;
-      if (head.val < x) {
-        if (lessThan == null) {
-          lessThan = head;
-          lessThanHead = lessThan;
-        } else {
-          lessThan.next = head;
-          lessThan = lessThan.next;
+    public ListNode partition(ListNode head, int x) {
+        ListNode lessHead = null;
+        ListNode lessCurr = null;
+        ListNode greaterHead = null;
+        ListNode greaterCurr = null;
+        while (head != null) {
+            if (head.val < x) {
+                if (lessCurr == null) {
+                    lessCurr = new ListNode(head.val);
+                    lessHead = lessCurr;
+                } else {
+                    lessCurr.next = new ListNode(head.val);
+                    lessCurr = lessCurr.next;
+                }
+            } else {
+                if (greaterCurr == null) {
+                    greaterCurr = new ListNode(head.val);
+                    greaterHead = greaterCurr;
+                } else {
+                    greaterCurr.next = new ListNode(head.val);
+                    greaterCurr = greaterCurr.next;
+                }
+            }
+            head = head.next;
         }
-        lessThan.next = null;
-      } else {
-        if (greaterThan == null) {
-          greaterThan = head;
-          greaterThanHead = greaterThan;
-        } else {
-          greaterThan.next = head;
-          greaterThan = greaterThan.next;
+        if (lessHead == null) {
+            return greaterHead;
         }
-        greaterThan.next = null;
-      }
-      head = nextNode;
+        lessCurr.next = greaterHead;
+        return lessHead;
     }
-    if (lessThanHead == null || greaterThanHead == null) {
-      return lessThan == null ? greaterThanHead : lessThanHead;
-    }
-    lessThan.next = greaterThanHead;
-    return lessThanHead;
-  }
 }
diff --git a/Medium/Peak Index in a Mountain Array.java b/Medium/Peak Index in a Mountain Array.java
new file mode 100644
index 00000000..d496f7c4
--- /dev/null
+++ b/Medium/Peak Index in a Mountain Array.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int peakIndexInMountainArray(int[] arr) {
+        int start = 0;
+        int end = arr.length - 1;
+        while (start < end) {
+            int mid = (start + end) / 2;
+            if (arr[mid] < arr[mid + 1]) {
+                start = mid + 1;
+            } else {
+                end = mid;
+            }
+        }
+        return start;
+    }
+}
diff --git a/Medium/Permutation in String.java b/Medium/Permutation in String.java
index ff95424e..dd255290 100644
--- a/Medium/Permutation in String.java	
+++ b/Medium/Permutation in String.java	
@@ -1,32 +1,38 @@
 class Solution {
-  public boolean checkInclusion(String s1, String s2) {
-    if (s2.length() < s1.length()) {
-      return false;
-    }
-    int[] frequency = new int[26];
-    for (int i = 0; i < s1.length(); i++) {
-      frequency[s1.charAt(i) - 'a']++;
-      frequency[s2.charAt(i) - 'a']--;
-    }
-    if (allZeroArray(frequency)) {
-      return true;
-    }
-    for (int i = s1.length(); i < s2.length(); i++) {
-      frequency[s2.charAt(i) - 'a']--;
-      frequency[s2.charAt(i - s1.length()) - 'a']++;
-      if (allZeroArray(frequency)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  private boolean allZeroArray(int[] frequency) {
-    for (int count : frequency) {
-      if (count != 0) {
+    public boolean checkInclusion(String s1, String s2) {
+        if (s1.length() > s2.length()) {
+            return false;
+        }
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : s1.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+        int n = s1.length();
+        int[] count = {map.size()};
+        for (int i = 0; i < n - 1; i++) {
+            updateMap(map, s2.charAt(i), count, true);
+        }
+        int start = 0;
+        for (int i = n - 1; i < s2.length(); i++) {
+            updateMap(map, s2.charAt(i), count, true);
+            if (count[0] == 0) {
+                return true;
+            }
+            updateMap(map, s2.charAt(start++), count, false);
+        }
         return false;
-      }
     }
-    return true;
-  }
+    
+    private void updateMap(Map<Character, Integer> map, char c, int[] count, boolean decrement) {
+        if (map.containsKey(c)) {
+            int diff = decrement ? -1 : 1;
+            map.put(c, map.get(c) + diff);
+            if (decrement && map.get(c) == 0) {
+                count[0]--;
+            }
+            if (!decrement && map.get(c) == 1) {
+                count[0]++;
+            }
+        }
+    }
 }
diff --git a/Medium/Permutations.java b/Medium/Permutations.java
index 760b7452..61c86f42 100644
--- a/Medium/Permutations.java
+++ b/Medium/Permutations.java
@@ -1,23 +1,25 @@
 class Solution {
-  public List<List<Integer>> permute(int[] nums) {
-    List<List<Integer>> result = new ArrayList<>();
-    helper(nums, result, new ArrayList<>(), new boolean[nums.length]);
-    return result;
-  }
-  
-  private void helper(int[] nums, List<List<Integer>> result, List<Integer> curr, boolean[] visited) {
-    if (curr.size() == nums.length) {
-      result.add(new ArrayList<>(curr));
-    } else {
-      for (int i = 0; i < nums.length; i++) {
-        if (!visited[i]) {
-          visited[i] = true;
-          curr.add(nums[i]);
-          helper(nums, result, curr, visited);
-          visited[i] = false;
-          curr.remove(curr.size() - 1);
+    public List<List<Integer>> permute(int[] nums) {
+        List<List<Integer>> result = new ArrayList<>();
+        Set<Integer> visited = new HashSet<>();
+        permute(nums, result, new ArrayList<>(), visited);
+        return result;
+    }
+    
+    private void permute(int[] nums, List<List<Integer>> result, List<Integer> curr, Set<Integer> visited) {
+        if (curr.size() == nums.length) {
+            result.add(new ArrayList<>(curr));
+            return;
+        }
+        for (int i = 0; i < nums.length; i++) {
+            if (visited.contains(nums[i])) {
+                continue;
+            }
+            visited.add(nums[i]);
+            curr.add(nums[i]);
+            permute(nums, result, curr, visited);
+            visited.remove(nums[i]);
+            curr.remove(curr.size() - 1);
         }
-      }
     }
-  }
 }
diff --git a/Medium/Possible Bipartition.java b/Medium/Possible Bipartition.java
new file mode 100644
index 00000000..4d2a0500
--- /dev/null
+++ b/Medium/Possible Bipartition.java	
@@ -0,0 +1,38 @@
+class Solution {
+    public boolean possibleBipartition(int n, int[][] dislikes) {
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        for (int[] dislike : dislikes) {
+            map.computeIfAbsent(dislike[0], k -> new ArrayList<>()).add(dislike[1]);
+            map.computeIfAbsent(dislike[1], k -> new ArrayList<>()).add(dislike[0]);
+        }
+        int[] color = new int[n + 1];
+        Arrays.fill(color, -1);
+        for (int i = 1; i <= n; i++) {
+            if (color[i] == -1) {
+                if (!bfs(i, map, color)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    
+    private boolean bfs(int node, Map<Integer, List<Integer>> map, int[] color) {
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(node);
+        color[node] = 0;
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            for (Integer neighbor : map.getOrDefault(removed, new ArrayList<>())) {
+                if (color[neighbor] == color[removed]) {
+                    return false;
+                }
+                if (color[neighbor] == -1) {
+                    color[neighbor] = 1 - color[removed];
+                    queue.add(neighbor);
+                }
+            }
+        }
+        return true;
+    }
+}
diff --git a/Medium/Product of Two Run-Length Encoded Arrays.java b/Medium/Product of Two Run-Length Encoded Arrays.java
index 7aa0b117..4aab9bc8 100644
--- a/Medium/Product of Two Run-Length Encoded Arrays.java	
+++ b/Medium/Product of Two Run-Length Encoded Arrays.java	
@@ -1,39 +1,31 @@
 class Solution {
-  public List<List<Integer>> findRLEArray(int[][] encoded1, int[][] encoded2) {
-    int idxOne = 0;
-    int idxTwo = 0;
-    List<List<Integer>> result = new ArrayList<>();
-    while (idxOne < encoded1.length && idxTwo < encoded2.length) {
-      int valueOne = encoded1[idxOne][0];
-      int frequencyOne = 0;
-      while (idxOne < encoded1.length && encoded1[idxOne][0] == valueOne) {
-        frequencyOne += encoded1[idxOne++][1];
-      }
-      idxOne--;
-      encoded1[idxOne][1] = frequencyOne;
-      int valueTwo = encoded2[idxTwo][0];
-      int frequencyTwo = 0;
-      while (idxTwo < encoded2.length && encoded2[idxTwo][0] == valueTwo) {
-        frequencyTwo += encoded2[idxTwo++][1];
-      }
-      idxTwo--;
-      encoded2[idxTwo][1] = frequencyTwo;
-      int prod = encoded1[idxOne][0] * encoded2[idxTwo][0];
-      int frequency = Math.min(encoded1[idxOne][1], encoded2[idxTwo][1]);
-      if (result.size() > 0 && result.get(result.size() - 1).get(0) == prod) {
-        result.get(result.size() - 1).set(1, result.get(result.size() - 1).get(1) + frequency);
-      } else {
-        result.add(Arrays.asList(prod, frequency));
-      }
-      encoded1[idxOne][1] -= frequency;
-      encoded2[idxTwo][1] -= frequency;
-      if (encoded1[idxOne][1] == 0) {
-        idxOne++;
-      }
-      if (encoded2[idxTwo][1] == 0) {
-        idxTwo++;
-      }
+    public List<List<Integer>> findRLEArray(int[][] encoded1, int[][] encoded2) {
+        int idxOne = 0;
+        int idxTwo = 0;
+        List<List<Integer>> result = new ArrayList<>();
+        while (idxOne < encoded1.length && idxTwo < encoded2.length) {
+            int valOne = encoded1[idxOne][0];
+            int valTwo = encoded2[idxTwo][0];
+            int countOne = encoded1[idxOne][1];
+            int countTwo = encoded2[idxTwo][1];
+            int value = valOne * valTwo;
+            int count = Math.min(countOne, countTwo);
+            encoded1[idxOne][1] -= count;
+            encoded2[idxTwo][1] -= count;
+            if (encoded1[idxOne][1] == 0) {
+                idxOne++;
+            }
+            if (encoded2[idxTwo][1] == 0) {
+                idxTwo++;
+            }
+            if (!result.isEmpty() && result.get(result.size() - 1).get(0) == value) {
+                int existingCount = result.get(result.size() - 1).get(1);
+                int newCount = existingCount + count;
+                result.get(result.size() - 1).set(1, newCount);
+            } else {
+                result.add(Arrays.asList(value, count));
+            }
+        }
+        return result;
     }
-    return result;
-  }
 }
diff --git a/Medium/Pseudo-Palindromic Paths in a Binary Tree.java b/Medium/Pseudo-Palindromic Paths in a Binary Tree.java
index 04cbe822..87acbbf4 100644
--- a/Medium/Pseudo-Palindromic Paths in a Binary Tree.java	
+++ b/Medium/Pseudo-Palindromic Paths in a Binary Tree.java	
@@ -14,43 +14,38 @@
  * }
  */
 class Solution {
-  public int pseudoPalindromicPaths (TreeNode root) {
-    Queue<NodePathPair> queue = new LinkedList<>();
-    NodePathPair nodePathPair = new NodePathPair(root, 0);
-    queue.add(nodePathPair);
-    int count = 0;
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        NodePathPair removed = queue.remove();
-        TreeNode node = removed.node;
-        int path = removed.path;
-        // XOR operation ensures that the bit corresponding to the number only appears in the
-        // path if it has occurred odd number of times. 
-        // 1 << node.val decides the bit of the value
-        path = path ^ (1 << node.val);
-        if (node.left == null && node.right == null) {
-          // Subtracting 1 means setting rightmost 1 bit to 0 and setting all lower bits to 1
-          count += (path & (path - 1)) == 0 ? 1 : 0;
-        } 
-        if (node.left != null) {
-          queue.add(new NodePathPair(node.left, path));
+    public int pseudoPalindromicPaths (TreeNode root) {
+        int[] result = {0};
+        Map<Integer, Integer> map = new HashMap<>();
+        helper(root, map, result);
+        return result[0];
+    }
+
+    private void helper(TreeNode root, Map<Integer, Integer> map, int[] result) {
+        if (root == null) {
+            return;
         }
-        if (node.right != null) {
-          queue.add(new NodePathPair(node.right, path));
+        map.put(root.val, map.getOrDefault(root.val, 0) + 1);
+        if (root.left == null && root.right == null) {
+            if (isPseudoPalindromic(map)) {
+                result[0]++;
+            }
         }
-      }
+        helper(root.left, map, result);
+        helper(root.right, map, result);
+        map.put(root.val, map.getOrDefault(root.val, 0) - 1);
     }
-    return count;
-  }
-  
-  private static class NodePathPair {
-    TreeNode node;
-    Integer path;
-    
-    public NodePathPair(TreeNode node, int path) {
-      this.node = node;
-      this.path = path;
+
+    private static boolean isPseudoPalindromic(Map<Integer, Integer> map) {
+        boolean oddFound = false;
+        for (Integer key : map.keySet()) {
+            if (map.get(key) % 2 != 0) {
+                if (oddFound) {
+                    return false;
+                }
+                oddFound = true;
+            }
+        }
+        return true;
     }
-  }
 }
diff --git a/Medium/README.md b/Medium/README.md
index 549b4e57..cb496742 100644
--- a/Medium/README.md
+++ b/Medium/README.md
@@ -1,545 +1,795 @@
 # Medium LeetCode-Java-Solutions 
 S.no | Coding Problem 
 --- | --- 
-1|[Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
-2|[Missing Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Ranges.java)
-3|[First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java)
-4|[Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java)
-5|[Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
-6|[3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java)
-7|[Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java)
-8|[House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java)
-9|[Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java)
-10|[Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java)
-11|[Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
-12|[Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
-13|[Reconstruct Itinerary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Itinerary.java)
-14|[Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java)
-15|[Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
-16|[Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java)
-17|[Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java)
-18|[Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java)
-19|[Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
-20|[Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
-21|[The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
-22|[Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java)
-23|[Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java)
-24|[Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
-25|[Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
-26|[Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
-27|[Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java)
-28|[Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java)
-29|[Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java)
-30|[Rectangle Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Overlap.java)
-31|[Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
-32|[Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java)
-33|[Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
-34|[Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
-35|[Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java)
-36|[Non Overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non%20Overlapping%20Intervals.java)
-37|[Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java)
-38|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java)
-39|[Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
-40|[Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java)
-41|[Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
-42|[Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java)
-43|[Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java)
-44|[Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
-45|[Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java)
-46|[Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java)
-47|[Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
-48|[Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
-49|[Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java)
-50|[Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
-51|[Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java)
-52|[Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java)
-53|[Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java)
-54|[Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java)
-55|[Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java)
-56|[Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java)
-57|[Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java)
-58|[Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
-59|[Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
-60|[Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java)
-61|[Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java)
-62|[Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java)
-63|[Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
-64|[Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
-65|[Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java)
-66|[Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java)
-67|[Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java)
-68|[Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
-69|[Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java)
-70|[Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java)
-71|[Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java)
-72|[Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
-73|[Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
-74|[Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java)
-75|[Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java)
-76|[As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java)
-77|[Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java)
-78|[Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java)
-79|[Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java)
-80|[Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java)
-81|[Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
-82|[Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
-83|[Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java)
-84|[Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java)
-85|[Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java)
-86|[Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java)
-87|[Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java)
-88|[Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java)
-89|[Find the Town Judge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Town%20Judge.java)
-90|[Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java)
-91|[Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
-92|[Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
-93|[Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java)
-94|[Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
-95|[Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java)
-96|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java)
-97|[Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
-98|[Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java)
-99|[Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
-100|[Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java)
-101|[Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java)
-102|[Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java)
-103|[Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java)
-104|[Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java)
-105|[Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java)
-106|[Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
-107|[Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java)
-108|[Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
-109|[Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java)
-110|[Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java)
-111|[Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
-112|[Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
-113|[Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java)
-114|[3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java)
-115|[Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
-116|[Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java)
-117|[Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
-118|[Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java)
-119|[Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java)
-120|[Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
-121|[4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java)
-122|[Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java)
-123|[Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
-124|[Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java)
-125|[Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
-126|[Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java)
-127|[Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java)
-128|[Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java)
-129|[House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java)
-130|[Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java)
-131|[Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
-132|[Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java)
-133|[Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
-134|[Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
-135|[Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
-136|[Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java)
-137|[Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java)
-138|[Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
-139|[Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java)
-140|[Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
-141|[Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java)
-142|[Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java)
-143|[Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java)
-144|[Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java)
-145|[Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
-146|[Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java)
-147|[Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java)
-148|[Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
-149|[Split Linked List into Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20into%20Parts.java)
-150|[Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
-151|[Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java)
-152|[Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
-153|[Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java)
-154|[Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
-155|[Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
-156|[Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
-157|[Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
-158|[Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
-159|[Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java)
-160|[Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
-161|[Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
-162|[Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java)
-163|[Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java)
-164|[Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java)
-165|[Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
-166|[Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java)
-167|[Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
-168|[Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
-169|[Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java)
-170|[Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java)
-171|[Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java)
-172|[Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java)
-173|[Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java)
-174|[Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java)
-175|[Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
-176|[Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
-177|[Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java)
-178|[Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java)
-179|[Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
-180|[Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
-181|[Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java)
-182|[Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
-183|[Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
-184|[Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
-185|[Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java)
-186|[Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
-187|[Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
-188|[Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java)
-189|[Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java)
-190|[Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
-191|[Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java)
-192|[Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java)
-193|[Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
-194|[Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java)
-195|[Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java)
-196|[Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java)
-197|[Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
-198|[Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
-199|[Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
-200|[Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java)
-201|[Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java)
-202|[Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java)
-203|[Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
-204|[Binary Tree Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Inorder%20Traversal.java)
-205|[Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
-206|[Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
-207|[Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java)
-208|[Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java)
-209|[Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
-210|[Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java)
-211|[Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
-212|[4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java)
-213|[Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java)
-214|[Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
-215|[Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java)
-216|[Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java)
-217|[Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java)
-218|[Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
-219|[Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java)
-220|[Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java)
-221|[Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java)
-222|[Is Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Subsequence.java)
-223|[Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
-224|[Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
-225|[Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java)
-226|[Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java)
-227|[Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
-228|[Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java)
-229|[Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java)
-230|[All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java)
-231|[Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
-232|[Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java)
-233|[Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java)
-234|[Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java)
-235|[Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java)
-236|[Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java)
-237|[Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
-238|[Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java)
-239|[Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java)
-240|[Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java)
-241|[Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java)
-242|[All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java)
-243|[Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
-244|[Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
-245|[Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java)
-246|[Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
-247|[Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java)
-248|[Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
-249|[Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java)
-250|[Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
-251|[Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
-252|[Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
-253|[Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java)
-254|[Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
-255|[Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java)
-256|[Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
-257|[Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java)
-258|[Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java)
-259|[Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
-260|[HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java)
-261|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java)
-262|[Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java)
-263|[Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java)
-264|[Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java)
-265|[Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
-266|[Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
-267|[Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java)
-268|[Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
-269|[Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
-270|[Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
-271|[Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
-272|[Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
-273|[Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java)
-274|[Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
-275|[Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java)
-276|[Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
-277|[Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
-278|[Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java)
-279|[Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
-280|[Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java)
-281|[Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java)
-282|[The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java)
-283|[Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
-284|[Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java)
-285|[Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java)
-286|[Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java)
-287|[Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
-288|[Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java)
-289|[Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java)
-290|[Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java)
-291|[Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java)
-292|[Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java)
-293|[RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
-294|[Vertical Order Traversal Of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vertical%20Order%20Traversal%20Of%20Binary%20Tree.java)
-295|[Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
-296|[Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java)
-297|[Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java)
-298|[Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java)
-299|[Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java)
-300|[Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java)
-301|[Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java)
-302|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
-303|[Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java)
-304|[Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java)
-305|[Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java)
-306|[4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java)
-307|[Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
-308|[Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java)
-309|[Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
-310|[Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
-311|[Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
-312|[Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java)
-313|[Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
-314|[Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java)
-315|[Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java)
-316|[Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java)
-317|[Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
-318|[Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
-319|[Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java)
-320|[Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java)
-321|[Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
-322|[Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java)
-323|[Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java)
-324|[Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
-325|[Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
-326|[Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java)
-327|[Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
-328|[Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
-329|[Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
-330|[Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
-331|[Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java)
-332|[Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java)
-333|[Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
-334|[Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java)
-335|[Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
-336|[Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java)
-337|[Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
-338|[Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
-339|[Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java)
-340|[Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java)
-341|[Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
-342|[Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
-343|[Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java)
-344|[Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java)
-345|[Add and Search Word - Data structure design](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20and%20Search%20Word%20-%20Data%20structure%20design.java)
-346|[Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java)
-347|[Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java)
-348|[Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
-349|[Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
-350|[Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java)
-351|[Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java)
-352|[Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java)
-353|[Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java)
-354|[Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
-355|[Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
-356|[Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java)
-357|[Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
-358|[Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java)
-359|[Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java)
-360|[Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
-361|[Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)
-362|[Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java)
-363|[Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java)
-364|[Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java)
-365|[Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java)
-366|[Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java)
-367|[Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
-368|[Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
-369|[Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java)
-370|[Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java)
-371|[Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java)
-372|[Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java)
-373|[Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java)
-374|[Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
-375|[Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
-376|[Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java)
-377|[Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java)
-378|[Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
-379|[Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java)
-380|[Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
-381|[Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java)
-382|[Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java)
-383|[Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java)
-384|[Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java)
-385|[The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java)
-386|[Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
-387|[Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
-388|[Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
-389|[Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java)
-390|[Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
-391|[Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java)
-392|[Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java)
-393|[Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java)
-394|[Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
-395|[Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
-396|[Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java)
-397|[Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
-398|[Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
-399|[Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java)
-400|[Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
-401|[Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java)
-402|[Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java)
-403|[Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java)
-404|[Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java)
-405|[Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java)
-406|[Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java)
-407|[My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
-408|[Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java)
-409|[Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java)
-410|[Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
-411|[Counting Bits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Counting%20Bits.java)
-412|[Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java)
-413|[Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java)
-414|[Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java)
-415|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
-416|[Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
-417|[Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
-418|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java)
-419|[Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
-420|[Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java)
-421|[132 Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/132%20Pattern.java)
-422|[Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java)
-423|[Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
-424|[Find the duplicate number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20duplicate%20number.java)
-425|[Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java)
-426|[Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java)
-427|[Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
-428|[Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java)
-429|[Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
-430|[My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
-431|[Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java)
-432|[Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java)
-433|[Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java)
-434|[Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
-435|[Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java)
-436|[Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
-437|[Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
-438|[Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java)
-439|[Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java)
-440|[Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
-441|[H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
-442|[Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java)
-443|[Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
-444|[Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java)
-445|[Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java)
-446|[Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
-447|[Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java)
-448|[Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java)
-449|[Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java)
-450|[Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java)
-451|[Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
-452|[The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java)
-453|[Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
-454|[Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
-455|[Teemo Attacking](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Teemo%20Attacking.java)
-456|[Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java)
-457|[Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java)
-458|[Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
-459|[Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java)
-460|[Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java)
-461|[Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java)
-462|[Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java)
-463|[Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java)
-464|[01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java)
-465|[Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java)
-466|[Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
-467|[Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java)
-468|[Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java)
-469|[Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
-470|[Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
-471|[Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java)
-472|[Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
-473|[Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
-474|[Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
-475|[Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java)
-476|[Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
-477|[String to Integer(atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer(atoi).java)
-478|[Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
-479|[Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
-480|[Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
-481|[Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java)
-482|[Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
-483|[Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
-484|[Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
-485|[Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
-486|[Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
-487|[Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java)
-488|[Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
-489|[Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java)
-490|[Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java)
-491|[Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
-492|[Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java)
-493|[Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java)
-494|[Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java)
-495|[Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java)
-496|[Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java)
-497|[Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java)
-498|[Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
-499|[Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
-500|[Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
-501|[Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java)
-502|[ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
-503|[Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
-504|[All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java)
-505|[Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
-506|[Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java)
-507|[People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java)
-508|[Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java)
-509|[All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java)
-510|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java)
-511|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java)
-512|[Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
-513|[Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java)
-514|[All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
-515|[Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
-516|[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Medium.md)
-517|[Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
-518|[Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
-519|[Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java)
-520|[Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
-521|[Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java)
-522|[Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
-523|[Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
-524|[Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java)
-525|[Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
-526|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java)
-527|[Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java)
-528|[H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
-529|[3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java)
-530|[Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
-531|[Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
-532|[Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java)
-533|[Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java)
-534|[Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
-535|[Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java)
-536|[Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
-537|[Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java)
-538|[Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
-539|[Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java)
-540|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
-541|[Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
-542|[Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java)
+1|[Jump Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20II.java)
+2|[Unique Paths II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths%20II.java)
+3|[Search a 2D Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix%20II.java)
+4|[First Unique Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/First%20Unique%20Number.java)
+5|[Minimum Number of Vertices to Reach All Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes.java)
+6|[Inorder Successor in BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST.java)
+7|[3Sum Closest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Closest.java)
+8|[Binary Tree Zigzag Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Zigzag%20Level%20Order%20Traversal.java)
+9|[Successful Pairs of Spells and Potions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Successful%20Pairs%20of%20Spells%20and%20Potions.java)
+10|[Sort the Jumbled Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Jumbled%20Numbers.java)
+11|[Closest Nodes Queries in a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Closest%20Nodes%20Queries%20in%20a%20Binary%20Search%20Tree.java)
+12|[House Robber III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20III.java)
+13|[Out of Boundary Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Out%20of%20Boundary%20Paths.java)
+14|[Campus Bikes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes.java)
+15|[Arithmetic Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Subarrays.java)
+16|[Binary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Level%20Order%20Traversal.java)
+17|[Vowels of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowels%20of%20All%20Substrings.java)
+18|[Grumpy Bookstore Owner](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Grumpy%20Bookstore%20Owner.java)
+19|[Minimize the Maximum Difference of Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20the%20Maximum%20Difference%20of%20Pairs.java)
+20|[Linked List Cycle II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Cycle%20II.java)
+21|[Dota2 Senate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dota2%20Senate.java)
+22|[Largest Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Number.java)
+23|[Stone Game II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stone%20Game%20II.java)
+24|[Web Crawler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Web%20Crawler.java)
+25|[Champagne Tower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Champagne%20Tower.java)
+26|[Candy Crush](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Candy%20Crush.java)
+27|[Bold Words in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bold%20Words%20in%20String.java)
+28|[Diagonal Traverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diagonal%20Traverse.java)
+29|[Shortest Way to Form String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Way%20to%20Form%20String.java)
+30|[Maximum Number of Coins You Can Get](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Coins%20You%20Can%20Get.java)
+31|[Masking Personal Information](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Masking%20Personal%20Information.java)
+32|[The Earliest Moment When Everyone Become Friends](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Earliest%20Moment%20When%20Everyone%20Become%20Friends.java)
+33|[Divide Two Integers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Two%20Integers.java)
+34|[Minimum Cost to Connect Sticks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20to%20Connect%20Sticks.java)
+35|[Lowest Common Ancestor of Deepest Leaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20Deepest%20Leaves.java)
+36|[Single Number III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20III.java)
+37|[Next Greater Element III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20III.java)
+38|[Making File Names Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Making%20File%20Names%20Unique.java)
+39|[Validate Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Binary%20Search%20Tree.java)
+40|[Sparse Matrix Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sparse%20Matrix%20Multiplication.java)
+41|[Uncrossed Lines](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Uncrossed%20Lines.java)
+42|[Capacity To Ship Packages Within D Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Capacity%20To%20Ship%20Packages%20Within%20D%20Days.java)
+43|[Count Vowel Strings in Ranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Vowel%20Strings%20in%20Ranges.java)
+44|[Set Matrix Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Set%20Matrix%20Zeroes.java)
+45|[Flatten a Multilevel Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20a%20Multilevel%20Doubly%20Linked%20List.java)
+46|[Word Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Subsets.java)
+47|[Find Smallest Common Element in All Rows](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Smallest%20Common%20Element%20in%20All%20Rows.java)
+48|[Reverse Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Integer.java)
+49|[Most Popular Video Creator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Popular%20Video%20Creator.java)
+50|[Most Stones Removed with Same Row or Column](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Stones%20Removed%20with%20Same%20Row%20or%20Column.java)
+51|[Shortest Word Distance II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20II.java)
+52|[Total Hamming Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Hamming%20Distance.java)
+53|[Sort Linked List Already Sorted Using Absolute Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Linked%20List%20Already%20Sorted%20Using%20Absolute%20Values.java)
+54|[Count Number of Homogenous Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Homogenous%20Substrings.java)
+55|[Score of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20of%20Parentheses.java)
+56|[Gas Station](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gas%20Station.java)
+57|[Number of Subarrays with Bounded Maximum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subarrays%20with%20Bounded%20Maximum.java)
+58|[Kth Largest Sum in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Sum%20in%20a%20Binary%20Tree.java)
+59|[Smallest Number in Infinite Set](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Number%20in%20Infinite%20Set.java)
+60|[All Divisions With the Highest Score of a Binary Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Divisions%20With%20the%20Highest%20Score%20of%20a%20Binary%20Array.java)
+61|[Non-decreasing Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-decreasing%20Array.java)
+62|[Palindrome Partitioning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindrome%20Partitioning.java)
+63|[Find all Duplicates in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20all%20Duplicates%20in%20an%20Array.java)
+64|[Find Largest Value in Each Tree Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Largest%20Value%20in%20Each%20Tree%20Row.java)
+65|[Flatten 2D Vector](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%202D%20Vector.java)
+66|[Find All Lonely Numbers in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Lonely%20Numbers%20in%20the%20Array.java)
+67|[Furthest Building You Can Reach](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Furthest%20Building%20You%20Can%20Reach.java)
+68|[Convert Binary Search Tree to Sorted Doubly Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Binary%20Search%20Tree%20to%20Sorted%20Doubly%20Linked%20List.java)
+69|[Design a File Sharing System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20File%20Sharing%20System.java)
+70|[Watering Plants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Watering%20Plants.java)
+71|[Smallest String Starting From Leaf](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20Starting%20From%20Leaf.java)
+72|[Throne Inheritence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Throne%20Inheritence.java)
+73|[Minimum Remove to Make Valid Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Remove%20to%20Make%20Valid%20Parentheses.java)
+74|[Implement Trie II (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20II%20(Prefix%20Tree).java)
+75|[Remove Covered Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Covered%20Intervals.java)
+76|[Minimum Add to Make Parentheses Valid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Add%20to%20Make%20Parentheses%20Valid.java)
+77|[Arithmetic Slices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Arithmetic%20Slices.java)
+78|[Binary Tree Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Preorder%20Traversal.java)
+79|[Time Needed to Inform All Employees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Inform%20All%20Employees.java)
+80|[Kill Process](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kill%20Process.java)
+81|[Maximum Twin Sum of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Twin%20Sum%20of%20a%20Linked%20List.java)
+82|[Line Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Line%20Reflection.java)
+83|[Maximum Number of Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Occurrences%20of%20a%20Substring.java)
+84|[Frequency Tracker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Frequency%20Tracker.java)
+85|[Diameter of N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Diameter%20of%20N-ary%20Tree.java)
+86|[Maximum Number of Non-Overlapping Subarrays With Sum Equals Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Non-Overlapping%20Subarrays%20With%20Sum%20Equals%20Target.java)
+87|[Majority Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Majority%20Element%20II.java)
+88|[Number of Ways to Split Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Ways%20to%20Split%20Array.java)
+89|[Plus One Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Plus%20One%20Linked%20List.java)
+90|[Append Characters to String to Make Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20Characters%20to%20String%20to%20Make%20Subsequence.java)
+91|[Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Consecutive%20Sequence.java)
+92|[Find Minimum in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Minimum%20in%20Rotated%20Sorted%20Array.java)
+93|[Decrease Elements To Make Array Zigzag](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decrease%20Elements%20To%20Make%20Array%20Zigzag.java)
+94|[Binary Tree Longest Consecutive Sequence II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence%20II.java)
+95|[Concatenation of Consecutive Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Concatenation%20of%20Consecutive%20Binary%20Numbers.java)
+96|[Bitwise AND of Numbers Range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bitwise%20AND%20of%20Numbers%20Range.java)
+97|[Maximum Points You Can Obtain from Cards](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Points%20You%20Can%20Obtain%20from%20Cards.java)
+98|[Count Number of Teams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Teams.java)
+99|[Sum of Subarray Minimums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Subarray%20Minimums.java)
+100|[Binary Trees With Factors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Trees%20With%20Factors.java)
+101|[Prime Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prime%20Palindrome.java)
+102|[Minimum Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Path%20Sum.java)
+103|[Friend Circles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friend%20Circles.java)
+104|[Matchsticks to Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Matchsticks%20to%20Square.java)
+105|[Valid Sudoku](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Sudoku.java)
+106|[Four Divisors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Four%20Divisors.java)
+107|[As Far from Land as Possible](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/As%20Far%20from%20Land%20as%20Possible.java)
+108|[Count Square Submatrices with All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Square%20Submatrices%20with%20All%20Ones.java)
+109|[Linked List in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20in%20Binary%20Tree.java)
+110|[Number of Nodes in the Sub-Tree With the Same Label](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Nodes%20in%20the%20Sub-Tree%20With%20the%20Same%20Label.java)
+111|[Pseudo-Palindromic Paths in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pseudo-Palindromic%20Paths%20in%20a%20Binary%20Tree.java)
+112|[Pancake Sorting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pancake%20Sorting.java)
+113|[Walls and Gates](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Walls%20and%20Gates.java)
+114|[Decode String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20String.java)
+115|[Combination Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20II.java)
+116|[Complete Binary Tree Insertor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complete%20Binary%20Tree%20Insertor.java)
+117|[Minimum Moves to Equal Array Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements.java)
+118|[Design an ATM Machine](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20ATM%20Machine.java)
+119|[Split Linked List in Parts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Linked%20List%20in%20Parts.java)
+120|[Longest Word With All Prefixes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20With%20All%20Prefixes.java)
+121|[Binary Tree Pruning](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Pruning.java)
+122|[Escape The Ghosts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Escape%20The%20Ghosts.java)
+123|[Longest Arithmetic Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Sequence.java)
+124|[Longest Arithmetic Subsequence of Given Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence%20of%20Given%20Difference.java)
+125|[Equal Row and Column Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Equal%20Row%20and%20Column%20Pairs.java)
+126|[Count Numbers With Unique Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Numbers%20With%20Unique%20Digits.java)
+127|[Maximum Average Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Average%20Subtree.java)
+128|[Product of Array Except self](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Array%20Except%20self.java)
+129|[Find Bottom Left Tree Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Bottom%20Left%20Tree%20Value.java)
+130|[Shifting Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shifting%20Letters.java)
+131|[Maximum Product of Splitted Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Splitted%20Binary%20Tree.java)
+132|[Minimum Knight Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Knight%20Moves.java)
+133|[3Sum With Multiplicity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20With%20Multiplicity.java)
+134|[Rotting Oranges](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotting%20Oranges.java)
+135|[Palindromic Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Palindromic%20Substrings.java)
+136|[Maximum of Absolute Value Expression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20of%20Absolute%20Value%20Expression.java)
+137|[Insert Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Interval.java)
+138|[Is Graph Bipartite](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Is%20Graph%20Bipartite.java)
+139|[Add Two Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers.java)
+140|[Find Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Permutation.java)
+141|[Number of Burgers with No Waste of Ingredients](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Burgers%20with%20No%20Waste%20of%20Ingredients.java)
+142|[Finding the Users Active Minutes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Finding%20the%20Users%20Active%20Minutes.java)
+143|[Validate Stack Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20Stack%20Sequences.java)
+144|[Number of Substrings Containing All Three Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20Containing%20All%20Three%20Characters.java)
+145|[Next Greater Element II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Element%20II.java)
+146|[Count and Say](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20and%20Say.java)
+147|[Design Add and Search Words Data Structure](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Add%20and%20Search%20Words%20Data%20Structure.java)
+148|[Maximum Score From Removing Stones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20From%20Removing%20Stones.java)
+149|[Minimum Consecutive Cards to Pick Up](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Consecutive%20Cards%20to%20Pick%20Up.java)
+150|[Score After Flipping Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Score%20After%20Flipping%20Matrix.java)
+151|[Jump Game VI](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20VI.java)
+152|[Design Browser History](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Browser%20History.java)
+153|[Cheapest Flights Within K Stops](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cheapest%20Flights%20Within%20K%20Stops.java)
+154|[Meeting Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Scheduler.java)
+155|[Perfect Squares](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Perfect%20Squares.java)
+156|[Maximum Matching of Players With Trainers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Matching%20of%20Players%20With%20Trainers.java)
+157|[Word Search](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Search.java)
+158|[Find Triangular Sum of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Triangular%20Sum%20of%20an%20Array.java)
+159|[Knight Dialer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Dialer.java)
+160|[3Sum Smaller](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum%20Smaller.java)
+161|[Repeated DNA Sequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Repeated%20DNA%20Sequences.java)
+162|[Lowest Common Ancestor of a Binary Tree III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20III.java)
+163|[Partition Array According to Given Pivot](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Array%20According%20to%20Given%20Pivot.java)
+164|[Construct K Palindrome Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20K%20Palindrome%20Strings.java)
+165|[Solve the Equation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solve%20the%20Equation.java)
+166|[Average Waiting Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Average%20Waiting%20Time.java)
+167|[Time Needed to Rearrange a Binary String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Needed%20to%20Rearrange%20a%20Binary%20String.java)
+168|[Sort Integers by The Power Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Integers%20by%20The%20Power%20Value.java)
+169|[Sum in a Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20in%20a%20Matrix.java)
+170|[Combination Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum.java)
+171|[Make String a Subsequence Using Cyclic Increments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Make%20String%20a%20Subsequence%20Using%20Cyclic%20Increments.java)
+172|[Merge Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Intervals.java)
+173|[4 Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Sum%20II.java)
+174|[Advantage Shuffle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Advantage%20Shuffle.java)
+175|[Number of Dice Rolls With Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Dice%20Rolls%20With%20Target%20Sum.java)
+176|[Minimum Flips to Make a OR b Equal to c](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Flips%20to%20Make%20a%20OR%20b%20Equal%20to%20c.java)
+177|[Basic Calculator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Basic%20Calculator%20II.java)
+178|[Find Original Array From Doubled Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Original%20Array%20From%20Doubled%20Array.java)
+179|[Maximum Length of Repeated Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Repeated%20Subarray.java)
+180|[Lonely Pixel I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lonely%20Pixel%20I.java)
+181|[Guess Number Higher or Lower II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Guess%20Number%20Higher%20or%20Lower%20II.java)
+182|[Remove Duplicate Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicate%20Letters.java)
+183|[Construct Binary Tree from Preorder and Inorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Preorder%20and%20Inorder%20Traversal.java)
+184|[Group the People Given the Group Size They Belong To](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20the%20People%20Given%20the%20Group%20Size%20They%20Belong%20To.java)
+185|[House Robber II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber%20II.java)
+186|[Find the Winner of an Array Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Winner%20of%20an%20Array%20Game.java)
+187|[Check if Strings Can be Made Equal With Operations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20Strings%20Can%20be%20Made%20Equal%20With%20Operations%20II.java)
+188|[Letter Combinations of a Phone Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Combinations%20of%20a%20Phone%20Number.java)
+189|[Implement Magic Dictionary](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Magic%20Dictionary.java)
+190|[Task Scheduler](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Task%20Scheduler.java)
+191|[Minimum Size Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Size%20Subarray%20Sum.java)
+192|[Max Chunks To Make Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Chunks%20To%20Make%20Sorted.java)
+193|[Max Number of K-Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Number%20of%20K-Sum%20Pairs.java)
+194|[Longest Word in Dictionary through Deleting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Word%20in%20Dictionary%20through%20Deleting.java)
+195|[Maximum Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree.java)
+196|[Find and Replace in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20in%20String.java)
+197|[Sort Characters By Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Characters%20By%20Frequency.java)
+198|[Maximum Erasure Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Erasure%20Value.java)
+199|[Number of Matching Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequences.java)
+200|[Simple Bank System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simple%20Bank%20System.java)
+201|[Camelcase Matching](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Camelcase%20Matching.java)
+202|[Split Array into Consecutive Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20Array%20into%20Consecutive%20Subsequences.java)
+203|[Integer To Roman](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Integer%20To%20Roman.java)
+204|[Smallest Value of the Rearranged Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Value%20of%20the%20Rearranged%20Number.java)
+205|[Count Servers That Communicate](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Servers%20That%20Communicate.java)
+206|[Execution of All Suffix Instructions Staying in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Execution%20of%20All%20Suffix%20Instructions%20Staying%20in%20a%20Grid.java)
+207|[Number of Laser Beams in a Bank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Laser%20Beams%20in%20a%20Bank.java)
+208|[Minimize Maximum Pair Sum in Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20Pair%20Sum%20in%20Array.java)
+209|[Lowest Common Ancestor of a Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree%20II.java)
+210|[Image Overlap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Image%20Overlap.java)
+211|[Balance a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Balance%20a%20Binary%20Search%20Tree.java)
+212|[Insert Greatest Common Divisors in Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Greatest%20Common%20Divisors%20in%20Linked%20List.java)
+213|[Reordered Power of 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reordered%20Power%20of%202.java)
+214|[Construct Binary Tree from Inorder and Postorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Tree%20from%20Inorder%20and%20Postorder%20Traversal.java)
+215|[Multiply Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Multiply%20Strings.java)
+216|[K Radius Subarray Averages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Radius%20Subarray%20Averages.java)
+217|[Minimum Health to Beat Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Health%20to%20Beat%20Game.java)
+218|[Path With Minimum Effort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Minimum%20Effort.java)
+219|[Append K Integers With Minimal Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Append%20K%20Integers%20With%20Minimal%20Sum.java)
+220|[Minimum Moves to Equal Array Elements II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Equal%20Array%20Elements%20II.java)
+221|[Parallel Courses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Parallel%20Courses.java)
+222|[Put Boxes Into the Warehouse I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Put%20Boxes%20Into%20the%20Warehouse%20I.java)
+223|[Adding Two Negabinary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Two%20Negabinary%20Numbers.java)
+224|[Minimum Rounds to Complete All Tasks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Rounds%20to%20Complete%20All%20Tasks.java)
+225|[Longest Happy String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Happy%20String.java)
+226|[Nested List Weight Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nested%20List%20Weight%20Sum%20II.java)
+227|[Range Sum Query 2D-Immutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%202D-Immutable.java)
+228|[Remove Nth Node From End of List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nth%20Node%20From%20End%20of%20List.java)
+229|[Peeking Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peeking%20Iterator.java)
+230|[Subsets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets.java)
+231|[Design Circular Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Queue.java)
+232|[4 Keys Keyboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4%20Keys%20Keyboard.java)
+233|[Single Element in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Element%20in%20a%20Sorted%20Array.java)
+234|[Permutations II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations%20II.java)
+235|[Knight Probability in Chessboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Knight%20Probability%20in%20Chessboard.java)
+236|[Reachable Nodes With Restrictions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reachable%20Nodes%20With%20Restrictions.java)
+237|[Longest ZigZag Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20ZigZag%20Path%20in%20a%20Binary%20Tree.java)
+238|[Reduce Array Size to The Half](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduce%20Array%20Size%20to%20The%20Half.java)
+239|[Maximum Length of Pair Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Pair%20Chain.java)
+240|[Binary Tree Vertical Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Vertical%20Order%20Traversal.java)
+241|[Reorder Data in Log Files](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Data%20in%20Log%20Files.java)
+242|[Maximum Product Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20Subarray.java)
+243|[Rotate List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20List.java)
+244|[Find the Celebrity](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Celebrity.java)
+245|[Swap Nodes in Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20Nodes%20in%20Pairs.java)
+246|[Filter Restaurants by Vegan-Friendly, Price and Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Filter%20Restaurants%20by%20Vegan-Friendly,%20Price%20and%20Distance.java)
+247|[Evaluate Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Division.java)
+248|[Minimum Operations to Make Array Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20Array%20Equal.java)
+249|[Combinations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combinations.java)
+250|[Max Area of Island](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Area%20of%20Island.java)
+251|[Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20List.java)
+252|[Most Frequent Subtree Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Frequent%20Subtree%20Sum.java)
+253|[Find Peak Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Peak%20Element.java)
+254|[Open The Lock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Open%20The%20Lock.java)
+255|[Fruit Into Baskets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fruit%20Into%20Baskets.java)
+256|[Maximum Sum of Almost Unique Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Almost%20Unique%20Subarray.java)
+257|[Remove K Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20K%20Digits.java)
+258|[Minimum Number of Steps to Make Two Strings Anagram](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram.java)
+259|[Connecting Cities With Minimum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Connecting%20Cities%20With%20Minimum%20Cost.java)
+260|[Decoded String at Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decoded%20String%20at%20Index.java)
+261|[Satisfisbility of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfisbility%20of%20Equality%20Equations.java)
+262|[Maximum Product of Word Lengths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Product%20of%20Word%20Lengths.java)
+263|[Maximum Number of Integers to Choose From a Range I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Integers%20to%20Choose%20From%20a%20Range%20I.java)
+264|[Pour Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pour%20Water.java)
+265|[Gray Code](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Gray%20Code.java)
+266|[Minimum Moves to Reach Target Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Moves%20to%20Reach%20Target%20Score.java)
+267|[Encode and Decode TinyURL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20TinyURL.java)
+268|[Game of Life](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Game%20of%20Life.java)
+269|[Number of Pairs of Strings With Concatenation Equal to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Strings%20With%20Concatenation%20Equal%20to%20Target.java)
+270|[Maximum Swap](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Swap.java)
+271|[Time Based Key-Value Store](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Time%20Based%20Key-Value%20Store.java)
+272|[Compare Version Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Compare%20Version%20Numbers.java)
+273|[Reverse Nodes in Even Length Groups](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Nodes%20in%20Even%20Length%20Groups.java)
+274|[Maximum Number of Vowels in a Substring of Given Length](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Vowels%20in%20a%20Substring%20of%20Given%20Length.java)
+275|[Graph Valid Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Graph%20Valid%20Tree.java)
+276|[Minimum Operations to Reduce X to Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Reduce%20X%20to%20Zero.java)
+277|[Group Anagrams](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Anagrams.java)
+278|[Delete the Middle Node of a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20the%20Middle%20Node%20of%20a%20Linked%20List.java)
+279|[Lowest Common Ancestor of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Tree.java)
+280|[Deepest Leaves Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Deepest%20Leaves%20Sum.java)
+281|[Minimize Maximum of Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Maximum%20of%20Array.java)
+282|[Boundary of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boundary%20of%20Binary%20Tree.java)
+283|[Clone N-ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20N-ary%20Tree.java)
+284|[Rotate Image](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Image.java)
+285|[Self Dividing Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Self%20Dividing%20Numbers.java)
+286|[Remove Nodes From Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Nodes%20From%20Linked%20List.java)
+287|[Map Sum Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Map%20Sum%20Pairs.java)
+288|[Restore the Array From Adjacent Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20the%20Array%20From%20Adjacent%20Pairs.java)
+289|[Find the Index of the Large Integer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20Large%20Integer.java)
+290|[Combination Sum IV](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20IV.java)
+291|[Pacific Atlantic Water Flow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pacific%20Atlantic%20Water%20Flow.java)
+292|[Delete Leaves With a Given Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Leaves%20With%20a%20Given%20Value.java)
+293|[Pow](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow.java)
+294|[Remove Comments](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Comments.java)
+295|[Longest Uploaded Prefix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Uploaded%20Prefix.java)
+296|[Rotated Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotated%20Digits.java)
+297|[Next Permutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Permutation.java)
+298|[Find the Substring With Maximum Cost](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Substring%20With%20Maximum%20Cost.java)
+299|[Design Log Storage System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Log%20Storage%20System.java)
+300|[Decode Ways](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Decode%20Ways.java)
+301|[Number of Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Longest%20Increasing%20Subsequence.java)
+302|[Triangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Triangle.java)
+303|[Non-overlapping Intervals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Non-overlapping%20Intervals.java)
+304|[Broken Calculator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Broken%20Calculator.java)
+305|[Maximum Score from Performing Multiplication Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Score%20from%20Performing%20Multiplication%20Operations.java)
+306|[Vowel Spellchecker](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Vowel%20Spellchecker.java)
+307|[Maximum Sum of Distinct Subarrays With Length K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20Distinct%20Subarrays%20With%20Length%20K.java)
+308|[4Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum.java)
+309|[House Robber](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/House%20Robber.java)
+310|[Find Root of N-Ary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Root%20of%20N-Ary%20Tree.java)
+311|[Rotate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Function.java)
+312|[Can Make Palindrome from Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Make%20Palindrome%20from%20Substring.java)
+313|[Find Distance in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Distance%20in%20a%20Binary%20Tree.java)
+314|[Possible Bipartition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Possible%20Bipartition.java)
+315|[Design Hit Counter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Hit%20Counter.java)
+316|[Insert into a Sorted Circular Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Sorted%20Circular%20Linked%20List.java)
+317|[Online Stock Span](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Stock%20Span.java)
+318|[Min Cost to Connect All Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Cost%20to%20Connect%20All%20Points.java)
+319|[Minimum Time to Collect All Apples in a Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Collect%20All%20Apples%20in%20a%20Tree.java)
+320|[Minimum Area Rectangle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Area%20Rectangle.java)
+321|[Invalid Transactions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Invalid%20Transactions.java)
+322|[Remove All Occurrences of a Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Occurrences%20of%20a%20Substring.java)
+323|[Minimum Average Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Average%20Difference.java)
+324|[Maximal Score After Applying K Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Score%20After%20Applying%20K%20Operations.java)
+325|[Minimum Amount of Time to Collect Garbage](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Amount%20of%20Time%20to%20Collect%20Garbage.java)
+326|[Search in Rotated Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array.java)
+327|[Letter Tiles Possibilities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Letter%20Tiles%20Possibilities.java)
+328|[Divide Players Into Teams of Equal Skill](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Players%20Into%20Teams%20of%20Equal%20Skill.java)
+329|[Path with Maximum Gold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Gold.java)
+330|[Copy List with Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Copy%20List%20with%20Random%20Pointer.java)
+331|[Number of Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Islands.java)
+332|[Total Cost to Hire K Workers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Total%20Cost%20to%20Hire%20K%20Workers.java)
+333|[Sum Multiples](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Multiples.java)
+334|[Custom Sort String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Custom%20Sort%20String.java)
+335|[Populating Next Right Pointers in Each Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node.java)
+336|[Mirror Reflection](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mirror%20Reflection.java)
+337|[All Possible Full Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Possible%20Full%20Binary%20Trees.java)
+338|[Maximum Total Importance of Roads](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Total%20Importance%20of%20Roads.java)
+339|[Sum Root to Leaf Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20Root%20to%20Leaf%20Numbers.java)
+340|[Contiguous Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contiguous%20Array.java)
+341|[Large Divisble Subset](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Large%20Divisble%20Subset.java)
+342|[Minimum Height Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Height%20Trees.java)
+343|[Analyze User Website Visit Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Analyze%20User%20Website%20Visit%20Pattern.java)
+344|[Partitioning Into Minimum Number Of Deci-Binary Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partitioning%20Into%20Minimum%20Number%20Of%20Deci-Binary%20Numbers.java)
+345|[Permutations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutations.java)
+346|[Maximum Sum of an Hourglass](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Sum%20of%20an%20Hourglass.java)
+347|[Minimum Fuel Cost to Report to the Capital](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Fuel%20Cost%20to%20Report%20to%20the%20Capital.java)
+348|[Find the Prefix Common Array of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Prefix%20Common%20Array%20of%20Two%20Arrays.java)
+349|[Coin Change 2](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change%202.java)
+350|[Construct Quad Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Quad%20Tree.java)
+351|[Valid Parenthesis String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Parenthesis%20String.java)
+352|[Apply Discount Every n Orders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20Every%20n%20Orders.java)
+353|[All Elements in Two Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Elements%20in%20Two%20Binary%20Search%20Trees.java)
+354|[Longest Substring Without Repeating Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20Without%20Repeating%20Characters.java)
+355|[Fraction to Recurring Decimal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fraction%20to%20Recurring%20Decimal.java)
+356|[Extra Characters in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Extra%20Characters%20in%20a%20String.java)
+357|[Product of the Last K Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20the%20Last%20K%20Numbers.java)
+358|[Wiggle Sort](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Sort.java)
+359|[Peak Index in a Mountain Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Peak%20Index%20in%20a%20Mountain%20Array.java)
+360|[Accounts Merge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Accounts%20Merge.java)
+361|[K Closest Points to Origin](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/K%20Closest%20Points%20to%20Origin.java)
+362|[Largest Time for Given Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20Time%20for%20Given%20Digits.java)
+363|[Fair Distribution of Cookies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Fair%20Distribution%20of%20Cookies.java)
+364|[Count Sub Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sub%20Islands.java)
+365|[Reverse Words in a String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String%20II.java)
+366|[Find Leaves of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Leaves%20of%20Binary%20Tree.java)
+367|[Partition Labels](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Labels.java)
+368|[Apply Discount to Prices](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Apply%20Discount%20to%20Prices.java)
+369|[Sort An Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20An%20Array.java)
+370|[Hand of Straights](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Hand%20of%20Straights.java)
+371|[Angle Between Hands of a Clock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Angle%20Between%20Hands%20of%20a%20Clock.java)
+372|[Maximum Star Sum of a Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Star%20Sum%20of%20a%20Graph.java)
+373|[Reorder List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20List.java)
+374|[Find a Corresponding Node of a Binary Tree in a Clone of That Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20a%20Corresponding%20Node%20of%20a%20Binary%20Tree%20in%20a%20Clone%20of%20That%20Tree.java)
+375|[Remove Colored Pieces if Both Neighbors are the Same Color](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Colored%20Pieces%20if%20Both%20Neighbors%20are%20the%20Same%20Color.java)
+376|[Find Consecutive Integers from a Data Stream](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Consecutive%20Integers%20from%20a%20Data%20Stream.java)
+377|[Find Eventual Safe States](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Eventual%20Safe%20States.java)
+378|[Odd Even Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Odd%20Even%20Linked%20Lists.java)
+379|[Find Right Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Right%20Interval.java)
+380|[Dot Product of Two Sparse Vectors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Dot%20Product%20of%20Two%20Sparse%20Vectors.java)
+381|[Minimum Number of Arrows to Burst Balloons](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Arrows%20to%20Burst%20Balloons.java)
+382|[Product of Two Run-Length Encoded Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Product%20of%20Two%20Run-Length%20Encoded%20Arrays.java)
+383|[HTML Entity Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/HTML%20Entity%20Parser.java)
+384|[Find All Anagrams in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Anagrams%20in%20a%20String.java)
+385|[Boats to Save People](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Boats%20to%20Save%20People.java)
+386|[Print Words Vertically](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Words%20Vertically.java)
+387|[Minimum Falling Path Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Falling%20Path%20Sum.java)
+388|[Strictly Palindromic Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Strictly%20Palindromic%20Number.java)
+389|[Sentence Similarity III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20III.java)
+390|[Minimum Genetic Mutation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Genetic%20Mutation.java)
+391|[Split BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Split%20BST.java)
+392|[Iterator for Combination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Iterator%20for%20Combination.java)
+393|[Valid Triangle Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Triangle%20Number.java)
+394|[Keys and Rooms](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Keys%20and%20Rooms.java)
+395|[Interval List Intersections](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interval%20List%20Intersections.java)
+396|[Subarray Sums Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sums%20Divisible%20by%20K.java)
+397|[Merge Nodes in Between Zeros](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20Nodes%20in%20Between%20Zeros.java)
+398|[Maximum Level Sum of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Level%20Sum%20of%20a%20Binary%20Tree.java)
+399|[Expressive Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Expressive%20Words.java)
+400|[Friends Of Appropriate Ages](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Friends%20Of%20Appropriate%20Ages.java)
+401|[Flatten Nested List Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Nested%20List%20Iterator.java)
+402|[Corporate Flight Bookings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Corporate%20Flight%20Bookings.java)
+403|[Unique Binary Search Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Binary%20Search%20Trees.java)
+404|[Longest Increasing Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Increasing%20Subsequence.java)
+405|[Design Front Middle Back Queue](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Front%20Middle%20Back%20Queue.java)
+406|[Design A Leaderboard](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20A%20Leaderboard.java)
+407|[Search in Rotated Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20Rotated%20Sorted%20Array%20II.java)
+408|[Tuple With Same Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tuple%20With%20Same%20Product.java)
+409|[Delete Nodes And Return Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Nodes%20And%20Return%20Forest.java)
+410|[The kth Factor of n](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20kth%20Factor%20of%20n.java)
+411|[Minimum Time Difference](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20Difference.java)
+412|[Maximum Length of Subarray With Positive Product](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Length%20of%20Subarray%20With%20Positive%20Product.java)
+413|[Smallest Integer Divisible by K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Integer%20Divisible%20by%20K.java)
+414|[Find Players With Zero or One Losses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Players%20With%20Zero%20or%20One%20Losses.java)
+415|[Min Stack](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Min%20Stack.java)
+416|[Remove Zero Sum Consecutive Nodes from Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Zero%20Sum%20Consecutive%20Nodes%20from%20Linked%20List.java)
+417|[Validate IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Validate%20IP%20Address.java)
+418|[Reduction Operations to Make the Array Elements Equal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reduction%20Operations%20to%20Make%20the%20Array%20Elements%20Equal.java)
+419|[Nearest Exit from Entrance in Maze](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Nearest%20Exit%20from%20Entrance%20in%20Maze.java)
+420|[Cinema Seat Allocation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Cinema%20Seat%20Allocation.java)
+421|[Delete Operation for Two Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Operation%20for%20Two%20Strings.java)
+422|[Path with Maximum Probability](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20with%20Maximum%20Probability.java)
+423|[Minimum Time to Complete Trips](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Complete%20Trips.java)
+424|[Check If All 1's Are at Least Length K Places Away](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20All%201's%20Are%20at%20Least%20Length%20K%20Places%20Away.java)
+425|[RLE Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/RLE%20Iterator.java)
+426|[Increasing Subsequences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Subsequences.java)
+427|[Number of Closed Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Closed%20Islands.java)
+428|[Number of Substrings With Only 1s](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Substrings%20With%20Only%201s.java)
+429|[Delete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Tree%20Nodes.java)
+430|[Exclusive Time of Functions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Exclusive%20Time%20of%20Functions.java)
+431|[Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Is%20a%20Valid%20Sequence%20from%20Root%20to%20Leaves%20Path%20in%20a%20Binary%20Tree.java)
+432|[Count Ways To Build Good Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Ways%20To%20Build%20Good%20Strings.java)
+433|[Minimum Score of a Path Between Two Cities](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20of%20a%20Path%20Between%20Two%20Cities.java)
+434|[Leftmost Column with at Least a One](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Leftmost%20Column%20with%20at%20Least%20a%20One.java)
+435|[Subsets II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subsets%20II.java)
+436|[One Edit Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/One%20Edit%20Distance.java)
+437|[N-ary Tree Level Order Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/N-ary%20Tree%20Level%20Order%20Traversal.java)
+438|[Design Snake Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Snake%20Game.java)
+439|[Swap For Longest Repeated Character Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swap%20For%20Longest%20Repeated%20Character%20Substring.java)
+440|[Find the Student that Will Replace the Chalk](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Student%20that%20Will%20Replace%20the%20Chalk.java)
+441|[LRU Cache](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/LRU%20Cache.java)
+442|[Maximum Number of Groups Entering a Competition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Groups%20Entering%20a%20Competition.java)
+443|[Container With Most Water](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Container%20With%20Most%20Water.java)
+444|[Subdomain Visit Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subdomain%20Visit%20Count.java)
+445|[4Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/4Sum%20II.java)
+446|[Word Ladder](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Ladder.java)
+447|[Delete Node in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Delete%20Node%20in%20a%20BST.java)
+448|[Longest Well-Performing Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Well-Performing%20Interval.java)
+449|[Reconstruct Original Digits from English](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reconstruct%20Original%20Digits%20from%20English.java)
+450|[Single Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Single%20Number%20II.java)
+451|[Maximum Value after Insertion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20after%20Insertion.java)
+452|[Optimal Division](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Division.java)
+453|[Continuous Subarray Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Continuous%20Subarray%20Sum.java)
+454|[Number of Operations to Make Network Connected](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Operations%20to%20Make%20Network%20Connected.java)
+455|[Network Delay Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Network%20Delay%20Time.java)
+456|[Flip Equivalent Binary Trees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flip%20Equivalent%20Binary%20Trees.java)
+457|[String to Integer (atoi)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20to%20Integer%20(atoi).java)
+458|[Coin Change](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Coin%20Change.java)
+459|[Max Consecutives Ones II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Consecutives%20Ones%20II.java)
+460|[Kth Smallest Element in a BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20BST.java)
+461|[UTF-8 Validation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/UTF-8%20Validation.java)
+462|[Remove Interval](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Interval.java)
+463|[Find Nearest Right Node in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Nearest%20Right%20Node%20in%20Binary%20Tree.java)
+464|[Create Binary Tree From Descriptions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Create%20Binary%20Tree%20From%20Descriptions.java)
+465|[Evaluate the Bracket Pairs of a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20the%20Bracket%20Pairs%20of%20a%20String.java)
+466|[Wiggle Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Wiggle%20Subsequence.java)
+467|[Random Pick Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20Index.java)
+468|[Distribute Coins in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Distribute%20Coins%20in%20Binary%20Tree.java)
+469|[Sum of Even Numbers After Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Even%20Numbers%20After%20Queries.java)
+470|[Path With Maximum Minimum Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20With%20Maximum%20Minimum%20Value.java)
+471|[Most Profit Assigning Work](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Most%20Profit%20Assigning%20Work.java)
+472|[The Number of Weak Characters in the Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Weak%20Characters%20in%20the%20Game.java)
+473|[Partition List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20List.java)
+474|[Number of Distinct Islands](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Islands.java)
+475|[Design Circular Deque](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Circular%20Deque.java)
+476|[Implement Trie (Prefix Tree)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Trie%20(Prefix%20Tree).java)
+477|[Maximize Number of Subsequences in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Number%20of%20Subsequences%20in%20a%20String.java)
+478|[Max Sum of a Pair With Equal Sum of Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Sum%20of%20a%20Pair%20With%20Equal%20Sum%20of%20Digits.java)
+479|[Number of Provinces](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Provinces.java)
+480|[Largest BST Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Largest%20BST%20Subtree.java)
+481|[Range Sum Query - Mutable](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20Query%20-%20Mutable.java)
+482|[Mini Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Mini%20Parser.java)
+483|[Number of Smooth Descent Periods of a Stock](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Smooth%20Descent%20Periods%20of%20a%20Stock.java)
+484|[Maximum Distance Between a Pair of Values](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Distance%20Between%20a%20Pair%20of%20Values.java)
+485|[Alert Using Same Key-Card Three or More Times in a One Hour Period](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Alert%20Using%20Same%20Key-Card%20Three%20or%20More%20Times%20in%20a%20One%20Hour%20Period.java)
+486|[Linked List Components](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Components.java)
+487|[Binary Tree Upside Down](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Upside%20Down.java)
+488|[New 21 Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/New%2021%20Game.java)
+489|[Max Increase to Keep City Skyline](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Max%20Increase%20to%20Keep%20City%20Skyline.java)
+490|[Daily Temperatures](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Daily%20Temperatures.java)
+491|[Binary Search Tree to Greater Sum Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20to%20Greater%20Sum%20Tree.java)
+492|[Subarray Product Less Than K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Product%20Less%20Than%20K.java)
+493|[Design a Stack With Increment Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20a%20Stack%20With%20Increment%20Operation.java)
+494|[Break a Palindrome](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Break%20a%20Palindrome.java)
+495|[Maximum Size Subarray Sum Equals k](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Size%20Subarray%20Sum%20Equals%20k.java)
+496|[Minimum Number of Steps to Make Two Strings Anagram II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Number%20of%20Steps%20to%20Make%20Two%20Strings%20Anagram%20II.java)
+497|[Subarray Sum Equals K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subarray%20Sum%20Equals%20K.java)
+498|[Car Pooling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Car%20Pooling.java)
+499|[Remove Sub-Folders from the Filesystem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Sub-Folders%20from%20the%20Filesystem.java)
+500|[Sum of Nodes with Even-Valued Grandparent](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Nodes%20with%20Even-Valued%20Grandparent.java)
+501|[Check If a String Can Break Another String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Can%20Break%20Another%20String.java)
+502|[Ternary Expression Parser](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ternary%20Expression%20Parser.java)
+503|[Generate Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Generate%20Parentheses.java)
+504|[Minimum Penalty for a Shop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Penalty%20for%20a%20Shop.java)
+505|[Encode and Decode Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Encode%20and%20Decode%20Strings.java)
+506|[Asteroid Collision](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Asteroid%20Collision.java)
+507|[Minimum Deletion Cost to Avoid Repeating Letters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletion%20Cost%20to%20Avoid%20Repeating%20Letters.java)
+508|[Design Phone Directory](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Phone%20Directory.java)
+509|[Remove Duplicates from Sorted List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20from%20Sorted%20List%20II.java)
+510|[Count Nodes Equal to Sum of Descendants](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Sum%20of%20Descendants.java)
+511|[Random Pick With Weight](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Random%20Pick%20With%20Weight.java)
+512|[Maximize the Topmost Element After K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Topmost%20Element%20After%20K%20Moves.java)
+513|[Swapping Nodes in a Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Swapping%20Nodes%20in%20a%20Linked%20List.java)
+514|[Number of Subsequences That Satisfy the Given Sum Condition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Subsequences%20That%20Satisfy%20the%20Given%20Sum%20Condition.java)
+515|[Ones and Zeroes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ones%20and%20Zeroes.java)
+516|[Number of Connected Components in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Connected%20Components%20in%20an%20Undirected%20Graph.java)
+517|[Display Table of Food Orders in a Restaurant](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Display%20Table%20of%20Food%20Orders%20in%20a%20Restaurant.java)
+518|[Campus Bikes II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Campus%20Bikes%20II.java)
+519|[Longest Line of Consecutive One in Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Line%20of%20Consecutive%20One%20in%20Matrix.java)
+520|[Zigzag Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Zigzag%20Iterator.java)
+521|[Merge In Between Linked Lists](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Merge%20In%20Between%20Linked%20Lists.java)
+522|[Surrounded Regions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Surrounded%20Regions.java)
+523|[Seat Reservation Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Seat%20Reservation%20Manager.java)
+524|[Print Immutable Linked List in Reverse](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Immutable%20Linked%20List%20in%20Reverse.java)
+525|[Tree Diameter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tree%20Diameter.java)
+526|[Incremental Memory Leak](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Incremental%20Memory%20Leak.java)
+527|[Lexicographically Smallest Equivalent String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20Equivalent%20String.java)
+528|[Reverse Words in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Words%20in%20a%20String.java)
+529|[Simplify Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Simplify%20Path.java)
+530|[Design Underground System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Underground%20System.java)
+531|[Sequential Digits](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sequential%20Digits.java)
+532|[Longest Substring with At Most Two Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20Two%20Distinct%20Characters.java)
+533|[Smallest String With Swaps](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20Swaps.java)
+534|[Jump Game III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game%20III.java)
+535|[Adding Spaces to a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Adding%20Spaces%20to%20a%20String.java)
+536|[Shortest Path with Alternating Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20with%20Alternating%20Colors.java)
+537|[Maximum Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subarray.java)
+538|[Removing Stars From a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Removing%20Stars%20From%20a%20String.java)
+539|[Find K Pairs with Smallest Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Pairs%20with%20Smallest%20Sums.java)
+540|[Check if There is a Valid Path in a Grid](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20if%20There%20is%20a%20Valid%20Path%20in%20a%20Grid.java)
+541|[Tweet Counts Per Frequency](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Tweet%20Counts%20Per%20Frequency.java)
+542|[Ugly Number II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Ugly%20Number%20II.java)
+543|[Find First and Last Position of Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20First%20and%20Last%20Position%20of%20Element%20in%20Sorted%20Array.java)
+544|[Longest Subarray of 1's After Deleting One Element](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Subarray%20of%201's%20After%20Deleting%20One%20Element.java)
+545|[Clone Binary Tree With Random Pointer](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Binary%20Tree%20With%20Random%20Pointer.java)
+546|[Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Continuous%20Subarray%20With%20Absolute%20Diff%20Less%20Than%20or%20Equal%20to%20Limit.java)
+547|[Count Number of Bad Pairs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Bad%20Pairs.java)
+548|[Super Ugly Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Super%20Ugly%20Number.java)
+549|[Add Two Numbers II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Two%20Numbers%20II.java)
+550|[Implement Rand10() Using Rand7()](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Implement%20Rand10()%20Using%20Rand7().java)
+551|[Minimum Deletions to Make Character Frequencies Unique](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Character%20Frequencies%20Unique.java)
+552|[Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Area%20of%20a%20Piece%20of%20Cake%20After%20Horizontal%20and%20Vertical%20Cuts.java)
+553|[Array Nesting](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Nesting.java)
+554|[Valid Square](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Square.java)
+555|[Find Closest Node to Given Two Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Closest%20Node%20to%20Given%20Two%20Nodes.java)
+556|[Course Schedule](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule.java)
+557|[The k Strongest Values in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20k%20Strongest%20Values%20in%20an%20Array.java)
+558|[Longest Arithmetic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Arithmetic%20Subsequence.java)
+559|[Optimal Partition of String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Optimal%20Partition%20of%20String.java)
+560|[Maximum Bags With Full Capacity of Rocks](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Bags%20With%20Full%20Capacity%20of%20Rocks.java)
+561|[Path Sum II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20II.java)
+562|[Unique Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Paths.java)
+563|[Replace Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Words.java)
+564|[Rank Teams by Votes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rank%20Teams%20by%20Votes.java)
+565|[Determine if a Cell Is Reachable at a Given Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20a%20Cell%20Is%20Reachable%20at%20a%20Given%20Time.java)
+566|[Jump Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Jump%20Game.java)
+567|[Can Convert String in K Moves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Can%20Convert%20String%20in%20K%20Moves.java)
+568|[Least Number of Unique Integers after K Removals](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Least%20Number%20of%20Unique%20Integers%20after%20K%20Removals.java)
+569|[Sum of Absolute Differences in a Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Absolute%20Differences%20in%20a%20Sorted%20Array.java)
+570|[Determine the Minimum Sum of a k-avoiding Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20the%20Minimum%20Sum%20of%20a%20k-avoiding%20Array.java)
+571|[Linked List Random Node](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Linked%20List%20Random%20Node.java)
+572|[Valid Tic-Tac-Toe State](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Valid%20Tic-Tac-Toe%20State.java)
+573|[Increasing Triplet Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Increasing%20Triplet%20Subsequence.java)
+574|[Partition Equal Subset Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Partition%20Equal%20Subset%20Sum.java)
+575|[Range Addition](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Addition.java)
+576|[Next Greater Numerically Balanced Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Numerically%20Balanced%20Number.java)
+577|[Interleaving String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Interleaving%20String.java)
+578|[String Compression](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/String%20Compression.java)
+579|[Insert Into a Cyclic Sorted List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Into%20a%20Cyclic%20Sorted%20List.java)
+580|[Count Submatrices With All Ones](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Submatrices%20With%20All%20Ones.java)
+581|[Shuffle an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shuffle%20an%20Array.java)
+582|[Battleships in a board](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Battleships%20in%20a%20board.java)
+583|[Shortest Path in Binary Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Path%20in%20Binary%20Matrix.java)
+584|[Brace Expansion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Brace%20Expansion.java)
+585|[Complex Number Multiplication](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Complex%20Number%20Multiplication.java)
+586|[Queries on a Permutation With Key](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queries%20on%20a%20Permutation%20With%20Key.java)
+587|[Find Duplicate Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20Subtrees.java)
+588|[Maximum Ice Cream Bars](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Ice%20Cream%20Bars.java)
+589|[Recover Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Recover%20Binary%20Search%20Tree.java)
+590|[My Calendar I](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20I.java)
+591|[Reorder Routes to Make All Paths Lead to the City Zero](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorder%20Routes%20to%20Make%20All%20Paths%20Lead%20to%20the%20City%20Zero.java)
+592|[Maximize the Confusion of an Exam](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20the%20Confusion%20of%20an%20Exam.java)
+593|[Evaluate Reverse Polish Notation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Evaluate%20Reverse%20Polish%20Notation.java)
+594|[Maximum Width Ramp](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20Ramp.java)
+595|[Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Sub-arrays%20of%20Size%20K%20and%20Average%20Greater%20than%20or%20Equal%20to%20Threshold.java)
+596|[Range Sum of Sorted Subarray Sums](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Range%20Sum%20of%20Sorted%20Subarray%20Sums.java)
+597|[Find The Original Array of Prefix Xor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20The%20Original%20Array%20of%20Prefix%20Xor.java)
+598|[Bomb Enemy](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bomb%20Enemy.java)
+599|[Find Center of Star Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Center%20of%20Star%20Graph.java)
+600|[Add Bold Tag in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Bold%20Tag%20in%20String.java)
+601|[Reverse Linked List II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Linked%20List%20II.java)
+602|[Permutation in String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Permutation%20in%20String.java)
+603|[Sum of Numbers With Units Digit K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Numbers%20With%20Units%20Digit%20K.java)
+604|[Two Sum II - Input Array Is Sorted](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20II%20-%20Input%20Array%20Is%20Sorted.java)
+605|[Maximum Number of Events That Can Be Attended](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Number%20of%20Events%20That%20Can%20Be%20Attended.java)
+606|[Shortest Word Distance III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Word%20Distance%20III.java)
+607|[Sender With Largest Word Count](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sender%20With%20Largest%20Word%20Count.java)
+608|[Short Encoding of Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Short%20Encoding%20of%20Words.java)
+609|[Serialize and Deserialize BST](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Serialize%20and%20Deserialize%20BST.java)
+610|[Remove All Ones With Row and Column Flips II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Ones%20With%20Row%20and%20Column%20Flips%20II.java)
+611|[Minimum Domino Rotations For Equal Row](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Domino%20Rotations%20For%20Equal%20Row.java)
+612|[132 Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/132%20Pattern.java)
+613|[Remove All Adjacent Duplicates in String II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20All%20Adjacent%20Duplicates%20in%20String%20II.java)
+614|[Insertion Sort List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insertion%20Sort%20List.java)
+615|[Length of the Longest Alphabetical Continuous Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Length%20of%20the%20Longest%20Alphabetical%20Continuous%20Substring.java)
+616|[Find the Duplicate Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Duplicate%20Number.java)
+617|[Replace Elements in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Replace%20Elements%20in%20an%20Array.java)
+618|[Design Twitter](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Twitter.java)
+619|[Last Moment Before All Ants Fall Out of a Plank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Moment%20Before%20All%20Ants%20Fall%20Out%20of%20a%20Plank.java)
+620|[Sentence Similarity II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sentence%20Similarity%20II.java)
+621|[Count Number of Distinct Integers After Reverse Operations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Number%20of%20Distinct%20Integers%20After%20Reverse%20Operations.java)
+622|[Find the Index of the First Occurrence in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Index%20of%20the%20First%20Occurrence%20in%20a%20String.java)
+623|[Last Stone Weight II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Last%20Stone%20Weight%20II.java)
+624|[Rectangle Area](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rectangle%20Area.java)
+625|[My Calendar II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/My%20Calendar%20II.java)
+626|[Find All Possible Recipes from Given Supplies](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20All%20Possible%20Recipes%20from%20Given%20Supplies.java)
+627|[Maximum Value at a Given Index in a Bounded Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Value%20at%20a%20Given%20Index%20in%20a%20Bounded%20Array.java)
+628|[Number of Distinct Substrings in a String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Distinct%20Substrings%20in%20a%20String.java)
+629|[Search Suggestions System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20Suggestions%20System.java)
+630|[Subrectangle Queries](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Subrectangle%20Queries.java)
+631|[Sort the Matrix Diagonally](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Matrix%20Diagonally.java)
+632|[Convert Sorted List to Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20Sorted%20List%20to%20Binary%20Search%20Tree.java)
+633|[Count Nodes Equal to Average of Subtree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Nodes%20Equal%20to%20Average%20of%20Subtree.java)
+634|[Bulb Switcher](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bulb%20Switcher.java)
+635|[Verify Preorder Serialization of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Verify%20Preorder%20Serialization%20of%20a%20Binary%20Tree.java)
+636|[Minimum Speed to Arrive on Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Speed%20to%20Arrive%20on%20Time.java)
+637|[Inorder Successor in BST II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Inorder%20Successor%20in%20BST%20II.java)
+638|[Detonate the Maximum Bombs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Detonate%20the%20Maximum%20Bombs.java)
+639|[Add Minimum Number of Rungs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20Minimum%20Number%20of%20Rungs.java)
+640|[Lexicographically Smallest String After Substring Operation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographically%20Smallest%20String%20After%20Substring%20Operation.java)
+641|[Find the City With the Smallest Number of Neighbors at a Threshold Distance](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20City%20With%20the%20Smallest%20Number%20of%20Neighbors%20at%20a%20Threshold%20Distance.java)
+642|[Node With Highest Edge Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Node%20With%20Highest%20Edge%20Score.java)
+643|[Output Contest Matches](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Output%20Contest%20Matches.java)
+644|[Design an Expression Tree With Evaluate Function](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20an%20Expression%20Tree%20With%20Evaluate%20Function.java)
+645|[H-Index](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index.java)
+646|[Best Time to Buy and Sell Stock with Cooldown](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.java)
+647|[Rabbits in Forest](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rabbits%20in%20Forest.java)
+648|[Count Univalue Subtrees](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Univalue%20Subtrees.java)
+649|[Find Elements in a Contaminated Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Elements%20in%20a%20Contaminated%20Binary%20Tree.java)
+650|[Next Greater Node In Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Greater%20Node%20In%20Linked%20List.java)
+651|[Maximum Nesting Depth of Two Valid Parentheses Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Nesting%20Depth%20of%20Two%20Valid%20Parentheses%20Strings.java)
+652|[Find and Replace Pattern](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20and%20Replace%20Pattern.java)
+653|[Design File System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20File%20System.java)
+654|[Determine if Two Strings Are Close](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Determine%20if%20Two%20Strings%20Are%20Close.java)
+655|[Maximum Absolute Sum of Any Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Absolute%20Sum%20of%20Any%20Subarray.java)
+656|[Number of Pairs of Interchangeable Rectangles](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Pairs%20of%20Interchangeable%20Rectangles.java)
+657|[Kth Largest Element in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Largest%20Element%20in%20an%20Array.java)
+658|[The Number of Full Rounds You Have Played](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/The%20Number%20of%20Full%20Rounds%20You%20Have%20Played.java)
+659|[Snapshot Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snapshot%20Array.java)
+660|[Top K Frequent Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Elements.java)
+661|[Smallest Subtree with all the Deepest Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20Subtree%20with%20all%20the%20Deepest%20Nodes.java)
+662|[Maximal Network Rank](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximal%20Network%20Rank.java)
+663|[Rearrange Array Elements by Sign](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20Elements%20by%20Sign.java)
+664|[Kth Smallest Element in a Sorted Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Kth%20Smallest%20Element%20in%20a%20Sorted%20Matrix.java)
+665|[Two City Scheduling](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20City%20Scheduling.java)
+666|[Minimum Score Triangulation of Polygon](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Score%20Triangulation%20of%20Polygon.java)
+667|[Binary Tree Coloring Game](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Coloring%20Game.java)
+668|[Maximum Difference Between Node and Ancestor](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Difference%20Between%20Node%20and%20Ancestor.java)
+669|[Sum of Beauty of All Substrings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sum%20of%20Beauty%20of%20All%20Substrings.java)
+670|[Push Dominoes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Push%20Dominoes.java)
+671|[Combination Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Combination%20Sum%20III.java)
+672|[Find K Closest Elements](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K%20Closest%20Elements.java)
+673|[01 Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/01%20Matrix.java)
+674|[Clone Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Clone%20Graph.java)
+675|[Longest Palindromic Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Substring.java)
+676|[Robot Bounded In Circle](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Robot%20Bounded%20In%20Circle.java)
+677|[Minimum Deletions to Make Array Beautiful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Deletions%20to%20Make%20Array%20Beautiful.java)
+678|[Koko Eating Bananas](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Koko%20Eating%20Bananas.java)
+679|[Statistics from a Large Sample](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Statistics%20from%20a%20Large%20Sample.java)
+680|[Insert Delete GetRandom O(1)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20Delete%20GetRandom%20O(1).java)
+681|[Longest Substring with At Most K Distinct Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Substring%20with%20At%20Most%20K%20Distinct%20Characters.java)
+682|[Minimum Swaps to Group All 1's Together](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Swaps%20to%20Group%20All%201's%20Together.java)
+683|[Path Sum III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Path%20Sum%20III.java)
+684|[Snakes and Ladders](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Snakes%20and%20Ladders.java)
+685|[Longest Palindromic Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Palindromic%20Subsequence.java)
+686|[Longest String Chain](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20String%20Chain.java)
+687|[Buildings With an Ocean View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Buildings%20With%20an%20Ocean%20View.java)
+688|[Sort Transformed Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Transformed%20Array.java)
+689|[Search in a Sorted Array of Unknown Size](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20in%20a%20Sorted%20Array%20of%20Unknown%20Size.java)
+690|[Minimize Product Sum of Two Arrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimize%20Product%20Sum%20of%20Two%20Arrays.java)
+691|[Count Complete Tree Nodes](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Complete%20Tree%20Nodes.java)
+692|[Minesweeper](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minesweeper.java)
+693|[Best Time to Buy and Sell Stock with Transaction Fee](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Transaction%20Fee.java)
+694|[Online Election](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Online%20Election.java)
+695|[Minimum Cost For Tickets](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Cost%20For%20Tickets.java)
+696|[Find K-Length Substrings With No Repeated Characters](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20K-Length%20Substrings%20With%20No%20Repeated%20Characters.java)
+697|[Pow(x, n)](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Pow(x,%20n).java)
+698|[Construct String With Repeat Limit](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20String%20With%20Repeat%20Limit.java)
+699|[Word Break](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Word%20Break.java)
+700|[Reverse Odd Levels of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Odd%20Levels%20of%20Binary%20Tree.java)
+701|[Design SQL](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20SQL.java)
+702|[Find the Kth Largest Integer in the Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Kth%20Largest%20Integer%20in%20the%20Array.java)
+703|[Flatten Binary Tree to Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Flatten%20Binary%20Tree%20to%20Linked%20List.java)
+704|[Sort Colors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20Colors.java)
+705|[Best Time to Buy and Sell Stock II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.java)
+706|[Longest Absolute File Path](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Longest%20Absolute%20File%20Path.java)
+707|[Count Unreachable Pairs of Nodes in an Undirected Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Unreachable%20Pairs%20of%20Nodes%20in%20an%20Undirected%20Graph.java)
+708|[Prison Cells After N Days](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Prison%20Cells%20After%20N%20Days.java)
+709|[Insert into a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insert%20into%20a%20Binary%20Search%20Tree.java)
+710|[Binary Search Tree Iterator II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator%20II.java)
+711|[Course Schedule II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Course%20Schedule%20II.java)
+712|[Remove Duplicates From Sorted Array II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20Sorted%20Array%20II.java)
+713|[Shortest Bridge](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Bridge.java)
+714|[Binary Search Tree Iterator](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Search%20Tree%20Iterator.java)
+715|[Find Duplicate File in System](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Duplicate%20File%20in%20System.java)
+716|[Insufficient Nodes in Root to Leaf Paths](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Insufficient%20Nodes%20in%20Root%20to%20Leaf%20Paths.java)
+717|[Divide Array in Sets of K Consecutive Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Divide%20Array%20in%20Sets%20of%20K%20Consecutive%20Numbers.java)
+718|[Check Completeness of a Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20Completeness%20of%20a%20Binary%20Tree.java)
+719|[Two Sum BSTs](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Two%20Sum%20BSTs.java)
+720|[Count Sorted Vowel Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Sorted%20Vowel%20Strings.java)
+721|[Check If a String Contains All Binary Codes of Size K](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Check%20If%20a%20String%20Contains%20All%20Binary%20Codes%20of%20Size%20K.java)
+722|[Contains Duplicate III](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Contains%20Duplicate%20III.java)
+723|[Stock Price Fluctuation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Stock%20Price%20Fluctuation.java)
+724|[Spiral Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix.java)
+725|[Next Closest Time](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Next%20Closest%20Time.java)
+726|[Find the Maximum Divisibility Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Maximum%20Divisibility%20Score.java)
+727|[Group Shifted Strings](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Group%20Shifted%20Strings.java)
+728|[Array Circular Loop](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Array%20Circular%20Loop.java)
+729|[ZigZag Conversion](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/ZigZag%20Conversion.java)
+730|[Find the Score of All Prefixes of an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Score%20of%20All%20Prefixes%20of%20an%20Array.java)
+731|[Number of Matching Subsequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Matching%20Subsequence.java)
+732|[All Paths From Source to Target](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20From%20Source%20to%20Target.java)
+733|[Spiral Matrix II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Spiral%20Matrix%20II.java)
+734|[Design Authentication Manager](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Authentication%20Manager.java)
+735|[Minimum Operations to Make a Special Number](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Operations%20to%20Make%20a%20Special%20Number.java)
+736|[People Whose List of Favorite Companies Is Not a Subset of Another List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/People%20Whose%20List%20of%20Favorite%20Companies%20Is%20Not%20a%20Subset%20of%20Another%20List.java)
+737|[Number of Enclaves](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Enclaves.java)
+738|[Sort the Students by Their Kth Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Sort%20the%20Students%20by%20Their%20Kth%20Score.java)
+739|[Number of Zero-Filled Subarrays](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Number%20of%20Zero-Filled%20Subarrays.java)
+740|[Bag of Tokens](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Bag%20of%20Tokens.java)
+741|[Binary Tree Longest Consecutive Sequence](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Longest%20Consecutive%20Sequence.java)
+742|[All Paths from Source Lead to Destination](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Paths%20from%20Source%20Lead%20to%20Destination.java)
+743|[Trim a Binary Search Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Trim%20a%20Binary%20Search%20Tree.java)
+744|[Lexicographical Numbers](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Lexicographical%20Numbers.java)
+745|[Minimum Time to Make Rope Colorful](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Minimum%20Time%20to%20Make%20Rope%20Colorful.java)
+746|[Rotate Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rotate%20Array.java)
+747|[Unique Word Abbrevation](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Unique%20Word%20Abbrevation.java)
+748|[Binary Tree Right Side View](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Binary%20Tree%20Right%20Side%20View.java)
+749|[Solving Questions With Brainpower](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Solving%20Questions%20With%20Brainpower.java)
+750|[All Nodes Distance K in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Nodes%20Distance%20K%20in%20Binary%20Tree.java)
+751|[Queue Reconstruction By Height](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Queue%20Reconstruction%20By%20Height.java)
+752|[Step-By-Step Directions From a Binary Tree Node to Another](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Step-By-Step%20Directions%20From%20a%20Binary%20Tree%20Node%20to%20Another.java)
+753|[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Medium.md)
+754|[Meeting Rooms II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Meeting%20Rooms%20II.java)
+755|[Maximum Binary Tree II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Binary%20Tree%20II.java)
+756|[Maximum Subsequence Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Subsequence%20Score.java)
+757|[Smallest String With A Given Numeric Value](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Smallest%20String%20With%20A%20Given%20Numeric%20Value.java)
+758|[Print Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Print%20Binary%20Tree.java)
+759|[Find Missing Observations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20Missing%20Observations.java)
+760|[Restore IP Address](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Restore%20IP%20Address.java)
+761|[Water & Jug Problem](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Water%20&%20Jug%20Problem.java)
+762|[Maximum Width of Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Width%20of%20Binary%20Tree.java)
+763|[Target Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Target%20Sum.java)
+764|[Find the Longest Semi-Repetitive Substring](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Longest%20Semi-Repetitive%20Substring.java)
+765|[Synonymous Sentences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Synonymous%20Sentences.java)
+766|[Top K Frequent Words](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Top%20K%20Frequent%20Words.java)
+767|[Convert an Array Into a 2D Array With Conditions](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Convert%20an%20Array%20Into%20a%202D%20Array%20With%20Conditions.java)
+768|[Shortest Unsorted Continuous Subarray](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Unsorted%20Continuous%20Subarray.java)
+769|[Satisfiability of Equality Equations](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Satisfiability%20of%20Equality%20Equations.java)
+770|[All Ancestors of a Node in a Directed Acyclic Graph](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/All%20Ancestors%20of%20a%20Node%20in%20a%20Directed%20Acyclic%20Graph.java)
+771|[Maximize Distance to Closest Person](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximize%20Distance%20to%20Closest%20Person.java)
+772|[Design Tic-Tac-Toe](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Design%20Tic-Tac-Toe.java)
+773|[H-Index II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/H-Index%20II.java)
+774|[3Sum](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/3Sum.java)
+775|[Maximum Consecutive Floors Without Special Floors](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20Consecutive%20Floors%20Without%20Special%20Floors.java)
+776|[Reorganize String](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reorganize%20String.java)
+777|[Reverse Substrings Between Each Pair of Parentheses](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Reverse%20Substrings%20Between%20Each%20Pair%20of%20Parentheses.java)
+778|[Maximum XOR of Two Numbers in an Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Maximum%20XOR%20of%20Two%20Numbers%20in%20an%20Array.java)
+779|[Count Good Nodes in Binary Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Good%20Nodes%20in%20Binary%20Tree.java)
+780|[Find the Minimum and Maximum Number of Nodes Between Critical Points](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Find%20the%20Minimum%20and%20Maximum%20Number%20of%20Nodes%20Between%20Critical%20Points.java)
+781|[Missing Element in Sorted Array](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Missing%20Element%20in%20Sorted%20Array.java)
+782|[Even Odd Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Even%20Odd%20Tree.java)
+783|[Rearrange Array to Maximize Prefix Score](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Rearrange%20Array%20to%20Maximize%20Prefix%20Score.java)
+784|[Search for a range](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20for%20a%20range.java)
+785|[Count Collisions on a Road](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Count%20Collisions%20on%20a%20Road.java)
+786|[Numbers With Same Consecutive Differences](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Numbers%20With%20Same%20Consecutive%20Differences.java)
+787|[Remove Duplicates From an Unsorted Linked List](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Remove%20Duplicates%20From%20an%20Unsorted%20Linked%20List.java)
+788|[Populating Next Right Pointers in Each Node II](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Populating%20Next%20Right%20Pointers%20in%20Each%20Node%20II.java)
+789|[Construct Binary Search Tree from Preorder Traversal](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Construct%20Binary%20Search%20Tree%20from%20Preorder%20Traversal.java)
+790|[Shortest Completing Word](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Shortest%20Completing%20Word.java)
+791|[Search a 2D Matrix](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Search%20a%202D%20Matrix.java)
+792|[Add One Row to Tree](https://github.com/varunu28/LeetCode-Java-Solutions/tree/master/Medium/Add%20One%20Row%20to%20Tree.java)
diff --git a/Medium/Range Sum of Sorted Subarray Sums.java b/Medium/Range Sum of Sorted Subarray Sums.java
index c8dad58b..9b7504b7 100644
--- a/Medium/Range Sum of Sorted Subarray Sums.java	
+++ b/Medium/Range Sum of Sorted Subarray Sums.java	
@@ -1,26 +1,23 @@
 class Solution {
-  final int MOD = 100000007;
-  public int rangeSum(int[] nums, int n, int left, int right) {
-    PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>(){
-      public int compare(int[] o1, int[] o2) {
-        return o1[0] - o2[0];
-      }
-    });
-    for (int i = 0; i < n; i++) {
-      pq.add(new int[]{nums[i], i + 1});
+    private static final int MOD = 1000_000_007;
+
+    public int rangeSum(int[] nums, int n, int left, int right) {
+        Queue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(o -> o[0]));
+        for (int i = 0; i < n; i++) {
+            pq.add(new int[]{nums[i], i + 1});
+        }
+        int sum = 0;
+        for (int i = 1; i <= right; i++) {
+            int[] removed = pq.poll();
+            if (i >= left) {
+                sum = (sum + removed[0]) % MOD;
+            }
+            if (removed[1] < n) {
+                removed[0] = removed[0] + nums[removed[1]];
+                removed[1]++;
+                pq.add(removed);
+            }
+        }
+        return sum;
     }
-    int sum = 0;
-    for (int i = 1; i <= right; i++) {
-      int[] removed = pq.poll();
-      if (i >= left) {
-        sum = (sum + removed[0]) % MOD;
-      }
-      if (removed[1] < n) {
-        removed[0] = removed[0] + nums[removed[1]];
-        removed[1]++;
-        pq.add(removed);
-      }
-    }
-    return sum;
-  }
 }
diff --git a/Medium/Rearrange Array Elements by Sign.java b/Medium/Rearrange Array Elements by Sign.java
index d2eb68e7..83857f13 100644
--- a/Medium/Rearrange Array Elements by Sign.java	
+++ b/Medium/Rearrange Array Elements by Sign.java	
@@ -1,21 +1,18 @@
 class Solution {
-  public int[] rearrangeArray(int[] nums) {
-    List<Integer> positive = new ArrayList<>();
-    List<Integer> negative = new ArrayList<>();
-    for (int num : nums) {
-      if (num > 0) {
-        positive.add(num);
-      } else {
-        negative.add(num);
-      }
+    public int[] rearrangeArray(int[] nums) {
+        int n = nums.length;
+        int[] result = new int[n];
+        int posIndex = 0;
+        int negIndex = 1;
+        for (int i = 0; i < n; i++) {
+            if (nums[i] > 0) {
+                result[posIndex] = nums[i];
+                posIndex += 2;
+            } else {
+                result[negIndex] = nums[i];
+                negIndex += 2;
+            }
+        }
+        return result;
     }
-    int positiveIdx = 0;
-    int negativeIdx = 0;
-    boolean positiveFlag = true;
-    for (int i = 0; i < nums.length; i++) {
-      nums[i] = positiveFlag ? positive.get(positiveIdx++) : negative.get(negativeIdx++);
-      positiveFlag = !positiveFlag;
-    }
-    return nums;
-  }
 }
diff --git a/Medium/Rearrange Array to Maximize Prefix Score.java b/Medium/Rearrange Array to Maximize Prefix Score.java
new file mode 100644
index 00000000..6f52eda8
--- /dev/null
+++ b/Medium/Rearrange Array to Maximize Prefix Score.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public int maxScore(int[] nums) {
+        Arrays.sort(nums);
+        long currPrefixSum = 0;
+        int prefixScore = 0;
+        for (int i = nums.length - 1; i >= 0; i--) {
+            currPrefixSum += nums[i];
+            if (currPrefixSum <= 0) {
+                break;
+            }
+            prefixScore++;
+        }
+        return prefixScore;
+    }
+}
diff --git a/Medium/Remove Adjacent Almost-Equal Characters.java b/Medium/Remove Adjacent Almost-Equal Characters.java
new file mode 100644
index 00000000..46bdf2ab
--- /dev/null
+++ b/Medium/Remove Adjacent Almost-Equal Characters.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public int removeAlmostEqualCharacters(String word) {
+        int count = 0;
+        for (int i = 0; i < word.length() - 1; i++) {
+            char curr = word.charAt(i);
+            char next = word.charAt(i + 1);
+            if (Math.abs(curr - next) <= 1) {
+                count++;
+                i++;
+            }
+        }
+        return count;
+    }
+}
diff --git a/Medium/Remove All Occurrences of a Substring.java b/Medium/Remove All Occurrences of a Substring.java
index 08fa1f78..e46ad3f2 100644
--- a/Medium/Remove All Occurrences of a Substring.java	
+++ b/Medium/Remove All Occurrences of a Substring.java	
@@ -1,12 +1,32 @@
 class Solution {
-  public String removeOccurrences(String s, String part) {
-    while (true) {
-      int idx = s.indexOf(part);
-      if (idx == -1) {
-        break;
-      }
-      s = s.substring(0, idx) + s.substring(idx + part.length());
+    public String removeOccurrences(String s, String part) {
+        Stack<Character> stack = new Stack<>();
+        int n = s.length();
+        int partLength = part.length();
+        for (int i = 0; i < n; i++) {
+            stack.push(s.charAt(i));
+            if (stack.size() >= partLength && check(stack, part, partLength)) {
+                for (int j = 0; j < partLength; j++) {
+                    stack.pop();
+                }
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        while (!stack.isEmpty()) {
+            sb.append(stack.pop());
+        }
+        return sb.reverse().toString();
+    }
+
+    private boolean check(Stack<Character> stack, String part, int partLength) {
+        Stack<Character> temp = new Stack<>();
+        temp.addAll(stack);
+        for (int i = partLength - 1; i >= 0; i--) {
+            if (temp.isEmpty() || temp.peek() != part.charAt(i)) {
+                return false;
+            }
+            temp.pop();
+        }
+        return true;
     }
-    return s;
-  }
 }
diff --git a/Medium/Remove Colored Pieces if Both Neighbors are the Same Color.java b/Medium/Remove Colored Pieces if Both Neighbors are the Same Color.java
new file mode 100644
index 00000000..950afa6f
--- /dev/null
+++ b/Medium/Remove Colored Pieces if Both Neighbors are the Same Color.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public boolean winnerOfGame(String colors) {
+        int alice = 0;
+        int bob = 0;
+        for (int i = 1; i < colors.length() - 1; i++) {
+            if (colors.charAt(i - 1) == colors.charAt(i) && colors.charAt(i + 1) == colors.charAt(i)) {
+                if (colors.charAt(i) == 'A') {
+                    alice++;
+                } else {
+                    bob++;
+                }
+            }
+        }
+        return alice - bob > 0;
+    }
+}
diff --git a/Medium/Remove Duplicate Letters.java b/Medium/Remove Duplicate Letters.java
index 25cfd16c..19bd928d 100644
--- a/Medium/Remove Duplicate Letters.java	
+++ b/Medium/Remove Duplicate Letters.java	
@@ -1,27 +1,25 @@
 class Solution {
-  public String removeDuplicateLetters(String s) {
-    int[] counter = new int[26];
-    for (char c : s.toCharArray()) {
-      counter[c - 'a']++;
+    public String removeDuplicateLetters(String s) {
+        Map<Character, Integer> lastIndexMap = new HashMap<>();
+        for (int i = 0; i < s.length(); i++) {
+            lastIndexMap.put(s.charAt(i), i);
+        }
+        Stack<Character> stack = new Stack<>();
+        Set<Character> visited = new HashSet<>();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (!visited.contains(c)) {
+                while (!stack.isEmpty() && c < stack.peek() && lastIndexMap.get(stack.peek()) > i) {
+                    visited.remove(stack.pop());
+                }
+                visited.add(c);
+                stack.push(c);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for (Character c : stack) {
+            sb.append(c);
+        }
+        return sb.toString();
     }
-    Stack<Integer> stack = new Stack<>();
-    boolean[] visited = new boolean[26];
-    for (char c : s.toCharArray()) {
-      int idx = c - 'a';
-      counter[idx]--;
-      if (visited[idx]) {
-        continue;
-      }
-      while (!stack.isEmpty() && stack.peek() > idx && counter[stack.peek()] > 0) {
-        visited[stack.pop()] = false;
-      }
-      stack.add(idx);
-      visited[idx] = true;
-    }
-    StringBuilder sb = new StringBuilder();
-    while (!stack.isEmpty()) {
-      sb.append((char) (stack.pop() + 'a'));
-    }
-    return sb.reverse().toString();
-  }
 }
diff --git a/Medium/Remove Duplicates From an Unsorted Linked List.java b/Medium/Remove Duplicates From an Unsorted Linked List.java
index e62d60c7..18308224 100644
--- a/Medium/Remove Duplicates From an Unsorted Linked List.java	
+++ b/Medium/Remove Duplicates From an Unsorted Linked List.java	
@@ -9,31 +9,29 @@
  * }
  */
 class Solution {
-  public ListNode deleteDuplicatesUnsorted(ListNode head) {
-    Map<Integer, Integer> map = new HashMap<>();
-    ListNode curr = head;
-    while (curr != null) {
-      map.put(curr.val, map.getOrDefault(curr.val, 0) + 1);
-      curr = curr.next;
-    }
-    curr = head;
-    ListNode newHead = null;
-    ListNode prev = null;
-    while (curr != null) {
-      if (map.get(curr.val) > 1) {
-        ListNode nextNode = curr.next;
-        if (prev != null) {
-          prev.next = nextNode;
+    public ListNode deleteDuplicatesUnsorted(ListNode head) {
+        Map<Integer, Integer> map = new HashMap<>();
+        ListNode curr = head;
+        while (curr != null) {
+            map.put(curr.val, map.getOrDefault(curr.val, 0) + 1);
+            curr = curr.next;
         }
-        curr = nextNode;
-      } else {
-        if (newHead == null) {
-          newHead = curr;
+        curr = head;
+        ListNode prev = null;
+        ListNode newHead = null;
+        while (curr != null) {
+            if (map.get(curr.val) > 1) {
+                if (prev != null) {
+                    prev.next = curr.next;
+                }
+            } else {
+                prev = curr;
+                if (newHead == null) {
+                    newHead = curr;
+                }
+            }
+            curr = curr.next;
         }
-        prev = curr;
-        curr = curr.next;
-      }
+        return newHead;
     }
-    return newHead;
-  }
 }
diff --git a/Medium/Remove Interval.java b/Medium/Remove Interval.java
index 0405621d..e64370e0 100644
--- a/Medium/Remove Interval.java	
+++ b/Medium/Remove Interval.java	
@@ -1,18 +1,37 @@
 class Solution {
-  public List<List<Integer>> removeInterval(int[][] intervals, int[] toBeRemoved) {
-    List<List<Integer>> result = new ArrayList<>();
-    for (int[] interval : intervals) {
-      if (interval[0] > toBeRemoved[1] || interval[1] < toBeRemoved[0]) {
-        result.add(Arrays.asList(interval[0], interval[1]));
-      } else {
-        if (interval[0] < toBeRemoved[0]) {
-          result.add(Arrays.asList(interval[0], toBeRemoved[0]));
+    public List<List<Integer>> removeInterval(int[][] intervals, int[] toBeRemoved) {
+        List<List<Integer>> result = new ArrayList<>();
+        int n = intervals.length;
+        int removeStart = toBeRemoved[0];
+        int removeEnd = toBeRemoved[1];
+        for (int i = 0; i < n; i++) {
+            int currStart = intervals[i][0];
+            int currEnd = intervals[i][1];
+            // complete overlap hence skipping complete interval
+            if (currStart >= removeStart && currEnd <= removeEnd) {
+                continue;
+            }
+            // no overlap hence adding complete interval
+            if ((currStart <= removeStart && currEnd <= removeStart) || (currStart >= removeEnd && currEnd >= removeEnd)) {
+                result.add(List.of(currStart, currEnd));
+                continue;
+            } 
+            // partial overlaps
+            if (currStart <= removeStart) {
+                int newStart = Math.min(currStart, removeStart);
+                int newEnd = Math.max(currStart, removeStart);
+                if (newStart != newEnd) {
+                    result.add(List.of(newStart, newEnd));
+                }
+            }
+            if (currEnd >= removeEnd) {
+                int newStart = Math.min(currEnd, removeEnd);
+                int newEnd = Math.max(currEnd, removeEnd);
+                if (newStart != newEnd) {
+                    result.add(List.of(newStart, newEnd));
+                }
+            }
         }
-        if (interval[1] > toBeRemoved[1]) {
-          result.add(Arrays.asList(toBeRemoved[1], interval[1]));
-        }
-      }
+        return result;
     }
-    return result;
-  } 
 }
diff --git a/Medium/Remove Nodes From Linked List.java b/Medium/Remove Nodes From Linked List.java
new file mode 100644
index 00000000..850e4da0
--- /dev/null
+++ b/Medium/Remove Nodes From Linked List.java	
@@ -0,0 +1,40 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode removeNodes(ListNode head) {
+        ListNode revNode = reverse(head);
+        ListNode curr = revNode;
+        ListNode prev = null;
+        int maxValue = Integer.MIN_VALUE;
+        while (curr != null) {
+            if (curr.val < maxValue) {
+                prev.next = curr.next;
+            } else {
+                prev = curr;
+                maxValue = Math.max(curr.val, maxValue);
+            }
+            curr = curr.next;
+        }
+        return reverse(revNode);
+    }
+    
+    private ListNode reverse(ListNode node) {
+        ListNode curr = node;
+        ListNode prev = null;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
+    }
+}
diff --git a/Medium/Remove Sub-Folders from the Filesystem.java b/Medium/Remove Sub-Folders from the Filesystem.java
index 2d91c97e..62f67bcd 100644
--- a/Medium/Remove Sub-Folders from the Filesystem.java	
+++ b/Medium/Remove Sub-Folders from the Filesystem.java	
@@ -1,24 +1,67 @@
 class Solution {
-  public List<String> removeSubfolders(String[] folder) {
-    Set<String> set = new HashSet<>();
-    Arrays.sort(folder, new Comparator<String>(){
-      public int compare(String s1, String s2) {
-        return s1.length() - s2.length();
-      }
-    });
-    for (String fl : folder) {
-      String[] files = fl.split("/");
-      StringBuilder sb = new StringBuilder();
-      for (int i = 1; i < files.length; i++) {
-        sb.append("/").append(files[i]);
-        if (set.contains(sb.toString())) {
-          break;
+    public List<String> removeSubfolders(String[] folder) {
+        TrieNode root = new TrieNode();
+        for (String file : folder) {
+            TrieNode curr = root;
+            String[] splits = file.split("/");
+            for (int i = 1; i < splits.length; i++) {
+                Optional<TrieNode> nextNode = curr.getChild(splits[i]);
+                if (nextNode.isEmpty()) {
+                    TrieNode newNode = curr.addChild(splits[i]);
+                    curr = newNode;
+                } else {
+                    curr = nextNode.get();
+                }
+            }
+            curr.markIsFolder();
+        }
+        List<String> result = new ArrayList<>();
+        for (String file : folder) {
+            TrieNode curr = root;
+            String[] splits = file.split("/");
+            boolean isSubfolder = false;
+            for (int i = 1; i < splits.length; i++) {
+                TrieNode nextNode = curr.getChild(splits[i]).get();
+                if (nextNode.isFolder() && i != splits.length - 1) {
+                    isSubfolder = true;
+                    break;
+                }
+                curr = nextNode;
+            }
+            if (!isSubfolder) {
+                result.add(file);
+            }
+        }
+        return result;
+    }
+
+    class TrieNode {
+        private boolean isFolder;
+        private Map<String, TrieNode> children;
+
+        public TrieNode() {
+            this.children = new HashMap<>();
+        }
+
+        public TrieNode addChild(String childKey) {
+            TrieNode node = new TrieNode();
+            children.put(childKey, node);
+            return node;
+        }
+
+        public Optional<TrieNode> getChild(String childKey) {
+            if (!children.containsKey(childKey)) {
+                return Optional.empty();
+            }
+            return Optional.of(children.get(childKey));
+        }
+
+        public void markIsFolder() {
+            isFolder = true;
+        }
+
+        public boolean isFolder() {
+            return isFolder;
         }
-      }
-      if (sb.length() > 0) {
-        set.add(sb.toString());
-      }
     }
-    return new ArrayList<>(set);
-  }
 }
diff --git a/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java b/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java
index 9807ca95..6f55accd 100644
--- a/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java	
+++ b/Medium/Remove Zero Sum Consecutive Nodes from Linked List.java	
@@ -9,25 +9,24 @@
  * }
  */
 class Solution {
-  public ListNode removeZeroSumSublists(ListNode head) {
-    ListNode dummy = new ListNode(0);
-    ListNode curr = head;
-    dummy.next = head;
-    Map<Integer, ListNode> map = new HashMap<>();
-    int prefixSum = 0;
-    map.put(0, dummy);
-    while (curr != null) {
-      prefixSum += curr.val;
-      map.put(prefixSum, curr);
-      curr = curr.next;
+    public ListNode removeZeroSumSublists(ListNode head) {
+        ListNode dummy = new ListNode(0, head);
+        ListNode curr = dummy;
+        int prefixSum = 0;
+        Map<Integer, ListNode> map = new HashMap<>();
+        map.put(0, curr);
+        while (curr != null) {
+            prefixSum += curr.val;
+            map.put(prefixSum, curr);
+            curr = curr.next;
+        }
+        prefixSum = 0;
+        curr = dummy;
+        while (curr != null) {
+            prefixSum += curr.val;
+            curr.next = map.get(prefixSum).next;
+            curr = curr.next;
+        }
+        return dummy.next;
     }
-    prefixSum = 0;
-    curr = dummy;
-    while (curr != null) {
-      prefixSum += curr.val;
-      curr.next = map.get(prefixSum).next;
-      curr = curr.next;
-    }
-    return dummy.next;
-  }
 }
diff --git a/Medium/Removing Stars From a String.java b/Medium/Removing Stars From a String.java
index 0cb79bea..9278128a 100644
--- a/Medium/Removing Stars From a String.java	
+++ b/Medium/Removing Stars From a String.java	
@@ -1,17 +1,17 @@
 class Solution {
-  public String removeStars(String s) {
-    Stack<Character> stack = new Stack<>();
-    for (char c : s.toCharArray()) {
-      if (c == '*') {
-        stack.pop();
-      } else {
-        stack.push(c);
-      }
+    public String removeStars(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (c == '*') {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        while (!stack.isEmpty()) {
+            sb.append(stack.pop());
+        }
+        return sb.reverse().toString();
     }
-    StringBuilder sb = new StringBuilder();
-    while (!stack.isEmpty()) {
-      sb.append(stack.pop());
-    }
-    return sb.reverse().toString();
-  }
 }
diff --git a/Medium/Reorder List.java b/Medium/Reorder List.java
index 769a555d..99b9ea19 100644
--- a/Medium/Reorder List.java	
+++ b/Medium/Reorder List.java	
@@ -9,35 +9,35 @@
  * }
  */
 class Solution {
-  public void reorderList(ListNode head) {
-    ListNode slow = head;
-    ListNode fast = head;
-    while (fast != null && fast.next != null) {
-      slow = slow.next;
-      fast = fast.next.next;
+    public void reorderList(ListNode head) {
+        ListNode slow = head;
+        ListNode fast = head;
+        while (fast != null && fast.next != null) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        ListNode secondHalf = reverse(slow.next);
+        slow.next = null;
+        ListNode firstHalf = head;
+        while (firstHalf != null && secondHalf != null) {
+            ListNode firstNext = firstHalf.next;
+            ListNode secondNext = secondHalf.next;
+            firstHalf.next = secondHalf;
+            secondHalf.next = firstNext;
+            firstHalf = firstNext;
+            secondHalf = secondNext;
+        }
     }
-    ListNode secondHalf = reverse(slow.next);
-    slow.next = null;
-    ListNode firstHalf = head;
-    while (firstHalf != null && secondHalf != null) {
-      ListNode firstHalfNext = firstHalf.next;
-      ListNode secondHalfNext = secondHalf.next;
-      firstHalf.next = secondHalf;
-      secondHalf.next = firstHalfNext;
-      firstHalf = firstHalfNext;
-      secondHalf = secondHalfNext;
+
+    private ListNode reverse(ListNode node) {
+        ListNode curr = node;
+        ListNode prev = null;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
     }
-  }
-  
-  private ListNode reverse(ListNode node) {
-    ListNode curr = node;
-    ListNode prev = null;
-    while (curr != null) {
-      ListNode next = curr.next;
-      curr.next = prev;
-      prev = curr;
-      curr = next;
-    }
-    return prev;
-  }
 }
diff --git a/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java b/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java
index 121798de..78f7e54f 100644
--- a/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java	
+++ b/Medium/Reorder Routes to Make All Paths Lead to the City Zero.java	
@@ -1,30 +1,31 @@
 class Solution {
-  public int minReorder(int n, int[][] connections) {
-    Map<Integer, Set<Integer>> map = new HashMap<>();
-    Set<String> set = new HashSet<>();
-    for (int[] connection : connections) {
-      map.computeIfAbsent(connection[0], k -> new HashSet<>()).add(connection[1]);
-      map.computeIfAbsent(connection[1], k -> new HashSet<>()).add(connection[0]);
-      set.add(connection[0] + "->" + connection[1]);
-    }
-    Queue<Integer> queue = new LinkedList<>();
-    queue.add(0);
-    int numOfReorders = 0;
-    boolean[] visited = new boolean[n];
-    visited[0] = true;
-    while (!queue.isEmpty()) {
-      int removed = queue.remove();
-      for (int connection : map.getOrDefault(removed, new HashSet<>())) {
-        if (visited[connection]) {
-          continue;
+    public int minReorder(int n, int[][] connections) {
+        Map<Integer, List<List<Integer>>> graph = new HashMap<>();
+        for (int[] conn : connections) {
+            graph.computeIfAbsent(conn[0], k -> new ArrayList<>()).add(List.of(conn[1], 1));
+            graph.computeIfAbsent(conn[1], k -> new ArrayList<>()).add(List.of(conn[0], 0));
         }
-        visited[connection] = true;
-        if (!set.contains(connection + "->" + removed)) {
-          numOfReorders++;
+        int[] count = {0};
+        bfs(0, n, graph, count);
+        return count[0];
+    }
+    
+    private void bfs(int node, int n, Map<Integer, List<List<Integer>>> graph, int[] count) {
+        Queue<Integer> queue = new LinkedList<>();
+        boolean[] visited = new boolean[n];
+        visited[node] = true;
+        queue.add(node);
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            for (List<Integer> conn : graph.getOrDefault(removed, new ArrayList<>())) {
+                int neighbor = conn.get(0);
+                int direction = conn.get(1);
+                if (!visited[neighbor]) {
+                    count[0] += direction;
+                    visited[neighbor] = true;
+                    queue.add(neighbor);
+                }
+            }
         }
-        queue.add(connection);
-      }
     }
-    return numOfReorders;
-  }
 }
diff --git a/Medium/Reorganize String.java b/Medium/Reorganize String.java
index f3c2dfc1..9dd20760 100644
--- a/Medium/Reorganize String.java	
+++ b/Medium/Reorganize String.java	
@@ -1,37 +1,38 @@
 class Solution {
-  public String reorganizeString(String s) {
-    Map<Character, Integer> map = new HashMap<>();
-    for (char c : s.toCharArray()) {
-      map.put(c, map.getOrDefault(c, 0) + 1);
-    }
-    PriorityQueue<Character> pq = new PriorityQueue<>(
-        (o1, o2) -> map.get(o2).compareTo(map.get(o1)));
-    pq.addAll(map.keySet());
-    StringBuilder sb = new StringBuilder();
-    while (!pq.isEmpty()) {
-      char removed = pq.poll();
-      if (!sb.isEmpty() && sb.charAt(sb.length() - 1) == removed) {
-        if (pq.isEmpty()) {
-          return "";
+    public String reorganizeString(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        int maxFrequency = 0;
+        char maxFrequencyLetter = ' ';
+        int n = s.length();
+        for (char c : s.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+            if (maxFrequency < map.get(c)) {
+                maxFrequency = map.get(c);
+                maxFrequencyLetter = c;
+            }
+        }
+        if (maxFrequency > (n + 1) / 2) {
+            return "";
         }
-        char secondRemoved = pq.poll();
-        pq.add(removed);
-        sb.append(secondRemoved);
-        updateStructure(map, pq, secondRemoved);
-      } else {
-        sb.append(removed);
-        updateStructure(map, pq, removed);
-      }
+        char[] letters = new char[s.length()];
+        int idx = 0;
+        idx = insertLetter(n, map, maxFrequencyLetter, letters, idx);
+        map.remove(maxFrequencyLetter);
+        for (Character key : map.keySet()) {
+            idx = insertLetter(n, map, key, letters, idx);
+        }
+        return String.valueOf(letters);
     }
-    return sb.toString();
-  }
 
-  private void updateStructure(Map<Character, Integer> map, PriorityQueue<Character> pq, char c) {
-    map.put(c, map.get(c) - 1);
-    if (map.get(c) > 0) {
-      pq.add(c);
-    } else {
-      map.remove(c);
+    private static int insertLetter(int n, Map<Character, Integer> map, char maxFrequencyLetter, char[] letters, int idx) {
+        while (map.get(maxFrequencyLetter) > 0) {
+            if (idx >= n) {
+                idx = 1;
+            }
+            letters[idx] = maxFrequencyLetter;
+            idx += 2;
+            map.put(maxFrequencyLetter, map.get(maxFrequencyLetter) - 1);
+        }
+        return idx;
     }
-  }
 }
diff --git a/Medium/Restore the Array From Adjacent Pairs.java b/Medium/Restore the Array From Adjacent Pairs.java
index bbe2461c..041f727d 100644
--- a/Medium/Restore the Array From Adjacent Pairs.java	
+++ b/Medium/Restore the Array From Adjacent Pairs.java	
@@ -1,25 +1,31 @@
 class Solution {
-  public int[] restoreArray(int[][] adjacentPairs) {
-    Map<Integer, List<Integer>> map = new HashMap<>();
-    for (int[] pair : adjacentPairs) {
-      map.computeIfAbsent(pair[0], k -> new ArrayList<>()).add(pair[1]);
-      map.computeIfAbsent(pair[1], k -> new ArrayList<>()).add(pair[0]);
+    public int[] restoreArray(int[][] adjacentPairs) {
+        int n = adjacentPairs.length + 1;
+        Map<Integer, List<Integer>> map = new HashMap<>();
+        for (int[] pair : adjacentPairs) {
+            map.computeIfAbsent(pair[0], k -> new ArrayList<>()).add(pair[1]);
+            map.computeIfAbsent(pair[1], k -> new ArrayList<>()).add(pair[0]);
+        }
+        Queue<Integer> queue = new LinkedList<>();
+        int firstElement = map.entrySet()
+                .stream()
+                .filter(entry -> entry.getValue().size() == 1)
+                .map(Map.Entry::getKey)
+                .findFirst()
+                .orElse(-1);
+        queue.add(firstElement);
+        Set<Integer> set = new HashSet<>();
+        int[] result = new int[n];
+        int idx = 0;
+        while (!queue.isEmpty()) {
+            int removed = queue.remove();
+            if (set.contains(removed)) {
+                continue;
+            }
+            result[idx++] = removed;
+            set.add(removed);
+            queue.addAll(map.get(removed));
+        }
+        return result;
     }
-    int head = map.keySet().stream().filter(k -> map.get(k).size() == 1).findFirst().orElse(-1);
-    Set<Integer> visited = new HashSet<>();
-    int[] result = new int[map.size()];
-    int idx = 0;
-    Queue<Integer> queue = new LinkedList<>();
-    queue.add(head);
-    while (!queue.isEmpty()) {
-      int removed = queue.remove();
-      if (visited.contains(removed)) {
-        continue;
-      }
-      result[idx++] = removed;
-      visited.add(removed);
-      queue.addAll(map.get(removed));
-    }
-    return result;
-  }
 }
diff --git a/Medium/Resulting String After Adjacent Removals.java b/Medium/Resulting String After Adjacent Removals.java
new file mode 100644
index 00000000..efa43bf6
--- /dev/null
+++ b/Medium/Resulting String After Adjacent Removals.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public String resultingString(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (!stack.isEmpty() && isAdjacent(stack.peek(), c)) {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        StringBuilder result = new StringBuilder();
+        for (char c : stack) {
+            result.append(c);
+        }
+        return result.toString();
+    }
+
+    private static boolean isAdjacent(char first, char second) {
+        return Math.abs(first - second) == 1 || (first == 'a' && second == 'z') || (first == 'z' && second == 'a');
+    }
+}
diff --git a/Medium/Reverse Linked List II.java b/Medium/Reverse Linked List II.java
index 53edc4e4..3835dbcd 100644
--- a/Medium/Reverse Linked List II.java	
+++ b/Medium/Reverse Linked List II.java	
@@ -9,41 +9,43 @@
  * }
  */
 class Solution {
-  public ListNode reverseBetween(ListNode head, int left, int right) {
-    ListNode prev = null;
-    ListNode start = head;
-    for (int i = 1; i < left; i++) {
-      prev = start;
-      start = start.next;
+    public ListNode reverseBetween(ListNode head, int left, int right) {
+        ListNode curr = head;
+        ListNode prevToLeft = null;
+        for (int i = 1; i < left; i++) {
+            prevToLeft = curr;
+            curr = curr.next;
+        }
+        ListNode nextToLeft = prevToLeft == null ? head : prevToLeft.next;
+        for (int i = left; i < right; i++) {
+            curr = curr.next;
+        }
+        ListNode nextToRight = curr.next;
+        curr.next = null;
+        if (prevToLeft != null) {
+            prevToLeft.next = null;
+        }
+        ListNode reversedStart = reverse(nextToLeft);
+        if (prevToLeft != null) {
+            prevToLeft.next = reversedStart;
+        }
+        curr = reversedStart;
+        while (curr.next != null) {
+            curr = curr.next;
+        }
+        curr.next = nextToRight;
+        return prevToLeft == null ? reversedStart : head;
     }
-    ListNode end = start;
-    for (int i = left; i < right; i++) {
-      end = end.next;
+    
+    private ListNode reverse(ListNode head) {
+        ListNode prev = null;
+        ListNode curr = head;
+        while (curr != null) {
+            ListNode next = curr.next;
+            curr.next = prev;
+            prev = curr;
+            curr = next;
+        }
+        return prev;
     }
-    ListNode nextToEnd = end.next;
-    end.next = null;
-    ListNode reverseStart = reverse(start);
-    if (prev != null) {
-      prev.next = reverseStart;
-    }
-    ListNode curr = reverseStart;
-    while (curr.next != null) {
-      curr = curr.next;
-    }
-    curr.next = nextToEnd;
-    return prev == null ? reverseStart : head;
-  }
-  
-  private ListNode reverse(ListNode node) {
-    ListNode prev = null;
-    ListNode next = null;
-    ListNode curr = node;
-    while (curr != null) {
-      next = curr.next;
-      curr.next = prev;
-      prev = curr;
-      curr = next;
-    }
-    return prev;
-  }
 }
diff --git a/Medium/Right Triangles.java b/Medium/Right Triangles.java
new file mode 100644
index 00000000..d94804b3
--- /dev/null
+++ b/Medium/Right Triangles.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public long numberOfRightTriangles(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        int[] rowCount = new int[rows];
+        int[] colCount = new int[cols];
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (grid[i][j] == 1) {
+                    rowCount[i]++;
+                    colCount[j]++;
+                }
+            }
+        }
+        long triangles = 0;
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                if (grid[i][j] == 1) {
+                    triangles += (rowCount[i] - 1) * (colCount[j] - 1);
+                }
+            }
+        }
+        return triangles;
+    }
+}
diff --git a/Medium/Score After Flipping Matrix.java b/Medium/Score After Flipping Matrix.java
index c369309d..54c3f3ac 100644
--- a/Medium/Score After Flipping Matrix.java	
+++ b/Medium/Score After Flipping Matrix.java	
@@ -1,59 +1,33 @@
 class Solution {
-    public int matrixScore(int[][] A) {
-        for (int i=0; i<A.length; i++) {
-            int actualSum = getDecimalValue(A[i], false);
-            int toggledSum = getDecimalValue(A[i], true);
-            
-            if (toggledSum > actualSum) {
-                for (int j=0; j<A[i].length; j++) {
-                    A[i][j] ^= 1;
+    public int matrixScore(int[][] grid) {
+        int rows = grid.length;
+        int cols = grid[0].length;
+        for (int i = 0; i < rows; i++) {
+            if (grid[i][0] == 0) {
+                for (int j = 0; j < cols; j++) {
+                    grid[i][j] = 1 - grid[i][j];
                 }
             }
         }
-        
-        for (int i=0; i<A[0].length; i++) {
-            int numZeroes = 0;
-            int numOnes = 0;
-            
-            for (int j=0; j<A.length; j++) {
-                if (A[j][i] == 1 ) {
-                    numOnes++;
-                }
-                else {
-                    numZeroes++;
+        for (int j = 1; j < cols; j++) {
+            int countZero = 0;
+            for (int[] row : grid) {
+                if (row[j] == 0) {
+                    countZero++;
                 }
             }
-            
-            if (numZeroes > numOnes) {
-                for (int j=0; j<A.length; j++) {
-                    A[j][i] ^= 1;
+            if(countZero > rows-countZero) {
+                for(int i = 0; i < rows; i++) {
+                    grid[i][j] = 1 - grid[i][j];
                 }
             }
         }
-        
-        int maxSum = 0;
-        for (int[] arr : A) {
-            maxSum += getDecimalValue(arr, false);
-        }
-        
-        return maxSum;
-    }
-    
-    private int getDecimalValue(int[] arr, boolean isToggled) {
-        int sum = 0;
-        int pow = 0;
-        
-        for (int i=arr.length-1; i>=0; i--) {
-            if (isToggled) {
-                sum += Math.pow(2, pow) * (arr[i] ^ 1);
-            }
-            else {
-                sum += Math.pow(2, pow) * arr[i];
+        int score = 0;
+        for (int[] row : grid) {
+            for (int j = 0; j < cols; j++) {
+                score += row[j] << (cols - j - 1);
             }
-            
-            pow++;
         }
-        
-        return sum;
+        return score;
     }
 }
diff --git a/Medium/Search a 2D Matrix.java b/Medium/Search a 2D Matrix.java
index e7de2a1f..086454e0 100644
--- a/Medium/Search a 2D Matrix.java	
+++ b/Medium/Search a 2D Matrix.java	
@@ -1,21 +1,21 @@
 class Solution {
-  public boolean searchMatrix(int[][] matrix, int target) {
-    int rowIdx = matrix.length - 1;
-    int colIdx = matrix[0].length - 1;
-    while (rowIdx >= 0 && colIdx >= 0) {
-      if (matrix[rowIdx][colIdx] == target) {
-        return true;
-      }
-      if (matrix[rowIdx][colIdx] > target) {
-        colIdx--;
-        if (colIdx < 0) {
-          colIdx = matrix[0].length - 1;
-          rowIdx--;
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int row = matrix.length - 1;
+        int col = matrix[0].length - 1;
+        while (row >= 0 && col >= 0) {
+            if (matrix[row][col] == target) {
+                return true;
+            }
+            if (matrix[row][col] > target) {
+                col--;
+                if (col < 0) {
+                    col = matrix[0].length - 1;
+                    row--;
+                }
+            } else {
+                row--;
+            }
         }
-      } else {
-        rowIdx--;
-      }
+        return false;
     }
-    return false;
-  }
 }
diff --git a/Medium/Search in Rotated Sorted Array II.java b/Medium/Search in Rotated Sorted Array II.java
index 65081528..bcb34f99 100644
--- a/Medium/Search in Rotated Sorted Array II.java	
+++ b/Medium/Search in Rotated Sorted Array II.java	
@@ -1,28 +1,28 @@
 class Solution {
-  public boolean search(int[] nums, int target) {
-    int start = 0;
-    int end = nums.length - 1;
-    while (start <= end) {
-      int mid = (start + end) / 2;
-      if (nums[mid] == target) {
-        return true;
-      }
-      if (nums[mid] < nums[end] || nums[mid] < nums[start]) {
-        if (target > nums[mid] && target <= nums[end]) {
-          start = mid + 1;
-        } else {
-          end = mid - 1;
+    public boolean search(int[] nums, int target) {
+        int start = 0;
+        int end = nums.length - 1;
+        while (start <= end) {
+            int mid = (start + end) / 2;
+            if (nums[mid] == target) {
+                return true;
+            }
+            if (nums[mid] < nums[end] || nums[mid] < nums[start]) {
+                if (target > nums[mid] && target <= nums[end]) {
+                    start = mid + 1;
+                } else {
+                    end = mid - 1;
+                }
+            } else if (nums[mid] > nums[start] || nums[mid] > nums[end]) {
+                if (target < nums[mid] && target >= nums[start]) {
+                    end = mid - 1;
+                } else {
+                    start = mid + 1;
+                }
+            } else {
+                end--;
+            }
         }
-      } else if (nums[mid] > nums[start] || nums[mid] > nums[end]) {
-        if (target < nums[mid] && target >= nums[start]) {
-          end = mid - 1;
-        } else {
-          start = mid + 1;
-        }
-      } else {
-        end--;
-      }
+        return false;
     }
-    return false;
-  }
 }
diff --git a/Medium/Seat Reservation Manager.java b/Medium/Seat Reservation Manager.java
index d8825a61..8a7e8edb 100644
--- a/Medium/Seat Reservation Manager.java	
+++ b/Medium/Seat Reservation Manager.java	
@@ -1,23 +1,21 @@
 class SeatManager {
 
-  PriorityQueue<Integer> pq;
-  int count;
+    private PriorityQueue<Integer> seats;
 
-  public SeatManager(int n) {
-    pq = new PriorityQueue<>();
-    count = 1;
-  }
-
-  public int reserve() {
-    if (pq.size() == 0) {
-      return count++;
+    public SeatManager(int n) {
+        this.seats = new PriorityQueue<>();
+        for (int i = 1; i <= n; i++) {
+            this.seats.add(i);
+        }
+    }
+    
+    public int reserve() {
+        return this.seats.poll();
+    }
+    
+    public void unreserve(int seatNumber) {
+        this.seats.add(seatNumber);
     }
-    return pq.remove();
-  }
-
-  public void unreserve(int seatNumber) {
-    pq.add(seatNumber);
-  }
 }
 
 /**
diff --git a/Medium/Sentence Similarity III.java b/Medium/Sentence Similarity III.java
index e85bb024..506dc110 100644
--- a/Medium/Sentence Similarity III.java	
+++ b/Medium/Sentence Similarity III.java	
@@ -1,31 +1,26 @@
 class Solution {
-  public boolean areSentencesSimilar(String sentence1, String sentence2) {
-    return isSimilar(sentence1.split(" "), sentence2.split(" ")) || isSimilar(sentence2.split(" "),
-        sentence1.split(" "));
-  }
-
-  private boolean isSimilar(String[] matcher, String[] target) {
-    int targetStartIdx = 0;
-    int matcherCurrentIdx = 0;
-    while (targetStartIdx < target.length && matcherCurrentIdx < matcher.length) {
-      if (!matcher[matcherCurrentIdx].equals(target[targetStartIdx])) {
-        break;
-      }
-      targetStartIdx++;
-      matcherCurrentIdx++;
+    public boolean areSentencesSimilar(String sentence1, String sentence2) {
+        int idxOneStart = 0;
+        int idxTwoStart = 0;
+        String[] wordsOne = sentence1.split("\\s+"); 
+        String[] wordsTwo = sentence2.split("\\s+"); 
+        while (idxOneStart < wordsOne.length && idxOneStart < wordsTwo.length && wordsOne[idxOneStart].equals(wordsTwo[idxTwoStart])) {
+            idxOneStart++;
+            idxTwoStart++;
+        }
+        boolean startFound = idxOneStart > 0;
+        if (idxOneStart == wordsOne.length && idxTwoStart == wordsTwo.length) {
+            return true;
+        }
+        int idxOneEnd = wordsOne.length - 1;
+        int idxTwoEnd = wordsTwo.length - 1;
+        while (idxOneEnd >= idxOneStart && idxTwoEnd >= idxTwoStart && wordsOne[idxOneEnd].equals(wordsTwo[idxTwoEnd])) {
+            idxOneEnd--;
+            idxTwoEnd--;
+        }
+        if (idxOneEnd != idxOneStart - 1 && idxTwoEnd != idxTwoStart - 1) {
+            return false;
+        }
+        return true;
     }
-    if (targetStartIdx == target.length) {
-      return true;
-    }
-    int targetEndIdx = target.length - 1;
-    matcherCurrentIdx = matcher.length - 1;
-    while (targetEndIdx >= targetStartIdx && matcherCurrentIdx >= 0) {
-      if (!matcher[matcherCurrentIdx].equals(target[targetEndIdx])) {
-        return false;
-      }
-      targetEndIdx--;
-      matcherCurrentIdx--;
-    }
-    return targetEndIdx == targetStartIdx - 1;
-  }
 }
diff --git a/Medium/Separate Black and White Balls.java b/Medium/Separate Black and White Balls.java
new file mode 100644
index 00000000..5fc4900f
--- /dev/null
+++ b/Medium/Separate Black and White Balls.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public long minimumSteps(String s) {
+        int whitePos = 0;
+        long swaps = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (s.charAt(i) == '0') {
+                swaps += i - whitePos;
+                whitePos++;
+            }
+        }
+        return swaps;
+    }
+}
diff --git a/Medium/Serialize and Deserialize BST.java b/Medium/Serialize and Deserialize BST.java
index ff587f9d..a6da4bff 100644
--- a/Medium/Serialize and Deserialize BST.java	
+++ b/Medium/Serialize and Deserialize BST.java	
@@ -10,48 +10,44 @@
 public class Codec {
 
     // Encodes a tree to a single string.
-  public String serialize(TreeNode root) {
-    if (root == null) {
-      return "";
+    public String serialize(TreeNode root) {
+        if (root == null) {
+            return "#";
+        }
+        StringBuilder sb = new StringBuilder();
+        dfsSerialize(root, sb);
+        return sb.toString().trim();
     }
-    StringBuilder sb = new StringBuilder();
-    dfs(root, sb);
-    return sb.toString().trim();
-  }
-  
-  private void dfs(TreeNode root, StringBuilder sb) {
-    if (root == null) {
-      return;
+    
+    private void dfsSerialize(TreeNode root, StringBuilder sb) {
+        if (root == null) {
+            sb.append("#").append(" ");
+            return;
+        }
+        sb.append(root.val).append(" ");
+        dfsSerialize(root.left, sb);
+        dfsSerialize(root.right, sb);
     }
-    sb.append(root.val).append(" ");
-    dfs(root.left, sb);
-    dfs(root.right, sb);
-  }
 
-  // Decodes your encoded data to tree.
-  public TreeNode deserialize(String data) {
-    if (data.length() == 0) {
-      return null;
+    // Decodes your encoded data to tree.
+    public TreeNode deserialize(String data) {
+        Queue<String> queue = new LinkedList<>(Arrays.asList(data.split("\\s+")));
+        return dfsDeserialize(queue);
     }
-    String[] split = data.split("\\s+");
-    return buildBST(split, 0, split.length - 1);
-  }
-  
-  private TreeNode buildBST(String[] data, int start, int end) {
-    if (start > end) {
-      return null;
+    
+    private TreeNode dfsDeserialize(Queue<String> queue) {
+        if (queue.isEmpty()) {
+            return null;
+        }
+        String removed = queue.remove();
+        if (removed.equals("#")) {
+            return null;
+        }
+        TreeNode root = new TreeNode(Integer.parseInt(removed));
+        root.left = dfsDeserialize(queue);
+        root.right = dfsDeserialize(queue);
+        return root;
     }
-    TreeNode root = new TreeNode(Integer.parseInt(data[start]));
-    int index;
-    for (index = start; index <= end; index++) {
-      if (Integer.parseInt(data[index]) > Integer.parseInt(data[start])) {
-        break;
-      }
-    }
-    root.left = buildBST(data, start + 1, index - 1);
-    root.right = buildBST(data, index, end);
-    return root;
-  }
 }
 
 // Your Codec object will be instantiated and called as such:
diff --git a/Medium/Shortest Bridge.java b/Medium/Shortest Bridge.java
new file mode 100644
index 00000000..f5194373
--- /dev/null
+++ b/Medium/Shortest Bridge.java	
@@ -0,0 +1,65 @@
+class Solution {
+    
+    private static final int[][] DIRS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+    
+    public int shortestBridge(int[][] grid) {
+        int n = grid.length;
+        int x = -1;
+        int y = -1;
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (grid[i][j] == 1) {
+                    x = i;
+                    y = j;
+                    break;
+                }
+            }
+        }
+        List<int[]> queueOne = new ArrayList<>();
+        List<int[]> queueTwo = new ArrayList<>();
+        queueOne.add(new int[]{x, y});
+        queueTwo.add(new int[]{x, y});
+        grid[x][y] = 2;
+        while (!queueOne.isEmpty()) {
+            List<int[]> bfs = new ArrayList<>();
+            for (int[] cell : queueOne) {
+                int currX = cell[0];
+                int currY = cell[1];
+                for (int[] dir : DIRS) {
+                    int newX = currX + dir[0];
+                    int newY = currY + dir[1];
+                    if (newX >= 0 && newX < n && newY >= 0 && newY < n && grid[newX][newY] == 1) {
+                        bfs.add(new int[]{newX, newY});
+                        queueTwo.add(new int[]{newX, newY});
+                        grid[newX][newY] = 2;
+                    }
+                }
+            }
+            queueOne = bfs;
+        }
+        int distance = 0;
+        while (!queueTwo.isEmpty()) {
+            List<int[]> bfs = new ArrayList<>();
+            for (int[] cell : queueTwo) {
+                int currX = cell[0];
+                int currY = cell[1];
+                for (int[] dir : DIRS) {
+                    int newX = currX + dir[0];
+                    int newY = currY + dir[1];
+                    if (newX >= 0 && newX < n && newY >= 0 && newY < n) {
+                        if (grid[newX][newY] == 1) {
+                            return distance;
+                        } else if (grid[newX][newY] == 0) {
+                            bfs.add(new int[]{newX, newY});
+                            grid[newX][newY] = -1;
+                        }
+                    }
+                }
+            }
+            queueTwo = bfs;
+            distance++;
+        }
+        return distance;
+    }
+}
+
diff --git a/Medium/Shortest Distance After Road Addition Queries I.java b/Medium/Shortest Distance After Road Addition Queries I.java
new file mode 100644
index 00000000..19a2ea74
--- /dev/null
+++ b/Medium/Shortest Distance After Road Addition Queries I.java	
@@ -0,0 +1,39 @@
+class Solution {
+    public int[] shortestDistanceAfterQueries(int n, int[][] queries) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
+        for (int i = 0; i < n - 1; i++) {
+            graph.computeIfAbsent(i, k -> new HashSet<>()).add(i + 1);
+        }
+        int[] result = new int[queries.length];
+        for (int i = 0; i < queries.length; i++) {
+            int[] query = queries[i];
+            graph.computeIfAbsent(query[0], k -> new HashSet<>()).add(query[1]);
+            result[i] = findDistance(graph, n - 1);
+        }
+        return result;
+    }
+
+    private int findDistance(Map<Integer, Set<Integer>> graph, int target) {
+        Queue<Integer> queue = new LinkedList<>();
+        Set<Integer> visited = new HashSet<>();
+        queue.add(0);
+        int distance = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            for (int i = 0; i < size; i++) {
+                Integer node = queue.poll();
+                if (node == target) {
+                    return distance;
+                }
+                for (Integer neighbor : graph.get(node)) {
+                    if (!visited.contains(neighbor)) {
+                        queue.add(neighbor);
+                        visited.add(node);
+                    }
+                }
+            }
+            distance++;
+        }
+        return -1;
+    }
+}
diff --git a/Medium/Shortest Path in Binary Matrix.java b/Medium/Shortest Path in Binary Matrix.java
index 9977e11b..0be69c86 100644
--- a/Medium/Shortest Path in Binary Matrix.java	
+++ b/Medium/Shortest Path in Binary Matrix.java	
@@ -1,37 +1,40 @@
 class Solution {
-  private final int[][] DIRS = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}, {1, 1}, {-1, 1}, {1, -1}, {-1, -1}};
-  
-  public int shortestPathBinaryMatrix(int[][] grid) {
-    if (grid[0][0] == 1) {
-      return -1;
-    }
-    int numRows = grid.length;
-    int numCols = grid[0].length;
-    boolean[][] visited = new boolean[numRows][numCols];
-    Queue<int[]> queue = new LinkedList<>();
-    queue.add(new int[]{0, 0});
-    visited[0][0] = true;
-    int numOfSteps = 0;
-    while (!queue.isEmpty()) {
-      numOfSteps++;
-      int size = queue.size();
-      while (size-- > 0) {
-        int[] removed = queue.remove();
-        int x = removed[0];
-        int y = removed[1];
-        if (x == numRows - 1 && y == numCols - 1) {
-          return numOfSteps;
+    
+    private static final int[][] DIRS = {{0,1},{0,-1},{1,0},{-1,0},{1,-1},{-1,1},{-1,-1},{1,1}};
+    
+    public int shortestPathBinaryMatrix(int[][] grid) {
+        int numRows = grid.length;
+        int numCols = grid[0].length;
+        if (grid[0][0] == 1 || grid[numRows - 1][numCols - 1] == 1) {
+            return -1;
         }
-        for (int[] dir : DIRS) {
-          int newX = x + dir[0];
-          int newY = y + dir[1];
-          if (newX >= 0 && newY >= 0 && newX < numRows && newY < numCols && !visited[newX][newY] && grid[newX][newY] == 0) {
-            queue.add(new int[]{newX, newY});
-            visited[newX][newY] = true;
-          }
+        int shortestDistance = 0;
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{0, 0});
+        boolean[][] visited = new boolean[numRows][numCols];
+        visited[0][0] = true;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            while (size-- > 0) {
+                int[] removed = queue.remove();
+                if (removed[0] == (numRows - 1) && removed[1] == (numCols - 1)) {
+                    return shortestDistance + 1;
+                }
+                for (int i = 0; i < DIRS.length; i++) {
+                    int newX = removed[0] + DIRS[i][0];
+                    int newY = removed[1] + DIRS[i][1];
+                    if (isValidCoordinate(newX, newY, numRows, numCols, visited, grid)) {
+                        queue.add(new int[]{newX, newY});
+                        visited[newX][newY] = true;
+                    }
+                }
+            }
+            shortestDistance++;
         }
-      }
+        return -1;
+    }
+    
+    private static boolean isValidCoordinate(int x, int y, int rows, int cols, boolean[][] visited, int[][] grid) {
+        return x >= 0 && x < rows && y >= 0 && y < cols && !visited[x][y] && grid[x][y] == 0;
     }
-    return -1;
-  }
 }
diff --git a/Medium/Shortest Path with Alternating Colors.java b/Medium/Shortest Path with Alternating Colors.java
index c2c3622a..63f670d0 100644
--- a/Medium/Shortest Path with Alternating Colors.java	
+++ b/Medium/Shortest Path with Alternating Colors.java	
@@ -1,72 +1,57 @@
 class Solution {
-  private final Integer RED = 1;
-  private final Integer BLUE = 2;
-  public int[] shortestAlternatingPaths(int n, int[][] red_edges, int[][] blue_edges) {
-    Map<Integer, List<Connection>> map = new HashMap<>();
-    for (int[] edge : red_edges) {
-      map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], RED));
-    }
-    for (int[] edge : blue_edges) {
-      map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], BLUE));
-    }
-    int[] distances = new int[n];
-    for (int i = 1; i < n; i++) {
-      distances[i] = getDistance(map, i, n);
-    }
-    return distances;
-  }
-  
-  private int getDistance(Map<Integer, List<Connection>> map, int target, int n) {
-    int curr = 0;
-    int steps = 0;
-    boolean found = false;
-    Queue<int[]> queue = new LinkedList<>();
-    boolean[][] visited = new boolean[2][n];
-    queue.add(new int[]{0, -1});
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size-- > 0) {
-        int[] removed = queue.remove();
-        if (removed[0] == target) {
-          found = true;
-          break;
+    
+    private static final Integer RED = 1;
+    private static final Integer BLUE = 2;
+    
+    public int[] shortestAlternatingPaths(int n, int[][] red_edges, int[][] blue_edges) {
+        Map<Integer, List<Connection>> map = new HashMap<>();
+        for (int[] edge : red_edges) {
+            map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], RED));
         }
-        int color = removed[1];
-        for (Connection connection : map.getOrDefault(removed[0], new ArrayList<>())) {
-          if (color == -1 && !visited[connection.color - 1][connection.val]) {
-            visited[connection.color - 1][connection.val] = true;
-            queue.add(connection.getArray());
-          }
-          else if (color == 1 && connection.color != 1 && !visited[connection.color - 1][connection.val]) {
-            visited[connection.color - 1][connection.val] = true;
-            queue.add(connection.getArray());
-          }
-          else if (color == 2 && connection.color != 2 && !visited[connection.color - 1][connection.val]) {
-            visited[connection.color - 1][connection.val] = true;
-            queue.add(connection.getArray());
-          }
+        for (int[] edge : blue_edges) {
+            map.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(new Connection(edge[1], BLUE));
+        }
+        int[] distances = new int[n];
+        for (int i = 1; i < n; i++) {
+            distances[i] = getDistance(map, i, n);
         }
-      }
-      if (found) {
-        break;
-      }
-      steps++;
+        return distances;
     }
-    return found ? steps : -1;
-  }
-}
-
 
-class Connection {
-  int val;
-  int color;
-  
-  public Connection(int val, int color) {
-    this.val = val;
-    this.color = color;
-  }
-  
-  public int[] getArray() {
-    return new int[]{this.val, this.color};
-  }
+    private int getDistance(Map<Integer, List<Connection>> map, int target, int n) {
+        int steps = 0;
+        Queue<int[]> queue = new LinkedList<>();
+        boolean[][] visited = new boolean[2][n];
+        queue.add(new int[]{0, -1});
+        while (!queue.isEmpty()) {
+          int size = queue.size();
+          while (size-- > 0) {
+            int[] removed = queue.remove();
+            if (removed[0] == target) {
+              return steps;
+            }
+            int color = removed[1];
+            for (Connection connection : map.getOrDefault(removed[0], new ArrayList<>())) {
+              if (color == -1 && !visited[connection.color - 1][connection.val]) {
+                visited[connection.color - 1][connection.val] = true;
+                queue.add(connection.getArray());
+              } else if (color == 1 && connection.color != 1 && !visited[connection.color - 1][connection.val]) {
+                visited[connection.color - 1][connection.val] = true;
+                queue.add(connection.getArray());
+              } else if (color == 2 && connection.color != 2 && !visited[connection.color - 1][connection.val]) {
+                visited[connection.color - 1][connection.val] = true;
+                queue.add(connection.getArray());
+              }
+            }
+          }
+          steps++;
+        }
+        return -1;
+    }
+    
+    private record Connection(int val, int color) {
+        public int[] getArray() {
+            return new int[]{this.val, this.color};
+        }
+    }
 }
diff --git a/Medium/Shortest Subarray to be Removed to Make Array Sorted.java b/Medium/Shortest Subarray to be Removed to Make Array Sorted.java
new file mode 100644
index 00000000..4ddb25e2
--- /dev/null
+++ b/Medium/Shortest Subarray to be Removed to Make Array Sorted.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public int findLengthOfShortestSubarray(int[] arr) {
+        int right = arr.length - 1;
+        while (right > 0 && arr[right] >= arr[right - 1]) {
+            right--;
+        }
+        int result = right;
+        int left = 0;
+        while (left < right && (left == 0 || arr[left - 1] <= arr[left])) {
+            while (right < arr.length && arr[left] > arr[right]) {
+                right++;
+            }
+            result = Math.min(result, right - left - 1);
+            left++;
+        }
+        return result;
+    }
+}
diff --git a/Medium/Shortest Way to Form String.java b/Medium/Shortest Way to Form String.java
index c5f28f1f..e87eaf33 100644
--- a/Medium/Shortest Way to Form String.java	
+++ b/Medium/Shortest Way to Form String.java	
@@ -1,28 +1,23 @@
 class Solution {
-  public int shortestWay(String source, String target) {
-    int count = 1;
-    int idx = 0;
-    int n = target.length();
-    int sourceIdx = 0;
-    boolean match = false;
-    while (idx < n) {
-      if (source.charAt(sourceIdx) == target.charAt(idx)) {
-        idx++;
-        sourceIdx++;
-        match = true;
-      }
-      else {
-        sourceIdx++;
-      }
-      if (sourceIdx == source.length() && idx != n) {
-        if (!match) {
-          return -1;
+    public int shortestWay(String source, String target) {
+        Set<Character> letters = source.chars().mapToObj(c -> (char) c).collect(Collectors.toSet());
+        int count = 0;
+        int sourceIdx = 0;
+        int targetIdx = 0;
+        while (targetIdx < target.length()) {
+            char targetLetter = target.charAt(targetIdx);
+            if (!letters.contains(targetLetter)) {
+                return -1;
+            }
+            if (targetLetter == source.charAt(sourceIdx)) {
+                targetIdx++;
+            }
+            sourceIdx++;
+            if (sourceIdx == source.length()) {
+                sourceIdx = 0;
+                count++;
+            }
         }
-        count++;
-        sourceIdx = 0;
-        match = false;
-      }
+        return count + (sourceIdx == 0 ? 0 : 1);
     }
-    return count;
-  }
 }
diff --git a/Medium/Shortest Word Distance III.java b/Medium/Shortest Word Distance III.java
index ba7216c1..fba93082 100644
--- a/Medium/Shortest Word Distance III.java	
+++ b/Medium/Shortest Word Distance III.java	
@@ -1,15 +1,24 @@
 class Solution {
-  public int shortestWordDistance(String[] wordsDict, String word1, String word2) {
-    int minIdxDiff = wordsDict.length;
-    int prevIdx = -1;
-    for (int i = 0; i < wordsDict.length; i++) {
-      if (wordsDict[i].equals(word1) || wordsDict[i].equals(word2)) {
-        if (prevIdx != -1 && (word1.equals(word2) || !wordsDict[prevIdx].equals(wordsDict[i]))) {
-          minIdxDiff = Math.min(minIdxDiff, Math.abs(prevIdx - i));
+    public int shortestWordDistance(String[] wordsDict, String word1, String word2) {
+        int idxOne = -1;
+        int idxTwo = -1;
+        int minDistance = Integer.MAX_VALUE;
+        boolean sameWord = word1.equals(word2);
+        for (int i = 0; i < wordsDict.length; i++) {
+            if (wordsDict[i].equals(word1)) {
+                idxOne = sameWord ? (idxOne == -1 ? i : idxOne) : i; 
+            }
+            if (wordsDict[i].equals(word2)) {
+                idxTwo = sameWord ? (idxOne != i ? i : idxTwo) : i; 
+            }
+            if (idxOne != -1 && idxTwo != -1) {
+                minDistance = Math.min(minDistance, Math.abs(idxOne - idxTwo));
+                if (sameWord) {
+                    idxOne = idxTwo;
+                    idxTwo = -1;
+                }
+            }
         }
-        prevIdx = i;
-      }
+        return minDistance;
     }
-    return minIdxDiff;
-  }
 }
diff --git a/Medium/Simplify Path.java b/Medium/Simplify Path.java
index 51c19971..b04ccd5e 100644
--- a/Medium/Simplify Path.java	
+++ b/Medium/Simplify Path.java	
@@ -1,22 +1,23 @@
 class Solution {
-  public String simplifyPath(String path) {
-    Stack<String> stack = new Stack<>();
-    String[] splits = path.split("/");
-    for (String split : splits) {
-      if (split.equals("") || split.equals(".")) {
-        continue;
-      } else if (split.equals("..")) {
-        if (!stack.isEmpty()) {
-          stack.pop();
+    public String simplifyPath(String path) {
+        Stack<String> stack = new Stack<>();
+        String[] splits = path.split("\\/");
+        for (String split : splits) {
+            if (split.equals(".") || split.equals("/") || split.isBlank()) {
+                continue;
+            }
+            if (split.equals("..")) {
+                if (!stack.isEmpty()) {
+                    stack.pop();
+                }
+            } else {
+                stack.push(split);
+            }
         }
-      } else {
-        stack.push(split);
-      }
-    }
-    StringBuilder resultingPath = new StringBuilder();
-    while (!stack.isEmpty()) {
-      resultingPath.insert(0, stack.pop()).insert(0, "/");
+        StringBuilder sb = new StringBuilder();
+        while (!stack.isEmpty()) {
+            sb.insert(0, stack.pop()).insert(0, "/");
+        }
+        return sb.length() == 0 ? "/" : sb.toString();
     }
-    return resultingPath.length() == 0 ? "/" : resultingPath.toString();
-  }
 }
diff --git a/Medium/Single Element in a Sorted Array.java b/Medium/Single Element in a Sorted Array.java
index 3565e0b3..924794d3 100644
--- a/Medium/Single Element in a Sorted Array.java	
+++ b/Medium/Single Element in a Sorted Array.java	
@@ -1,25 +1,25 @@
 class Solution {
-  public int singleNonDuplicate(int[] nums) {
-    if (nums.length == 1) {
-      return nums[0];
+    public int singleNonDuplicate(int[] nums) {
+        int start = 0;
+        int end = nums.length - 1;
+        while (start < end) {
+            int mid = (end - start) / 2 + start;
+            if (nums[mid + 1] == nums[mid]) {
+                if ((end - mid) % 2 == 0) {
+                    start = mid + 2;
+                } else {
+                    end = mid - 1;
+                }               
+            } else if (nums[mid - 1] == nums[mid]) {
+                if ((end - mid) % 2 == 0) {
+                    end = mid - 2;
+                } else {
+                    start = mid + 1;
+                }
+            } else {
+                return nums[mid];
+            }
+        }
+        return nums[start];
     }
-    return binarySearchHelper(nums, 0, nums.length - 1);
-  }
-  
-  private int binarySearchHelper(int[] nums, int start, int end) {
-    if (start > end) {
-      return Integer.MIN_VALUE;
-    }
-    int mid = (start + end) / 2;
-    if (mid == 0 && mid + 1 < nums.length && nums[mid] != nums[mid + 1]) {
-      return nums[mid];
-    }
-    if (mid == nums.length - 1 && mid - 1 >= 0 && nums[mid] != nums[mid - 1]) {
-      return nums[mid];
-    }
-    if (mid + 1 < nums.length && nums[mid] != nums[mid + 1] && mid - 1 >= 0 && nums[mid] != nums[mid - 1]) {
-      return nums[mid];
-    }
-    return Math.max(binarySearchHelper(nums, start, mid - 1), binarySearchHelper(nums, mid + 1, end));
-  }
 }
diff --git a/Medium/Smallest Common Region.java b/Medium/Smallest Common Region.java
new file mode 100644
index 00000000..4d8ce894
--- /dev/null
+++ b/Medium/Smallest Common Region.java	
@@ -0,0 +1,32 @@
+class Solution {
+    public String findSmallestRegion(List<List<String>> regions, String region1, String region2) {
+        Map<String, String> regionToParentMap = new HashMap<>();
+        for (List<String> region : regions) {
+            String parent = region.getFirst();
+            for (int i = 1; i < region.size(); i++) {
+                regionToParentMap.put(region.get(i), parent);
+            }
+        }
+        List<String> pathOne = trace(region1, regionToParentMap);
+        List<String> pathTwo = trace(region2, regionToParentMap);
+        int idxOne = 0;
+        int idxTwo = 0;
+        while (idxOne < pathOne.size() && idxTwo < pathTwo.size() && pathOne.get(idxOne).equals(pathTwo.get(idxTwo))) {
+            idxOne++;
+            idxTwo++;
+        }
+        return pathOne.get(idxOne - 1);
+    }
+
+    private List<String> trace(String region, Map<String, String> regionToParentMap) {
+        List<String> path = new ArrayList<>();
+        path.add(region);
+        while (regionToParentMap.containsKey(region)) {
+            String parent = regionToParentMap.get(region);
+            path.add(parent);
+            region = parent;
+        }
+        Collections.reverse(path);
+        return path;
+    }
+}
diff --git a/Medium/Smallest Number in Infinite Set.java b/Medium/Smallest Number in Infinite Set.java
new file mode 100644
index 00000000..2555f5ce
--- /dev/null
+++ b/Medium/Smallest Number in Infinite Set.java	
@@ -0,0 +1,34 @@
+class SmallestInfiniteSet {
+    
+    private final PriorityQueue<Integer> pq;
+    private int current;
+    
+    public SmallestInfiniteSet() {
+        this.pq = new PriorityQueue<>();
+        this.current = 1;
+    }
+    
+    public int popSmallest() {
+        int result = current;
+        if (!pq.isEmpty() && pq.peek() < current) {
+            result = pq.poll();  
+        } else {
+            current++;
+        }
+        while (!pq.isEmpty() && pq.peek() == result) {
+            pq.poll();
+        }
+        return result;
+    }
+    
+    public void addBack(int num) {
+        pq.add(num);
+    }
+}
+
+/**
+ * Your SmallestInfiniteSet object will be instantiated and called as such:
+ * SmallestInfiniteSet obj = new SmallestInfiniteSet();
+ * int param_1 = obj.popSmallest();
+ * obj.addBack(num);
+ */
diff --git a/Medium/Snapshot Array.java b/Medium/Snapshot Array.java
index d735dde3..282b6476 100644
--- a/Medium/Snapshot Array.java	
+++ b/Medium/Snapshot Array.java	
@@ -1,26 +1,28 @@
 class SnapshotArray {
-  TreeMap<Integer, Integer>[] A;
-  int snapId;
-  public SnapshotArray(int length) {
-    A = new TreeMap[length];
-    snapId = 0;
-    for (int i = 0; i < length; i++) {
-      A[i] = new TreeMap<Integer, Integer>();
-      A[i].put(0, 0);
+    
+    private final TreeMap<Integer, Integer>[] db;
+    private int currentSnapId;
+
+    public SnapshotArray(int length) {
+        db = new TreeMap[length];
+        for (int i = 0; i < length; i++) {
+            db[i] = new TreeMap<Integer, Integer>();
+            db[i].put(0, 0);
+        }
+        this.currentSnapId = 0;
     }
-  }
 
-  public void set(int index, int val) {
-    A[index].put(snapId, val);
-  }
+    public void set(int index, int val) {
+        db[index].put(currentSnapId, val);
+    }
 
-  public int snap() {
-    return snapId++;
-  }
+    public int snap() {
+        return currentSnapId++;
+    }
 
-  public int get(int index, int snap_id) {
-    return A[index].floorEntry(snap_id).getValue();
-  }
+    public int get(int index, int snap_id) {
+        return db[index].floorEntry(snap_id).getValue();
+    }
 }
 
 /**
diff --git a/Medium/Solving Questions With Brainpower.java b/Medium/Solving Questions With Brainpower.java
new file mode 100644
index 00000000..76e640d1
--- /dev/null
+++ b/Medium/Solving Questions With Brainpower.java	
@@ -0,0 +1,19 @@
+class Solution {
+    public long mostPoints(int[][] questions) {
+        Long[] dp = new Long[questions.length];
+        return helper(questions, 0, dp);
+    }
+    
+    private long helper(int[][] questions, int idx, Long[] dp) {
+        if (idx >= questions.length) {
+            return 0;
+        }
+        if (dp[idx] != null) {
+            return dp[idx];
+        }
+        return dp[idx] = Math.max(
+            questions[idx][0] + helper(questions, idx + questions[idx][1] + 1, dp),
+            helper(questions, idx + 1, dp)
+        );
+    }
+}
diff --git a/Medium/Sort An Array.java b/Medium/Sort An Array.java
index 7c3f105e..a906afc4 100644
--- a/Medium/Sort An Array.java	
+++ b/Medium/Sort An Array.java	
@@ -1,40 +1,39 @@
 class Solution {
-  public int[] sortArray(int[] nums) {
-    int n = nums.length - 1;
-    mergeSort(nums, 0, n);
-    return nums;
-  }
-  
-  private void mergeSort(int[] nums, int start, int end) {
-    if (end - start + 1 <= 1) {
-      return;
+    public int[] sortArray(int[] nums) {
+        mergeSort(nums, 0, nums.length - 1);
+        return nums;
     }
-    int mid = start + (end - start) / 2;
-    mergeSort(nums, start, mid);
-    mergeSort(nums, mid + 1, end);
-    merge(nums, start, mid, end);
-  }
   
-  private void merge(int[] nums, int start, int mid, int end) {
-    int left = start;
-    int right = mid + 1;
-    int[] temp = new int[end - start + 1];
-    int idx = 0;
-    while (left <= mid && right <= end) {
-      if (nums[left] < nums[right]) {
-        temp[idx++] = nums[left++];
-      } else {
-        temp[idx++] = nums[right++];
-      }
-    }
-    while (left <= mid) {
-      temp[idx++] = nums[left++];
+    private void mergeSort(int[] nums, int start, int end) {
+        if (end - start <= 0) {
+            return;
+        }
+        int mid = start + (end - start) / 2;
+        mergeSort(nums, start, mid);
+        mergeSort(nums, mid + 1, end);
+        merge(nums, start, mid, end);
     }
-    while (right <= end) {
-      temp[idx++] = nums[right++];
-    }
-    for (int i = start; i <= end; i++) {
-      nums[i] = temp[i - start];
+  
+    private void merge(int[] nums, int start, int mid, int end) {
+        int left = start;
+        int right = mid + 1;
+        int[] temp = new int[end - start + 1];
+        int idx = 0;
+        while (left <= mid && right <= end) {
+            if (nums[left] < nums[right]) {
+                temp[idx++] = nums[left++];
+            } else {
+                temp[idx++] = nums[right++];
+            }
+        }
+        while (left <= mid) {
+            temp[idx++] = nums[left++];
+        }
+        while (right <= end) {
+            temp[idx++] = nums[right++];
+        }
+        for (int i = start; i <= end; i++) {
+            nums[i] = temp[i - start];
+        }
     }
-  }
 }
diff --git a/Medium/Sort Characters By Frequency.java b/Medium/Sort Characters By Frequency.java
index d85dc32a..7c0978bc 100644
--- a/Medium/Sort Characters By Frequency.java	
+++ b/Medium/Sort Characters By Frequency.java	
@@ -1,41 +1,32 @@
 class Solution {
-  public String frequencySort(String s) {
-    int[] freqMap = new int[62];
-    int maxFrequency = 0;
-    for (char c : s.toCharArray()) {
-      int charIdx = getCharIndex(c);
-      freqMap[charIdx]++;
-      maxFrequency = Math.max(maxFrequency, freqMap[charIdx]);
-    }
-    List<Character>[] revMap = new List[maxFrequency + 1];
-    for (int i = 0; i < 62; i++) {
-      char c = getDecodedChar(i);
-      int currFreq = freqMap[i];
-      if (currFreq != 0) {
-        if (revMap[currFreq] == null) {
-          revMap[currFreq] = new ArrayList<>();
+    
+    private static final String ALL_LETTERS = 
+        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    
+    public String frequencySort(String s) {
+        Map<Character, Integer> map = new HashMap<>();
+        int maxFrequency = 0;
+        for (char c : s.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+            maxFrequency = Math.max(maxFrequency, map.get(c));
         }
-        revMap[currFreq].add(c);
-      }
-    }
-    StringBuilder sb = new StringBuilder();
-    for (int i = maxFrequency; i > 0; i--) {
-      if (revMap[i] != null) {
-        List<Character> characterList = revMap[i];
-        for (char c : characterList) {
-          sb.append(String.valueOf(c).repeat(i));
+        List<Character>[] frequencyToChar = new List[maxFrequency + 1];
+        for (char c : map.keySet()) {
+            if (frequencyToChar[map.get(c)] == null) {
+                frequencyToChar[map.get(c)] = new ArrayList<>();
+            }
+            frequencyToChar[map.get(c)].add(c);
+        }
+        StringBuilder sb = new StringBuilder();
+        for (int i = maxFrequency; i > 0; i--) {
+            List<Character> characters = frequencyToChar[i] == null ? 
+                new ArrayList<>() : frequencyToChar[i];
+            for (char c : characters) {
+                for (int j = 0; j < i; j++) {
+                    sb.append(c);
+                }
+            }
         }
-      }
+        return sb.toString();
     }
-    return sb.toString();
-  }
-
-  private char getDecodedChar(int idx) {
-    return (char) (idx < 26 ? 97 + idx : (idx >= 52 ? 48 + idx - 52 : 65 + idx - 26));
-  }
-
-  private int getCharIndex(char c) {
-    return Character.isDigit(c) ? 52 + c - '0'
-        : (Character.isUpperCase(c) ? c - 'A' + 26 : c - 'a');
-  }
 }
diff --git a/Medium/Sort Linked List Already Sorted Using Absolute Values.java b/Medium/Sort Linked List Already Sorted Using Absolute Values.java
new file mode 100644
index 00000000..fd43f251
--- /dev/null
+++ b/Medium/Sort Linked List Already Sorted Using Absolute Values.java	
@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode sortLinkedList(ListNode head) {
+        ListNode curr = head;
+        while (curr != null && curr.next != null){
+           if (curr.next.val < 0) {
+               // Make a new head with negative value and assign its next pointer to current head
+               head = new ListNode(curr.next.val,head);
+               curr.next = curr.next.next;
+           } else {
+                curr = curr.next;
+           }  
+        } 
+        return head; 
+    }
+}
diff --git a/Medium/Sort the Students by Their Kth Score.java b/Medium/Sort the Students by Their Kth Score.java
new file mode 100644
index 00000000..7c4f83e9
--- /dev/null
+++ b/Medium/Sort the Students by Their Kth Score.java	
@@ -0,0 +1,6 @@
+class Solution {
+    public int[][] sortTheStudents(int[][] score, int k) {
+        Arrays.sort(score, (o1, o2) -> o2[k] - o1[k]);
+        return score;
+    }
+}
diff --git a/Medium/Spiral Matrix II.java b/Medium/Spiral Matrix II.java
index ffa09b62..636fbb69 100644
--- a/Medium/Spiral Matrix II.java	
+++ b/Medium/Spiral Matrix II.java	
@@ -1,29 +1,33 @@
 class Solution {
-  public int[][] generateMatrix(int n) {
-    int[][] ans = new int[n][n];
-    int left = 0;
-    int top = 0;
-    int right = n -1;
-    int down = n - 1;
-    int count = 1;
-    while (left <= right) {
-      for (int j = left; j <= right; j ++) {
-        ans[top][j] = count++;
-      }
-      top++;
-      for (int i = top; i <= down; i ++) {
-        ans[i][right] = count ++;
-      }
-      right--;
-      for (int j = right; j >= left; j --) {
-        ans[down][j] = count ++;
-      }
-      down--;
-      for (int i = down; i >= top; i --) {
-        ans[i][left] = count ++;
-      }
-      left++;
+    public int[][] generateMatrix(int n) {
+        int[][] result = new int[n][n];
+        int rowStart = 0;
+        int rowEnd = n - 1;
+        int colStart = 0;
+        int colEnd = n - 1;
+        int value = 1;
+        while (rowStart <= rowEnd && colStart <= colEnd) {
+            for (int i = colStart; i <= colEnd; i++) {
+                result[rowStart][i] = value++;
+            }
+            rowStart++;
+            for (int i = rowStart; i <= rowEnd; i++) {
+                result[i][colEnd] = value++;
+            }
+            colEnd--;
+            if (rowStart <= rowEnd) {
+                for (int i = colEnd; i >= colStart; i--) {
+                    result[rowEnd][i] = value++;
+                }
+                rowEnd--;
+            }
+            if (colStart <= colEnd) {
+                for (int i = rowEnd; i >= rowStart; i--) {
+                    result[i][colStart] = value++;
+                }
+                colStart++;
+            }
+        }
+        return result;
     }
-    return ans;
-  }
 }
diff --git a/Medium/Spiral Matrix IV.java b/Medium/Spiral Matrix IV.java
new file mode 100644
index 00000000..5136b493
--- /dev/null
+++ b/Medium/Spiral Matrix IV.java	
@@ -0,0 +1,45 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public int[][] spiralMatrix(int m, int n, ListNode head) {
+        int[][] result = new int[m][n];
+        for (int i = 0; i < m; i++) {
+            Arrays.fill(result[i], -1);
+        }
+        int topRow = 0;
+        int bottomRow = m - 1;
+        int leftColumn = 0;
+        int rightColumn = n - 1;
+        while (head != null) {
+            for (int col = leftColumn; col <= rightColumn && head != null; col++) {
+                result[topRow][col] = head.val;
+                head = head.next;
+            }
+            topRow++;
+            for (int row = topRow; row <= bottomRow && head != null; row++) {
+                result[row][rightColumn] = head.val;
+                head = head.next;
+            }
+            rightColumn--;
+            for (int col = rightColumn; col >= leftColumn && head != null; col--) {
+                result[bottomRow][col] = head.val;
+                head = head.next;
+            }
+            bottomRow--;
+            for (int row = bottomRow; row >= topRow && head != null; row--) {
+                result[row][leftColumn] = head.val;
+                head = head.next;
+            }
+            leftColumn++;
+        }
+        return result;
+    }
+}
diff --git a/Medium/Spiral Matrix.java b/Medium/Spiral Matrix.java
index 6004fe4d..252374fb 100644
--- a/Medium/Spiral Matrix.java	
+++ b/Medium/Spiral Matrix.java	
@@ -1,32 +1,32 @@
 class Solution {
-  public List<Integer> spiralOrder(int[][] matrix) {
-    List<Integer> list = new ArrayList<>();
-    int rowStart = 0;
-    int rowEnd = matrix.length - 1;
-    int colStart = 0;
-    int colEnd = matrix[0].length - 1;
-    while (rowStart <= rowEnd && colStart <= colEnd) {
-      for (int i = colStart; i <= colEnd; i++) {
-        list.add(matrix[rowStart][i]);
-      }
-      rowStart++;
-      for (int i = rowStart; i <= rowEnd; i++) {
-        list.add(matrix[i][colEnd]);
-      }
-      colEnd--;
-      if (rowStart <= rowEnd) {
-        for (int i = colEnd; i >= colStart; i--) {
-          list.add(matrix[rowEnd][i]);
+    public List<Integer> spiralOrder(int[][] matrix) {
+        List<Integer> result = new ArrayList<>();
+        int rowStart = 0;
+        int rowEnd = matrix.length - 1;
+        int colStart = 0;
+        int colEnd = matrix[0].length - 1;
+        while (rowStart <= rowEnd && colStart <= colEnd) {
+            for (int i = colStart; i <= colEnd; i++) {
+                result.add(matrix[rowStart][i]);
+            }
+            rowStart++;
+            for (int i = rowStart; i <= rowEnd; i++) {
+                result.add(matrix[i][colEnd]);
+            }
+            colEnd--;
+            if (rowStart <= rowEnd) {
+                for (int i = colEnd; i >= colStart; i--) {
+                    result.add(matrix[rowEnd][i]);
+                }
+                rowEnd--;
+            }
+            if (colStart <= colEnd) {
+                for (int i = rowEnd; i >= rowStart; i--) {
+                    result.add(matrix[i][colStart]);
+                }
+                colStart++;
+            }
         }
-        rowEnd--;
-      }
-      if (colStart <= colEnd) {
-        for (int i = rowEnd; i >= rowStart; i--) {
-          list.add(matrix[i][colStart]);
-        }
-        colStart++;
-      }
+        return result;
     }
-    return list;
-  }
 }
diff --git a/Medium/Split Linked List in Parts.java b/Medium/Split Linked List in Parts.java
index 30121c82..2fdd787c 100644
--- a/Medium/Split Linked List in Parts.java	
+++ b/Medium/Split Linked List in Parts.java	
@@ -7,25 +7,27 @@
  *     ListNode(int val) { this.val = val; }
  *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  * }
-*/
+ */
 class Solution {
-  public ListNode[] splitListToParts(ListNode head, int k) {
-    ListNode[] arr = new ListNode[k];
-    int nodeLength = 0;
-    for (ListNode curr = head; curr != null; curr = curr.next) {
-      nodeLength++;
+    public ListNode[] splitListToParts(ListNode head, int k) {
+        int length = 0;
+        ListNode curr = head;
+        while (curr != null) {
+            length++;
+            curr = curr.next;
+        }
+        ListNode[] splits = new ListNode[k];
+        int elementsPerPart = length / k;
+        int partsWithExtra = length % k;
+        ListNode prev = null;
+        for (int i = 0; i < k && head != null; i++, partsWithExtra--) {
+            splits[i] = head;
+            for (int j = 0; j < elementsPerPart + (partsWithExtra > 0 ? 1 : 0); j++) {
+                prev = head;
+                head = head.next;
+            }
+            prev.next = null;
+        }
+        return splits;
     }
-    int n = nodeLength / k;
-    int remaining = nodeLength % k;
-    ListNode prev = null;
-    for (int i = 0; i < k && head != null; i++, remaining--) {
-      arr[i] = head;
-      for (int j = 0; j < n + (remaining > 0 ? 1 : 0); j++) {
-        prev = head;
-        head = head.next;
-      }
-      prev.next = null;
-    }
-    return arr;
-  }
 }
diff --git a/Medium/Split a String Into the Max Number of Unique Substrings.java b/Medium/Split a String Into the Max Number of Unique Substrings.java
new file mode 100644
index 00000000..3e418df7
--- /dev/null
+++ b/Medium/Split a String Into the Max Number of Unique Substrings.java	
@@ -0,0 +1,21 @@
+class Solution {
+    public int maxUniqueSplit(String s) {
+        Set<String> seen = new HashSet<>();
+        return backtrack(s, 0, seen);
+    }
+
+    private int backtrack(String s, int idx, Set<String> seen) {
+        if (idx == s.length()) {
+            return 0;
+        }
+        int count = 0;
+        for (int end = idx + 1; end <= s.length(); end++) {
+            String substring = s.substring(idx, end);
+            if (seen.add(substring)) {
+                count = Math.max(count, 1 + backtrack(s, end, seen));
+                seen.remove(substring);
+            }
+        }
+        return count;
+    }
+}
diff --git a/Medium/Stone Game II.java b/Medium/Stone Game II.java
new file mode 100644
index 00000000..c56cbd43
--- /dev/null
+++ b/Medium/Stone Game II.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int stoneGameII(int[] piles) {
+        Integer[][][] dp = new Integer[2][piles.length + 1][piles.length + 1];
+        return helper(piles, dp, 0, 0, 1);
+    }
+    
+    private int helper(int[] piles, Integer[][][] dp, int p, int i, int m) {
+        if (i == piles.length) {
+            return 0;
+        }
+        if (dp[p][i][m] != null) {
+            return dp[p][i][m];
+        }
+        int result = p == 1 ? 1000_000 : -1;
+        int s = 0;
+        for (int j = 1; j <= Math.min(2 * m, piles.length - i); j++) {
+            s += piles[i + j - 1];
+            if (p == 0) {
+                result = Math.max(result, s + helper(piles, dp, 1, i + j, Math.max(m, j)));
+            } else {
+                result = Math.min(result, helper(piles, dp, 0, i + j, Math.max(m, j)));
+            }
+        }
+        return dp[p][i][m] = result;
+    }
+}
diff --git a/Medium/String Compression III.java b/Medium/String Compression III.java
new file mode 100644
index 00000000..03a6737c
--- /dev/null
+++ b/Medium/String Compression III.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public String compressedString(String word) {
+        StringBuilder sb = new StringBuilder();
+        int idx = 0;
+        while (idx < word.length()) {
+            char c = word.charAt(idx);
+            int count = 0;
+            while (idx < word.length() && word.charAt(idx) == c && count < 9) {
+                idx++;
+                count++;
+            }
+            sb.append(count).append(c);
+        }
+        return sb.toString();
+    }
+}
diff --git a/Medium/String Compression.java b/Medium/String Compression.java
index 182df66f..060e655e 100644
--- a/Medium/String Compression.java	
+++ b/Medium/String Compression.java	
@@ -1,22 +1,21 @@
 class Solution {
-  public int compress(char[] chars) {
-    int idx = 0;
-    int startIdx = 0;
-    while (idx < chars.length) {
-      char c = chars[idx];
-      int count = 0;
-      while (idx < chars.length && chars[idx] == c) {
-        idx++;
-        count++;
-      }
-      chars[startIdx++] = c;
-      if (count > 1) {
-        String countString = String.valueOf(count);
-        for (char cs : countString.toCharArray()) {
-          chars[startIdx++] = cs;
+    public int compress(char[] chars) {
+        int startIdx = 0;
+        for (int i = 0; i < chars.length;) {
+            char c = chars[i];
+            int count = 0;
+            while (i < chars.length && chars[i] == c) {
+                count++;
+                i++;
+            }
+            chars[startIdx++] = c;
+            if (count > 1) {
+                String temp = String.valueOf(count);
+                for (char digit : temp.toCharArray()) {
+                    chars[startIdx++] = digit;
+                }
+            }
         }
-      }
+        return startIdx;
     }
-    return startIdx;
-  }
 }
diff --git a/Medium/Subarray Product Less Than K.java b/Medium/Subarray Product Less Than K.java
index 68ba3e13..3f53dc87 100644
--- a/Medium/Subarray Product Less Than K.java	
+++ b/Medium/Subarray Product Less Than K.java	
@@ -1,18 +1,20 @@
 class Solution {
-  public int numSubarrayProductLessThanK(int[] nums, int k) {
-    if (k <= 1) {
-      return 0;
+    public int numSubarrayProductLessThanK(int[] nums, int k) {
+        if (k <= 1) {
+            return 0;
+        }
+        int prod = 1;
+        int start = 0;
+        int end = 0;
+        int n = nums.length;
+        int result = 0;
+        while (end < n) {
+            prod *= nums[end++];
+            while (start < end && prod >= k) {
+                prod /= nums[start++];
+            }
+            result += end - start;
+        }
+        return result;
     }
-    int prod = 1;
-    int ans = 0;
-    int left = 0;
-    for (int right = 0; right < nums.length; right++) {
-      prod *= nums[right];
-      while (prod >= k) {
-        prod /= nums[left++];
-      }
-      ans += right - left + 1;
-    }
-    return ans;
-  }
 }
diff --git a/Medium/Substrings That Begin and End With the Same Letter.java b/Medium/Substrings That Begin and End With the Same Letter.java
new file mode 100644
index 00000000..62c93389
--- /dev/null
+++ b/Medium/Substrings That Begin and End With the Same Letter.java	
@@ -0,0 +1,12 @@
+class Solution {
+    public long numberOfSubstrings(String s) {
+        int n = s.length();
+        long result = 0;
+        long[] prefixCount = new long[26];
+        for (int i = 0; i < n; i++) {
+            prefixCount[s.charAt(i) - 'a']++;
+            result += prefixCount[s.charAt(i) - 'a'];
+        }
+        return result;
+    }
+}
diff --git a/Medium/Successful Pairs of Spells and Potions.java b/Medium/Successful Pairs of Spells and Potions.java
index 40c459c7..8a8e6886 100644
--- a/Medium/Successful Pairs of Spells and Potions.java	
+++ b/Medium/Successful Pairs of Spells and Potions.java	
@@ -1,26 +1,26 @@
 class Solution {
-  public int[] successfulPairs(int[] spells, int[] potions, long success) {
-    int[] result = new int[spells.length];
-    Arrays.sort(potions);
-    for (int i = 0; i < spells.length; i++) {
-      int idx = getSuccessIdx(potions, spells[i], success);
-      result[i] = potions.length - idx;
+    public int[] successfulPairs(int[] spells, int[] potions, long success) {
+        Arrays.sort(potions);
+        int[] result = new int[spells.length];
+        for (int i = 0; i < spells.length; i++) {
+            result[i] = findCountOfSuccessfulPotion(potions, success, (long) spells[i]);
+        }
+        return result;
     }
-    return result;
-  }
-  
-  private int getSuccessIdx(int[] potions, int spell, long success) {
-    int left = 0;
-    int right = potions.length;
-    while (left < right) {
-      int mid = (left + right) / 2;
-      long currSuccess = ((long) potions[mid]) * spell;
-      if (currSuccess >= success) {
-        right = mid;
-      } else {
-        left = mid + 1;
-      }
+    
+    private int findCountOfSuccessfulPotion(int[] potions, long success, long spell) {
+        int left = 0;
+        int right = potions.length - 1;
+        int minIdx = Integer.MAX_VALUE;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (potions[mid] * spell >= success) {
+                minIdx = Math.min(minIdx, mid);
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return minIdx == Integer.MAX_VALUE ? 0 : (potions.length - minIdx);
     }
-    return left;
-  }
 }
diff --git a/Medium/Sum Multiples.java b/Medium/Sum Multiples.java
new file mode 100644
index 00000000..59bfa012
--- /dev/null
+++ b/Medium/Sum Multiples.java	
@@ -0,0 +1,7 @@
+class Solution {
+    public int sumOfMultiples(int n) {
+        return IntStream.rangeClosed(1, n)
+                .filter(value -> value % 3 == 0 || value % 5 == 0 || value % 7 == 0)
+                .sum();
+    }
+}
diff --git a/Medium/Sum Root to Leaf Numbers.java b/Medium/Sum Root to Leaf Numbers.java
index 63179830..0cad0868 100644
--- a/Medium/Sum Root to Leaf Numbers.java	
+++ b/Medium/Sum Root to Leaf Numbers.java	
@@ -14,22 +14,29 @@
  * }
  */
 class Solution {
-  public int sumNumbers(TreeNode root) {
-    int[] sum = {0};
-    helper(root, 0, sum);
-    return sum[0];
-  }
-  
-  private void helper(TreeNode root, int currValue, int[] sum) {
-    if (root == null) {
-      return;
+    public int sumNumbers(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        Queue<NodeSumPair> queue = new LinkedList<>();
+        queue.add(new NodeSumPair(root, 0));
+        int totalSum = 0;
+        while (!queue.isEmpty()) {
+            NodeSumPair removed = queue.remove();
+            TreeNode node = removed.node;
+            int currSum = removed.sum * 10 + node.val;
+            if (node.left == null && node.right == null) {
+                totalSum += currSum;
+            }
+            if (node.left != null) {
+                queue.add(new NodeSumPair(node.left, currSum));
+            }
+            if (node.right != null) {
+                queue.add(new NodeSumPair(node.right, currSum));
+            }
+        }
+        return totalSum;
     }
-    currValue = currValue * 10 + root.val;
-    if (root.left == null && root.right == null) {
-      sum[0] += currValue;
-      return;
-    }
-    helper(root.left, currValue, sum);
-    helper(root.right, currValue, sum);
-  }
+    
+    private static record NodeSumPair(TreeNode node, int sum) {}
 }
diff --git a/Medium/Sum in a Matrix.java b/Medium/Sum in a Matrix.java
new file mode 100644
index 00000000..0261f81b
--- /dev/null
+++ b/Medium/Sum in a Matrix.java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int matrixSum(int[][] nums) {
+        for (int[] num : nums) {
+            Arrays.sort(num);
+        }
+        int score = 0;
+        for (int i = 0; i < nums[0].length; i++) {
+            int maxNum = 0;
+            for (int[] num : nums) {
+                maxNum = Math.max(maxNum, num[i]);
+            }
+            score += maxNum;
+        }
+        return score;
+    }
+}
diff --git a/Medium/Sum of Square Numbers.java b/Medium/Sum of Square Numbers.java
new file mode 100644
index 00000000..13f138c2
--- /dev/null
+++ b/Medium/Sum of Square Numbers.java	
@@ -0,0 +1,18 @@
+class Solution {
+    public boolean judgeSquareSum(int c) {
+        long left = 0;
+        long right = (long) Math.sqrt(c);
+        while (left <= right) {
+            long sum = left * left + right * right;
+            if (sum == c) {
+                return true;
+            }
+            if (sum > c) {
+                right--;
+            } else {
+                left++;
+            }
+        }
+        return false;
+    }
+}
diff --git a/Medium/Swap Nodes in Pairs.java b/Medium/Swap Nodes in Pairs.java
index 980e4356..505f7af0 100644
--- a/Medium/Swap Nodes in Pairs.java	
+++ b/Medium/Swap Nodes in Pairs.java	
@@ -9,22 +9,23 @@
  * }
  */
 class Solution {
-  public ListNode swapPairs(ListNode head) {
-    ListNode curr = head;
-    ListNode prev = null;
-    while (curr != null && curr.next != null) {
-      ListNode nextNode = curr.next;
-      if (curr == head) {
-        head = nextNode;
-      }
-      curr.next = nextNode.next;
-      nextNode.next = curr;
-      if (prev != null) {
-        prev.next = nextNode;
-      }
-      prev = curr;
-      curr = curr.next;
+    public ListNode swapPairs(ListNode head) {
+        ListNode curr = head;
+        ListNode prev = null;
+        while (curr != null && curr.next != null) {
+            ListNode nextNode = curr.next;
+            ListNode nextToNext = curr.next.next;
+            if (prev == null) {
+                head = nextNode;
+            } 
+            if (prev != null) {
+                prev.next = nextNode;
+            }
+            nextNode.next = curr;
+            curr.next = nextToNext;
+            prev = curr;
+            curr = nextToNext;
+        } 
+        return head;
     }
-    return head;
-  }
 }
diff --git a/Medium/Take K of Each Character From Left and Right.java b/Medium/Take K of Each Character From Left and Right.java
new file mode 100644
index 00000000..4b878ce0
--- /dev/null
+++ b/Medium/Take K of Each Character From Left and Right.java	
@@ -0,0 +1,27 @@
+class Solution {
+    public int takeCharacters(String s, int k) {
+        int[] counter = new int[3];
+        int n = s.length();
+        for (char c : s.toCharArray()) {
+            counter[c - 'a']++;
+        }
+        for (int i = 0; i < 3; i++) {
+            if (counter[i] < k) {
+                return -1;
+            }
+        }
+        int[] window = new int[3];
+        int left = 0;
+        int maxWindow = 0;
+        for (int right = 0; right < n; right++) {
+            window[s.charAt(right) - 'a']++;
+            while (left <= right && 
+                (counter[0] - window[0] < k || counter[1] - window[1] < k || counter[2] - window[2] < k)) {
+                window[s.charAt(left) - 'a']--;
+                left++;
+            }
+            maxWindow = Math.max(maxWindow, right - left + 1);
+        }
+        return n - maxWindow;
+    }
+}
diff --git a/Medium/Task Scheduler.java b/Medium/Task Scheduler.java
index 558e1f77..0023aa9d 100644
--- a/Medium/Task Scheduler.java	
+++ b/Medium/Task Scheduler.java	
@@ -1,16 +1,30 @@
 class Solution {
-  public int leastInterval(char[] tasks, int n) {
-    int[] frequencies = new int[26];
-    for (char task : tasks) {
-      frequencies[task - 'A']++;
+    public int leastInterval(char[] tasks, int n) {
+        Map<Character, Integer> map = new HashMap<>();
+        for (char c : tasks) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
+        pq.addAll(map.values());
+        int cycles = 0;
+        while (!pq.isEmpty()) {
+            List<Integer> temp = new ArrayList<>();
+            // Wait for one cooldown period and process one occurrence of all remaining tasks
+            for (int i = 0; i < n + 1; i++) {
+                if (!pq.isEmpty()) {
+                    temp.add(pq.remove());
+                }
+            }
+            // If task has more occurrences left then add it back to heap
+            for (int task : temp) {
+                if (task > 1) {
+                    pq.add(task - 1);
+                }
+            }
+            // If heap is empty that means we finished all tasks and don't need to wait for 
+            // the whole cooldown to finish else add one complete cooldown period
+            cycles += pq.isEmpty() ? temp.size() : n + 1;
+        }
+        return cycles;
     }
-    Arrays.sort(frequencies);
-    int maxFrequency = frequencies[25];
-    int idleTime = (maxFrequency - 1) * n;
-    for (int i = frequencies.length - 2; i >= 0 && idleTime > 0; i--) {
-      idleTime -= Math.min(maxFrequency - 1, frequencies[i]);
-    }
-    idleTime = Math.max(0, idleTime);
-    return idleTime + tasks.length;
-  }
 }
diff --git a/Medium/Ternary Expression Parser.java b/Medium/Ternary Expression Parser.java
index c0079881..6798336d 100644
--- a/Medium/Ternary Expression Parser.java	
+++ b/Medium/Ternary Expression Parser.java	
@@ -1,23 +1,19 @@
 class Solution {
-  public String parseTernary(String expression) {
-    if (expression == null || expression.length() == 0) {
-      return "";
+    public String parseTernary(String expression) {
+        Stack<Character> stack = new Stack<>();
+        int idx = expression.length() - 1;
+        while (idx >= 0) {
+            char c = expression.charAt(idx);
+            if (c >= '0' && c <= '9' || c == 'T' || c == 'F') {
+                stack.push(c);
+            } else if (c == '?') {
+                char trueValue = stack.pop();
+                char falseValue = stack.pop();
+                stack.push(expression.charAt(idx - 1) == 'T' ? trueValue : falseValue);
+                idx--;
+            }
+            idx--;
+        }
+        return String.valueOf(stack.pop());
     }
-    Deque<Character> stack = new LinkedList<>();
-    int n = expression.length();
-    for (int i = n - 1; i >= 0; i--) {
-      char c = expression.charAt(i);
-      if (!stack.isEmpty() && stack.peek() == '?') {
-        stack.pop();  // Pop ?
-        char first = stack.pop();
-        stack.pop();  // Pop :
-        char second = stack.pop();
-        stack.push(c == 'T' ? first : second);
-      }
-      else {
-        stack.push(c);
-      }
-    }
-    return String.valueOf(stack.peek());
-  }
 }
diff --git a/Medium/The Earliest Moment When Everyone Become Friends.java b/Medium/The Earliest Moment When Everyone Become Friends.java
index 578a04cb..8de3e818 100644
--- a/Medium/The Earliest Moment When Everyone Become Friends.java	
+++ b/Medium/The Earliest Moment When Everyone Become Friends.java	
@@ -1,54 +1,42 @@
 class Solution {
-  public int earliestAcq(int[][] logs, int n) {
-    Arrays.sort(logs, Comparator.comparingInt(o -> o[0]));
-    DisjointSet disjointSet = new DisjointSet(n);
-    for (int[] log : logs) {
-      disjointSet.union(log[1], log[2]);
-      if (disjointSet.unionCount == 1) {
-        return log[0];
-      }
+    public int earliestAcq(int[][] logs, int n) {
+        Arrays.sort(logs, Comparator.comparingInt(a -> a[0]));
+        UnionFind uf = new UnionFind(n);
+        for (int[] log : logs) {
+            uf.union(log[1], log[2]);
+            if (uf.count == 1) {
+                return log[0];
+            }
+        }
+        return -1;
     }
-    return -1;
-  }
-
-  private static final class DisjointSet {
 
-    private final int[] root;
-    private final int[] rank;
-    public int unionCount;
-
-    public DisjointSet(int size) {
-      this.root = new int[size];
-      this.rank = new int[size];
-      for (int i = 0; i < size; i++) {
-        this.root[i] = i;
-        this.rank[i] = 1;
-      }
-      this.unionCount = size;
-    }
+    static class UnionFind {
+        private final int[] parent;
+        private int count;
 
-    public void union(int nodeOne, int nodeTwo) {
-      int rootOne = find(nodeOne);
-      int rootTwo = find(nodeTwo);
-      if (rootOne != rootTwo) {
-        if (this.rank[rootOne] > this.rank[rootTwo]) {
-          this.root[rootTwo] = rootOne;
-        } else if (this.rank[rootOne] < this.rank[rootTwo]) {
-          this.root[rootOne] = rootTwo;
-        } else {
-          this.root[rootTwo] = rootOne;
-          this.rank[rootOne]++;
+        public UnionFind(int n) {
+            parent = new int[n];
+            count = n;
+            for (int i = 0; i < n; i++) {
+                parent[i] = i;
+            }
         }
-        this.unionCount--;
-      }
-    }
 
+        public int find(int node) {
+            if (parent[node] != node) {
+                parent[node] = find(parent[node]);
+            }
+            return parent[node];
+        }
 
-    public int find(int node) {
-      if (node == root[node]) {
-        return node;
-      }
-      return root[node] = find(root[node]);
+        public void union(int x, int y) {
+            int rootX = find(x);
+            int rootY = find(y);
+            if (rootX != rootY) {
+                parent[rootX] = rootY;
+                count--;
+            }
+        }
     }
-  }
 }
diff --git a/Medium/The Number of Beautiful Subsets.java b/Medium/The Number of Beautiful Subsets.java
new file mode 100644
index 00000000..7057a18d
--- /dev/null
+++ b/Medium/The Number of Beautiful Subsets.java	
@@ -0,0 +1,20 @@
+class Solution {
+    public int beautifulSubsets(int[] nums, int k) {
+        Map<Integer, Integer> freqMap = new HashMap<>();
+        Arrays.sort(nums);
+        return countBeautifulSubsets(nums, k, freqMap, 0) - 1;
+    }
+
+    private int countBeautifulSubsets(int[] nums, int k, Map<Integer, Integer> freqMap, int idx) {
+        if (idx == nums.length) {
+            return 1;
+        }
+        int count = countBeautifulSubsets(nums, k, freqMap, idx + 1);
+        if (freqMap.getOrDefault(nums[idx] - k, 0) == 0) {
+            freqMap.put(nums[idx], freqMap.getOrDefault(nums[idx], 0) + 1);
+            count += countBeautifulSubsets(nums, k, freqMap, idx + 1);
+            freqMap.put(nums[idx], freqMap.getOrDefault(nums[idx], 0) - 1);
+        }
+        return count;
+    }
+}
diff --git a/Medium/The Number of the Smallest Unoccupied Chair.java b/Medium/The Number of the Smallest Unoccupied Chair.java
new file mode 100644
index 00000000..6bd41ad2
--- /dev/null
+++ b/Medium/The Number of the Smallest Unoccupied Chair.java	
@@ -0,0 +1,35 @@
+class Solution {
+    public int smallestChair(int[][] times, int targetFriend) {
+        PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> {
+            int c = o1[0] - o2[0];
+            if (c == 0) {
+                return o1[1] - o2[1];
+            }
+            return c;
+        });
+        for (int i = 0; i < times.length; i++) {
+            pq.add(new int[]{times[i][0], times[i][1], i});
+        }
+        PriorityQueue<int[]> occupiedChairs = new PriorityQueue<>(Comparator.comparingInt(o -> o[0]));
+        PriorityQueue<Integer> emptyChairs = new PriorityQueue<>();
+        int currChair = 0;
+        while (!pq.isEmpty()) {
+            int[] time = pq.poll();
+            while (!occupiedChairs.isEmpty() && occupiedChairs.peek()[0] <= time[0]) {
+                int[] chair = occupiedChairs.poll();
+                emptyChairs.add(chair[1]);
+            }
+            if (time[2] == targetFriend) {
+                return emptyChairs.isEmpty() ? currChair : emptyChairs.poll();
+            }
+            if (emptyChairs.isEmpty()) {
+                occupiedChairs.add(new int[]{time[1], currChair});
+                currChair++;
+            } else {
+                int chair = emptyChairs.poll();
+                occupiedChairs.add(new int[]{time[1], chair});
+            }
+        }
+        return -1;
+    }
+}
diff --git a/Medium/The k-th Lexicographical String of All Happy Strings of Length n.java b/Medium/The k-th Lexicographical String of All Happy Strings of Length n.java
new file mode 100644
index 00000000..413b67d5
--- /dev/null
+++ b/Medium/The k-th Lexicographical String of All Happy Strings of Length n.java	
@@ -0,0 +1,28 @@
+class Solution {
+    private static final char[] CHARS = {'a', 'b', 'c'};
+
+    public String getHappyString(int n, int k) {
+        Set<String> set = new HashSet<>();
+        backtrack(set, new StringBuilder(), n);
+        if (set.size() < k) {
+            return "";
+        }
+        List<String> list = new ArrayList<>(set);
+        Collections.sort(list);
+        return list.get(k - 1);
+    }
+
+    private void backtrack(Set<String> set, StringBuilder sb, int n) {
+        if (sb.length() == n) {
+            set.add(sb.toString());
+            return;
+        }
+        for (char c : CHARS) {
+            if (sb.isEmpty() || sb.charAt(sb.length() - 1) != c) {
+                sb.append(c);
+                backtrack(set, sb, n);
+                sb.deleteCharAt(sb.length() - 1);
+            }
+        }
+    }
+}
diff --git a/Medium/Time Needed to Inform All Employees.java b/Medium/Time Needed to Inform All Employees.java
index 901f53b5..f8cc21ac 100644
--- a/Medium/Time Needed to Inform All Employees.java	
+++ b/Medium/Time Needed to Inform All Employees.java	
@@ -1,23 +1,24 @@
 class Solution {
-  public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) {
-    Map<Integer, List<Integer>> organization = new HashMap<>();
-    for (int i = 0; i < manager.length; i++) {
-      if (manager[i] != -1) {
-        organization.computeIfAbsent(manager[i], k -> new ArrayList<>()).add(i);
-      }
+    public int numOfMinutes(int n, int headID, int[] manager, int[] informTime) {
+        Map<Integer, List<Integer>> organization = new HashMap<>();
+        for (int i = 0; i < manager.length; i++) {
+            if (manager[i] == -1) {
+                continue;
+            }
+            organization.computeIfAbsent(manager[i], k -> new ArrayList<>()).add(i);
+        }
+        int maxTime = 0;
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{headID, 0});
+        while (!queue.isEmpty()) {
+            int[] removed = queue.remove();
+            int currManager = removed[0];
+            int timeElapsed = removed[1];
+            maxTime = Math.max(maxTime, timeElapsed);
+            for (Integer employee : organization.getOrDefault(currManager, new ArrayList<>())) {
+                queue.add(new int[]{employee, timeElapsed + informTime[currManager]});
+            }
+        }
+        return maxTime;
     }
-    int totalTime = 0;
-    Queue<int[]> queue = new LinkedList<>();
-    queue.add(new int[]{headID, 0});
-    while (!queue.isEmpty()) {
-      int[] removed = queue.remove();
-      int id = removed[0]; 
-      int time = removed[1]; 
-      totalTime = Math.max(totalTime, time);
-      for (int associate : organization.getOrDefault(id, new ArrayList<>())) {
-        queue.add(new int[]{associate, time + informTime[id]});
-      }
-    }
-    return totalTime;
-  }
 }
diff --git a/Medium/Total Characters in String After Transformations I.java b/Medium/Total Characters in String After Transformations I.java
new file mode 100644
index 00000000..3751ab7e
--- /dev/null
+++ b/Medium/Total Characters in String After Transformations I.java	
@@ -0,0 +1,25 @@
+class Solution {
+
+    private static final int MOD = 1000_0000_07;
+
+    public int lengthAfterTransformations(String s, int t) {
+        int[] frequency = new int[26];
+        for (char c : s.toCharArray()) {
+            frequency[c - 'a']++;
+        }
+        for (int round = 0; round < t; round++) {
+            int[] next = new int[26];
+            next[0] = frequency[25]; // Transformation from 'z'
+            next[1] = (frequency[25] + frequency[0]) % MOD; // Transformation from either 'z' or 'a'
+            for (int i = 2; i < 26; i++) {
+                next[i] = frequency[i - 1]; // Transformation for next character
+            }
+            frequency = next;
+        }
+        int result = 0;
+        for (int i = 0; i < 26; i++) {
+            result = (result + frequency[i]) % MOD;
+        }
+        return result;
+    }
+}
diff --git a/Medium/Total Cost to Hire K Workers.java b/Medium/Total Cost to Hire K Workers.java
new file mode 100644
index 00000000..c5708a4b
--- /dev/null
+++ b/Medium/Total Cost to Hire K Workers.java	
@@ -0,0 +1,29 @@
+class Solution {
+    public long totalCost(int[] costs, int k, int candidates) {
+        PriorityQueue<Integer> headWorkers = new PriorityQueue<>();
+        PriorityQueue<Integer> tailWorkers = new PriorityQueue<>();
+        for (int i = 0; i < candidates; i++) {
+            headWorkers.add(costs[i]);
+        }
+        for (int i = Math.max(candidates, costs.length - candidates); i < costs.length; i++) {
+            tailWorkers.add(costs[i]);
+        }
+        int headIdx = candidates;
+        int tailIdx = costs.length - candidates - 1;
+        long result = 0;
+        for (int i = 0; i < k; i++) {
+            if (tailWorkers.isEmpty() || (!headWorkers.isEmpty() && headWorkers.peek() <= tailWorkers.peek())) {
+                result += headWorkers.poll();
+                if (headIdx <= tailIdx) {
+                    headWorkers.add(costs[headIdx++]);
+                }
+            } else {
+                result += tailWorkers.poll();
+                if (headIdx <= tailIdx) {
+                    tailWorkers.add(costs[tailIdx--]);
+                }
+            }
+        }
+        return result;
+    }
+}
diff --git a/Medium/Tree Diameter.java b/Medium/Tree Diameter.java
index 28dca810..87d5eab9 100644
--- a/Medium/Tree Diameter.java	
+++ b/Medium/Tree Diameter.java	
@@ -1,36 +1,39 @@
 class Solution {
-  public int treeDiameter(int[][] edges) {
-    Map<Integer, List<Integer>> graph = new HashMap<>();
-    for (int[] edge : edges) {
-      graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
-      graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+    public int treeDiameter(int[][] edges) {
+        int n = edges.length;
+        List<Set<Integer>> graph = new ArrayList<>();
+        boolean[] visited = new boolean[n + 1];
+        for (int i = 0; i < n + 1; i++) {
+            graph.add(new HashSet<>());
+        }
+        for (int[] edge : edges) {
+            int nodeOne = edge[0];
+            int nodeTwo = edge[1];
+            graph.get(nodeOne).add(nodeTwo);
+            graph.get(nodeTwo).add(nodeOne);
+        }
+        int[] diameter = {0};
+        dfs(0, visited, graph, diameter);
+        return diameter[0];
     }
-    int farthestNode = bfsHelper(graph, 0)[0];
-    return bfsHelper(graph, farthestNode)[1];
-  }
 
-  private int[] bfsHelper(Map<Integer, List<Integer>> graph, int node) {
-    int farthestNode = 0;
-    int steps = 0;
-    Queue<Integer> queue = new LinkedList<>();
-    queue.add(node);
-    Set<Integer> visited = new HashSet<>();
-    while (!queue.isEmpty()) {
-      int size = queue.size();
-      while (size--  > 0) {
-        int removedNode = queue.remove();
-        visited.add(removedNode);
-        farthestNode = removedNode;
-        for (Integer peer : graph.getOrDefault(removedNode, new ArrayList<>())) {
-          if (!visited.contains(peer)) {
-            queue.add(peer);
-          }
+    private int dfs(int node, boolean[] visited, List<Set<Integer>> graph, int[] diameter) {
+        int highestDistance = 0;
+        int secondHighestDistance = 0;
+        visited[node] = true;
+        for (Integer conn : graph.get(node)) {
+            int distance = 0;
+            if (!visited[conn]) {
+                distance = 1 + dfs(conn, visited, graph, diameter);
+            }
+            if (distance > highestDistance) {
+                secondHighestDistance = highestDistance;
+                highestDistance = distance;
+            } else if (distance > secondHighestDistance) {
+                secondHighestDistance = distance;
+            }
         }
-      }
-      if (!queue.isEmpty()) {
-        steps++;
-      }
+        diameter[0] = Math.max(diameter[0], highestDistance + secondHighestDistance);
+        return highestDistance;
     }
-    return new int[]{farthestNode, steps};
-  }
 }
diff --git a/Medium/Uncrossed Lines.java b/Medium/Uncrossed Lines.java
index 6a923dfa..729da13d 100644
--- a/Medium/Uncrossed Lines.java	
+++ b/Medium/Uncrossed Lines.java	
@@ -1,23 +1,21 @@
 class Solution {
-  Integer[][] dp;
-  public int maxUncrossedLines(int[] A, int[] B) {
-    dp = new Integer[A.length][B.length];
-    return helper(A, 0, B, 0);
-  } 
-  
-  private int helper(int[] A, int idxA, int[] B, int idxB) {
-    if (idxA == A.length || idxB == B.length) {
-      return 0;
-    } 
-    if (dp[idxA][idxB] != null) {
-      return dp[idxA][idxB];
+    public int maxUncrossedLines(int[] nums1, int[] nums2) {
+        Integer[][] dp = new Integer[nums1.length][nums2.length];
+        return helper(nums1, 0, nums2, 0, dp);
     }
-    if (A[idxA] == B[idxB]) {
-      dp[idxA][idxB] = 1 + helper(A, idxA + 1, B, idxB + 1);
+    
+    private int helper(int[] nums1, int idxOne, int[] nums2, int idxTwo, Integer[][] dp) {
+        if (idxOne == nums1.length || idxTwo == nums2.length) {
+            return 0;
+        }
+        if (dp[idxOne][idxTwo] != null) {
+            return dp[idxOne][idxTwo];
+        }
+        if (nums1[idxOne] == nums2[idxTwo]) {
+            return dp[idxOne][idxTwo] = 1 + helper(nums1, idxOne + 1, nums2, idxTwo + 1, dp);
+        }
+        return dp[idxOne][idxTwo] = Math.max(
+            helper(nums1, idxOne, nums2, idxTwo + 1, dp), 
+            helper(nums1, idxOne + 1, nums2, idxTwo, dp));
     }
-    else {
-      dp[idxA][idxB] = Math.max(helper(A, idxA + 1, B, idxB), helper(A, idxA, B, idxB + 1));
-    }
-    return dp[idxA][idxB];
-  }
 }
diff --git a/Medium/Using a Robot to Print the Lexicographically Smallest String.java b/Medium/Using a Robot to Print the Lexicographically Smallest String.java
new file mode 100644
index 00000000..8d9c2064
--- /dev/null
+++ b/Medium/Using a Robot to Print the Lexicographically Smallest String.java	
@@ -0,0 +1,31 @@
+class Solution {
+    public String robotWithString(String s) {
+        int[] counter = new int[26];
+        for (char c : s.toCharArray()) {
+            counter[c - 'a']++;
+        }
+        Stack<Character> stack = new Stack<>();
+        StringBuilder sb = new StringBuilder();
+        for (char c : s.toCharArray()) {
+            stack.push(c);
+            counter[c - 'a']--;
+            while (!stack.isEmpty() && isSmallest(stack.peek(), counter)) {
+                sb.append(stack.pop());
+            }
+        }
+        while (!stack.isEmpty()) {
+            sb.append(stack.pop());
+        }
+        return sb.toString();
+    }
+
+    private boolean isSmallest(char c, int[] counter) {
+        int limit = c - 'a';
+        for (int i = 0; i < limit; i++) {
+            if (counter[i] > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/Medium/Validate Stack Sequences.java b/Medium/Validate Stack Sequences.java
index 87d61d31..64ae1452 100644
--- a/Medium/Validate Stack Sequences.java	
+++ b/Medium/Validate Stack Sequences.java	
@@ -1,22 +1,20 @@
 class Solution {
-  public boolean validateStackSequences(int[] pushed, int[] popped) {
-    Stack<Integer> stack = new Stack<>();
-    int pushIdx = 0;
-    int popIdx = 0;
-    while (pushIdx < pushed.length) {
-      while (!stack.isEmpty() && popped[popIdx] == stack.peek()) {
-        stack.pop();
-        popIdx++;
-      }
-      stack.push(pushed[pushIdx++]);
+    public boolean validateStackSequences(int[] pushed, int[] popped) {
+        Stack<Integer> stack = new Stack<>();
+        int pushedIdx = 0;
+        int poppedIdx = 0;
+        while (pushedIdx < pushed.length && poppedIdx < popped.length) {
+            if (!stack.isEmpty() && stack.peek() == popped[poppedIdx]) {
+                stack.pop();
+                poppedIdx++;
+            } else {
+                stack.push(pushed[pushedIdx++]);
+            }
+        }
+        while (poppedIdx < popped.length && !stack.isEmpty() && stack.peek() == popped[poppedIdx]) {
+            stack.pop();
+            poppedIdx++;
+        }
+        return pushedIdx == pushed.length && poppedIdx == popped.length;
     }
-    while (popIdx < popped.length) {
-      if (stack.isEmpty() || stack.peek() != popped[popIdx]) {
-        return false;
-      }
-      stack.pop();
-      popIdx++;
-    }
-    return true;
-  }
 }
diff --git a/Medium/Walking Robot Simulation.java b/Medium/Walking Robot Simulation.java
new file mode 100644
index 00000000..bfc2784f
--- /dev/null
+++ b/Medium/Walking Robot Simulation.java	
@@ -0,0 +1,41 @@
+class Solution {
+    private static final int[][] DIRECTIONS = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
+    private static final int HASH_MULTIPLIER = 60001;
+
+    public int robotSim(int[] commands, int[][] obstacles) {
+        Set<Integer> obstacleSet = new HashSet<>();
+        for (int[] obstacle : obstacles) {
+            obstacleSet.add(hashCoordinates(obstacle[0], obstacle[1]));
+        }
+        int maxDistance = 0;
+        int currentDirection = 0;
+        int x = 0;
+        int y = 0;
+        for (int command : commands) {
+            if (command == -1) {
+                currentDirection = (currentDirection + 1) % 4;
+                continue;
+            }
+            if (command == -2) {
+                currentDirection = (currentDirection + 3) % 4;
+                continue;
+            }
+            int[] direction = DIRECTIONS[currentDirection];
+            for (int i = 0; i < command; i++) {
+                int nextX = x + direction[0];
+                int nextY = y + direction[1];
+                if (obstacleSet.contains(hashCoordinates(nextX, nextY))) {
+                    break;
+                }
+                x = nextX;
+                y = nextY;
+            }
+            maxDistance = Math.max(maxDistance, x * x + y * y);
+        }
+        return maxDistance;
+    }
+
+    private static int hashCoordinates(int x, int y) {
+        return x + HASH_MULTIPLIER * y;
+    }
+}
diff --git a/Medium/Water Bottles II.java b/Medium/Water Bottles II.java
new file mode 100644
index 00000000..d9205f31
--- /dev/null
+++ b/Medium/Water Bottles II.java	
@@ -0,0 +1,12 @@
+class Solution {
+    public int maxBottlesDrunk(int numBottles, int numExchange) {
+        int total = numBottles;
+        while (numBottles >= numExchange) {
+            numBottles -= numExchange;
+            numExchange++;
+            total++;
+            numBottles++;
+        }
+        return total;
+    }
+}
diff --git a/Medium/Widest Vertical Area Between Two Points Containing No Points.java b/Medium/Widest Vertical Area Between Two Points Containing No Points.java
new file mode 100644
index 00000000..d2e07d21
--- /dev/null
+++ b/Medium/Widest Vertical Area Between Two Points Containing No Points.java	
@@ -0,0 +1,11 @@
+class Solution {
+    public int maxWidthOfVerticalArea(int[][] points) {
+        Arrays.sort(points, (a, b) -> a[0] - b[0]);
+        int maxWidth = 0;
+        for (int i = 1; i < points.length; i++) {
+            int width = points[i][0] - points[i - 1][0];
+            maxWidth = Math.max(maxWidth, width);
+        }
+        return maxWidth;
+    }
+}
diff --git a/Medium/Wiggle Sort.java b/Medium/Wiggle Sort.java
index e4e8ad13..68cac74b 100644
--- a/Medium/Wiggle Sort.java	
+++ b/Medium/Wiggle Sort.java	
@@ -1,24 +1,11 @@
 class Solution {
-  public void wiggleSort(int[] nums) {
-    boolean small = true;
-    for (int i = 0; i < nums.length - 1; i++) {
-      if (small) {
-        if (nums[i] > nums[i + 1]) {
-          swap(nums, i, i + 1);
+    public void wiggleSort(int[] nums) {
+        for (int i = 1; i < nums.length; i++) {
+            if ((i % 2 == 1 && nums[i] < nums[i - 1]) || (i % 2 != 1 && nums[i] > nums[i - 1])) {
+                int temp = nums[i];
+                nums[i] = nums[i - 1];
+                nums[i - 1] = temp;
+            } 
         }
-      }
-      else {
-        if (nums[i] < nums[i + 1]) {
-          swap(nums, i, i + 1);
-        }
-      }
-      small = !small;
     }
-  }
-  
-  private void swap(int[] nums, int idx1, int idx2) {
-    int temp = nums[idx2];
-    nums[idx2] = nums[idx1];
-    nums[idx1] = temp;
-  }
 }
diff --git a/Medium/XOR Queries of a Subarray.java b/Medium/XOR Queries of a Subarray.java
new file mode 100644
index 00000000..0bdfc9ca
--- /dev/null
+++ b/Medium/XOR Queries of a Subarray.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int[] xorQueries(int[] arr, int[][] queries) {
+        int n = arr.length;
+        int[] prefixXors = new int[n];
+        int xor = 0;
+        for (int i = 0; i < n; i++) {
+            xor = xor ^ arr[i];
+            prefixXors[i] = xor;
+        }
+        n = queries.length;
+        int[] result = new int[n];
+        for (int i = 0; i < n; i++) {
+            int[] query = queries[i];
+            int left = query[0];
+            int right = query[1];
+            int xorResult = prefixXors[right];
+            if (left != 0) {
+                xorResult = xorResult ^ prefixXors[left - 1];
+            }
+            result[i] = xorResult;
+        }
+        return result;
+    }
+}
diff --git a/Medium/Zero Array Transformation I.java b/Medium/Zero Array Transformation I.java
new file mode 100644
index 00000000..2b9ab602
--- /dev/null
+++ b/Medium/Zero Array Transformation I.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public boolean isZeroArray(int[] nums, int[][] queries) {
+        int n = nums.length;
+        int[] diff = new int[n + 1];
+        for (int[] query : queries) {
+            int left = query[0];
+            int right = query[1];
+            diff[left] += 1;
+            diff[right + 1] -= 1;
+        }
+        int[] operation = new int[n + 1];
+        int currOperation = 0;
+        for (int i = 0; i < n + 1; i++) {
+            currOperation += diff[i];
+            operation[i] = currOperation;
+        }
+        for (int i = 0; i < n; i++) {
+            if (operation[i] < nums[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/Medium/ZigZag Conversion.java b/Medium/ZigZag Conversion.java
index 62539da4..31793633 100644
--- a/Medium/ZigZag Conversion.java	
+++ b/Medium/ZigZag Conversion.java	
@@ -1,25 +1,29 @@
 class Solution {
-  public String convert(String s, int numRows) {
-    if (numRows == 1) {
-      return s;
+    public String convert(String s, int numRows) {
+        if (numRows == 1) {
+            return s;
+        }
+        StringBuilder[] rows = new StringBuilder[numRows];
+        for (int i = 0; i < numRows; i++) {
+            rows[i] = new StringBuilder();
+        }
+        int row = 0;
+        int n = s.length();
+        int idx = 0;
+        while (idx < n) {
+            while (idx < n && row < numRows) {
+                rows[row++].append(s.charAt(idx++));
+            }
+            row -= 2;
+            while (idx < n && row >= 0) {
+                rows[row--].append(s.charAt(idx++));
+            }
+            row += 2;
+        }
+        StringBuilder result = new StringBuilder();
+        for (StringBuilder sb : rows) {
+            result.append(sb.toString());
+        }
+        return result.toString();
     }
-    List<StringBuilder> list = new ArrayList<>();
-    for (int i = 0; i < numRows; i++) {
-      list.add(new StringBuilder());
-    }
-    int idx = 0;
-    boolean downDirection = false;
-    for (char c : s.toCharArray()) {
-      list.get(idx).append(c);
-      if (idx == 0 || idx == numRows - 1) {
-        downDirection = !downDirection;
-      }
-      idx += downDirection ? 1 : -1;
-    }
-    StringBuilder result = new StringBuilder();
-    for (StringBuilder sb : list) {
-      result.append(sb.toString());
-    }
-    return result.toString();
-  }
 }
diff --git a/README.md b/README.md
index ddb9b55e..617cd951 100644
--- a/README.md
+++ b/README.md
@@ -2,11 +2,12 @@
 
 ## Solutions to Leetcode problems in Java
 
-## [Current Leetcode profile: Solved 1100+ Problems](https://leetcode.com/varunsjsu/)
+## [Current Leetcode profile: Solved 1700+ Problems](https://leetcode.com/varunsjsu/)
 ## [Previous Leetcode profile: Solved 759 Problems](https://leetcode.com/varunu28/)
 
 Problem Category | Count
 --- | --- 
-[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 452
-[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 543
-[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 67
+[Easy](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Easy/README.md) | 607
+[Medium](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Medium/README.md) | 793
+[Hard](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Hard/README.md) | 125
+[Concurrency](https://github.com/varunu28/LeetCode-Java-Solutions/blob/master/Concurrency/README.md) | 9
diff --git a/commit-script.sh b/commit-script.sh
new file mode 100755
index 00000000..90a4f404
--- /dev/null
+++ b/commit-script.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+git add .
+
+if git status | grep -q 'modified'; then
+    status=$(git status | grep 'modified')
+    modified_file=${status##*/}
+    git commit -m "Updated ${modified_file}"
+elif git status | grep -q 'new file:'; then
+    status=$(git status | grep 'new file:')
+    added_file=${status##*/}
+    git commit -m "Added ${added_file}"
+fi
+
+git push