add 58 LengthOfLastWord and update other solutions

Author: FreeTymeKiyan

src/main/java/com/freetymekiyan/algorithms/level/easy/AddBinary.java

@@ -16,55 +16,55 @@
  */
 class AddBinary {
 
-    /**
-     * Math. String.
-     * Initialize two pointers i and j at the end of a and b.
-     * Use one integer c for the carry.
-     * While i >= 0 or j >= 0 or c == 1:
-     * | Add char in a or 0 to carry c. Move i.
-     * | Add char in b or 0 to carry c. Move j.
-     * | c % 2 is the current digit.
-     * | Insert current digit to the front of result.
-     * | c / 2 is the next carry.
-     * Return result string.
-     */
-    public String addBinary(String a, String b) {
-        StringBuilder sum = new StringBuilder();
-        int i = a.length() - 1;
-        int j = b.length() - 1;
-        int c = 0;
-        while (i >= 0 || j >= 0 || c == 1) {
-            c += (i >= 0 ? a.charAt(i--) - '0' : 0);
-            c += (j >= 0 ? b.charAt(j--) - '0' : 0);
-            sum.insert(0, c % 2);
-            c >>= 1;
-        }
-        return sum.toString();
+  /**
+   * Math. String.
+   * Initialize two pointers i and j at the end of a and b.
+   * Use one integer c for the carry.
+   * While i >= 0 or j >= 0 or c == 1:
+   * | Add char in a or 0 to carry c. Move i.
+   * | Add char in b or 0 to carry c. Move j.
+   * | c % 2 is the current digit.
+   * | Insert current digit to the front of result.
+   * | c / 2 is the next carry.
+   * Return result string.
+   */
+  public String addBinary(String a, String b) {
+    StringBuilder sum = new StringBuilder();
+    int i = a.length() - 1;
+    int j = b.length() - 1;
+    int c = 0;
+    while (i >= 0 || j >= 0 || c == 1) {
+      c += (i >= 0 ? a.charAt(i--) - '0' : 0);
+      c += (j >= 0 ? b.charAt(j--) - '0' : 0);
+      sum.insert(0, c % 2);
+      c >>= 1;
     }
+    return sum.toString();
+  }
 
-    /**
-     * Math. String.
-     * From end to start, do it digit-by-digit.
-     * Get current digits of ab and b, add them up.
-     * Also use an integer to store carry from the previous addition.
-     * Store the sum to result and update carry for each round.
-     * Stop when longest string is reached.
-     * Remember to check carry before return, if carry is 1, it should still be inserted to the result.
-     */
-    public String addBinary2(String a, String b) {
-        int m = a.length();
-        int n = b.length();
-        int carry = 0;
-        StringBuilder res = new StringBuilder();
-        int i = 0;
-        while (i < m || i < n) { // The longer one of ab and b
-            int p = i < m ? a.charAt(m - 1 - i) - '0' : 0;
-            int q = i < n ? b.charAt(n - 1 - i) - '0' : 0;
-            int temp = p + q + carry; // Sum of current digits and previous carry
-            carry = temp / 2; // temp can be 0, 1, 2, 3. When temp >= 2, carry = 1; otherwise, carry = 0
-            res.insert(0, temp % 2); // When temp is odd, result is 1; otherwise, result is 0
-            i++;
-        }
-        return carry == 0 ? res.toString() : "1" + res.toString(); // Don't forget the carry at last.
+  /**
+   * Math. String.
+   * From end to start, do it digit-by-digit.
+   * Get current digits of ab and b, add them up.
+   * Also use an integer to store carry from the previous addition.
+   * Store the sum to result and update carry for each round.
+   * Stop when longest string is reached.
+   * Remember to check carry before return, if carry is 1, it should still be inserted to the result.
+   */
+  public String addBinary2(String a, String b) {
+    int m = a.length();
+    int n = b.length();
+    int carry = 0;
+    StringBuilder res = new StringBuilder();
+    int i = 0;
+    while (i < m || i < n) { // The longer one of ab and b
+      int p = i < m ? a.charAt(m - 1 - i) - '0' : 0;
+      int q = i < n ? b.charAt(n - 1 - i) - '0' : 0;
+      int temp = p + q + carry; // Sum of current digits and previous carry
+      carry = temp / 2; // temp can be 0, 1, 2, 3. When temp >= 2, carry = 1; otherwise, carry = 0
+      res.insert(0, temp % 2); // When temp is odd, result is 1; otherwise, result is 0
+      i++;
     }
+    return carry == 0 ? res.toString() : "1" + res.toString(); // Don't forget the carry at last.
+  }
 }

src/main/java/com/freetymekiyan/algorithms/level/easy/LengthOfLastWord.java

@@ -0,0 +1,35 @@
+package com.freetymekiyan.algorithms.level.easy;
+
+/**
+ * 58. Length of Last Word
+ * <p>
+ * Given a string s consists of upper/lower-case alphabets and empty space characters ' ', return the length of last
+ * word in the string.
+ * <p>
+ * If the last word does not exist, return 0.
+ * <p>
+ * Note: A word is defined as a character sequence consists of non-space characters only.
+ * <p>
+ * Example:
+ * <p>
+ * Input: "Hello World"
+ * Output: 5
+ * <p>
+ * Related Topics: String
+ */
+public class LengthOfLastWord {
+
+  public int lengthOfLastWord(String s) {
+    s = s.trim();
+    char space = ' ';
+    if (s.indexOf(space) == -1) return s.length(); // No space
+    int len = s.length();
+    // Find the starting index of the last word
+    for (int i = len - 1; i >= 0; i--) {
+      if (s.charAt(i) == ' ' && i != len - 1) {
+        return len - 1 - i;
+      }
+    }
+    return 0;
+  }
+}

src/main/java/com/freetymekiyan/algorithms/level/easy/PlusOne.java

@@ -11,40 +11,40 @@
  */
 public class PlusOne {
 
-    public int[] plusOne(int[] digits) {
-        for (int i = digits.length - 1; i >= 0; i--) {
-            digits[i] = 1 + digits[i];
-            if (digits[i] == 10) { // Carry.
-                digits[i] = 0;
-            } else { // No carry, just return.
-                return digits;
-            }
-        }
-        // Not returned, must have carry.
-        int[] ans = new int[digits.length + 1];
-        ans[0] = 1;
-        for (int i = 0; i < digits.length; i++) {
-            ans[i + 1] = digits[i];
-        }
-        return ans;
+  public int[] plusOne(int[] digits) {
+    for (int i = digits.length - 1; i >= 0; i--) {
+      digits[i] = 1 + digits[i];
+      if (digits[i] == 10) { // Carry.
+        digits[i] = 0;
+      } else { // No carry, just return.
+        return digits;
+      }
     }
+    // Not returned, must have carry.
+    int[] ans = new int[digits.length + 1];
+    ans[0] = 1;
+    for (int i = 0; i < digits.length; i++) {
+      ans[i + 1] = digits[i];
+    }
+    return ans;
+  }
 
-    public int[] plusOneB(int[] digits) {
-        int count = digits.length;
-        while (count > 0) {
-            digits[count - 1] = digits[count - 1] + 1;
-            if (digits[count - 1] > 9) {
-                digits[count - 1] = 0;
-            } else {
-                return digits;
-            }
-            count--;
-        }
-        int[] result = new int[digits.length + 1];
-        result[0] = 1;
-        for (int i = 1; i < digits.length; i++) {
-            result[i] = digits[i - 1];
-        }
-        return result;
+  public int[] plusOneB(int[] digits) {
+    int count = digits.length;
+    while (count > 0) {
+      digits[count - 1] = digits[count - 1] + 1;
+      if (digits[count - 1] > 9) {
+        digits[count - 1] = 0;
+      } else {
+        return digits;
+      }
+      count--;
+    }
+    int[] result = new int[digits.length + 1];
+    result[0] = 1;
+    for (int i = 1; i < digits.length; i++) {
+      result[i] = digits[i - 1];
     }
+    return result;
+  }
 }

src/main/java/com/freetymekiyan/algorithms/level/hard/InsertInterval.java

@@ -26,57 +26,57 @@
  */
 public class InsertInterval {
 
-    /**
-     * Array. In-place solution.
-     * Skip the non-overlapping intervals whose end time is before new interval's start.
-     * For overlapped intervals that start before new interval end.
-     * | Remove this overlapped interval from list.
-     * | Merge it with the new interval by: 1. update start to min start times; 2. update end to max end times.
-     * Add new interval in the position i.
-     */
-    public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
-        int i = 0;
-        // Skip the non-overlapping intervals.
-        while (i < intervals.size() && intervals.get(i).end < newInterval.start) {
-            i++;
-        }
-        // Now i == intervals.size() OR intervals.get(i).end >= newInterval.start
-        while (i < intervals.size() && intervals.get(i).start <= newInterval.end) { // Compare current interval with merged new interval.
-            Interval inter = intervals.remove(i); // Remove the overlapped interval.
-            newInterval.start = Math.min(inter.start, newInterval.start);
-            newInterval.end = Math.max(inter.end, newInterval.end);
-        }
-        intervals.add(i, newInterval);
-        return intervals;
+  /**
+   * Array. In-place solution.
+   * Skip the non-overlapping intervals whose end time is before new interval's start.
+   * For overlapped intervals that start before new interval end.
+   * | Remove this overlapped interval from list.
+   * | Merge it with the new interval by: 1. update start to min start times; 2. update end to max end times.
+   * Add new interval in the position i.
+   */
+  public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
+    int i = 0;
+    // Skip the non-overlapping intervals.
+    while (i < intervals.size() && intervals.get(i).end < newInterval.start) {
+      i++;
     }
+    // Now i == intervals.size() OR intervals.get(i).end >= newInterval.start
+    while (i < intervals.size() && intervals.get(i).start <= newInterval.end) { // Compare current interval with merged new interval.
+      Interval inter = intervals.remove(i); // Remove the overlapped interval.
+      newInterval.start = Math.min(inter.start, newInterval.start);
+      newInterval.end = Math.max(inter.end, newInterval.end);
+    }
+    intervals.add(i, newInterval);
+    return intervals;
+  }
 
-    /**
-     * Array. Sort. Not in place solution. O(n) Time.
-     * Make use of intervals are sorted.
-     * Create a result list of intervals, res.
-     * Add new interval to res first.
-     * Go through the given intervals.
-     * For each interval i, there are 3 situations:
-     * 1) i and previous interval not overlapping, in front of the new interval.
-     * 2) No overlap, behind the new interval
-     * 3) Overlap, merge with the new interval
-     */
-    public List<Interval> insertB(List<Interval> intervals, Interval newInterval) {
-        List<Interval> res = new LinkedList<>();
-        res.add(newInterval);
-        for (Interval i : intervals) {
-            int start = res.get(res.size() - 1).start; // Last interval.
-            int end = res.get(res.size() - 1).end;
-            if (i.end < start) { // i ends before last interval.
-                res.add(res.size() - 1, i); // Insert it before last interval.
-            } else if (end < i.start) { // i starts after last interval.
-                res.add(i); // Append it to last.
-            } else { // i overlaps with last interval.
-                start = Math.min(start, i.start);
-                end = Math.max(end, i.end);
-                res.set(res.size() - 1, new Interval(start, end));
-            }
-        }
-        return res;
+  /**
+   * Array. Sort. Not in place solution. O(n) Time.
+   * Make use of intervals are sorted.
+   * Create a result list of intervals, res.
+   * Add new interval to res first.
+   * Go through the given intervals.
+   * For each interval i, there are 3 situations:
+   * 1) i and previous interval not overlapping, in front of the new interval.
+   * 2) No overlap, behind the new interval
+   * 3) Overlap, merge with the new interval
+   */
+  public List<Interval> insertB(List<Interval> intervals, Interval newInterval) {
+    List<Interval> res = new LinkedList<>();
+    res.add(newInterval);
+    for (Interval i : intervals) {
+      int start = res.get(res.size() - 1).start; // Last interval.
+      int end = res.get(res.size() - 1).end;
+      if (i.end < start) { // i ends before last interval.
+        res.add(res.size() - 1, i); // Insert it before last interval.
+      } else if (end < i.start) { // i starts after last interval.
+        res.add(i); // Append it to last.
+      } else { // i overlaps with last interval.
+        start = Math.min(start, i.start);
+        end = Math.max(end, i.end);
+        res.set(res.size() - 1, new Interval(start, end));
+      }
     }
+    return res;
+  }
 }