如何使用以下逻辑在 python 中编写罗马数字到 integer 转换的逻辑

Question

我正在尝试将给定的罗马数字转换为仅用于编程练习的数字，使用以下逻辑（我不想更改此逻辑，除非它被错误地认为）在这里，

M - 1000, C-100, X-10, V-5, I-1

例子：

Input - MCMXCVI

Expected Result - 1996

逻辑 - 1000 + (1000-100) + (100-10) + 5 + 1

索引1 + (3-2) + (5-4) + 6 + 7

在这里，我正在从当前值中搜索下一个值，如果它不大于我们通常添加它，则减去它。

这是我尝试过的，我无法正确编码，花了很多时间，想寻求帮助。

def roman_numeral(num):
    """
    Write a Python class to convert an roman numeral to a integer.
    Logic: https://www.rapidtables.com/convert/number/how-roman-numerals-to-number.html
    """
    # Input the string 
    # Map of roman numerals and the corresponding values in a dictionary.
    NUMERALS = {1000:'M', 900:'CM', 500:'D', 400:'CD', 100:'C', 90:'XC',
                50:'L', 40:'XL', 10:'X', 9:'IX', 5:'V', 4:'IV', 1:'I'}
    retval=[]
     
    #Check if each char matches with the dictionary and take the numerical value of the inputed roman 
     
    for k in range(len(num)):
        for i,j in NUMERALS.items():
            if(j==num[k]):
                retval.append(i)
                 
    elm_count = len(retval)       
    result=0 
    result_less=0
    result_more=0
    ind_tracker=0
     
#Check if next char from the position of current char if that numerical value is greater then current numerical value.
#If it is greater subtract the current numeric value, if not greater then add it.    
    for ind,i in enumerate(retval):
        print('ind= ',ind,'i= ', i)
#Using this below condition to skip if we have already subtracted the current value from previous value.
        if( ind_tracker>ind):
            continue
        if((ind+1 < elm_count)):
                if(i<retval[ind+1]):
                    #print('result=',result,'retval[ind]=',retval[ind],'retval[ind+1]=', retval[ind+1])
                    result_less=retval[ind+1]-retval[ind]
                    print('result_less=',result_less)
                    ind_tracker=ind+1
                else:
                    result_more+=retval[ind]+result_less
                    print('result_more=',result_more)
                     
                    result=result_more   
    print('final result= ',result)    
    return result
 
roman_numeral('MCMXCVI')

我得到的 output 是

3185 

我希望得到

1996

Answer 1

您可以使用（自行实现）：

class RomanToDecimal:
    conversion = {'M': 1000, 'CM': 900, 'D': 500, 'CD': 400, 'C': 100, 'XC': 90, 'L': 50, 'XL': 40, 'X': 10, 'IX': 9,
                  'V': 5, 'IV': 4, 'I': 1}

    def convert(self, roman):
        total = 0
        while len(roman):
            before = len(roman)
            for key in self.conversion:
                if roman.startswith(key):
                    total += self.conversion[key]
                    roman = roman[len(key):]
            after = len(roman)
            if before == after:
                raise ValueError("Not a Roman numeral.")
        return total

try:
    rtd = RomanToDecimal()
    assert rtd.convert('M') == 1000
    assert rtd.convert('XXXVI') == 36
    assert rtd.convert('MMXII') == 2012
    assert rtd.convert('MMXX') == 2020
except ValueError as error:
    print(error)

Answer 2

您可以更改基本概念。 如果您反转罗马数字并基本上从字符串的右侧开始，那么整个事情就会变得非常简单。

这个想法是，如果您从右侧开始，如果下一个数字大于或等于当前数字，则将该数字添加到总数中，如果下一个数字小于前一个数字，则从总数中减去。

roman = "MCMXCVI"

NUMERALS = {1000:'M', 900:'CM', 500:'D', 400:'CD', 100:'C', 90:'XC',
                50:'L', 40:'XL', 10:'X', 9:'IX', 5:'V', 4:'IV', 1:'I'}

# reverse roman number letters (basically start from the end
roman_reversed = list(reversed(roman))
#invert the dictionary because we want to translate the letter to numbers not the other way around
inverse_NUMERALS = {v: k for k, v in NUMERALS.items()}

# get the number for each character on its own:
lst_numbers = [inverse_NUMERALS.get(x) for x in roman_reversed]


# loop through the list of numbers
total = 0
previous = 0
for numb in lst_numbers:
    if numb >= previous:
        total += numb
    else:
        total -= numb
    previous = numb
    
print(total)
#Out[21]: 1996

Answer 3

我对您现有的代码做了一些小改动！

1. 我添加了一个变量“flag”，默认设置为 False，当 result_less 时，我将其设置为 true
2. 为了检查我们是否减去，我使用了这个标志，当标志为真时，我将其设为假并跳过迭代。
3. 添加了一个新的 if 语句来检查最后一个数字
4. 在 result_more 上，result+=retval[ind]，没有使用 result_less 值
5. 在 result_less 上，result+=retval[ind+1]-retval[ind]。 在这两种情况下，为了简单起见，我都更改了结果值，而不是更改更多和更少的值。

顺便说一句，我摆脱了那些 result_more 和 result_less 变量，但保留了打印语句。

这是您的代码，已修改：

def roman_numeral(num):
    """
    Write a Python class to convert an roman numeral to a integer.
    Logic: https://www.rapidtables.com/convert/number/how-roman-numerals-to-number.html
    """
    # Input the string 
    # Map of roman numerals and the corresponding values in a dictionary.
    NUMERALS = {1000:'M', 900:'CM', 500:'D', 400:'CD', 100:'C', 90:'XC',
                50:'L', 40:'XL', 10:'X', 9:'IX', 5:'V', 4:'IV', 1:'I'}
    retval=[]
     
    #Check if each char matches with the dictionary and take the numerical value of the inputed roman 
     
    for k in range(len(num)):
        for i,j in NUMERALS.items():
            if(j==num[k]):
                retval.append(i)

    elm_count = len(retval)       
    result=0 
    result_less=0
    result_more=0
    # ind_tracker=0
    flag = False
    
    #Check if next char from the position of current char if that numerical value is greater then current numerical value.
    #If it is greater subtract the current numeric value, if not greater then add it.   

    for ind,i in enumerate(retval):
        print('ind= ',ind,'i= ', i)
        #Using this below condition to skip if we have already subtracted the current value from previous value.
        # if( ind_tracker>ind):
        #     continue
        
        if(flag):
          print("Skipped! Already Subracted!")
          flag=False
          continue
        
        if((ind+1 == elm_count)):
          # if last digit is greater than it's previous, the flag will skip this iteration
          print('last digit=',retval[ind])   
           result+=retval[ind]
        
        if((ind+1 < elm_count)):
                if(i<retval[ind+1]):
                    #print('result=',result,'retval[ind]=',retval[ind],'retval[ind+1]=', retval[ind+1])
                    # result_less=retval[ind+1]-retval[ind]
                    result+=retval[ind+1]-retval[ind]
                    print('result_less=',retval[ind+1]-retval[ind])
                    # ind_tracker=ind+1
                    flag = True
                else:
                    # result_more+=retval[ind]+result_less
                    result+=retval[ind]
                    print('result_more=',retval[ind])            
                    # result=result_more   
    
    print('final result= ',result)    
    return result

roman_numeral('MCMXCVI')