more problems and solutions

Author: repl

.gitignore

@@ -33,4 +33,5 @@ HELP.md
 ensime-langserver.log
 .ensime_cache
 
-target/
+target/
+bin/

src/main/java/array/Candy.java

@@ -1,6 +1,13 @@
 package array;
 
 public class Candy {
+    /*
+      There are N children standing in a line. Each child is assigned a rating value. You are
+      giving candies to these children subjected to the following requirements:
+      1. Each child must have at least one candy. 2. Children with a higher rating get
+      more candies than their neighbors.
+      What is the minimum candies you must give?    
+     */
     public static void main(String[] args) {
 
     }

src/main/java/array/ContainerWithMostWater.java

@@ -1,27 +1,37 @@
 package array;
 
-class ContainerCoord {
-    float x;
-    float y;
-    public ContainerCoord(float x, float y) {
-        this.x = x;
-        this.y = y;
-    }
-}
-
 public class ContainerWithMostWater {
+    /*
+      Given n non-negative integers a1, a2, ..., an, where each represents a point at coordinate
+      (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai)
+      and (i, 0). Find two lines, which together with x-axis forms a container, such that the
+      container contains the most water.
+
+      Initially we can assume the result is 0. Then we scan from both sides. 
+      If leftHeight < rightHeight, move right and find a value that is greater than leftHeight. 
+      if leftHeight > rightHeight, move left and find a value that is greater than rightHeight.
+      Additionally, keep tracking the max value.
+     */    
     public static void main(String[] args) {
-        ContainerCoord c1 = new ContainerCoord(0, 1);
-        ContainerCoord c2 = new ContainerCoord(1, 2);
-        ContainerCoord c3 = new ContainerCoord(2, 3);
-        ContainerCoord c4 = new ContainerCoord(3, 2);
-        ContainerCoord c5 = new ContainerCoord(4, 2.5f);
-        ContainerCoord c6 = new ContainerCoord(5, 2);
-        ContainerCoord c7 = new ContainerCoord(6, 4);
-        ContainerCoord c8 = new ContainerCoord(7, 2);
+        System.out.println(compute(new int[]{1,2,4,2,3,2,5,2}));
+        System.out.println(compute(new int[]{1,1,3,2,4,1,4,2,2,3}));                                   
+    }
 
-        
-        System.out.println();
+    public static int compute(int[] arr) {
+        if (arr == null || arr.length < 2) {
+            return 0;
+        }
+        int max = 0;
+        int left = 0;
+        int right = arr.length - 1;
+        while (left < right) {
+            max = Math.max(max, (right - left) * Math.min(arr[left], arr[right]));
+            if (arr[left] <arr[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+        return max;
     }
-    
 }

src/main/java/array/BinarySearchOutOfOrder.java renamed to src/main/java/array/ElementMatchingFunction.java

@@ -2,7 +2,8 @@
 
 import java.util.*;
 
-/* Find index in a binary search array where value at the index is same as index.
+/* Find elements in an array which satisfied given function definition:
+   Function will return true for value x, if all numbers on left side of x are small and all number on  the right side of x are greater. 
 
 From: https://www.geeksforgeeks.org/google-interview-experience-for-sde-1/
 Example: [ 4, 3, 1, 5, 7, 6, 10]
@@ -11,7 +12,7 @@
 Space Complexity: O(n)
 */
 
-public class BinarySearchOutOfOrder {
+public class ElementMatchingFunction {
     public static void main(String[] args) {
 
         int[] input = {4, 3, 1, 5, 7, 6, 10};

src/main/java/array/MinimumSizeSubArraySum.java

@@ -0,0 +1,38 @@
+package array;
+
+public class MinimumSizeSubArraySum {
+    /* Given an array of integers and a integer s, find the length of the minimum subarray whose sum is greater or same as s.
+
+       For example, int array = 2,3,1,2,4,3, and S = 7, result would be 2 (for subarray 4,3)
+     */
+    public static void main(String args[ ])  { 
+         System.out.println( compute(new int[]{2,3,1,2,4,3}, 7) );
+    }
+
+    private static int compute(int[] arr, int s) {
+        int min = Integer.MAX_VALUE;
+        int l = 0, r = 0;
+        int sum = arr[l];
+        if (sum >= s) {
+          min = 1;
+          r = 1;
+          sum = sum + arr[r];
+        }
+        do {
+            System.out.println("l: " + l + ", r: " + r + ", sum: " + sum);
+            if (sum >= s) {
+                if (r - l + 1 < min) {
+                    min = r - l + 1;
+                }
+                sum = sum - arr[l];
+                l++;
+            } else {
+               r++;
+               if (r < arr.length) {
+                  sum = sum + arr[r];
+               }
+            }
+        } while (l < r && r < arr.length);
+        return (min == Integer.MAX_VALUE)? 0: min;
+    }
+}

src/main/java/array/PairWithGivenSum.java

@@ -19,7 +19,7 @@ public static void main(String args[]) {
 
             int sum = sc.nextInt();
 
-            Stack<String> res = compute(n, arr, sum);
+            Stack<String> res = compute2(n, arr, sum);
             if (res.empty()) {
                 System.out.println("-1");
             } else {
@@ -30,6 +30,7 @@ public static void main(String args[]) {
         }
     }
 
+    /* Using OBhashmap */
     public static Stack<String> compute(int n, int[] arr, int sum) {
         Stack<String> res = new Stack<>();
         int resIndex = 0;
@@ -43,5 +44,25 @@ public static Stack<String> compute(int n, int[] arr, int sum) {
         }
         return res;
     }
+
+    /* If input is sorted */
+    public static Stack<String> compute2(int n, int[] arr, int sum) {
+        Stack<String> res = new Stack<>();
+        int i = 0;
+        int j = arr.length - 1;
+        while (i<j) {
+            int x = arr[i] + arr[j];
+            if (x < sum) {
+                i++;
+            } else if (x > sum) {
+                j--;
+            } else {
+                res.push(arr[i] + ", " + arr[j]);
+                i++;
+                j--;
+            }
+        }
+        return res;
+    }
 }
 

src/main/java/array/ThreeSumClosest.java

@@ -0,0 +1,45 @@
+package array;
+
+import java.util.*;
+
+public class ThreeSumClosest {
+    /*
+      Given an array S of n integers, find three integers in S such that the sum is closest to a
+      given number, target. Return the sum of the three integers. You may assume that each
+      input would have exactly one solution.
+    
+      For example, given array S = {-1 2 1 -4}, and target = 1.
+      The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
+     */
+    public static void main(String[] args) {
+        System.out.println ( threeSum(new int[]{ -1, 0, 1, 2, -1, -4}, 4));
+    }
+
+    private static int threeSum(int[] input, int target) {
+        Arrays.sort(input);
+        int min = Integer.MAX_VALUE;
+        int result = 0;
+        
+        for(int i=0;i<input.length-2;i++) {
+            int start = i+1;
+            int end = input.length-1;
+            while (start < end) {
+                int sum = input[i] + input[start] + input[end];
+                int diff = Math.abs(sum - target);
+                if (diff == 0) {
+                    return sum;
+                }
+                if (diff < min) {
+                    min = diff;
+                    result = sum;
+                }
+                if (sum < target) {
+                    start++;
+                } else {
+                    end--;
+                }
+            }
+        }
+        return result;
+    }
+}

src/main/java/array/TrappingRainWater.java

@@ -0,0 +1,20 @@
+package array;
+
+public class TrappingRainWater {
+    /*
+      Given n non-negative integers representing an elevation map where the width of each
+      bar is 1, compute how much water it is able to trap after raining.
+      For example, given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.
+     */    
+    public static void main(String[] args) {
+        System.out.println(compute(new int[]{1,2,4,2,3,2,5,2}));
+    }
+
+    public static int compute(int[] arr) {
+        if (arr == null || arr.length < 2) {
+            return 0;
+        }
+        //TODO 
+        return 0;
+    }
+}

src/main/java/dynamicprogramming/BalloonBurst.java

@@ -0,0 +1,35 @@
+package dynamicprogramming;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BalloonBurst {
+    public static void main(String[] args) {
+        System.out.println(maxCoinsNaive(new int[]{3,5,8}));
+    }
+
+    public static int maxCoinsNaive(int[] nums) {
+        List<Integer> balloons = new ArrayList<>();
+        for (int i = 0; i < nums.length; i++)
+            balloons.add(nums[i]);
+        return maxCoinNaiveRec(balloons);
+    }
+
+    public static int maxCoinNaiveRec(List<Integer> balloons) {
+        int max = 0;
+        int listSize = balloons.size();
+        int i = 0;
+        while(i < listSize) {
+            int left = (i == 0) ? 1 : balloons.get(i - 1);
+            int right = (i == listSize - 1) ? 1 : balloons.get(i + 1);
+            int n = left * balloons.get(i) * right;
+            List<Integer> tmp = new ArrayList<>(balloons);
+            tmp.remove(i);
+            max = Math.max(max, n + maxCoinNaiveRec(tmp));
+            i++;
+        }
+        System.out.println("list:" + balloons + ", max:" + max);
+        return max;
+    }
+
+}

src/main/java/dynamicprogramming/Fibonacci.java

@@ -18,8 +18,8 @@ public static void main(String[] args) {
 	}
 
 	void initialize() {
-                for (int i = 0; i < MAX; i++) {
-                        lookup[i] = NIL;
+        for (int i = 0; i < MAX; i++) {
+            lookup[i] = NIL;
 		}
 	}
 

src/main/java/dynamicprogramming/LongestPalindromicSubString.java

@@ -0,0 +1,27 @@
+package dynamicprogramming;
+
+public class LongestPalindromicSubString {
+    /*
+      https://leetcode.com/problems/longest-palindromic-substring/
+      Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.
+      Example 1:
+    
+      Input: "babad"
+      Output: "bab"
+      Note: "aba" is also a valid answer.
+    
+      Example 2:
+    
+      Input: "cbbd"
+      Output: "bb"    
+    */
+    public static void main(String[] args) {
+        LongestPalindromicSubString instance = new LongestPalindromicSubString();
+        System.out.println(instance.longestPalindrome("babad"));
+        System.out.println(instance.longestPalindrome("cbbd"));
+    }
+
+    public String longestPalindrome(String s) {
+        return null;
+    }
+}

src/main/java/dynamicprogramming/SharingChocolateBar.java

@@ -16,6 +16,8 @@ public class SharingChocolateBar {
      * sweetness level 7, 7, 9, 9 respectively)
      */
     public static void main(String[] args) {
-        
+        int numBars = 7;
+        int[] sweetness = {1, 2, 4, 7, 3, 6, 9};
+
     }
 }

src/main/java/graph/CloneGraph.java

@@ -0,0 +1,35 @@
+package graph;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
+public class CloneGraph {
+    public static void main(String[] args) {
+        GraphNode n4 = new GraphNode("4");
+        GraphNode n3 = new GraphNode("3", Arrays.asList(n4));
+        GraphNode n2 = new GraphNode("2", Arrays.asList(n3, n4));
+        GraphNode n1 = new GraphNode("1", Arrays.asList(n2, n4));
+
+        LinkedList<GraphNode> queue = new LinkedList<>();
+        Map<GraphNode, GraphNode> map = new HashMap<>();
+        queue.add(n1);
+        GraphNode newHead = new GraphNode(n1.label);
+        map.put(n1, newHead);
+        while (!queue.isEmpty()) {
+            GraphNode n = queue.pop();
+            System.out.println("Next: " + n.label);
+            for (GraphNode neighborNode: n.neighbours) {
+                if (map.getOrDefault(neighborNode, null) == null) {
+                    GraphNode newNode = new GraphNode(neighborNode.label);
+                    map.put(neighborNode, newNode);
+                    map.get(n).neighbours.add(newNode);
+                    queue.add(neighborNode);
+                } else {
+                    map.get(n).neighbours.add(map.get(neighborNode));
+                }
+            }
+        }
+    }
+}

src/main/java/graph/GraphNode.java

@@ -0,0 +1,21 @@
+package graph;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public class GraphNode {
+    public String label;
+    public List<GraphNode> neighbours;
+    public boolean visited;
+    public GraphNode next;
+
+    public GraphNode(String value) {
+        label = value;
+        neighbours = new ArrayList<GraphNode>();
+    }
+
+    public GraphNode(String value, List<GraphNode> n) {
+        label = value;
+        neighbours = n;
+    }
+}