added 0013_roman_integer.py

Author: nyierr

problems/easy/0013_roman_integer.py

@@ -0,0 +1,88 @@
+"""
+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, 2 is written as II in Roman numeral, just two
+one's added together. 12 is written as XII, which is simply X + II.
+The number 27 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.
+
+Example 1:
+  Input: s = "III"
+  Output: 3
+  Explanation: III = 3.
+
+Example 2:
+  Input: s = "LVIII"
+  Output: 58
+  Explanation: L = 50, V= 5, III = 3.
+
+Example 3:
+  Input: s = "MCMXCIV"
+  Output: 1994
+  Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
+
+Constraints:
+  * 1 <= s.length <= 15
+  * s contains only the characters ('I', 'V', 'X', 'L', 'C', 'D', 'M').
+  * It is guaranteed that s is a valid roman numeral in the range [1, 3999].
+"""
+
+class Solution:
+    # O(n) approach, using two mappings 
+    #def romanToInt(self, s: str) -> int:
+    #   mapping = {'I':1, 'V':5, 'X':10, 'L':50,
+    #       'C':100, 'D':500, 'M':1000}
+    
+    #   special = {'IV':4, 'IX':9, 'XL': 40, 'XC':90,
+    #       'CD':400, 'CM':900}
+    
+    #   t = 0
+    #   i = 0
+    #   while i < len(s):
+    #       if i < len(s) - 1 and s[i:i+2] in special:
+    #           t += special[s[i:i+2]]
+    #           i += 2
+    #       else:
+    #           t += mapping[s[i]]
+    #           i += 1
+                
+    #   return t
+  
+    # O(n) approach, but we go from right to left -
+    # if s[i] < s[i+1], then we subtract s[i] instead of
+    # adding it
+    def romanToInt(self, s: str) -> int:
+        mapping = {'I':1, 'V':5, 'X':10, 'L':50,
+            'C':100, 'D':500, 'M':1000}
+        
+        t = mapping[s[len(s)-1]]
+        i = len(s) - 2
+        while i >= 0:
+            factor = 1
+            if mapping[s[i]] < mapping[s[i+1]]:
+                factor = -1
+               
+            t += factor * mapping[s[i]]           
+            i -= 1
+            
+        return t