init markdown dir

Author: coderbean

markdown/11. Container With Most Water.md

@@ -0,0 +1,42 @@
+### [11\. Container With Most Water](https://leetcode.com/problems/container-with-most-water/)
+
+Difficulty: **Medium**
+
+
+Given _n_ non-negative integers _a<sub style="display: inline;">1</sub>_, _a<sub style="display: inline;">2</sub>_, ..., _a<sub style="display: inline;">n </sub>_, where each represents a point at coordinate (_i_, _a<sub style="display: inline;">i</sub>_). _n_ vertical lines are drawn such that the two endpoints of line _i_ is at (_i_, _a<sub style="display: inline;">i</sub>_) and (_i_, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.
+
+**Note: **You may not slant the container and _n_ is at least 2.
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/07/17/question_11.jpg)
+
+<small style="display: inline;">The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49\.</small>
+
+**Example:**
+
+```
+Input: [1,8,6,2,5,4,8,3,7]
+Output: 49```
+
+
+#### Solution
+
+Language: **Java**
+
+```java
+class Solution {
+    public int maxArea(int[] height) {
+        int i = 0;
+        int j = height.length - 1;
+        int water = 0;
+        while (i < j) {
+            water = Math.max((j - i) * Math.min(height[i], height[j]), water);
+            if (height[i] < height[j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return water;
+    }
+}
+```

markdown/12. Integer to Roman.md

@@ -0,0 +1,76 @@
+### [12\. Integer to Roman](https://leetcode.com/problems/integer-to-roman/)
+
+Difficulty: **Medium**
+
+
+Roman numerals are represented by seven different symbols: `I`, `V`, `X`, `L`, `C`, `D` and `M`.
+
+```
+Symbol       Value
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000```
+
+For example, two is written as `II` in Roman numeral, just two one's added together. Twelve is written as, `XII`, which is simply `X` + `II`. The number twenty seven is written as `XXVII`, which is `XX` + `V` + `II`.
+
+Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not `IIII`. Instead, the number four is written as `IV`. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as `IX`. There are six instances where subtraction is used:
+
+*   `I` can be placed before `V` (5) and `X` (10) to make 4 and 9. 
+*   `X` can be placed before `L` (50) and `C` (100) to make 40 and 90. 
+*   `C` can be placed before `D` (500) and `M` (1000) to make 400 and 900.
+
+Given an integer, convert it to a roman numeral. Input is guaranteed to be within the range from 1 to 3999.
+
+**Example 1:**
+
+```
+Input: 3
+Output: "III"```
+
+**Example 2:**
+
+```
+Input: 4
+Output: "IV"```
+
+**Example 3:**
+
+```
+Input: 9
+Output: "IX"```
+
+**Example 4:**
+
+```
+Input: 58
+Output: "LVIII"
+Explanation: L = 50, V = 5, III = 3.
+```
+
+**Example 5:**
+
+```
+Input: 1994
+Output: "MCMXCIV"
+Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.```
+
+
+#### Solution
+
+Language: **Java**
+
+```java
+class Solution {
+    public String intToRoman(int num) {
+        String M[] = {"", "M", "MM", "MMM"};
+        String C[] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
+        String X[] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
+        String I[] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
+        return M[num/1000] + C[(num%1000)/100] + X[(num%100)/10] + I[num%10];
+    }
+}
+```

markdown/13. Roman to Integer.md

@@ -0,0 +1,102 @@
+### [13\. Roman to Integer](https://leetcode.com/problems/roman-to-integer/)
+
+Difficulty: **Easy**
+
+
+Roman numerals are represented by seven different symbols: `I`, `V`, `X`, `L`, `C`, `D` and `M`.
+
+```
+Symbol       Value
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000```
+
+For example, two is written as `II` in Roman numeral, just two one's added together. Twelve is written as, `XII`, which is simply `X` + `II`. The number twenty seven is written as `XXVII`, which is `XX` + `V` + `II`.
+
+Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not `IIII`. Instead, the number four is written as `IV`. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as `IX`. There are six instances where subtraction is used:
+
+*   `I` can be placed before `V` (5) and `X` (10) to make 4 and 9. 
+*   `X` can be placed before `L` (50) and `C` (100) to make 40 and 90. 
+*   `C` can be placed before `D` (500) and `M` (1000) to make 400 and 900.
+
+Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999.
+
+**Example 1:**
+
+```
+Input: "III"
+Output: 3```
+
+**Example 2:**
+
+```
+Input: "IV"
+Output: 4```
+
+**Example 3:**
+
+```
+Input: "IX"
+Output: 9```
+
+**Example 4:**
+
+```
+Input: "LVIII"
+Output: 58
+Explanation: L = 50, V= 5, III = 3.
+```
+
+**Example 5:**
+
+```
+Input: "MCMXCIV"
+Output: 1994
+Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.```
+
+
+#### Solution
+
+Language: **Java**
+
+```java
+class Solution {
+    public int romanToInt(String s) {
+        int result = 0;
+        for (int i = 0; i < s.length(); i++) {
+            int cur = getInt(s.charAt(i));
+            if (i + 1 < s.length() && getInt(s.charAt(i + 1)) > getInt(s.charAt(i))) {
+                result -= cur;
+            } else {
+                result += cur;
+            }
+        }
+        return result;
+    }
+​
+    private int getInt(char ch) {
+        switch (ch) {
+            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;
+            default:
+                return 0;
+        }
+    }
+}
+```

