Solution is Added

Author: anjha1

0009.palindrome-number/PalindromeNumber.java

@@ -0,0 +1,16 @@
+class PalindromeNumber {
+    public boolean isPalindrome(int x) {
+        if (x == 0) {
+            return true;
+        }
+        if (x < 0 || x % 10 == 0) {
+            return false;
+        }
+        int right = 0;
+        while (x > right) {
+            right = right * 10 + x % 10;
+            x /= 10;
+        }
+        return x == right || x == right / 10;
+    }
+}

0009.palindrome-number/README.md

@@ -0,0 +1 @@
+# [9. Palindrome Number](https://leetcode.com/problems/palindrome-number/)

0011.container-with-most-water/ContainerWithMostWater.java

@@ -0,0 +1,15 @@
+class ContainerWithMostWater {
+    public int maxArea(int[] height) {
+        if (height.length == 0) return 0;
+        if (height.length == 1) return height[0];
+        int maxArea = 0, left = 0, right = height.length - 1;
+        while (left < right) {
+            int area = Math.min(height[left], height[right]) * (right - left);
+            maxArea = Math.max(maxArea, area);
+            if (height[left] > height[right]) right--;
+            else left++;
+        }
+
+        return maxArea;
+    }
+}

0011.container-with-most-water/README.md

@@ -0,0 +1 @@
+# [11. Container With Most Water](https://leetcode.com/problems/container-with-most-water/)

0012.integer-to-roman/IntegerToRoman.java

@@ -0,0 +1,15 @@
+class IntegerToRoman {
+    private final static int[] val = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+    private final static String[] rom = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
+
+    public String intToRoman(int num) {
+        StringBuilder res = new StringBuilder();
+        for (int i = 0; num > 0; i++) {
+            while (num >= val[i]) {
+                res.append(rom[i]);
+                num -= val[i];
+            }
+        }
+        return res.toString();
+    }
+}

0012.integer-to-roman/README.md

@@ -0,0 +1 @@
+# [12. Integer to Roman](https://leetcode.com/problems/integer-to-roman/)

0013.roman-to-integer/README.md

@@ -0,0 +1 @@
+# [13. Roman to Integer](https://leetcode.com/problems/roman-to-integer/)

0013.roman-to-integer/RomanToInteger.java

@@ -0,0 +1,28 @@
+class RomanToInteger {
+    private int getNum(char c) {
+        switch (c) {
+            case 'I': return 1;
+            case 'V': return 5;
+            case 'X': return 10;
+            case 'L': return 50;
+            case 'C': return 100;
+            case 'D': return 500;
+            case 'M': return 1000;
+        }
+        return 0;
+    }
+
+    public int romanToInt(String s) {
+        int res = 0;
+        char[] stringArray = s.toCharArray();
+        for (int i = 0; i < s.length(); i++) {
+            if (i + 1 < s.length() && getNum(stringArray[i]) < getNum(stringArray[i + 1])) {
+                res -= getNum(stringArray[i]);
+            } else {
+                res += getNum(stringArray[i]);
+            }
+        }
+
+        return res;
+    }
+}

0014.longest-common-prefix/LongestCommonPrefix.java

@@ -0,0 +1,13 @@
+class LongestCommonPrefix {
+    public String longestCommonPrefix(String[] strs) {
+        if (strs.length == 0) return "";
+        String prefix = strs[0];
+        for (int i = 1; i < strs.length; i++) {
+            while (strs[i].indexOf(prefix) != 0) {
+                prefix = prefix.substring(0, prefix.length() - 1);
+                if (prefix.isEmpty()) return "";
+            }
+        }
+        return prefix;
+    }
+}

0014.longest-common-prefix/README.md

@@ -0,0 +1 @@
+# [14. Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/)

0015.3sum/README.md

@@ -0,0 +1,6 @@
+# [15. 3Sum](https://leetcode.com/problems/3sum/)
+
+Complexity Analysis:
+
+- Time Complexity: $O(n^2)$. Sort’s time complexity is $O(n\log^n)$ and the iteration with two pointers is $O(n^2)$, so the total time complexity is $O(n^2)$.
+- Space Complexity: $O(n)$. $n$ is the length of nums. We use an extra ArrayList with complexity $O(3(n-2))$ to save the answer.

0015.3sum/ThreeSum.java

@@ -0,0 +1,39 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+class ThreeSum {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums);
+        List<List<Integer>> ans = new ArrayList<>();
+        int n = nums.length;
+
+        // we only want to find three numbers, so we just need to find length - 2 numbers.
+        for (int first = 0; first < n - 2; first++) {
+            // remove duplicates
+            if (first > 0 && nums[first] == nums[first - 1])
+                continue;
+
+            int second = first + 1;
+            int third = n - 1;
+            while (second < third) {
+                int threeSum = nums[first] + nums[second] + nums[third];
+                if (threeSum < 0)
+                    second++;
+                else if (threeSum > 0)
+                    third--;
+                else {
+                    ans.add(Arrays.asList(nums[first], nums[second], nums[third]));
+                    // remove duplicates in two pointers
+                    while (second < third && nums[second] == nums[second + 1])
+                        second++;
+                    while (second < third && nums[third] == nums[third - 1])
+                        third--;
+                    second++;
+                    third--;
+                }
+            }
+        }
+        return ans;
+    }
+}

0016.3sum-closest/README.md

@@ -0,0 +1 @@
+# [16. 3Sum Closest](https://leetcode.com/problems/3sum-closest/)

0016.3sum-closest/ThreeSumClosestClass.java

@@ -0,0 +1,20 @@
+import java.util.Arrays;
+
+class ThreeSumClosestClass {
+    public int threeSumClosest(int[] nums, int target) {
+        int result = nums[0] + nums[1] + nums[nums.length - 1];
+        Arrays.sort(nums);
+        for (int i = 0; i < nums.length; i++) {
+            int start = i + 1, end = nums.length - 1;
+            while (start < end) {
+                int sum = nums[i] + nums[start] + nums[end];
+                if (sum > target) end--;
+                else start++;
+                if (Math.abs(sum - target) < Math.abs(result - target)) {
+                    result = sum;
+                }
+            }
+        }
+        return result;
+    }
+}

0017.letter-combinations-of-a-phone-number/LetterCombinationsOfAPhoneNumber.java

@@ -0,0 +1,24 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+class LetterCombinationsOfAPhoneNumber {
+    private void backtrack(List<String> res, char[] digits, String s, String[] dict) {
+        if (s.length() == digits.length) {
+            res.add(s);
+            return;
+        }
+        int digit = digits[s.length()] - '0';
+        for (char letter : dict[digit].toCharArray()) {
+            backtrack(res, digits, s + Character.toString(letter), dict);
+        }
+    }
+
+    public List<String> letterCombinations(String digits) {
+        List<String> res = new ArrayList<>();
+        if (digits.length() == 0) return res;
+        String[] dict = new String[]{"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+        backtrack(res, digits.toCharArray(), "", dict);
+        return res;
+    }
+}

0017.letter-combinations-of-a-phone-number/README.md

@@ -0,0 +1 @@
+# [17. Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/)