More problems

Author: repl

src/main/java/array/ConvertToBiggestNum.java

@@ -0,0 +1,24 @@
+package array;
+
+import java.util.Comparator;
+import java.util.*;
+
+public class ConvertToBiggestNum {
+    /* Write a function that takes a number as input and outputs the biggest number with the same set of digits. */
+
+    public static void main(String[] args) {
+        int input = 423865;
+        System.out.println(convert(input));
+    }
+
+    public static int convert(int n) {
+        String strN = String.valueOf(n);
+        char[] arrN = strN.toCharArray();
+        Arrays.sort(arrN);
+        StringBuilder strBuilder = new StringBuilder();
+        for (int i = arrN.length - 1; i >= 0; i--) {
+            strBuilder.append(arrN[i]);
+        }
+        return Integer.parseInt(strBuilder.toString());
+    }
+}

src/main/java/array/InsertInterval.java

@@ -0,0 +1,69 @@
+package array;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public class InsertInterval {
+    /*
+      LeetCode 57. Insert Interval    
+      Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).
+    
+      You may assume that the intervals were initially sorted according to their start times.
+    
+      Example 1:
+    
+      Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
+      Output: [[1,5],[6,9]]
+    
+      Example 2:
+    
+      Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
+      Output: [[1,2],[3,10],[12,16]]
+      Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].    
+     */
+    public static class Tuple {
+        int x, y;
+        public Tuple(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+        public String toString() {
+            return "[" + x + "," + y + "]";
+        }
+    }
+    public static void main(String[] args) {
+        int[][] intervals = { { 1, 2 }, { 3, 5 }, { 6, 7 }, { 8, 10 }, { 12, 16 } };
+        int[] newInterval = {4,8};
+
+        InsertInterval instance = new InsertInterval();
+        instance.insert(intervals, newInterval);
+    }
+
+    public int[][] insert(int[][] intervals, int[] newInterval) {
+        List<Tuple> result = new ArrayList<>();
+        boolean started = false;
+        boolean ended = false;
+        int startVal = 0;
+        for (int i = 0;i<intervals.length;i++) {
+            int[] next = intervals[i];
+            if (newInterval[0] >= next[0] && newInterval[0] <= next[1]) {
+                if (newInterval[1] <= next[1]) {
+                    result.add(new Tuple(next[0], next[1]));
+                } else {
+                    //net interval starts at this interval and continues
+                    started = true;
+                    startVal = next[0];
+                }
+            } else if (newInterval[0] < next[0]) {
+                if (started && newInterval[1] <= next[1]) {                    
+                    result.add(new Tuple(startVal, next[1]));
+                    ended = true;
+                }
+            } else if (ended) {
+                result.add(new Tuple(next[0], next[1]));
+            }
+        }
+        System.out.println(result);
+        return null;
+    }    
+}

src/main/java/array/MergeInterval.java

@@ -0,0 +1,65 @@
+package array;
+
+import java.util.*;
+
+public class MergeInterval {
+    public static void main(String[] args) {
+        /*
+          Given a collection of intervals, merge all overlapping intervals.
+
+          For example,
+          Given [1,3],[2,6],[8,10],[15,18],
+          return [1,6],[8,10],[15,18].        
+         */
+        int[][] input = { { 1, 3 }, { 2, 6 }, { 8, 10 }, { 15, 18 } };
+        int[][] output = mergeInterval(input);
+        System.out.print("\n[");
+        for (int i = 0; i< output.length; i++) {
+            if (i > 0) {
+                System.out.print(", ");
+            }
+            System.out.print("[" + output[i][0] + "," + output[i][1] + "]");
+        }
+        System.out.print("]\n");
+    }
+
+    static class Tuple {
+        int x;
+        int y;
+        public Tuple(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+        public String toString() {
+            return "[" + x + "," + y + "]";
+        }
+    }
+    public static int[][] mergeInterval(int[][] input) {
+        List<Tuple> collect = new ArrayList<>();
+        int l = input[0][0], h = input[0][1];
+        for (int i=1;i<input.length;i++) {
+            boolean l_mod = false, h_mod = false;
+            if (input[i][0] > l && input[i][1] < h) {
+                continue;
+            } else if (input[i][0] < l && input[i][1] > h) {
+                l = input[i][0];
+                h = input[i][1];
+            } else if (input[i][0] > l && input[i][0] < h && input[i][1] > h) {
+                h = input[i][1];
+            } else if (input[i][0] < l && input[i][1] > l && input[i][1] < h) {
+                l = input[i][0];
+            } else {
+                collect.add(new Tuple(l, h));
+                l = input[i][0];
+                h = input[i][1];
+            }
+        }
+        collect.add(new Tuple(l, h));
+        final int[][] result = new int[collect.size()][2];
+        for (int i = 0; i<collect.size(); i++) {
+            result[i][0] = collect.get(i).x;
+            result[i][1] = collect.get(i).y;
+        }
+        return result;
+    }
+}

src/main/java/array/SearchInRotatedSortedArray.java

@@ -0,0 +1,115 @@
+package array;
+
+import java.util.Arrays;
+
+public class SearchInRotatedSortedArray {
+    /*
+      LeetCode 33. Search in Rotated Sorted Array
+      Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
+
+      (i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).
+
+      You are given a target value to search. If found in the array return its index, otherwise return -1.
+
+      You may assume no duplicate exists in the array.
+
+      Your algorithm's runtime complexity must be in the order of O(log n).
+
+      Example 1:
+
+      Input: nums = [4,5,6,7,0,1,2], target = 0
+      Output: 4
+
+      Example 2:
+
+      Input: nums = [4,5,6,7,0,1,2], target = 3
+      Output: -1    
+     */
+
+    public static void main(String[] args) {
+        SearchInRotatedSortedArray instance = new SearchInRotatedSortedArray();
+        int[] input = {4, 5, 6, 7, 0, 1, 2};
+        System.out.println(instance.search(input, 0));
+        System.out.println(instance.search(input, 3));
+        System.out.println(instance.search(input, 4));
+        System.out.println(instance.search(input, 2));
+        System.out.println(instance.search(input, 7));
+        int[] input2 = {};
+        System.out.println(instance.search(input2, 7));
+        int[] input3 = {1};
+        System.out.println(instance.search(input3, 2));
+        int[] input4 = {4,5,6,7,8,9,1,2,3};
+        System.out.println(instance.search(input4, 1));
+
+        System.out.println(instance.search2(input4, 0, 8, 1));
+    }
+
+    public int search(int[] nums, int target) {
+        if (nums.length == 0) {
+            return -1;
+        }
+
+        int l = 0, h = nums.length - 1;
+        int mid = 0;
+        while (l <= h) {
+            mid = l + (h - l) / 2;
+            if (nums[l] == target) {
+                return l;
+            } else if (nums[h] == target) {
+                return h;
+            }
+            if (nums[mid] == target) {
+                return mid;
+            } else if (nums[mid] > nums[h]) {
+                l = mid + 1;
+            } else {
+                h = mid - 1;
+            }
+        }
+        System.out.println("mid: " + mid + ", value: " + nums[mid]);
+        if (target < nums[nums.length -1]) {
+            l = mid + 1;
+            h = nums.length - 1;
+        } else {
+            l = 0;
+            h = mid - 1;
+        }
+        while (l<=h) {
+            mid = l + (h - l) / 2;
+            if (nums[mid] < target) {
+                l = mid + 1;
+            } else if (nums[mid] > target) {
+                h = mid - 1;
+            } else {
+                return mid;
+            }
+        }
+        return -1;
+    }
+
+    //Alternate solution
+    public int search2(int[] nums, int left, int right, int target) {
+        if (left == right) {
+            return (nums[left] == target)? left: -1;
+        }
+        int mid = left + (right - left) / 2;
+        if (nums[mid] == target)
+            return mid;
+
+        //pivot is on the right of the mid element
+        if (nums[left] <= nums[mid]) {
+            if (target >= nums[left] && target <= nums[mid]) {
+                return search2(nums, left, mid - 1, target);
+            } else {
+                return search2(nums, mid + 1, right, target);
+            }
+        } else {
+            //pivot is on the left of the mid element
+            if (target >= nums[mid] && target <= nums[right]) {
+                return search2(nums, mid + 1, right, target);
+            } else {
+                return search2(nums, left, mid - 1, target);                
+            }
+        }        
+    }
+}

src/main/java/dynamicprogramming/ParenthesisPermutation.java

@@ -0,0 +1,32 @@
+package dynamicprogramming;
+
+import java.util.*;
+
+public class ParenthesisPermutation {
+
+    /*     Print all possible n pairs of balanced parentheses.
+    
+     For example, when n is 2, the function should print “(())” and “()()”. When n is 3, we should get “((()))”, “(()())”, “(())()”, “()(())”, “()()()”. 
+    */
+    public static void main(String[] args) {
+        int n = 4;
+        System.out.println(getPermutation(n));
+    }
+
+    private static List<String> getPermutation(int n) {
+        List<String> result = new ArrayList<>();
+        getPermAux(n, n, "", result);
+        return result;
+    }
+    private static void getPermAux(int left, int right, String combination, List<String> collection) {
+        if (left == 0 && right == 0) {            
+            collection.add(combination);
+        }
+        if (left > 0) {
+            getPermAux(left - 1, right, combination + "(", collection);
+        }
+        if (right > left) {
+            getPermAux(left, right - 1, combination + ")", collection);
+        }
+    }
+}

src/main/java/java8/StreamTest.java

@@ -0,0 +1,13 @@
+package java8;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class StreamTest {
+    public static void main(String[] args) {
+        List<Integer> list = Arrays.asList(3, 4, 5);
+        System.out.println(list.stream().flatMap(i -> Arrays.asList(i, i).stream()).collect(Collectors.toList()));
+    }
+}