markdown/14. Longest Common Prefix.md

@@ -0,0 +1,62 @@
+### [14\. Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/)
+
+Difficulty: **Easy**
+
+
+Write a function to find the longest common prefix string amongst an array of strings.
+
+If there is no common prefix, return an empty string `""`.
+
+**Example 1:**
+
+```
+Input: ["flower","flow","flight"]
+Output: "fl"
+```
+
+**Example 2:**
+
+```
+Input: ["dog","racecar","car"]
+Output: ""
+Explanation: There is no common prefix among the input strings.
+```
+
+**Note:**
+
+All given inputs are in lowercase letters `a-z`.
+
+
+#### Solution
+
+Language: **Java**
+
+```java
+class Solution {
+    public String longestCommonPrefix(String[] strs) {
+        if (strs.length == 0) {
+            return "";
+        }
+​
+        if (strs.length == 1) {
+            return strs[0];
+        }
+        int minLenth = strs[0].length();
+​
+        for (String str : strs) {
+            if (minLenth > str.length()) {
+                minLenth = str.length();
+            }
+        }
+​
+        for (int longPrefixIndex = 0; longPrefixIndex < minLenth; longPrefixIndex++) {
+            for (int j = 0; j < strs.length - 1; j++) {
+                if (strs[j].charAt(longPrefixIndex) != strs[j + 1].charAt(longPrefixIndex)) {
+                    return strs[0].substring(0, longPrefixIndex);
+                }
+            }
+        }
+        return "";
+    }
+}
+```

markdown/15. 3Sum.md

@@ -0,0 +1,75 @@
+### [15\. 3Sum](https://leetcode.com/problems/3sum/)
+
+Difficulty: **Medium**
+
+
+Given an array `nums` of _n_ integers, are there elements _a_, _b_, _c_ in `nums` such that _a_ + _b_ + _c_ = 0? Find all unique triplets in the array which gives the sum of zero.
+
+**Note:**
+
+The solution set must not contain duplicate triplets.
+
+**Example:**
+
+```
+Given array nums = [-1, 0, 1, 2, -1, -4],
+
+A solution set is:
+[
+  [-1, 0, 1],
+  [-1, -1, 2]
+]
+```
+
+
+#### Solution
+
+Language: **Java**
+
+```java
+class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        if (nums.length < 3) {
+            return Collections.emptyList();
+        }
+​
+        Arrays.sort(nums); // 排序用于剔除重复项
+        Set<List<Integer>> resultSet = new HashSet<>();
+        Map<Integer, List<Integer>> index = new HashMap<>();
+        // List<Integer> numList = new ArrayList<>();
+        for (int i = 0; i < nums.length; i++) {
+            index.computeIfAbsent(nums[i], k -> new ArrayList<>());
+            index.get(nums[i]).add(i);
+        }
+​
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] > 0) {
+                continue;
+            }
+            if (i > 0 && nums[i] == nums[i - 1]) {
+                continue;
+            }
+​
+            for (int j = i + 1; j < nums.length; j++) {
+                int sum = nums[i] + nums[j];
+                if (-sum < nums[j] || -sum > nums[nums.length - 1]) {
+                    continue;
+                }
+                List<Integer> integers = Arrays.asList(nums[i], nums[j], -sum);
+                if (resultSet.contains(integers)) {
+                    continue;
+                }
+                if (index.get(-sum) != null) {
+                    for (Integer integer : index.get(-sum)) {
+                        if (integer > j) {
+                            resultSet.add(integers);
+                        }
+                    }
+                }
+            }
+        }
+        return new ArrayList<>(resultSet);
+    }
+}
+​
+```