汉化

Author: guobinhit

README.md

@@ -35,16 +35,53 @@
  */
 public class _122 {
     public int maxProfit(int[] prices) {
-        int profit = 0, i = 0;
-        while (i < prices.length) {
-            // find next local minimum
-            while (i < prices.length - 1 && prices[i + 1] <= prices[i]) i++;
-            // need increment to avoid infinite loop for "[1]"
-            int min = prices[i++];
-            // find next local maximum
-            while (i < prices.length - 1 && prices[i + 1] >= prices[i]) i++;
-            profit += i < prices.length ? prices[i++] - min : 0;
+        return calculate(prices, 0);
+    }
+
+    private int calculate(int prices[], int s) {
+        if (s >= prices.length)
+            return 0;
+        int max = 0;
+        for (int start = s; start < prices.length; start++) {
+            int maxprofit = 0;
+            for (int i = start + 1; i < prices.length; i++) {
+                if (prices[start] < prices[i]) {
+                    int profit = calculate(prices, i + 1) + prices[i] - prices[start];
+                    if (profit > maxprofit)
+                        maxprofit = profit;
+                }
+            }
+            if (maxprofit > max)
+                max = maxprofit;
+        }
+        return max;
+    }
+
+    public int maxProfit2(int[] prices) {
+        if (prices == null || prices.length == 0) return 0;
+        int i = 0;
+        int valley = prices[0];
+        int peak = prices[0];
+        int maxprofit = 0;
+        while (i < prices.length - 1) {
+            while (i < prices.length - 1 && prices[i] >= prices[i + 1])
+                i++;
+            valley = prices[i];
+            while (i < prices.length - 1 && prices[i] <= prices[i + 1])
+                i++;
+            peak = prices[i];
+            maxprofit += peak - valley;
+        }
+        return maxprofit;
+    }
+
+    public int maxProfit3(int[] prices) {
+        int maxProfit = 0;
+        for (int i = 1; i < prices.length; i++) {
+            if (prices[i] > prices[i - 1]) {
+                maxProfit += prices[i] - prices[i - 1];
+            }
         }
-        return profit;
+        return maxProfit;
     }
 }

codes/java/leetcodes/src/main/java/com/hit/basmath/interview/top_interview_questions/easy_collection/array/_122.java

@@ -25,12 +25,29 @@
  * Explanation: In this case, no transaction is done, i.e. max profit = 0.
  */
 public class _121 {
+
     public int maxProfit(int[] prices) {
-        int maxCur = 0, maxSoFar = 0;
-        for (int i = 1; i < prices.length; i++) {
-            maxCur = Math.max(0, maxCur += prices[i] - prices[i - 1]);
-            maxSoFar = Math.max(maxCur, maxSoFar);
+        int maxProfit = 0;
+        for (int i = 0; i < prices.length - 1; i++) {
+            for (int j = i + 1; j < prices.length; j++) {
+                int profit = prices[j] - prices[i];
+                if (profit > maxProfit)
+                    maxProfit = profit;
+            }
+        }
+        return maxProfit;
+    }
+
+    public int maxProfit2(int[] prices) {
+        int minPrice = Integer.MAX_VALUE;
+        int maxProfit = 0;
+        for (int price : prices) {
+            if (price < minPrice) {
+                minPrice = price;
+            } else if (price - minPrice > maxProfit) {
+                maxProfit = price - minPrice;
+            }
         }
-        return maxSoFar;
+        return maxProfit;
     }
 }

codes/java/leetcodes/src/main/java/com/hit/basmath/interview/top_interview_questions/easy_collection/dynamic_programming/_121.java

@@ -28,15 +28,12 @@ public int maxSubArray(int[] nums) {
             dp[i] = nums[i] + (dp[i - 1] > 0 ? dp[i - 1] : 0);
             max = Math.max(max, dp[i]);
         }
-
         return max;
     }
 
     public int maxSubArray2(int[] nums) {
-        int n = nums.length;
         int currSum = nums[0], maxSum = nums[0];
-
-        for (int i = 1; i < n; ++i) {
+        for (int i = 1; i < nums.length; ++i) {
             currSum = Math.max(nums[i], currSum + nums[i]);
             maxSum = Math.max(maxSum, currSum);
         }

codes/java/leetcodes/src/main/java/com/hit/basmath/interview/top_interview_questions/easy_collection/dynamic_programming/_53.java

@@ -23,7 +23,6 @@ public int countPrimes(int n) {
                 }
             }
         }
-
         return count;
     }
 }

