Koko bananas

solutions/ContainerWMostWater.java

@@ -0,0 +1,18 @@
+class Solution {
+    public int maxArea(int[] height) {
+        int l = 0;
+        int r = height.length - 1;
+        int res = 0;
+
+        while(l < r){
+            int area = Math.min(height[l], height[r]) * (r - l);
+            res = Math.max(res, area);
+            if (height[l] <= height[r]) {
+                l++;
+            }else{
+                r--;
+            }
+        }
+        return res;
+    }
+}

solutions/DailyTemps.java

@@ -0,0 +1,17 @@
+import java.util.Stack;
+
+public class DailyTemps {
+    int[] res = new int[temperatures.length];
+    Stack<int[]> stack = new Stack<>();
+
+    for(int i = 0; i < temperatures.length; i++){
+        int t = temperatures[i];
+
+        while(!stack.isEmpty() && t > stack.peek()[0]){
+            int[] pair = stack.pop();
+            res[pair[1]] = i - pair[i];
+        }
+        stack.push(new int[]{t, i});
+    }
+    return res;
+}

solutions/Eval_Rev_Polish_Notation.java

@@ -0,0 +1,26 @@
+import java.util.Stack;
+
+class Solution {
+    public int evalRPN(String[] tokens) {
+        Stack<Integer> stack = new Stack<>();
+
+        for(String c : tokens){
+            if(c.equals("+")){
+                stack.push(stack.pop() + stack.pop());
+            } else if(c.equals("-")){
+                int a = stack.pop();
+                int b = stack.pop();
+                stack.push(b - a);
+            } else if(c.equals("*")){
+                stack.push(stack.pop() * stack.pop());
+            } else if(c.equals("/")){
+                int a = stack.pop();
+                int b = stack.pop();
+                stack.push(b / a);
+            } else {
+                stack.push(Integer.parseInt(c));
+            }
+        }
+        return stack.pop();
+    }
+}

solutions/FindMinSortedArray.java

@@ -0,0 +1,16 @@
+public class FindMinSortedArray {
+    public int findMin(int[] nums){
+    int l = 0;
+    int r = nums.length - 1;
+
+    while(l < r){
+        int m = l + (r - l) / 2;
+        if (nums[m] < nums[r]) {
+            r = m;
+        } else {
+            l = m + 1;
+        }
+    }
+    return nums[l];
+    }
+}

solutions/Gen_Parentheses.java

@@ -0,0 +1,30 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class Solution {
+    private void backtrack(int openN, int closedN, int n, List<String> res, StringBuilder stack) {
+        if(openN == closedN && openN == n){
+            res.add(stack.toString());
+            return;
+        }
+
+        if(openN < closedN){
+            stack.append('(');
+            backtrack(openN + 1, closedN, n, res, stack);
+            stack.deleteCharAt(stack.length() - 1);
+        }
+
+        if(closedN < openN){
+            stack.append(')');
+            backtrack(openN, closedN + 1, n, res, stack);
+            stack.deleteCharAt(stack.length() - 1);
+        }
+
+        public List<String> generateParenthesis(int n){
+            List<String> res = new ArrayList<>();
+            StringBuilder stack = new StringBuilder();
+            backtrack(0, 0, n, res, stack);
+            return res;
+        }
+    }
+}

solutions/Group Anagrams.js

@@ -0,0 +1,24 @@
+class Solution {
+    /**
+     * @param {string[]} strs
+     * @return {string[][]}
+     */
+    groupAnagrams(strs) {
+        res = {};
+
+        for(let s in strs){
+           let count = Array(26).fill(0);
+
+           for(let letter in s){
+            count[letter.charCodeAt(0) - 'a'.charCodeAt(0)] += 1;
+           }
+           const key = count.join(',');
+
+           if(!res[key]){
+            res[key] = [];
+           }
+           res[key].push(s);
+        }
+        return Object.values(res);
+}
+}

solutions/Group_Anagram.java

@@ -0,0 +1,19 @@
+import java.util.*;
+
+public class Group_Anagram {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        Map<String, List<String>> res = new HashMap<>;
+
+        for (String s : strs) {
+            int[] count = new int[26];
+            for (char c : s.toCharArray()) {
+                count[c - 'a']++;
+            }
+
+            String key = Arrays.toString(count);
+            res.putIfAbsent(key, new ArrayList());
+            res.get(key).add(s);
+        }
+        return new ArrayList<>(res.values());
+    }
+}

solutions/KokoBananas.java

@@ -0,0 +1,25 @@
+import java.util.Arrays;
+
+public class KokoBananas {
+    public int minEatingSpeed(int[] piles, int h){
+        int l = 1;
+        int r = Arrays.stream(piles).max().getAsInt();
+        int res = r;
+
+        while(l <= r){
+            int k = (l + r) / 2;
+
+            int totalTime = 0;
+            for(int p : piles){
+                totalTime += Math.ceil((double) p / k);
+            }
+            if(totalTime <= h){
+                res = k;
+                r = k - 1;
+            } else{
+                l = k + 1;
+            }
+        }
+        return res;
+    }
+}

solutions/LConsSeq.java

@@ -0,0 +1,19 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        Map<Integer, Integer> mp = new HashMap<>();
+        int res = 0;
+
+        for(int num : nums){
+            if (!mp.containsKey(num)){
+                mp.put(num, mp.getOrDefault(num - 1, 0) + mp.getOrDefault(num + 1, 0) + 1);
+                mp.put(num - mp.getOrDefault(num - 1, 0), mp.get(num));
+                mp.put(num + mp.getOrDefault(num + 1, 0), mp.get(num));
+                res = Math.max(res, mp.get(num));
+            }
+        }
+        return res;
+    }
+}