The Leetcode

The Leetcode

Author: yuzhangcmu

AddBinary.java

@@ -0,0 +1,65 @@
+package Algorithms;
+
+public class AddBinary {
+    public static void main(String[] args) {
+        AddBinary ab = new AddBinary();
+        System.out.println(ab.addBinary("100", "110010"));
+        
+        return;
+        
+    }
+    
+    public String addBinary(String a, String b) {
+        int sLen = 0;
+        int lLen = 0;
+        int carries = 0;
+        
+        String l = null;
+        String s = null;
+        if (a.length() > b.length()) {
+            sLen = b.length();
+            lLen = a.length();
+            l = a;
+            s = b;
+        } else {
+            sLen = a.length();
+            lLen = b.length();
+            l = b;
+            s = a;
+        }
+        
+        StringBuilder rst = new StringBuilder();
+        
+        int i = 0;
+        for (i = sLen - 1; i >= 0; i--) {
+            int sum = (int)(s.charAt(i) - '0') + (int)(l.charAt(lLen - sLen + i) - '0') + carries;
+            if (sum >= 2) {
+                carries = 1;
+            } else {
+                carries = 0;
+            }
+            rst.insert(0, String.valueOf(sum%2));
+        }
+        
+        for (i = lLen - sLen - 1; i >= 0; i--) {
+            if (carries == 1) {
+                if (l.charAt(i) == '0') {
+                    carries = 0;
+                    rst.insert(0,'1');
+                } else {
+                    rst.insert(0,'0');
+                }               
+            } else {
+                rst.insert(0, l, 0, i + 1);
+                return rst.toString();
+            }
+        }
+        
+        if (carries == 1) {
+            rst.insert(0,'1');
+        }
+        
+        return rst.toString();        
+    }
+
+}

Ag.java

@@ -0,0 +1,7 @@
+package Algorithms;
+
+
+
+abstract public class Ag {
+
+}

Anagrams.java

@@ -0,0 +1,55 @@
+package Algorithms;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+
+public class Anagrams {
+    public static void main(String[] args) {
+        Anagrams an = new Anagrams();
+        String[] strs = {"car","dog","god","rac","mon","bac","acr","mea","cab", "abd", "adb"};
+        //String[] strs = {"abc", "bac"};
+        System.out.println(an.anagrams(strs).toString());
+    }
+    
+    private int getHash(int[] count) {
+        int hash = 0;
+        int a = 378551;
+        int b = 63689;
+        
+//        int a = 777877;
+//        int b = 123451;
+        for (int num : count) {
+            hash = hash * a + num;
+            a = a * b;
+        }
+        return hash;
+    }
+    
+    public ArrayList<String> anagrams(String[] strs) {
+        ArrayList<String> result = new ArrayList<String>();
+        HashMap<Integer, ArrayList<String>> map = new HashMap<Integer, ArrayList<String>>();
+
+        for (String str : strs) {
+            int[] count = new int[26];
+            for (int i = 0; i < str.length(); i++) {
+                count[str.charAt(i) - 'a']++;
+            }
+
+            int hash = getHash(count);
+            if (!map.containsKey(hash)) {
+                map.put(hash, new ArrayList<String>());
+            }
+
+            map.get(hash).add(str);
+        }
+
+        for (ArrayList<String> tmp : map.values()) {
+            if (tmp.size() > 1) {
+                result.addAll(tmp);
+            }
+        }
+
+        return result;
+    }
+
+}

BinarySearch.java

@@ -0,0 +1,55 @@
+package Algorithms;
+
+public class BinarySearch {
+    public static void main(String[] strs) {
+        BinarySearch bs = new BinarySearch();
+        int[] num = new int[]{0,1,2,3,4,5};
+        int target = 9;
+        System.out.print(bs.binarySearch(num, target));
+        //int[] num2 = new int[0];
+        //System.out.print(bs.binarySearch(num2, target));
+    }
+    
+    public int binarySearch(int num[], int target) {
+        if (num == null || num.length == 0) {
+            return -1;
+        }
+        
+        int left = 0;
+        int right = num.length - 1;
+        
+        String test = "test";
+        String t2 = test.substring(0,0);
+        System.out.printf(test.substring(0,0));
+        
+//        while (left <= right) {
+//            int mid = left + (right - left)/2;
+//            if (num[mid] > target) {
+//                right = mid - 1;
+//            } else if (num[mid] < target) {
+//                left = mid + 1;
+//            } else {
+//                return mid;
+//            }
+//        }
+        // [1, 2]
+        while (left + 1 < right) {
+            int mid = left + (right - left)/2;
+            if (num[mid] > target) {
+                right = mid;
+            } else if (num[mid] < target) {
+                left = mid;
+            } else {
+                return mid;
+            }
+        }
+        
+        if (num[left] == target) {
+            return left;
+        } else if (num[right] == target) {
+            return right;
+        }
+        
+        return -1;
+    }
+}