codes/java/leetcodes/src/main/java/com/hit/basmath/interview/top_interview_questions/easy_collection/math/_204.java

@@ -29,13 +29,15 @@
 public class _190 {
     // you need treat n as an unsigned value
     public int reverseBits(int n) {
-        int result = 0;
+        int ans = 0;
         for (int i = 0; i < 32; i++) {
-            result += n & 1;
-            n >>>= 1;   // CATCH: must do unsigned shift
-            if (i < 31) // CATCH: for last digit, don't shift!
-                result <<= 1;
+            // handle the lowest bit of binary every time
+            int curr = n & 1;
+            // directly arrange the lowest bit of binary to the final position
+            ans += (curr << (31 - i));
+            // update n
+            n = n >> 1;
         }
-        return result;
+        return ans;
     }
 }

codes/java/leetcodes/src/main/java/com/hit/basmath/interview/top_interview_questions/easy_collection/others/_190.java

@@ -1,4 +1,4 @@
-    package com.hit.basmath.interview.top_interview_questions.easy_collection.others;
+package com.hit.basmath.interview.top_interview_questions.easy_collection.others;
 
 /**
  * 191. Number of 1 Bits
@@ -37,11 +37,15 @@
 public class _191 {
     // you need to treat n as an unsigned value
     public int hammingWeight(int n) {
-        int ones = 0;
+        int sum = 0;
         while (n != 0) {
-            ones = ones + (n & 1);
-            n = n >>> 1;
+            sum++;
+            /**
+             * n & (n - 1) always change the lowest 1 in n to 0
+             * and keep the other bits unchanged
+             */
+            n &= (n - 1);
         }
-        return ones;
+        return sum;
     }
 }

codes/java/leetcodes/src/main/java/com/hit/basmath/interview/top_interview_questions/easy_collection/others/_191.java

@@ -21,11 +21,10 @@
  */
 public class _268 {
     public int missingNumber(int[] nums) {
-        int xor = 0, i = 0;
-        for (i = 0; i < nums.length; i++) {
-            xor = xor ^ i ^ nums[i];
+        int missing = nums.length;
+        for (int i = 0; i < nums.length; i++) {
+            missing ^= i ^ nums[i];
         }
-
-        return xor ^ i;
+        return missing;
     }
 }

codes/java/leetcodes/src/main/java/com/hit/basmath/interview/top_interview_questions/easy_collection/others/_268.java

@@ -1,5 +1,7 @@
 package com.hit.basmath.interview.top_interview_questions.easy_collection.strings;
 
+import java.util.Arrays;
+
 /**
  * 242. Valid Anagram
  * <p>
@@ -25,10 +27,30 @@
  */
 public class _242 {
     public boolean isAnagram(String s, String t) {
-        int[] alphabet = new int[26];
-        for (int i = 0; i < s.length(); i++) alphabet[s.charAt(i) - 'a']++;
-        for (int i = 0; i < t.length(); i++) alphabet[t.charAt(i) - 'a']--;
-        for (int i : alphabet) if (i != 0) return false;
+        if (s.length() != t.length()) {
+            return false;
+        }
+        char[] str1 = s.toCharArray();
+        char[] str2 = t.toCharArray();
+        Arrays.sort(str1);
+        Arrays.sort(str2);
+        return Arrays.equals(str1, str2);
+    }
+
+    public boolean isAnagram2(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+        int[] counter = new int[26];
+        for (int i = 0; i < s.length(); i++) {
+            counter[s.charAt(i) - 'a']++;
+            counter[t.charAt(i) - 'a']--;
+        }
+        for (int count : counter) {
+            if (count != 0) {
+                return false;
+            }
+        }
         return true;
     }
 }

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

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