13. Roman to Integer

Author: zhangbo54

src/leetcode/_12_/md.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];
+    }
+}
+```

src/leetcode/_13_/Main.java

@@ -0,0 +1,38 @@
+package leetcode._13_;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by zhangbo54 on 2019-03-04.
+ */
+public class Main {
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.romanToInt("LVIII"));
+        // Integer.parseInt("1" + Integer.MAX_VALUE);
+    }
+
+    static
+    class Solution {
+        public int romanToInt(String s) {
+            int result = 0;
+            List<String> M = Arrays.asList("MMM", "MM", "M");
+            List<String> C = Arrays.asList("CM", "DCCC", "DCC", "DC", "D", "CD", "CCC", "CC", "C");
+            List<String> X = Arrays.asList("XC", "LXXX", "LXX", "LX", "L", "XL", "XXX", "XX", "X");
+            List<String> I = Arrays.asList("IX", "VIII", "VII", "VI", "V", "IV", "III", "II", "I");
+            List<List<String>> list = Arrays.asList(M, C, X, I);
+            int size = 1000;
+            for (List<String> item : list) {
+                for (int i = 0; i < item.size(); i++) {
+                    if (s.startsWith(item.get(i))) {
+                        result += (item.size() - i) * size;
+                        s = s.substring(item.get(i).length());
+                    }
+                }
+                size /= 10;
+            }
+            return result;
+        }
+    }
+}

src/leetcode/_13_/Main2.java

@@ -0,0 +1,52 @@
+package leetcode._13_;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by zhangbo54 on 2019-03-04.
+ */
+public class Main2 {
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.romanToInt("LVIII"));
+        // Integer.parseInt("1" + Integer.MAX_VALUE);
+    }
+
+    static
+    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;
+            }
+        }
+    }
+}

src/leetcode/_13_/solution1.md

@@ -0,0 +1,89 @@
+### [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;
+        List<String> M = Arrays.asList("MMM", "MM", "M");
+        List<String> C = Arrays.asList("CM", "DCCC", "DCC", "DC", "D", "CD", "CCC", "CC", "C");
+        List<String> X = Arrays.asList("XC", "LXXX", "LXX", "LX", "L", "XL", "XXX", "XX", "X");
+        List<String> I = Arrays.asList("IX", "VIII", "VII", "VI", "V", "IV", "III", "II", "I");
+        List<List<String>> list = Arrays.asList(M, C, X, I);
+        int size = 1000;
+        for (List<String> item : list) {
+            for (int i = 0; i < item.size(); i++) {
+                if (s.startsWith(item.get(i))) {
+                    result += (item.size() - i) * size;
+                    s = s.substring(item.get(i).length());
+                }
+            }
+            size /= 10;
+        }
+        return result;
+    }
+}
+            case 'I':
+```

src/leetcode/_13_/solution2.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;
+        }
+    }
+}
+```