Combination2.java

@@ -0,0 +1,59 @@
+package Algorithms;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class Combination2 {
+    public static void main(String[] args) {
+        ArrayList<Character> test = new ArrayList<Character>();
+        
+        test.add('c');
+        test.add('b');
+        
+        System.out.printf("Result: %s", test.toString());
+        
+        Combination2 cb = new Combination2();
+        int[] num = {2,2,2};
+        cb.combinationSum2(num, 4);
+    }
+    
+    public ArrayList<ArrayList<Integer>> combinationSum2(int[] num, int target) {
+        
+        // first we should sort the array.
+        Arrays.sort(num);
+        
+        ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
+        ArrayList<Integer> path = new ArrayList<Integer>();
+        
+        cmbHelp(num, 0, path, rst, target);
+        
+        return rst;
+    }
+    
+    public void cmbHelp(int[] num, int index, ArrayList<Integer> path, ArrayList<ArrayList<Integer>> rst, int target) {
+        if (target == 0) {
+            // add the current set into the result.
+            rst.add(new ArrayList<Integer>(path));
+        }
+        
+        for (int i = index; i < num.length; i++) {
+            if (num[i] > target) {
+                // don't need to add new element;
+                return;
+            }
+            
+            if (i >= 1 && 
+                num[i] == num[i - 1] && 
+                (path.size() == 0 || path.get(path.size() - 1) != num[i])) {
+                continue;     
+            }
+                
+            path.add(num[i]);
+            cmbHelp(num, i + 1, path, rst, target - num[i]);
+            path.remove(path.size() - 1);
+        }
+        
+        return;
+    }
+
+}

CombinationSum.java

@@ -0,0 +1,78 @@
+package Algorithms;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class CombinationSum{
+    public ArrayList<ArrayList<Integer>> combine(int n, int k) {
+        ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>>();
+        
+        help(n, 0, new ArrayList<Integer>(), rst, k);
+        
+        return rst;
+    }
+    
+    public void help(int n, int index, ArrayList<Integer> path, ArrayList<ArrayList<Integer>> rst, int k) {
+        if (path.size() == k) {
+            rst.add(new ArrayList<Integer>(path));
+            return;
+        }
+        
+        for (int i = index; i < n; i++) {
+            path.add(i + 1);
+            help(n, i + 1, path, rst, k);
+            path.remove(path.size() - 1);
+        }
+        
+        return;
+    }
+    
+    
+    public static void main(String[] args) {
+        CombinationSum cs = new CombinationSum();
+        
+        int[] num = {1,2};
+        cs.combine(1, 1);
+        
+        
+        
+        
+        
+    }
+    
+    public ArrayList<ArrayList<Integer>> combinationSum(int[] candidates, int target) {
+        ArrayList<ArrayList<Integer>> rst = new ArrayList<ArrayList<Integer>> ();
+        Arrays.sort(candidates);
+
+        help(candidates, 0, new ArrayList<Integer>(), rst, target);
+        
+        System.out.printf(rst.toString());
+        
+        return rst;
+    }
+    
+    public void help(int[] cand, int index, ArrayList<Integer> path, ArrayList<ArrayList<Integer>> rst, int target) {
+        if (target == 0) {
+            // add the current set into the result.
+            rst.add(new ArrayList<Integer>(path));
+            return;
+        }
+        
+        int pre = -1;
+        for (int i = index; i < cand.length; i++) {
+            if (cand[i] > target) {
+                // because the sequence is ascending, so we don't need to go on.
+                break;
+            }
+            
+            if (cand[i] == pre)
+            
+            path.add(cand[i]);
+            help(cand, index, path, rst, target - cand[i]);
+            path.remove(path.size() - 1);
+        }
+        
+        return;
+    }
+
+}

DivideTwoIntegers.java

@@ -0,0 +1,24 @@
+package Algorithms;
+
+public class DivideTwoIntegers {
+    public static void main(String[] args) {
+        System.out.println(divide(-2147483648, 1));
+    }
+    
+    public static int divide(int dividend, int divisor) {
+        long a = Math.abs((long)dividend);
+        long b = Math.abs((long)divisor);
+        int ret = 0;
+        
+        while (a >= b) {
+            long bTmp = b;
+            int cnt = 1;
+            for (int i = 1; a >= bTmp; cnt <<= 1, bTmp <<= 1) {
+                a -= bTmp;
+                ret += cnt;
+            }
+        }
+        
+        return ((dividend > 0) ^ (divisor > 0)) ? -ret: ret;
+    }
+}