diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 00000000..cee61fb9
Binary files /dev/null and b/.DS_Store differ
diff --git a/Week_1/3sum.java b/Week_1/3sum.java
new file mode 100644
index 00000000..6fc2a868
--- /dev/null
+++ b/Week_1/3sum.java
@@ -0,0 +1,30 @@
+import java.util.*;
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> res = new ArrayList<>();
+        Arrays.sort(nums);
+
+        for (int i = 0; i < nums.length; i++) {
+            if (i > 0 && nums[i] == nums[i-1]) {
+                continue;
+            }
+            int j = i + 1;
+            int k = nums.length - 1;
+            while (j < k) {
+                int total = nums[i] + nums[j] + nums[k];
+                if (total > 0) {
+                    k--;
+                } else if (total < 0) {
+                    j++;
+                } else {
+                    res.add(Arrays.asList(nums[i], nums[j], nums[k]));
+                    j++;
+                    while (nums[j] == nums[j-1] && j < k) {
+                        j++;
+                    }
+                }
+            }
+        }
+        return res;        
+    }
+}
\ No newline at end of file
diff --git a/Week_1/3sumClosest.java b/Week_1/3sumClosest.java
new file mode 100644
index 00000000..1c82de8a
--- /dev/null
+++ b/Week_1/3sumClosest.java
@@ -0,0 +1,30 @@
+import java.util.*;
+class Solution {
+  public int threeSumClosest(int[] nums, int target) {
+    int ans = nums[0] + nums[1] + nums[2];
+
+    Arrays.sort(nums);
+
+    for (int i = 0; i + 2 < nums.length; ++i) {
+      if (i > 0 && nums[i] == nums[i - 1])
+        continue;
+      // Choose nums[i] as the first number in the triplet, then search the
+      // remaining numbers in [i + 1, n - 1].
+      int l = i + 1;
+      int r = nums.length - 1;
+      while (l < r) {
+        final int sum = nums[i] + nums[l] + nums[r];
+        if (sum == target)
+          return sum;
+        if (Math.abs(sum - target) < Math.abs(ans - target))
+          ans = sum;
+        if (sum < target)
+          ++l;
+        else
+          --r;
+      }
+    }
+
+    return ans;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/assignCookies.java b/Week_1/assignCookies.java
new file mode 100644
index 00000000..5f74bb4c
--- /dev/null
+++ b/Week_1/assignCookies.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class Solution {
+    public int findContentChildren(int[] g, int[] s) {
+        Arrays.sort(g);
+        Arrays.sort(s);
+        int m=g.length;
+        int n=s.length;
+       int i=0,j=0;
+       while(i<m && j<n){
+                if(g[i]<=s[j]){
+                    i++;
+                    j++;
+                }
+                else{
+            j++;
+        }
+       }
+        return i;
+    }
+}
\ No newline at end of file
diff --git a/Week_1/cntNumOfNiceSubarrays.java b/Week_1/cntNumOfNiceSubarrays.java
new file mode 100644
index 00000000..fa85ab53
--- /dev/null
+++ b/Week_1/cntNumOfNiceSubarrays.java
@@ -0,0 +1,25 @@
+class Solution {
+  public int numberOfSubarrays(int[] nums, int k) {
+    return numberOfSubarraysAtMost(nums, k) - numberOfSubarraysAtMost(nums, k - 1);
+  }
+
+  private int numberOfSubarraysAtMost(int[] nums, int k) {
+    int ans = 0;
+
+    for (int l = 0, r = 0; r <= nums.length;)
+      if (k >= 0) {
+        ans += r - l;
+        if (r == nums.length)
+          break;
+        if (nums[r] % 2 == 1)
+          --k;
+        ++r;
+      } else {
+        if (nums[l] % 2 == 1)
+          ++k;
+        ++l;
+      }
+
+    return ans;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/commonChar.java b/Week_1/commonChar.java
new file mode 100644
index 00000000..0bb8324e
--- /dev/null
+++ b/Week_1/commonChar.java
@@ -0,0 +1,29 @@
+import java.util.*;
+
+class Solution {
+    public List<String> commonChars(String[] words) {
+        Map<Character,Integer> map = new HashMap<>();
+        String first = words[0];
+
+        for(int i =0; i<first.length(); i++){
+            map.put(first.charAt(i), map.getOrDefault(first.charAt(i),0)+1);
+        }
+        for(int i=1; i<words.length; i++){
+            Map<Character,Integer> currMap = new HashMap<>();
+            String curr = words[i];
+            for(int j =0; j<curr.length(); j++){
+                currMap.put(curr.charAt(j), currMap.getOrDefault(curr.charAt(j),0)+1);
+            }
+            for(Character key : map.keySet()){
+                map.put(key, Math.min(map.get(key),currMap.getOrDefault(key,0)));
+            }
+        }
+        List<String> result= new ArrayList<>();
+        for(Character key : map.keySet()){
+            for(int i=0; i<map.get(key);i++){
+                result.add(key.toString());
+            }
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/Week_1/contSubarraySum.java b/Week_1/contSubarraySum.java
new file mode 100644
index 00000000..bb82c8d3
--- /dev/null
+++ b/Week_1/contSubarraySum.java
@@ -0,0 +1,23 @@
+import java.util.*;
+class Solution {
+  public boolean checkSubarraySum(int[] nums, int k) {
+    int prefix = 0;
+    Map<Integer, Integer> prefixToIndex = new HashMap<>();
+    prefixToIndex.put(0, -1);
+
+    for (int i = 0; i < nums.length; ++i) {
+      prefix += nums[i];
+      if (k != 0)
+        prefix %= k;
+      if (prefixToIndex.containsKey(prefix)) {
+        if (i - prefixToIndex.get(prefix) > 1)
+          return true;
+      } else {
+        // Set a new key if it's absent because the previous index is better.
+        prefixToIndex.put(prefix, i);
+      }
+    }
+
+    return false;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/containerWithMostWater.java b/Week_1/containerWithMostWater.java
new file mode 100644
index 00000000..8010a335
--- /dev/null
+++ b/Week_1/containerWithMostWater.java
@@ -0,0 +1,18 @@
+class Solution {
+  public int maxArea(int[] height) {
+    int ans = 0;
+    int l = 0;
+    int r = height.length - 1;
+
+    while (l < r) {
+      final int minHeight = Math.min(height[l], height[r]);
+      ans = Math.max(ans, minHeight * (r - l));
+      if (height[l] < height[r])
+        ++l;
+      else
+        --r;
+    }
+
+    return ans;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/contiguousArray.java b/Week_1/contiguousArray.java
new file mode 100644
index 00000000..df307905
--- /dev/null
+++ b/Week_1/contiguousArray.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class Solution {
+  public int findMaxLength(int[] nums) {
+    int ans = 0;
+    int prefix = 0;
+    Map<Integer, Integer> prefixToIndex = new HashMap<>();
+    prefixToIndex.put(0, -1);
+
+    for (int i = 0; i < nums.length; ++i) {
+      prefix += nums[i] == 1 ? 1 : -1;
+      if (prefixToIndex.containsKey(prefix))
+        ans = Math.max(ans, i - prefixToIndex.get(prefix));
+      else
+        prefixToIndex.put(prefix, i);
+    }
+
+    return ans;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/countElementWithMaxFrequency.java b/Week_1/countElementWithMaxFrequency.java
new file mode 100644
index 00000000..8a65cffc
--- /dev/null
+++ b/Week_1/countElementWithMaxFrequency.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class Solution {
+  public int maxFrequencyElements(int[] nums) {
+    final int kMax = 100;
+    int ans = 0;
+    int[] count = new int[kMax + 1];
+
+    for (final int num : nums)
+      ++count[num];
+
+    final int maxFreq = Arrays.stream(count).max().getAsInt();
+
+    for (final int freq : count)
+      if (freq == maxFreq)
+        ans += maxFreq;
+
+    return ans;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/divideArrays.java b/Week_1/divideArrays.java
new file mode 100644
index 00000000..ac19d52d
--- /dev/null
+++ b/Week_1/divideArrays.java
@@ -0,0 +1,27 @@
+import java.util.*;
+
+class Solution {
+    public int[][] divideArray(int[] nums, int k) {
+        int ans[][]=new int[nums.length/3][3];
+        int ind=0;
+        Arrays.sort(nums);
+        for(int i=0;i<nums.length;i+=3)
+        {
+            int first=nums[i];
+            int second=nums[i+1];
+            int third=nums[i+2];
+            if(third-first <= k)
+            {
+                ans[ind][0]=first;
+                ans[ind][1]=second;
+                ans[ind][2]=third;
+                ind++;
+            }
+            else
+            {
+                return new int[0][0];
+            }
+        }
+        return ans; 
+    }
+}
\ No newline at end of file
diff --git a/Week_1/findPivotIndex.java b/Week_1/findPivotIndex.java
new file mode 100644
index 00000000..379010aa
--- /dev/null
+++ b/Week_1/findPivotIndex.java
@@ -0,0 +1,15 @@
+import java.util.*;
+class Solution {
+  public int pivotIndex(int[] nums) {
+    final int sum = Arrays.stream(nums).sum();
+    int prefix = 0;
+
+    for (int i = 0; i < nums.length; ++i) {
+      if (prefix == sum - prefix - nums[i])
+        return i;
+      prefix += nums[i];
+    }
+
+    return -1;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/kRadiusSubarrayAvg.java b/Week_1/kRadiusSubarrayAvg.java
new file mode 100644
index 00000000..c655e533
--- /dev/null
+++ b/Week_1/kRadiusSubarrayAvg.java
@@ -0,0 +1,24 @@
+import java.util.*;
+class Solution {
+  public int[] getAverages(int[] nums, int k) {
+    final int n = nums.length;
+    final int size = 2 * k + 1;
+    int[] ans = new int[n];
+    Arrays.fill(ans, -1);
+    if (size > n)
+      return ans;
+
+    long sum = 0;
+
+    for (int i = 0; i < size; ++i)
+      sum += nums[i];
+
+    for (int i = k; i + k < n; ++i) {
+      ans[i] = (int) (sum / size);
+      if (i + k + 1 < n)
+        sum += nums[i + k + 1] - nums[i - k];
+    }
+
+    return ans;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/lemonade.java b/Week_1/lemonade.java
new file mode 100644
index 00000000..3c63b744
--- /dev/null
+++ b/Week_1/lemonade.java
@@ -0,0 +1,26 @@
+class Solution {
+  public boolean lemonadeChange(int[] bills) {
+    int fives = 0;
+    int tens = 0;
+
+    for (final int bill : bills) {
+      if (bill == 5) {
+        ++fives;
+      } else if (bill == 10) {
+        --fives;
+        ++tens;
+      } else { // bill == 20
+        if (tens > 0) {
+          --tens;
+          --fives;
+        } else {
+          fives -= 3;
+        }
+      }
+      if (fives < 0)
+        return false;
+    }
+
+    return true;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/longestMountainInArray.java b/Week_1/longestMountainInArray.java
new file mode 100644
index 00000000..6398d68a
--- /dev/null
+++ b/Week_1/longestMountainInArray.java
@@ -0,0 +1,28 @@
+class Solution {
+  public int longestMountain(int[] arr) {
+    int ans = 0;
+
+    for (int i = 0; i + 1 < arr.length;) {
+      while (i + 1 < arr.length && arr[i] == arr[i + 1])
+        ++i;
+
+      int increasing = 0;
+      int decreasing = 0;
+
+      while (i + 1 < arr.length && arr[i] < arr[i + 1]) {
+        ++increasing;
+        ++i;
+      }
+
+      while (i + 1 < arr.length && arr[i] > arr[i + 1]) {
+        ++decreasing;
+        ++i;
+      }
+
+      if (increasing > 0 && decreasing > 0)
+        ans = Math.max(ans, increasing + decreasing + 1);
+    }
+
+    return ans;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/maxErasureValue.java b/Week_1/maxErasureValue.java
new file mode 100644
index 00000000..3bb87235
--- /dev/null
+++ b/Week_1/maxErasureValue.java
@@ -0,0 +1,19 @@
+import java.util.*;
+class Solution {
+  public int maximumUniqueSubarray(int[] nums) {
+    int ans = 0;
+    int score = 0;
+    Set<Integer> seen = new HashSet<>();
+
+    for (int l = 0, r = 0; r < nums.length; ++r) {
+      while (!seen.add(nums[r])) {
+        score -= nums[l];
+        seen.remove(nums[l++]);
+      }
+      score += nums[r];
+      ans = Math.max(ans, score);
+    }
+
+    return ans;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/maxProductSubarray.java b/Week_1/maxProductSubarray.java
new file mode 100644
index 00000000..38456e87
--- /dev/null
+++ b/Week_1/maxProductSubarray.java
@@ -0,0 +1,23 @@
+class Solution {
+  public int maxProduct(int[] nums) {
+    int ans = nums[0];
+    int dpMin = nums[0]; // the minimum so far
+    int dpMax = nums[0]; // the maximum so far
+
+    for (int i = 1; i < nums.length; ++i) {
+      final int num = nums[i];
+      final int prevMin = dpMin; // dpMin[i - 1]
+      final int prevMax = dpMax; // dpMax[i - 1]
+      if (num < 0) {
+        dpMin = Math.min(prevMax * num, num);
+        dpMax = Math.max(prevMin * num, num);
+      } else {
+        dpMin = Math.min(prevMin * num, num);
+        dpMax = Math.max(prevMax * num, num);
+      }
+      ans = Math.max(ans, dpMax);
+    }
+
+    return ans;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/minCommonValue.java b/Week_1/minCommonValue.java
new file mode 100644
index 00000000..cd5359be
--- /dev/null
+++ b/Week_1/minCommonValue.java
@@ -0,0 +1,17 @@
+class Solution {
+  public int getCommon(int[] nums1, int[] nums2) {
+    int i = 0; // nums1's index
+    int j = 0; // nums2's index
+
+    while (i < nums1.length && j < nums1.length) {
+      if (nums1[i] == nums2[j])
+        return nums1[i];
+      if (nums1[i] < nums2[j])
+        ++i;
+      else
+        ++j;
+    }
+
+    return -1;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/subarraySumEqualsK.java b/Week_1/subarraySumEqualsK.java
new file mode 100644
index 00000000..8d4ec60b
--- /dev/null
+++ b/Week_1/subarraySumEqualsK.java
@@ -0,0 +1,17 @@
+import java.util.*;
+class Solution {
+  public int subarraySum(int[] nums, int k) {
+    int ans = 0;
+    int prefix = 0;
+    Map<Integer, Integer> count = new HashMap<>();
+    count.put(0, 1);
+
+    for (final int num : nums) {
+      prefix += num;
+      ans += count.getOrDefault(prefix - k, 0);
+      count.merge(prefix, 1, Integer::sum);
+    }
+
+    return ans;
+  }
+}
\ No newline at end of file
diff --git a/Week_1/twoChocolates.java b/Week_1/twoChocolates.java
new file mode 100644
index 00000000..a5109785
--- /dev/null
+++ b/Week_1/twoChocolates.java
@@ -0,0 +1,14 @@
+import java.util.*;
+class Solution {
+    public int buyChoco(int[] prices, int money) {
+        Arrays.sort(prices);
+        int total=prices[0]+prices[1];
+        if(total<=money){
+            return money-total;
+        }
+        else{
+            return money;
+        }
+    }
+}
+//hkshshhh
\ No newline at end of file
diff --git a/Week_2/Find_minimum_in_rotated_sorted_array.java b/Week_2/Find_minimum_in_rotated_sorted_array.java
new file mode 100644
index 00000000..2cc7c097
--- /dev/null
+++ b/Week_2/Find_minimum_in_rotated_sorted_array.java
@@ -0,0 +1,22 @@
+package Week_2;
+
+    class Solution {
+    public int findMin(int[] nums) {
+        int min= Integer.MAX_VALUE;
+        int n=nums.length;
+        int left=0;
+        int right=n-1;
+
+        while(left<right){
+            int mid= left+(right-left)/2;
+            if(nums[mid]>nums[right]){
+                left=mid+1;
+            }else{
+                right=mid;
+            }
+        }
+     return nums[left];       
+    }
+
+}
+
diff --git a/Week_2/Solution.java b/Week_2/Solution.java
new file mode 100644
index 00000000..9d29b6a0
--- /dev/null
+++ b/Week_2/Solution.java
@@ -0,0 +1,24 @@
+package Week_2;
+import java.util.*;
+
+public class Solution extends VersionControl {
+  public int firstBadVersion(int n) {
+    int l = 1;
+    int r = n;
+
+    while (l < r) {
+      final int m = l + (r - l) / 2;
+      if (isBadVersion(m))
+              r = m;
+            else
+              l = m + 1;
+          }
+      
+          return l;
+        }
+      
+        private boolean isBadVersion(int m) {
+          // TODO Auto-generated method stub
+          throw new UnsupportedOperationException("Unimplemented method 'isBadVersion'");
+        }
+}
\ No newline at end of file
diff --git a/Week_2/VersionControl.java b/Week_2/VersionControl.java
new file mode 100644
index 00000000..9bedb47e
--- /dev/null
+++ b/Week_2/VersionControl.java
@@ -0,0 +1,5 @@
+package Week_2;
+
+public class VersionControl {
+
+}
diff --git a/Week_2/binary_search.java b/Week_2/binary_search.java
new file mode 100644
index 00000000..0bb83e06
--- /dev/null
+++ b/Week_2/binary_search.java
@@ -0,0 +1,24 @@
+package Week_2;
+
+class Solution {
+    public int search(int[] nums, int target) {
+        int low = 0;
+        int high = nums.length - 1;
+
+        while (low <= high) {
+            int mid = low + (high - low) / 2;
+
+            if (nums[mid] == target) {
+                return mid;
+            }
+            else if (target < nums[mid]) {
+                high = mid - 1;
+            }
+            else if (target > nums[mid]) {
+                low = mid + 1;
+            }
+        }
+
+        return -1;
+    }
+}
\ No newline at end of file
diff --git a/Week_2/find_a_peak_element_II.java b/Week_2/find_a_peak_element_II.java
new file mode 100644
index 00000000..b919e4fb
--- /dev/null
+++ b/Week_2/find_a_peak_element_II.java
@@ -0,0 +1,27 @@
+package Week_2;
+import java.util.Arrays;
+
+class Solution {
+  public int[] findPeakGrid(int[][] mat) {
+    int l = 0;
+    int r = mat.length - 1;
+
+    while (l < r) {
+      final int m = (l + r) / 2;
+      if (Arrays.stream(mat[m]).max().getAsInt() >= Arrays.stream(mat[m + 1]).max().getAsInt())
+        r = m;
+      else
+        l = m + 1;
+    }
+
+    return new int[] {l, getMaxIndex(mat[l])};
+  }
+
+  private int getMaxIndex(int[] A) {
+    int[] res = {0, A[0]};
+    for (int i = 1; i < A.length; ++i)
+      if (A[i] > res[1])
+        res = new int[] {i, A[i]};
+    return res[0];
+  }
+}
diff --git a/Week_2/find_first_and_last_position.java b/Week_2/find_first_and_last_position.java
new file mode 100644
index 00000000..af590c7a
--- /dev/null
+++ b/Week_2/find_first_and_last_position.java
@@ -0,0 +1,24 @@
+package Week_2;
+
+class Solution {
+  public int[] searchRange(int[] nums, int target) {
+    final int l = firstGreaterEqual(nums, target);
+    if (l == nums.length || nums[l] != target)
+      return new int[] {-1, -1};
+    final int r = firstGreaterEqual(nums, target + 1) - 1;
+    return new int[] {l, r};
+  }
+
+  private int firstGreaterEqual(int[] A, int target) {
+    int l = 0;
+    int r = A.length;
+    while (l < r) {
+      final int m = (l + r) / 2;
+      if (A[m] >= target)
+        r = m;
+      else
+        l = m + 1;
+    }
+    return l;
+  }
+}
\ No newline at end of file
diff --git a/Week_2/find_peak_element.java b/Week_2/find_peak_element.java
new file mode 100644
index 00000000..078198f7
--- /dev/null
+++ b/Week_2/find_peak_element.java
@@ -0,0 +1,18 @@
+package Week_2;
+
+  class Solution {
+  public int findPeakElement(int[] nums) {
+    int l = 0;
+    int r = nums.length - 1;
+
+    while (l < r) {
+      final int m = (l + r) / 2;
+      if (nums[m] >= nums[m + 1])
+        r = m;
+      else
+        l = m + 1;
+    }
+
+    return l;
+  }
+}
diff --git a/Week_2/find_smallest_number_greater_than_target.java b/Week_2/find_smallest_number_greater_than_target.java
new file mode 100644
index 00000000..061cfffc
--- /dev/null
+++ b/Week_2/find_smallest_number_greater_than_target.java
@@ -0,0 +1,19 @@
+package Week_2;
+
+class Solution {
+    public char nextGreatestLetter(char[] letters, char target) {
+         int start =0;
+         int end= letters.length-1;
+         while(start<=end){
+            int mid = start+(end-start)/2;
+
+                if(letters[mid]>target){
+                    end = mid-1;
+                }else{
+                    start = mid+1;
+                }
+
+         }
+         return letters[start % letters.length];
+    }
+}
\ No newline at end of file
diff --git a/Week_2/koko_eating_bananas.java b/Week_2/koko_eating_bananas.java
new file mode 100644
index 00000000..f7698ea9
--- /dev/null
+++ b/Week_2/koko_eating_bananas.java
@@ -0,0 +1,24 @@
+package Week_2;
+import java.util.Arrays;
+class Solution {
+  public int minEatingSpeed(int[] piles, int h) {
+    int l = 1;
+    int r = Arrays.stream(piles).max().getAsInt();
+
+    while (l < r) {
+      final int m = (l + r) / 2;
+      if (eatHours(piles, m) <= h)
+        r = m;
+      else
+        l = m + 1;
+    }
+
+    return l;
+  }
+
+  // Returns the hours to eat all the piles with speed m.
+  private int eatHours(int[] piles, int m) {
+    return Arrays.stream(piles).reduce(
+        0, (subtotal, pile) -> subtotal + (pile - 1) / m + 1); // ceil(pile / m)
+  }
+}
\ No newline at end of file
diff --git a/Week_2/median_of_two_sorted_arrays.java b/Week_2/median_of_two_sorted_arrays.java
new file mode 100644
index 00000000..3f92c519
--- /dev/null
+++ b/Week_2/median_of_two_sorted_arrays.java
@@ -0,0 +1,32 @@
+package Week_2;
+
+class Solution {
+  public double findMedianSortedArrays(int[] nums1, int[] nums2) {
+    final int n1 = nums1.length;
+    final int n2 = nums2.length;
+    if (n1 > n2)
+      return findMedianSortedArrays(nums2, nums1);
+
+    int l = 0;
+    int r = n1;
+
+    while (l <= r) {
+      final int partition1 = (l + r) / 2;
+      final int partition2 = (n1 + n2 + 1) / 2 - partition1;
+      final int maxLeft1 = partition1 == 0 ? Integer.MIN_VALUE : nums1[partition1 - 1];
+      final int maxLeft2 = partition2 == 0 ? Integer.MIN_VALUE : nums2[partition2 - 1];
+      final int minRight1 = partition1 == n1 ? Integer.MAX_VALUE : nums1[partition1];
+      final int minRight2 = partition2 == n2 ? Integer.MAX_VALUE : nums2[partition2];
+      if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1)
+        return (n1 + n2) % 2 == 0
+            ? (Math.max(maxLeft1, maxLeft2) + Math.min(minRight1, minRight2)) * 0.5
+            : Math.max(maxLeft1, maxLeft2);
+      else if (maxLeft1 > minRight2)
+        r = partition1 - 1;
+      else
+        l = partition1 + 1;
+    }
+
+    throw new IllegalArgumentException();
+  }
+}
diff --git a/Week_2/min._speed_to_arrive_on_time.java b/Week_2/min._speed_to_arrive_on_time.java
new file mode 100644
index 00000000..4c7114ab
--- /dev/null
+++ b/Week_2/min._speed_to_arrive_on_time.java
@@ -0,0 +1,28 @@
+package Week_2;
+
+class Solution {
+  public int minSpeedOnTime(int[] dist, double hour) {
+    int ans = -1;
+    int l = 1;
+    int r = (int) 1e7;
+
+    while (l <= r) {
+      final int m = (l + r) / 2;
+      if (time(dist, hour, m) > hour) {
+        l = m + 1;
+      } else {
+        ans = m;
+        r = m - 1;
+      }
+    }
+
+    return ans;
+  }
+
+  private double time(int[] dist, double hour, int speed) {
+    double sum = 0;
+    for (int i = 0; i < dist.length - 1; ++i)
+      sum += Math.ceil((double) dist[i] / speed);
+    return sum + (double) dist[dist.length - 1] / speed;
+  }
+}
diff --git a/Week_2/search a 2d matrix.java b/Week_2/search a 2d matrix.java
new file mode 100644
index 00000000..2abc6e7c
--- /dev/null
+++ b/Week_2/search a 2d matrix.java	
@@ -0,0 +1,39 @@
+package Week_2;
+
+class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        int top = 0;
+        int bot = matrix.length - 1;
+
+        while (top <= bot) {
+            int mid = (top + bot) / 2;
+
+            if (matrix[mid][0] < target && matrix[mid][matrix[mid].length - 1] > target) {
+                break;
+            } else if (matrix[mid][0] > target) {
+                bot = mid - 1;
+            } else {
+                top = mid + 1;
+            }
+        }
+
+        int row = (top + bot) / 2;
+
+        int left = 0;
+        int right = matrix[row].length - 1;
+
+        while (left <= right) {
+            int mid = (left + right) / 2;
+
+            if (matrix[row][mid] == target) {
+                return true;
+            } else if (matrix[row][mid] > target) {
+                right = mid - 1;
+            } else {
+                left = mid + 1;
+            }
+        }
+
+        return false;        
+    }
+}
\ No newline at end of file
diff --git a/Week_2/search_in_rotated_sorted_array.java b/Week_2/search_in_rotated_sorted_array.java
new file mode 100644
index 00000000..2f524425
--- /dev/null
+++ b/Week_2/search_in_rotated_sorted_array.java
@@ -0,0 +1,27 @@
+package Week_2;
+
+class Solution {
+  public int search(int[] nums, int target) {
+    int l = 0;
+    int r = nums.length - 1;
+
+    while (l <= r) {
+      final int m = (l + r) / 2;
+      if (nums[m] == target)
+        return m;
+      if (nums[l] <= nums[m]) { // nums[l..m] are sorted.
+        if (nums[l] <= target && target < nums[m])
+          r = m - 1;
+        else
+          l = m + 1;
+      } else { // nums[m..n - 1] are sorted.
+        if (nums[m] < target && target <= nums[r])
+          l = m + 1;
+        else
+          r = m - 1;
+      }
+    }
+
+    return -1;
+  }
+}
diff --git a/Week_2/search_insert_position.java b/Week_2/search_insert_position.java
new file mode 100644
index 00000000..856ec0b7
--- /dev/null
+++ b/Week_2/search_insert_position.java
@@ -0,0 +1,12 @@
+package Week_2;
+  class Solution {
+    public int searchInsert(int[] nums, int target) {
+        for(int i=0;i<nums.length;i++){
+            if(nums[i]>=target)
+                return i;
+        }
+        return nums.length;
+        
+    }
+}
+    
\ No newline at end of file
diff --git a/Week_2/split_array_largest_sum.java b/Week_2/split_array_largest_sum.java
new file mode 100644
index 00000000..bf80074a
--- /dev/null
+++ b/Week_2/split_array_largest_sum.java
@@ -0,0 +1,33 @@
+package Week_2;
+import java.util.*;
+
+class Solution {
+  public int splitArray(int[] nums, int k) {
+    final int n = nums.length;
+    int[][] mem = new int[n + 1][k + 1];
+    int[] prefix = new int[n + 1];
+    Arrays.stream(mem).forEach(A -> Arrays.fill(A, Integer.MAX_VALUE));
+
+    for (int i = 0; i < n; ++i)
+      prefix[i + 1] = nums[i] + prefix[i];
+
+    return splitArray(nums, n, k, prefix, mem);
+  }
+
+  // Returns the minimum of the maximum sum to split the first i numbers into k
+  // groups.
+  private int splitArray(int[] nums, int i, int k, int[] prefix, int[][] mem) {
+    if (k == 1)
+      return prefix[i];
+    if (mem[i][k] < Integer.MAX_VALUE)
+      return mem[i][k];
+
+    // Try all the possible partitions.
+    for (int j = k - 1; j < i; ++j)
+      mem[i][k] = Math.min(mem[i][k],                                        //
+                           Math.max(splitArray(nums, j, k - 1, prefix, mem), //
+                                    prefix[i] - prefix[j]));
+
+    return mem[i][k];
+  }
+}
diff --git a/Week_2/sqrt(x).java b/Week_2/sqrt(x).java
new file mode 100644
index 00000000..92b621e7
--- /dev/null
+++ b/Week_2/sqrt(x).java
@@ -0,0 +1,21 @@
+package Week_2;
+
+class Solution {
+    public int mySqrt(int x) {
+        if (x == 0) {
+            return 0;
+        }
+        int first = 1, last = x;
+        while (first <= last) {
+            int mid = first + (last - first) / 2;
+            if (mid == x / mid) {
+                return mid;
+            } else if (mid > x / mid) {
+                last = mid - 1;
+            } else {
+                first = mid + 1;
+            }
+        }
+        return last;
+    }
+}
\ No newline at end of file