Signed-off-by: yuduozhou <[email protected]>

Author: yuduozhou

ThreeSum.java 3Sum.java

@@ -0,0 +1,25 @@
+public class Solution {
+    public String countAndSay(int n) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        String result = "1";
+    	for (int i = 0; i < n-1; i++) {
+			result = sayIt(result);
+		}
+		return result;
+    }
+
+	public String sayIt(String s) {
+		StringBuilder buf = new StringBuilder();
+        int length = s.length();
+		for (int i = 0; i < length; i++) {
+			int count = 1;
+			while (i + 1 < length && s.charAt(i + 1) == s.charAt(i)) {
+				i++;
+				count++;
+			}
+			buf.append(String.valueOf(count) + String.valueOf(s.charAt(i)));
+		}	
+		return buf.toString();
+	}
+}

ThreeSumClosest.java 3SumClosest.java

@@ -0,0 +1,46 @@
+public class Solution {
+    public int numDecodings(String s) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+
+        if (s.equals("") || s.charAt(0) == '0'){            
+            return 0;
+        }
+        if (s.length() == 1){
+            return 1;
+        }
+        return count(s);
+    }
+    
+    public int count(String s){
+        int len = s.length();
+        int[] code = new int[len];
+        int[] dWays = new int[len];
+        for (int i = 0; i < len; i++){
+            code[i] = Integer.parseInt(s.substring(i, i + 1));
+            // Avoid all zeros.
+            if (code[i] == 0){
+                if (code[i - 1] != 1 && code[i - 1] != 2){
+                    return 0;
+                }
+            }
+        }
+        dWays[0] = (code[1] == 0)? 0 : 1;
+        int temp = code[0] * 10 + code[1];
+        dWays[1] = ( temp > 26 || temp % 10 == 0) ? 1 : 2;
+        
+        for (int i = 2; i < len; i++){
+            int number = code[i - 1] * 10 + code[i];
+            if (number % 10 == 0){
+                dWays[i] = dWays[i - 2];
+            }
+            else if (number <= 26 && number > 10){
+                dWays[i] = dWays[i - 1] + dWays[i - 2];
+            }
+            else{
+                dWays[i] = dWays[i - 1];
+            }
+        }
+        return dWays[len - 1];
+    }    
+}

FourSum.java 4Sum.java

@@ -0,0 +1,36 @@
+public class Solution {
+    public int divide(int dividend, int divisor) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        
+        int a = Math.abs(dividend);
+        int b = Math.abs(divisor);
+        boolean neg = (dividend > 0 && divisor < 0) || (dividend < 0 && divisor > 0);
+        if (divisor == 0) {
+            return Integer.MAX_VALUE;
+        }
+        if (divisor == Integer.MIN_VALUE) {
+            return (dividend == Integer.MIN_VALUE) ? 1 : 0;
+        }
+        if (dividend == Integer.MIN_VALUE) {
+            if (neg) {
+                return -1 + divide(dividend + b, b);
+            }
+            else {
+                return 1 - divide(dividend + b, b);
+            }
+        }
+        int product = b, result = 0;
+        while (a >= b) {
+            int q = 1;
+            while (a - product >= product) {
+                q = q << 1;
+                product = product << 1;
+            }
+            a = a - product;
+            product = b;
+            result += q;
+        }
+        return (neg) ? -result : result;
+    }
+}

InOrderTraversal.java BinaryTreeInOrderTraversal.java

@@ -0,0 +1,38 @@
+public class Solution {
+    public int minDistance(String word1, String word2) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+
+        if (word1.equals(word2)) return 0;
+        int len1 = word1.length(), len2 = word2.length();
+        if (len1 == 0) return len2;
+        if (len2 == 0) return len1;
+        
+        int[][] dist = new int[len1 + 1][len2 + 1];
+        dist[0][0] = 0;
+        for (int i = 1; i <= len1; i ++){
+            dist[i][0] = i;
+        }
+        for (int j = 1; j <= len2; j ++){
+            dist[0][j] = j;
+        }
+        for (int i = 1; i <= len1; i ++){
+            for (int j = 1; j <= len2; j ++){
+                dist[i][j] = findMin(
+                    dist[i - 1][j] + 1, dist[i][j - 1] + 1,
+                    dist[i - 1][j - 1] + (word1.charAt(i - 1) == word2.charAt(j - 1) ? 0 : 1));
+            }
+        }
+        return dist[len1][len2];
+    }
+    
+    public int findMin(int ... num){
+        int min = num[0];
+        for (int i = 1; i < num.length; i ++){
+            if (num[i] < min){
+                min = num[i];
+            }
+        }
+        return min;
+    }
+}

CountAndSay.java

@@ -0,0 +1,21 @@
+public class Solution {
+    public int firstMissingPositive(int[] A) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        if (A.length < 1) return 1;
+        int i = 0;
+        for (i = 0; i < A.length; i++){
+            while (A[i] > 0 && A[i] <= A.length && A[i] != i + 1 && A[A[i] - 1] != A[i]){
+                int temp = A[i];
+                A[i] = A[temp - 1];
+                A[temp - 1] = temp;
+            }
+        }
+        
+        for (i = 0; i < A.length; i++){
+            if (A[i] != i + 1)
+                return i + 1;
+        }
+        return i + 1;
+    }
+}

DecodeWays.java

@@ -0,0 +1,28 @@
+public class Solution {
+    public ArrayList<String> generateParenthesis(int n) {
+        // Start typing your Java solution below
+        // DO NOT write main() function
+        
+        ArrayList<String> result = new ArrayList<String>();
+        char[] parens = new char[n+n];
+        gp (result, 0, 0, n, parens);
+        return result;
+    }
+    
+    public void gp(ArrayList<String> result, int left, int right, int n, char[] parens) {
+        if (left == right && left == n) {
+            result.add(new String(parens));
+            return;
+        }
+        
+        if (left < n) {
+            parens[left + right] = '(';
+            gp(result, left + 1, right, n, parens);
+        }
+        
+        if (right < left) {
+            parens[left + right] = ')';
+            gp(result, left, right + 1, n, parens);
+        }
+    }
+}

DivideTwoInteger.java

@@ -0,0 +1,29 @@
+public class Solution {
+    public ArrayList<Integer> grayCode(int n) {
+    // Start typing your Java solution below
+    // DO NOT write main() function
+        ArrayList<Integer> result = new ArrayList<Integer>();
+        if (n <= 1) {
+            for (int i = 0; i <= n; i++){
+                result.add(i);
+            }
+            return result;
+        }
+        result = grayCode(n - 1);
+        ArrayList<Integer> r1 = reverse(result);
+        int x = 1 << (n-1);
+        for (int i = 0; i < r1.size(); i++) {
+            r1.set(i, r1.get(i) + x);
+        }
+        result.addAll(r1);
+        return result;
+    }
+    
+    public ArrayList<Integer> reverse (ArrayList<Integer> r) {
+        ArrayList<Integer> rev = new ArrayList<Integer>();
+        for (int i = r.size() - 1; i >= 0; i--) {
+            rev.add(r.get(i));
+        }
+        return rev;
+    } 
+}