str

Author: idf

src/AddBinary/Solution.java

@@ -0,0 +1,51 @@
+package AddBinary;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * User: Danyang
+ * Date: 1/28/2015
+ * Time: 0:17
+ *
+ * Given two binary strings, return their sum (also a binary string).
+
+ For example,
+ a = "11"
+ b = "1"
+ Return "100".
+ */
+public class Solution {
+    /**
+     * Reverse
+     * @param a
+     * @param b
+     * @return
+     */
+    public String addBinary(String a, String b) {
+        List<Integer> ret = new ArrayList<>();
+        if(a.length()>b.length()) {
+            String t = a; a = b; b = t;
+        }
+        List<Integer> lst_a = a.chars().map(e -> e-'0').boxed().collect(Collectors.toList());
+        List<Integer> lst_b = b.chars().map(e -> e-'0').boxed().collect(Collectors.toList());
+        Collections.reverse(lst_a);
+        Collections.reverse(lst_b);
+        int carry = 0;
+        for(int i=0; i<lst_b.size(); i++) {
+            int s = carry+lst_b.get(i);
+            if(i<lst_a.size())
+                s += lst_a.get(i);
+            ret.add(s%2);
+            carry = s/2;
+        }
+        while(carry!=0) {
+            ret.add(carry%2);
+            carry -= 1;
+        }
+        Collections.reverse(ret);
+        return ret.stream().map(Object::toString).collect(Collectors.joining());
+    }
+}

src/CountandSay/Solution.java

@@ -0,0 +1,45 @@
+package CountandSay;
+
+/**
+ * User: Danyang
+ * Date: 1/28/2015
+ * Time: 10:37
+ *
+ * The count-and-say sequence is the sequence of integers beginning as follows:
+ 1, 11, 21, 1211, 111221, ...
+
+ 1 is read off as "one 1" or 11.
+ 11 is read off as "two 1s" or 21.
+ 21 is read off as "one 2, then one 1" or 1211.
+ Given an integer n, generate the nth sequence.
+
+ Note: The sequence of integers will be represented as a string.
+ */
+public class Solution {
+    public String countAndSay(int n) {
+        String ret = "1";
+        for(int i=0; i<n-1; i++)
+            ret = trans(ret);
+        return  ret;
+    }
+
+    /**
+     * Two pointers
+     * Notice:
+     * 1. initial condition of j
+     * @param s
+     * @return
+     */
+    String trans(String s) {
+        StringBuilder sb = new StringBuilder();
+        char[] cs = s.toCharArray();
+        int i = 0;
+        int j = 0;
+        while(i<cs.length && j<cs.length) {
+            for(; j<cs.length && cs[i]==cs[j]; j++);
+            sb.append(j-i).append(cs[i]);
+            i = j;
+        }
+        return sb.toString();
+    }
+}

src/RestoreIPAddresses/Solution.java

@@ -0,0 +1,64 @@
+package RestoreIPAddresses;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * User: Danyang
+ * Date: 1/28/2015
+ * Time: 10:58
+ *
+ * Given a string containing only digits, restore it by returning all possible valid IP address combinations.
+
+ For example:
+ Given "25525511135",
+
+ return ["255.255.11.135", "255.255.111.35"]. (Order does not matter)
+ */
+public class Solution {
+    /**
+     * Notice:
+     * 1. zero heading
+     * @param s
+     * @return
+     */
+    public List<String> restoreIpAddresses(String s) {
+        List<String> ret = new ArrayList<>();
+        dfs(s, 4, new ArrayList<>(), ret);
+        return ret;
+    }
+
+    void dfs(String seq, int n, List<String> cur, List<String> ret) {
+        if(n==0) {
+            if(seq.length()==0)
+                ret.add(cur.stream().collect(Collectors.joining(".")));
+        }
+        else {
+            for(int i=1; i<=seq.length() && i<=3; i++) {
+                String sub = seq.substring(0, i);
+                if(isValidSegment(sub)) {
+                    cur.add(sub);
+                    dfs(seq.substring(i, seq.length()), n-1, cur, ret);
+                    cur.remove(cur.size()-1);
+                }
+            }
+        }
+
+    }
+
+    boolean isValidSegment(String s) {
+        if(s.length()>3 || s.length()<1)
+            return false;
+        if(s.length()>1 && s.charAt(0)=='0')
+            return false;
+        if(Integer.parseInt(s)>255)
+            return false;
+        return true;
+    }
+
+    public static void main(String[] args) {
+        List<String> ret = new Solution().restoreIpAddresses("25525511135");
+        System.out.println(ret);
+    }
+}

src/ValidPalindrome/Solution.java

@@ -0,0 +1,27 @@
+package ValidPalindrome;
+
+/**
+ * User: Danyang
+ * Date: 1/28/2015
+ * Time: 10:46
+ *
+ * Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
+
+ For example,
+ "A man, a plan, a canal: Panama" is a palindrome.
+ "race a car" is not a palindrome.
+
+ Note:
+ Have you consider that the string might be empty? This is a good question to ask during an interview.
+
+ For the purpose of this problem, we define empty string as valid palindrome.
+ */
+public class Solution {
+    public boolean isPalindrome(String s) {
+        int[] cs = s.toLowerCase().chars().filter(e -> e>='a' && e<='z' || e>='0' && e<='9').toArray();
+        for(int i=0; i<cs.length/2; i++)
+            if(cs[i]!=cs[cs.length-1-i])
+                return false;
+        return true;
+    }
+}