Arpit 2215800003

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;        
+    }
+}

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;
+  }
+}

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;
+    }
+}

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;
+  }
+}

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;
+    }
+}

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;
+  }
+}

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;
+  }
+}

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;
+  }
+}

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;
+  }
+}

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; 
+    }
+}

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;
+  }
+}

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;
+  }
+}

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;
+  }
+}

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;
+  }
+}

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;
+  }
+}