Some changes

Author: Tushar Roy

src/com/interview/array/MaxProductSubarray.java

@@ -15,26 +15,34 @@
 public class MaxProductSubarray {
 
     public int maxProduct(int[] nums) {
-        int min = 1;
-        int max = 1;
-        int maxSoFar = nums[0];
+        //neg maintains the multiplication which is negative since last 0
+        //pos maintains the multiplication which is positive since last 0
+        int neg = 1;
+        int pos = 1;
+        int maxProduct = nums[0];
         for (int i = 0; i < nums.length; i++) {
-            if (nums[i] > 0) {
-                max = max * nums[i];
-                min = Math.min(min * nums[i], 1);
-                maxSoFar = Math.max(maxSoFar, max);
-            } else if (nums[i] == 0) {
-                min = 1;
-                max = 1;
-                maxSoFar = Math.max(maxSoFar, 0);
+            if (nums[i] == 0) {
+                neg = 1;
+                pos = 1;
+                maxProduct = Math.max(maxProduct, 0);
+            } else if (nums[i] < 0) {
+                int temp = pos;
+                if (neg < 0) {
+                    pos = neg * nums[i];
+                    maxProduct = Math.max(pos, maxProduct);
+                } else {
+                    pos = 1;
+                }
+                neg = temp * nums[i];
             } else {
-                int t = max * nums[i];
-                maxSoFar = Math.max(maxSoFar, min * nums[i]);
-                max = Math.max(1, min*nums[i]);
-                min = t;
+                if (neg < 0) {
+                    neg *= nums[i];
+                }
+                pos *= nums[i];
+                maxProduct = Math.max(pos, maxProduct);
             }
         }
-        return maxSoFar;
+        return maxProduct;
     }
 
     public static void main(String args[]){

src/com/interview/array/MultiplyAllFieldsExceptOwnPosition.java

@@ -1,8 +1,7 @@
 package com.interview.array;
 
 /**
- * http://www.careercup.com/question?id=5179916190482432
- * Look out for division by 0
+ * https://leetcode.com/problems/product-of-array-except-self/
  */
 public class MultiplyAllFieldsExceptOwnPosition {
 
@@ -11,17 +10,15 @@ public int[] multiply(int nums[]) {
             return new int[0];
         }
         int[] output = new int[nums.length];
-        int product = nums[0];
+        output[0] = 1;
         for (int i = 1; i < nums.length; i++) {
-            output[i] = product;
-            product *= nums[i];
+            output[i] = output[i - 1] * nums[i - 1];
         }
 
-        output[0] = 1;
-        product = nums[nums.length - 1];
-        for (int i = nums.length - 2; i >= 0; i--) {
-            output[i] *= product;
-            product *= nums[i];
+        int mult = 1;
+        for (int i = nums.length - 1; i >= 0; i--) {
+            output[i] *= mult;
+            mult *= nums[i];
         }
         return output;
     }

src/com/interview/binarysearch/MinimumInSortedRotatedArray.java

@@ -1,15 +1,15 @@
 package com.interview.binarysearch;
 
 /**
- * Created by tushar_v_roy on 3/21/16.
+ * https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
  */
 public class MinimumInSortedRotatedArray {
     public int findMin(int[] nums) {
         int low = 0;
         int high = nums.length - 1;
         while (low < high) {
             int middle = (low + high)/2;
-            if ((middle == 0 || nums[middle] < nums[middle - 1]) && (middle == nums.length - 1 || nums[middle] < nums[middle + 1])) {
+            if ((middle == 0 && nums[middle] < nums[middle + 1]) || (middle > 0 && nums[middle] < nums[middle - 1])) {
                 return nums[middle];
             }
             else if (nums[middle] > nums[high]) {
@@ -18,7 +18,6 @@ else if (nums[middle] > nums[high]) {
                 high = middle - 1;
             }
         }
-
         return nums[low];
     }
 }

src/com/interview/multithreaded/DependencyTaskExecutor.java

@@ -10,6 +10,7 @@
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.RunnableFuture;
 
 /**
  * Given a Task with list of its dependencies and execute method. Run the task such that dependencies are executed first.
@@ -106,4 +107,32 @@ public void execute() {
             e.printStackTrace();
         }
     }
+}
+
+class FutureTask implements Runnable {
+
+    Task task;
+    List<FutureTask> chainedTasks = new ArrayList<>();
+    Executor executor;
+    FutureTask(Task task, Executor executor) {
+        this.task = task;
+        this.executor = executor;
+    }
+    @Override
+    public void run() {
+        task.execute();
+        for (FutureTask t : chainedTasks) {
+            supplyAsync(t, executor);
+        }
+    }
+
+    void supplyAsync(FutureTask task, Executor executor) {
+        executor.execute(task);
+    }
+
+    void addChain(FutureTask task) {
+        task.addChain(this);
+    }
+
+
 }

src/com/interview/recursion/OptimalDivision.java

@@ -0,0 +1,70 @@
+package com.interview.recursion;
+
+/**
+ * Date 05/09/2017
+ * @author Tushar Roy
+ *
+ * https://leetcode.com/problems/optimal-division/#/description
+ */
+public class OptimalDivision {
+    public String optimalDivision(int[] nums) {
+        Result r = optimalDivison(nums, 0, nums.length - 1, true);
+        System.out.println(r.val);
+        return r.str;
+    }
+
+    private Result optimalDivison(int[] nums, int start, int end, boolean maximize) {
+        if (start == end) {
+            return new Result(nums[start], String.valueOf(nums[start]));
+        }
+
+        double maxResult = 0;
+        double minResult = Double.MAX_VALUE;
+        String result = "";
+        int cutI = start;
+        String part1 = "";
+        String part2 = "";
+        for (int i = start; i < end; i++) {
+            Result d1 = optimalDivison(nums, start, i, maximize);
+            Result d2 = optimalDivison(nums, i + 1, end, !maximize);
+            double val = d1.val / d2.val;
+            if (maximize) {
+                if (maxResult < val) {
+                    maxResult = val;
+                    part1 = d1.str;
+                    part2 = d2.str;
+                    cutI = i;
+                }
+            } else {
+                if (minResult > val) {
+                    minResult = val;
+                    part1 = d1.str;
+                    part2 = d2.str;
+                    cutI = i;
+                }
+            }
+        }
+        if (cutI < end - 1) {
+            result = part1 + "/(" + part2 + ")";
+        } else {
+            result = part1 + "/" + part2;
+        }
+        return maximize ? new Result(maxResult, result) : new Result(minResult, result);
+    }
+
+    class Result {
+        double val;
+        String str;
+        Result(double val, String str) {
+            this.val = val;
+            this.str = str;
+        }
+    }
+
+    public static void main(String args[]) {
+       // int[] nums = {1000, 100, 10, 2};
+        int[] nums = {6,2,3,4,5};
+        OptimalDivision od = new OptimalDivision();
+        System.out.println(od.optimalDivision(nums));
+    }
+}