Added

Author: kavyashreeshah

Resources/S03 - Arrays/Best Time to Buy and Sell Stock.java

@@ -0,0 +1,17 @@
+class Solution {
+    public int maxProfit(int[] prices) {
+        int minSoFar = prices[0];
+        int ans = 0;
+        
+        for(int i = 1; i < prices.length; i++) {
+            int profit = prices[i] - minSoFar;
+            if (profit > ans) {
+                ans = profit;
+            }
+            
+            minSoFar = Math.min(prices[i], minSoFar);
+        }
+        
+        return ans;
+    }
+}

Resources/S03 - Arrays/Encode And Decode Strings.java

@@ -0,0 +1,49 @@
+public class Codec {
+
+    public String encode(List<String> strs) {
+        StringBuilder sb = new StringBuilder();
+        for (String s : strs) {
+            int i = 0;
+            while (i < s.length()) {
+                if (s.charAt(i) == ';') {
+                    sb.append("/;");
+                }
+                else if (s.charAt(i) == '/') {
+                    sb.append("//");
+                }
+                else {
+                    sb.append(s.charAt(i));
+                }
+                i++;
+            }
+            sb.append(";");
+        }
+
+        return sb.toString();
+    }
+
+    public List<String> decode(String s) {
+        List<String> decodedStrings = new ArrayList<>();
+
+        StringBuilder currentString = new StringBuilder();
+
+        int i = 0;
+        while (i < s.length()) {
+            if (s.charAt(i) == '/') {
+                currentString.append(s.charAt(i + 1));
+                i += 2;
+            }
+            else if (s.charAt(i) != ';') {
+                currentString.append(s.charAt(i));
+                i++;
+            }
+            else {
+                decodedStrings.add(currentString.toString());
+                currentString.setLength(0);
+                i++;
+            }
+        }
+
+        return decodedStrings;
+    }
+}

Resources/S03 - Arrays/K Closest Points To Origin.java

@@ -0,0 +1,51 @@
+import java.util.Random;
+
+class Solution {
+    public int[][] kClosest(int[][] points, int k) {
+        int left = 0, right = points.length - 1;
+        while (left <= right) {
+            int pivotIndex = partition(points, left, right);
+            if (pivotIndex == k - 1) {
+                break;
+            } else if (pivotIndex < k - 1) {
+                left = pivotIndex + 1;
+            } else {
+                right = pivotIndex - 1;
+            }
+        }
+
+        int[][] result = new int[k][2];
+        for (int i = 0; i < k; i++) {
+            result[i] = points[i];
+        }
+
+        return result;
+    }
+
+    private int partition(int[][] points, int left, int right) {
+        int pivotIndex = left + new Random().nextInt(right - left + 1);
+        int[] pivotPoint = points[pivotIndex];
+        swap(points, pivotIndex, right);
+
+        int i = left;
+        for (int j = left; j < right; j++) {
+            if (compare(points[j], pivotPoint) < 0) {
+                swap(points, i++, j);
+            }
+        }
+        swap(points, i, right);
+        return i;
+    }
+
+    private int compare(int[] point1, int[] point2) {
+        return (point1[0] * point1[0] + point1[1] * point1[1]) -
+               (point2[0] * point2[0] + point2[1] * point2[1]);
+    }
+
+    private void swap(int[][] points, int i, int j) {
+        int[] temp = points[i];
+        points[i] = points[j];
+        points[j] = temp;
+    }
+}
+

Resources/S03 - Arrays/Max Consecutive Ones_1.java

@@ -0,0 +1,20 @@
+class Solution {
+    public int findMaxConsecutiveOnes(int[] nums) {
+        int ans = 0;
+        int count = 0;
+        
+        for(int i = 0; i < nums.length; i++) {
+            if (nums[i] == 0) {
+                count = 0;
+            }
+            else {
+                count++;
+            }
+            if (count > ans) {
+                ans = count;
+            }
+        }
+        
+        return ans;
+    }
+}

Resources/S03 - Arrays/Maximum Product Subarray_1.java

@@ -0,0 +1,28 @@
+class Solution {
+    public int maxProduct(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
+        
+        int maxProduct = nums[0];
+        int minProduct = nums[0];
+        
+        int result = nums[0];
+        
+        for(int i = 1; i < nums.length; i++) {
+            if (nums[i] >= 0) {
+                maxProduct = Math.max(nums[i], maxProduct * nums[i]);
+                minProduct = Math.min(nums[i], minProduct * nums[i]);
+            }
+            else {
+                int temp = maxProduct;
+                maxProduct = Math.max(nums[i], minProduct * nums[i]);
+                minProduct = Math.min(nums[i], temp * nums[i]);
+            }
+            
+            result = Math.max(result, maxProduct);
+        }
+        
+        return result;
+    }
+}

