update

Author: guobinhit

codes/java/leetcodes/src/main/java/com/hit/basmath/interview/top_interview_questions/easy_collection/strings/_7.java

@@ -42,4 +42,25 @@ public int reverse(int x) {
 
         return result;
     }
+
+    public int reverse2(int x) {
+        int rev = 0;
+
+        while (x != 0) {
+            int pop = x % 10;
+            x /= 10;
+
+            if (rev > Integer.MAX_VALUE / 10 ||
+                    (rev == Integer.MAX_VALUE / 10 && pop > 7)) {
+                return 0;
+            }
+
+            if (rev < Integer.MIN_VALUE / 10 ||
+                    (rev == Integer.MIN_VALUE / 10 && pop < -8)) {
+                return 0;
+            }
+            rev = rev * 10 + pop;
+        }
+        return rev;
+    }
 }

codes/java/leetcodes/src/main/java/com/hit/basmath/learn/hash_table/_3.java

@@ -1,6 +1,9 @@
 package com.hit.basmath.learn.hash_table;
 
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
 
 /**
  * 3. Longest Substring Without Repeating Characters
@@ -28,17 +31,77 @@
  * Note that the answer must be a substring, "pwke" is a subsequence and not a substring.
  */
 public class _3 {
+    /**
+     * Solution 1: Violence method
+     *
+     * @param s
+     * @return
+     */
     public int lengthOfLongestSubstring(String s) {
-        if (s.length() == 0) return 0;
-        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
-        int max = 0;
-        for (int i = 0, j = 0; i < s.length(); ++i) {
-            if (map.containsKey(s.charAt(i))) {
-                j = Math.max(j, map.get(s.charAt(i)) + 1);
+        int n = s.length();
+        int ans = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j <= n; j++) {
+                if (allUnique(s, i, j)) {
+                    ans = Math.max(ans, j - i);
+                }
             }
-            map.put(s.charAt(i), i);
-            max = Math.max(max, i - j + 1);
         }
-        return max;
+        return ans;
+    }
+
+    private boolean allUnique(String s, int start, int end) {
+        Set<Character> aSet = new HashSet<>();
+        for (int i = start; i < end; i++) {
+            if (aSet.contains(s.charAt(i))) {
+                return false;
+            } else {
+                aSet.add(s.charAt(i));
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Solution 2: Slide window method
+     *
+     * @param s
+     * @return
+     */
+    public int lengthOfLongestSubstring2(String s) {
+        int n = s.length();
+        Set<Character> set = new HashSet<>();
+        int ans = 0, i = 0, j = 0;
+        while (i < n && j < n) {
+            // try to extend the range [i, j]
+            if (!set.contains(s.charAt(j))) {
+                set.add(s.charAt(j++));
+                ans = Math.max(ans, j - i);
+            } else {
+                set.remove(s.charAt(i++));
+            }
+        }
+        return ans;
+    }
+
+    /**
+     * Solution 3: Slide window method of optimize
+     *
+     * @param s
+     * @return
+     */
+    public int lengthOfLongestSubstring3(String s) {
+        int n = s.length(), ans = 0;
+        // current index of character
+        Map<Character, Integer> map = new HashMap<>();
+        // try to extend the range [i, j]
+        for (int j = 0, i = 0; j < n; j++) {
+            if (map.containsKey(s.charAt(j))) {
+                i = Math.max(map.get(s.charAt(j)), i);
+            }
+            ans = Math.max(ans, j - i + 1);
+            map.put(s.charAt(j), j + 1);
+        }
+        return ans;
     }
 }

codes/java/leetcodes/src/main/java/com/hit/basmath/learn/others/_35.java

@@ -29,13 +29,17 @@
  */
 public class _35 {
     public int searchInsert(int[] nums, int target) {
-        int low = 0, high = nums.length - 1;
-        while (low <= high) {
-            int mid = (low + high) / 2;
-            if (nums[mid] == target) return mid;
-            else if (nums[mid] > target) high = mid - 1;
-            else low = mid + 1;
+        int left = 0, right = nums.length - 1;
+        while (left <= right) {
+            int mid = (left + right) / 2;
+            if (nums[mid] == target) {
+                return mid;
+            } else if (nums[mid] < target) {
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
         }
-        return low;
+        return left;
     }
 }

codes/java/leetcodes/src/main/java/com/hit/basmath/learn/others/_9.java

@@ -28,17 +28,43 @@
  */
 public class _9 {
     public boolean isPalindrome(int x) {
+        String reversedStr = (new StringBuilder(x + "")).reverse().toString();
+        return (x + "").equals(reversedStr);
+    }
+
+    public boolean isPalindrome2(int x) {
+        if (x < 0)
+            return false;
+
+        int div = 1;
+
+        while (x / div >= 10)
+            div *= 10;
+
+        while (x > 0) {
+            int left = x/ div;
+            int right = x % 10;
+            if (left != right) {
+                return false;
+            }
+            x = (x % div) / 10;
+            div /= 100;
+        }
+        return true;
+    }
+
+    public boolean isPalindrome3(int x) {
         // negative and 10 times numbers is not a palindrome
         if (x < 0 || (x != 0 && x % 10 == 0)) {
             return false;
         }
 
-        int rev = 0;
-        while (x > rev) {
-            rev = rev * 10 + x % 10;
+        int revertedNumber = 0;
+        while (x > revertedNumber) {
+            revertedNumber = revertedNumber * 10 + x % 10;
             x = x / 10;
         }
 
-        return (x == rev || x == rev / 10);
+        return (x == revertedNumber || x == revertedNumber / 10);
     }
 }