Merge branch 'master' of https://github.com/javadev/leetcode-in-java

Author: javadev

Diff for: src/main/java/s0001.two.sum/Solution.java

@@ -21,7 +21,7 @@ public int[] twoSum(int[] nums, int target) {
                 left++;
             }
         }
-        
+
         for (int i = 0; i < nums.length; i++) {
             if (nums1[left] == nums[i]) {
                 result[0] = i;
@@ -34,7 +34,7 @@ public int[] twoSum(int[] nums, int target) {
                 break;
             }
         }
-        
+
         int tmp = result[0];
         result[0] = Math.min(result[0], result[1]);
         result[1] = Math.max(tmp, result[1]);

Diff for: src/main/java/s0002.add.two.numbers/ListNode.java

@@ -3,6 +3,7 @@
 public class ListNode {
     int val;
     ListNode next;
+
     ListNode(int x) {
         val = x;
     }

Diff for: src/main/java/s0002.add.two.numbers/Solution.java

@@ -1,12 +1,8 @@
 package s0002.add.two.numbers;
 
 /**
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
+ * Definition for singly-linked list. public class ListNode { int val; ListNode next; ListNode(int
+ * x) { val = x; } }
  */
 public class Solution {
     public ListNode addTwoNumbers(ListNode l1, ListNode l2) {

Diff for: src/main/java/s0003.longest.substring.without.repeating.characters/Solution.java

@@ -3,10 +3,10 @@
 public class Solution {
     public int lengthOfLongestSubstring(String s) {
         int lastIndices[] = new int[256];
-        for (int i = 0; i<256; i++) {
+        for (int i = 0; i < 256; i++) {
             lastIndices[i] = -1;
         }
-        
+
         int maxLen = 0;
         int curLen = 0;
         int start = 0;
@@ -22,13 +22,13 @@ public int lengthOfLongestSubstring(String s) {
                 curLen = i - start + 1;
                 lastIndices[cur] = i;
             }
-            
+
             if (curLen > maxLen) {
                 maxLen = curLen;
                 bestStart = start;
             }
         }
-        
+
         return maxLen;
     }
 }

Diff for: src/main/java/s0004.median.of.two.sorted.arrays/Solution.java

@@ -6,18 +6,14 @@
 
 public class Solution {
     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
-        List<Integer> l=new ArrayList<Integer>();
+        List<Integer> l = new ArrayList<Integer>();
         double f;
-        for(int i=0;i<nums1.length;i++) 
-            l.add(nums1[i]);
-        for(int j=0;j<nums2.length;j++)
-               l.add(nums2[j]);
+        for (int i = 0; i < nums1.length; i++) l.add(nums1[i]);
+        for (int j = 0; j < nums2.length; j++) l.add(nums2[j]);
         Collections.sort(l);
-        int k=l.size();
-        if(k%2==0)
-           f=(double)((l.get(k/2-1))+(l.get(k/2)))/2;
-        else 
-            f = l.get(((k + 1) / 2)-1);
+        int k = l.size();
+        if (k % 2 == 0) f = (double) ((l.get(k / 2 - 1)) + (l.get(k / 2))) / 2;
+        else f = l.get(((k + 1) / 2) - 1);
         return f;
     }
 }

Diff for: src/main/java/s0005.longest.palindromic.substring/Solution.java

@@ -5,7 +5,8 @@ public String longestPalindrome(String s) {
         int start = 0, end = 0;
         char[] cs = s.toCharArray();
         for (int i = 0, max = 0, prev = 0; i < cs.length; ++i) {
-            if (i - max - 1 >= 0 && cs[i - max - 1] == cs[i]
+            if (i - max - 1 >= 0
+                    && cs[i - max - 1] == cs[i]
                     && (prev == i - 1 || isPalindrome(cs, i - max, i))) {
                 start = i - max - 1;
                 end = i + 1;

Diff for: src/main/java/s0006.zigzag.conversion/Solution.java

@@ -2,19 +2,19 @@
 
 public class Solution {
     public String convert(String s, int numRows) {
-        if(s==null||s.length()<=numRows||numRows==1) return s;
+        if (s == null || s.length() <= numRows || numRows == 1) return s;
         char letters[] = new char[s.length()];
-        for(int i=0,k=0;i<numRows;i++){
-            if(i==0||i==numRows-1){
-                for(int j=i;j<s.length();j+=2*numRows-2){
-                    letters[k++]=s.charAt(j);
+        for (int i = 0, k = 0; i < numRows; i++) {
+            if (i == 0 || i == numRows - 1) {
+                for (int j = i; j < s.length(); j += 2 * numRows - 2) {
+                    letters[k++] = s.charAt(j);
                 }
                 continue;
             }
-            letters[k++]=s.charAt(i);
-            for(int j=2*numRows-2-i;j<s.length();j+=2*numRows-2){
-                    letters[k++]=s.charAt(j);
-                    if(j+2*i<s.length()) letters[k++]=s.charAt(j+2*i);
+            letters[k++] = s.charAt(i);
+            for (int j = 2 * numRows - 2 - i; j < s.length(); j += 2 * numRows - 2) {
+                letters[k++] = s.charAt(j);
+                if (j + 2 * i < s.length()) letters[k++] = s.charAt(j + 2 * i);
             }
         }
         return new String(letters);

Diff for: src/main/java/s0007.reverse.integer/Solution.java

@@ -2,7 +2,7 @@
 
 public class Solution {
     public int reverse(int x) {
-        long rev = 0; 
+        long rev = 0;
         while (x != 0) {
             rev = (rev * 10) + (x % 10);
             x /= 10;

Diff for: src/main/java/s0008.string.to.integer.atoi/Solution.java

@@ -2,15 +2,14 @@
 
 public class Solution {
     public int myAtoi(String str) {
-        if (str == null || str.length() == 0)
-            return 0;
+        if (str == null || str.length() == 0) return 0;
 
         int i = 0;
         boolean negetiveSign = false;
         char[] input = str.toCharArray();
 
         while (i < input.length && input[i] == ' ') {
-            i++;  
+            i++;
         }
 
         if (i == input.length) {
@@ -24,7 +23,7 @@ public int myAtoi(String str) {
 
         int num = 0;
         while (i < input.length && input[i] <= '9' && input[i] >= '0') {
-            int tem = input[i] - '0';  //current char
+            int tem = input[i] - '0'; // current char
             tem = negetiveSign ? -tem : tem;
 
             if (num == 0 && tem == '0') { // avoid invalid number like 038

Diff for: src/main/java/s0009.palindrome.number/Solution.java

@@ -7,11 +7,10 @@ public boolean isPalindrome(int x) {
         }
         int rev = 0;
         int localX = x;
-        while (localX > 0)
-        {
-          rev *= 10;
-          rev += localX % 10;
-          localX /= 10;
+        while (localX > 0) {
+            rev *= 10;
+            rev += localX % 10;
+            localX /= 10;
         }
         return rev == x;
     }

Diff for: src/main/java/s0010.regular.expression.matching/Solution.java

@@ -0,0 +1,25 @@
+package s0010.regular.expression.matching;
+
+public class Solution {
+    public boolean isMatch(String s, String p) {
+        Boolean dp[][] = new Boolean[s.length() + 1][p.length() + 1];
+        return isMatch(s, p, 0, 0, dp);
+    }
+
+    public boolean isMatch(String s, String p, int i, int j, Boolean dp[][]) {
+        if (i == s.length() && j == p.length()) {
+            return true;
+        }
+        if (j == p.length()) {
+            return false;
+        }
+        if (dp[i][j] != null) {
+            return dp[i][j];
+        }
+        boolean ans = i < s.length() && (s.charAt(i) == p.charAt(j) || p.charAt(j) == '.');
+        if (j + 1 < p.length() && p.charAt(j + 1) == '*') {
+            return dp[i][j] = isMatch(s, p, i, j + 2, dp) || (ans && isMatch(s, p, i + 1, j, dp));
+        }
+        return dp[i][j] = ans && isMatch(s, p, i + 1, j + 1, dp);
+    }
+}

Diff for: src/main/java/s0011.container.with.most.water/Solution.java

@@ -0,0 +1,21 @@
+package s0011.container.with.most.water;
+
+public class Solution {
+    public int maxArea(int[] height) {
+        int max_area = -1;
+        int left = 0;
+        int right = height.length - 1;
+
+        while (left < right) {
+            if (height[left] < height[right]) {
+                max_area = Math.max(max_area, height[left] * (right - left));
+                left++;
+            } else {
+                max_area = Math.max(max_area, height[right] * (right - left));
+                right--;
+            }
+        }
+
+        return max_area;
+    }
+}

Diff for: src/main/java/s0012.integer.to.roman/Solution.java

@@ -0,0 +1,93 @@
+package s0012.integer.to.roman;
+
+public class Solution {
+    public String intToRoman(int num) {
+
+        StringBuilder sb = new StringBuilder();
+        int m = 1000;
+        int d = 500;
+        int c = 100;
+        int l = 50;
+        int x = 10;
+        int v = 5;
+        int i = 1;
+
+        num = numerals(sb, num, 0, 0, m, ' ', ' ', 'M');
+        num = numerals(sb, num, m, d, c, 'M', 'D', 'C');
+        num = numerals(sb, num, c, l, x, 'C', 'L', 'X');
+        num = numerals(sb, num, x, v, i, 'X', 'V', 'I');
+
+        return sb.toString();
+    }
+
+    public int numerals(
+            StringBuilder sb,
+            int num,
+            int ten,
+            int five,
+            int one,
+            char c_ten,
+            char c_five,
+            char c_one) {
+        int div = num / one;
+        switch (div) {
+            case 9:
+                {
+                    sb.append(c_one);
+                    sb.append(c_ten);
+                    break;
+                }
+            case 8:
+                {
+                    sb.append(c_five);
+                    sb.append(c_one);
+                    sb.append(c_one);
+                    sb.append(c_one);
+                    break;
+                }
+            case 7:
+                {
+                    sb.append(c_five);
+                    sb.append(c_one);
+                    sb.append(c_one);
+                    break;
+                }
+            case 6:
+                {
+                    sb.append(c_five);
+                    sb.append(c_one);
+                    break;
+                }
+            case 5:
+                {
+                    sb.append(c_five);
+                    break;
+                }
+            case 4:
+                {
+                    sb.append(c_one);
+                    sb.append(c_five);
+                    break;
+                }
+            case 3:
+                {
+                    sb.append(c_one);
+                    sb.append(c_one);
+                    sb.append(c_one);
+                    break;
+                }
+            case 2:
+                {
+                    sb.append(c_one);
+                    sb.append(c_one);
+                    break;
+                }
+            case 1:
+                {
+                    sb.append(c_one);
+                    break;
+                }
+        }
+        return num - (div * one);
+    }
+}

Diff for: src/main/java/s0307.range.sum.query.mutable/NumArray.java

@@ -0,0 +1,40 @@
+package s0307.range.sum.query.mutable;
+
+public class NumArray {
+    private int[] nums;
+    private int sum;
+
+    public NumArray(int[] nums) {
+        this.nums = nums;
+        sum = 0;
+        for (int i = 0; i < nums.length; i++) {
+            sum += nums[i];
+        }
+    }
+
+    public void update(int index, int val) {
+        sum -= nums[index] - val;
+        nums[index] = val;
+    }
+
+    public int sumRange(int left, int right) {
+        int sumRange = 0;
+        if ((right - left) < nums.length / 2) {
+            // Array to sum is less than half
+            for (int i = left; i <= right; i++) {
+                sumRange += nums[i];
+            }
+        } else {
+            // Array to sum is more than half
+            // Better to take total sum and substract the numbers not in range
+            sumRange = sum;
+            for (int i = 0; i < left; i++) {
+                sumRange -= nums[i];
+            }
+            for (int i = right + 1; i < nums.length; i++) {
+                sumRange -= nums[i];
+            }
+        }
+        return sumRange;
+    }
+}

Diff for: src/test/java/s0001.two.sum/SolutionTest.java

@@ -2,11 +2,14 @@
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
+
 import org.junit.Test;
 
 public class SolutionTest {
     @Test
     public void twoSum() {
-        assertThat(java.util.Arrays.toString(new Solution().twoSum(new int[] {2, 7, 11, 15}, 9)), equalTo("[0, 1]"));
+        assertThat(
+                java.util.Arrays.toString(new Solution().twoSum(new int[] {2, 7, 11, 15}, 9)),
+                equalTo("[0, 1]"));
     }
 }