Resources/S03 - Arrays/Product Of Array Except Self_1.java

@@ -0,0 +1,27 @@
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int[] left = new int[nums.length];
+        int[] right = new int[nums.length];
+        
+        int[] output = new int[nums.length];
+        
+        int n = nums.length;
+        
+        left[0] = 1;
+        right[n-1] = 1;
+        
+        for(int i = 1; i < n; i++) {
+            left[i] = left[i-1]*nums[i-1];
+        }
+        
+        for(int i = n - 2; i >= 0; i--) {
+            right[i] = right[i+1]*nums[i+1];
+        }
+        
+        for(int i = 0; i < n; i++) {
+            output[i] = left[i]*right[i];
+        }
+        
+        return output;
+    }
+}

Resources/S03 - Arrays/Rotate Array.java

@@ -0,0 +1,22 @@
+class Solution {
+    public void rotate(int[] nums, int k) {
+        
+        int n = nums.length;
+        k = k%n;
+        reverse(nums, 0, n - 1);
+        reverse(nums, 0, k - 1);
+        reverse(nums, k, n - 1);
+    }
+    
+    void reverse(int[] nums, int start, int end) {
+        int i = start, j = end;
+        
+        while (i < j) {
+            int temp = nums[i];
+            nums[i] = nums[j];
+            nums[j] = temp;
+            i++;
+            j--;
+        }
+    }
+}

Resources/S03 - Arrays/Valid Sudoku_1.java

@@ -0,0 +1,37 @@
+class Solution {
+    public boolean isValidSudoku(char[][] board) {
+        Set<Character>[] rowSet = new HashSet[9];
+        Set<Character>[] colSet = new HashSet[9];
+        Set<Character>[] gridSet = new HashSet[9];
+        
+        for(int i = 0; i < 9; i++) {
+            rowSet[i] = new HashSet<>();
+            colSet[i] = new HashSet<>();
+            gridSet[i] = new HashSet<>();
+            
+        }
+        
+        for(int i = 0; i < 9; i++) {
+            for(int j = 0; j < 9; j++) {
+                int gridNo = (i/3)*3 + (j/3);
+                
+                if (board[i][j] != '.') {
+                    boolean isPresentInRow = rowSet[i].contains(board[i][j]);
+                    boolean isPresentInCol = colSet[j].contains(board[i][j]);
+                    boolean isPresentInGrid = gridSet[gridNo].contains(board[i][j]);
+                    
+                    if (isPresentInRow || isPresentInCol || isPresentInGrid) {
+                        return false;
+                    }
+                    
+                    rowSet[i].add(board[i][j]);
+                    colSet[j].add(board[i][j]);
+                    gridSet[gridNo].add(board[i][j]);
+                }
+            }
+        }
+        
+        return true;
+      
+    }
+}

Resources/S03 - Arrays/maximum sum subarray.java

@@ -0,0 +1,18 @@
+class Solution {
+    public int maxSubArray(int[] nums) {
+        int maxSoFar = nums[0];
+        int currentSum = nums[0];
+        
+        for(int i = 1; i < nums.length; i++) {
+            if (currentSum < 0) {
+                currentSum = 0;
+            }
+            currentSum = currentSum + nums[i];
+            if (currentSum > maxSoFar) {
+                maxSoFar = currentSum;
+            }
+        }
+        
+        return maxSoFar;
+    }
+}

Resources/S04 - Sort/Sort Colors.java

@@ -0,0 +1,29 @@
+class Solution {
+public int[] sortColors(int[] nums) {
+
+        int[] hash = new int[3];
+        Arrays.fill(hash, 0);
+
+
+        int i = 0;
+        while (i < nums.length) {
+            if (nums[i] == 0) hash[0] = hash[0] + 1;
+            if (nums[i] == 1) hash[1] = hash[1] + 1;
+            if (nums[i] == 2) hash[2] = hash[2] + 1;
+
+            i++;
+        }
+        i = 0;
+        int k = 0;
+        while (i < hash.length) {
+            int j = hash[i];
+            while (j > 0) {
+                nums[k] = i;
+                k++;
+                j--;
+            }
+            i++;
+        }
+        return nums;
+    }
+}