More problem solving

Author: repl

src/main/java/array/AdvanceToEnd.java

@@ -0,0 +1,30 @@
+package array;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class AdvanceToEnd {
+    public static void main(String[] args) {
+        System.out.println(compute(Arrays.asList(3, 3, 1, 0, 2, 0, 1)));
+        System.out.println(compute(Arrays.asList(3, 2, 0, 0, 2, 0, 1)));
+        System.out.println(compute(Arrays.asList(2,3,5,5,7,11,11,11,13)));
+    }
+
+    public static boolean compute(List<Integer> input) {
+        return compute(input, input.size() - 1);
+    }
+
+    public static boolean compute(List<Integer> input, int endIndex) {
+        if (endIndex == 0) {
+            return true;
+        }
+        for (int i = endIndex - 1; i >= 0; i--) {
+            if (input.get(i) >= (endIndex - i)) {
+                if (compute(input, i)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

src/main/java/array/BackspaceStringCompare.java

@@ -0,0 +1,33 @@
+package array;
+
+import java.util.Arrays;
+
+public class BackspaceStringCompare {
+    public static void main(String[] args) {
+        String s = "ab#c", t = "ad#c";
+        System.out.println(compute(s, t));
+
+        System.out.println(compute("ab#d", "ad#b"));
+    }
+
+    public static boolean compute(String s, String t) {
+        return (getFinal(s).equals(getFinal(t)));
+    }
+
+    public static String getFinal(String s) {
+        int i = 0, x = -1;
+        char[] newS = new char[s.length()];
+        Arrays.fill(newS, ' ');
+        while (i < s.length()) {
+            if (s.charAt(i) == '#') {
+                if (x >= 0) {
+                    newS[x--] = ' ';
+                }
+            } else {
+                newS[++x] = s.charAt(i);
+            }
+            i++;
+        }
+        return new String(newS);
+    }
+}

src/main/java/array/BuySellStockTwice.java

@@ -0,0 +1,33 @@
+package array;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class BuySellStockTwice {
+    public static void main(String[] args) {
+        System.out.println(compute(Arrays.asList(12.0,11.0,13.0,9.0,12.0,8.0,14.0,13.0,15.0)));
+    }
+
+    public static Double compute(List<Double> prices) {
+        double maxTotalProfit = 0.0;
+        List<Double> firstBuySellProfits = new ArrayList<>();
+
+        double minPriceSoFar = Double.MAX_VALUE;
+        //compute first buy-sell profit by each day
+        for (int i = 0; i < prices.size();++i) {
+            minPriceSoFar = Math.min(minPriceSoFar, prices.get(i));
+            maxTotalProfit = Math.max(maxTotalProfit, prices.get(i) - minPriceSoFar);
+            firstBuySellProfits.add(maxTotalProfit);
+        }
+        // Backward phase. For each day, find the maximum profit if we make
+        // the second buy on that day.
+        double maxPriceSoFar = Double.MIN_VALUE;
+        for (int i = prices.size() - 1; i > 0; --i) {
+            maxPriceSoFar = Math.max(maxPriceSoFar , prices.get(i));
+            maxTotalProfit = Math.max(maxTotalProfit , maxPriceSoFar - prices.get(i)
+                                      + firstBuySellProfits.get(i - 1));
+        }
+        return maxTotalProfit;
+    }
+}

src/main/java/array/GroupEvenOdd.java

@@ -0,0 +1,30 @@
+package array;
+
+public class GroupEvenOdd {
+    public static void main(String[] args) {
+        int[] input = {1,2,3,4,5,6,7};
+        compute(input);
+        System.out.print("[");
+        for (int i = 0;i<input.length;i++) {
+            System.out.print(input[i]);
+        }
+        System.out.println("]");
+    }
+
+    public static void compute(int[] input) {
+        int i = 0, s = 0, e = input.length - 1;
+        while (i < e) {
+            int temp = input[i];
+            if (input[i] % 2 == 0) {
+                input[i] = input[s];
+                input[s] = temp;
+                s++;
+            } else {
+                input[i] = input[e];
+                input[e] = temp;
+                e--;
+            }
+            i++;
+        }
+    }
+}

src/main/java/array/IncrementInteger.java

@@ -0,0 +1,32 @@
+package array;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class IncrementInteger {
+    public static void main(String[] args) {
+        System.out.println(compute(Stream.of(1,2,3).collect(Collectors.toList())));
+        System.out.println(compute(Stream.of(9,9,9).collect(Collectors.toList())));
+    }
+
+    public static List<Integer> compute(List<Integer> input) {
+        int i = input.size() - 1;
+        while (i>=0) {
+            int val = input.get(i) + 1;
+            if (val == 10) {
+                input.set(i, 0);
+            } else {
+                input.set(i, val);
+                break;
+            }
+            i--;
+        }
+        if (i == -1) {
+            input.set(0, 0);
+            input.add(0, 1);
+        }
+        return input;
+    }
+}

src/main/java/array/IntersectionOfTwoArrays.java

@@ -0,0 +1,38 @@
+package array;
+
+import java.util.Arrays;
+import java.util.HashSet;
+
+public class IntersectionOfTwoArrays {
+    public static void main(String[] args) {
+        int[] nums1 = { 1, 2, 3, 4 };
+        int[] nums2 = { 3, 5, 6, 7 };
+        System.out.println(compute(nums1, nums2));
+    }
+
+    //Time = O(n), space=O(n)
+    public static Integer[] compute(int[] nums1, int[] nums2) {
+        HashSet<Integer> set1 = new HashSet<>();
+        for (int i: nums1) {
+            set1.add(i);
+        }
+        HashSet<Integer> intersectionSet = new HashSet<>();
+        for (int i: nums2) {
+            if (set1.contains(i)) {
+                intersectionSet.add(i);
+            }
+        }
+        return intersectionSet.toArray(Integer[]::new);
+    }
+
+    public static Integer[] compute2(int[] nums1, int[] nums2) {
+        Arrays.sort(nums2);
+        HashSet<Integer> intersectionSet = new HashSet<>();
+        for (int i=0;i<nums1.length;i++) {
+            if (Arrays.binarySearch(nums2, nums1[i]) > -1) {
+                intersectionSet.add(nums1[i]);
+            }
+        }
+        return intersectionSet.toArray(Integer[]::new);
+    }
+}

src/main/java/array/IntervalListIntersections.java

@@ -0,0 +1,59 @@
+package array;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class IntervalListIntersections {
+    public static void main(String[] args) {
+        Interval[] a = {new Interval(0,2), new Interval(5,10), new Interval(13,23), new Interval(24,25)};
+        Interval[] b = {new Interval(1,5), new Interval(8,12), new Interval(15, 24), new Interval(25,26)};
+
+        Interval[] output = compute(a, b);
+        System.out.println("[");
+        for (int i = 0; i < output.length;i++) {
+            System.out.println(String.format("(%d, %d), ", output[i].s, output[i].e));
+        }
+        System.out.println("]");
+    }
+
+    public static Interval[] compute(Interval[] a, Interval[] b) {
+        List<Interval> result = new ArrayList<>();
+        int aIdx = 0, bIdx = 0;
+        Interval addition = null;
+        while (aIdx < a.length && bIdx < b.length) {
+            int as = a[aIdx].s;
+            int ae = a[aIdx].e;
+            int bs = b[bIdx].s;
+            int be = b[bIdx].e;
+            if (ae < bs) {
+                //if a is before b, then increment aIdx
+                aIdx++;
+            } else if (as > be) {
+                //if a is after b, then increment bIdx
+                bIdx++;
+            } else if (as <= bs && ae >= bs && ae <= be) {
+                //If rear of a overlaps with b
+                addition = new Interval(bs, ae);
+                aIdx++;
+            } else if (as >= bs && ae <= be) {
+                //If a is within b
+                addition = new Interval(as, ae);
+                aIdx++;
+            } else if (bs <= as && be >= as && be <= ae) {
+                //if rear of b overlaps with a
+                addition = new Interval(as, be);
+                bIdx++;
+            } else if (bs >= as && be <= ae) {
+                //if b is within a
+                addition = new Interval(bs, be);
+                bIdx++;
+            }
+            if (addition != null) {
+                System.out.println("Adding: " + addition.s + ", " + addition.e);
+                result.add(addition);
+                addition = null;
+            }
+        }
+        return result.toArray(Interval[]::new);
+    }
+}

src/main/java/array/PartitionOnPivot.java

@@ -0,0 +1,27 @@
+package array;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class PartitionOnPivot {
+    public static void main(String[] args) {
+        List<Integer> array = Arrays.asList(0,1,2,0,2,1,1);
+        System.out.println(compute(array, 3));
+    }
+
+    public static List<Integer> compute(List<Integer> input, int pivot) {
+        int j = input.size() - 1, n = 0;
+        int pv = input.get(pivot);
+        while (n < j) {
+            if (input.get(n) > pv) {
+                int temp = input.get(n);
+                input.set(n, input.get(j));
+                input.set(j, temp);
+                j--;
+            } else {
+                n++;
+            }
+        }
+        return input;
+    }
+}

src/main/java/array/Permutation.java

@@ -0,0 +1,39 @@
+package array;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class Permutation {
+    public static void main(String[] args) {
+        System.out.println(compute(Stream.of(1,2,3).collect(Collectors.toList())));
+    }
+
+    public static List<List<Integer>> compute(List<Integer> a) {
+        return compute(a, 0, a.size() - 1);
+    }
+
+    public static List<List<Integer>> compute(List<Integer> a, int s, int e) {
+        if (s >= e) {
+            List<Integer> newList = new ArrayList<>();
+            newList.addAll(a);
+            return Arrays.asList(newList);
+        }
+        List<List<Integer>> res = new ArrayList<>();
+        for (int i = s; i <= e; i++) {
+            swap(a, s, i);
+            res.addAll(compute(a, s + 1, e));
+            swap(a, i, s);
+        }
+        return res;
+    }
+
+    public static void swap(List<Integer> a, int x, int y) {
+        int temp = a.get(x);
+        a.set(x, a.get(y));
+        a.set(y, temp);
+    }
+}

src/main/java/array/SearchInsertPosition.java

@@ -0,0 +1,49 @@
+package array;
+
+public class SearchInsertPosition {
+    public static void main(String[] args) {
+
+        int[] input = { 1, 3, 5, 6 };
+        System.out.println("Result for " + input + " is " + compute(input, 5));
+        int[] input2={1,3,5,6};
+        System.out.println("Result for " + input2 + " is " + compute(input2, 2));
+        int[] input3 = { 1, 3, 5, 6 };
+        System.out.println("Result for " + input3 + " is " + compute(input3, 7));
+        int[] input4 = { 1, 3, 5, 6 };
+        System.out.println("Result for " + input4 + " is " + compute(input4, 0));
+    }
+
+    public static int compute(int[] input, int k) {
+        return bs(input, k, 0, input.length - 1);
+    }
+
+    public static int bs(int[] input, int k, int l, int r) {
+        if (l>r) {
+            return l;
+        }
+        if (input[l] == k) {
+            return l;
+        } else if (input[r] == k) {
+            return r;
+        } else {
+            if (l == r) {
+                if (k < input[l]) {
+                    return l;
+                } else if (k > input[l]) {
+                    return l + 1;
+                } else {
+                    return l;
+                }
+            } else {
+                int m = l + (r - 1) / 2;
+                if (input[m] == k) {
+                    return m;
+                } else if (k < input[m]) {
+                    return bs(input, k, l, m - 1);
+                } else {
+                    return bs(input, k, m + 1, r);
+                }
+            }
+        }
+    }
+}