Преобразование римских чисел в целые числа в python

Ответ 1

Рассмотрим этот дополнительный псевдокод и подсказки (некоторые из них действительны для Python, некоторые - нет, но есть заметки).

def numberOfNumeral(n):
    """ Return the number represented by the single numeral """
    # e.g. "v" -> 5, "i" -> 5 (and handle v/V cases, etc.)

# avoid "string" as a variable name
# I chose "ns" for "numerals" (which might be better),
# but I'm also a bit terse .. anyway, name variables for what they represents.
ns = str(input("Enter a roman numeral"))

while ns:
   firstNum = numberOfNumeral(ns[0])
   # This makes secondValue = -1 when there is only one numeral left
   # so firstNum is always "at least" secondNum when len(ns) == 1. 
   secondNum = numberOfNumeral(ns[1]) if len(ns) > 1 else -1
   if firstNum is at least secondNum:
      # Add firstNum to total.
      # Remove the character - so that the loop state advances.
      # If we don't don't his, as in the original, it will never end.
      # Here we use "slice notation".
      ns = ns[1:] 
   else:
      # Add the difference, secondNum - firstNum, to total.
      # Remove both characters - again, so we advance state.
      ns = ns[2:]

• Объяснить нотацию фрагмента Python
• У Python есть тернарный условный оператор?

Ответ 2

Не нужно изобретать велосипед (если вы этого не хотите). Python поставляется с конвертером:

import roman;
n=roman.fromRoman("X"); #n becomes 10

Если вам это нужно для номеров 5000 и выше, вам нужно будет написать новую функцию, и, возможно, сделать свой собственный шрифт для представления строк по римским цифрам. (Он будет работать только с некоторыми номерами, при этом остановка на 4999 - это действительно хорошая идея.)

Чтобы преобразовать в римские цифры, используйте roman.toRoman(myInt).

Кто-то еще на самом деле связан с одним и тем же исходным кодом, который использует roman-модуль в одном из комментариев выше, но я не думаю, что они упомянули, что он действительно поставляется с Python.

EDIT: Обратите внимание, что на некоторых системах (я думаю, Windows) вы не можете просто набрать import roman из установки по умолчанию. Тем не менее, исходный код по-прежнему работает в Windows, и он включен в загрузку исходного кода Python 3.4.1 (возможно, более ранние версии) в этом месте /Python-3.4.1/Doc/tools/roman.py

Ответ 3

Римские цифры читаются слева направо, когда вы добавляете или вычитаете значение каждого символа.

Если значение ниже, чем следующее значение, оно будет вычтено. В противном случае это будет добавлено.

Например, мы хотим преобразовать римскую цифру MCMLIV в арабское число:

M = 1000 must be added, because the following letter C =100 is lower.
C = 100 must be subtracted because the following letter M =1000 is greater.
M = 1000 must be added, because the following letter L = 50 is lower.
L = 50 must be added, because the following letter I =1 is lower.
I = 1 must be subtracted, because the following letter V = 5 is greater.
V = 5 must be added, because there are no more symbols left.

Теперь мы можем рассчитать число:

1000 - 100 + 1000 + 50 - 1 + 5 = 1954 

ссылка: http://www.mathinary.com/roman_numerals_from_roman_numerals_to_arabic_numbers.jsp

def from_roman(num):
    roman_numerals = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
    result = 0
    for i,c in enumerate(num):
        if (i+1) == len(num) or roman_numerals[c] >= roman_numerals[num[i+1]]:
            result += roman_numerals[c]
        else:
            result -= roman_numerals[c]
    return result

Ответ 4

Вот мое решение:

numerals = [
        {'letter': 'M', 'value': 1000},
        {'letter': 'D', 'value': 500},
        {'letter': 'C', 'value': 100},
        {'letter': 'L', 'value': 50},
        {'letter': 'X', 'value': 10},
        {'letter': 'V', 'value': 5},
        {'letter': 'I', 'value': 1},
    ]

def arabic_to_roman(number):
    remainder = number
    result = ''
    for numeral_index in xrange(len(numerals)):
        numeral = numerals[numeral_index]
        next_numeral = numerals[numeral_index + 1] if numeral_index + 1 < len(numerals) else None

        factor = remainder / numeral['value']
        remainder -= factor * numeral['value']

        if next_numeral:
            numeral_difference = numeral['value'] - next_numeral['value']
            if (remainder - numeral_difference >= 0) and (numeral_difference > next_numeral['value']):
                result += next_numeral['letter'] + numeral['letter']
                remainder -= numeral_difference

        if factor > 0:
            result += numeral['letter'] * factor

    return result


def roman_to_arabic(number):
    index_by_letter = {}
    for index in xrange(len(numerals)):
        index_by_letter[numerals[index]['letter']] = index

    result = 0
    previous_value = None
    for letter in reversed(number):
        index = index_by_letter[letter]
        value = numerals[index]['value']
        if (previous_value is None) or (previous_value <= value):
            result += value
        else:
            result -= value
        previous_value = value

    return result

Ответ 5

Хорошо, есть много чего не так с тем, что у вас в настоящее время.

Во-первых, причина, по которой вы получаете пучок 0, состоит в том, что вы никогда не выходите из цикла while string != "":, и он никогда не добавляет целые числа в общую сумму. Таким образом, total остается равным нулю и продолжает печататься. Я прокомментировал введенный вами код, чтобы помочь вам понять, что происходит.

def main():
    string=str(input("Enter a roman numeral"))
    total=0
    while string != "": # Empty strings evaluate as False, this can just be 'while string:'
        if string[1] == string[2] or string == len([1]): # Here you are testing the 2nd and 3rd elements.
                                                         # Also, you want to do len(string) == 1
                                                         # string will never == len([1]), so you never
                                                         # execute the code in this block.
            total += string[1]+1   # You want to add the corresponding value of string[0], use a dictionary.
        print (total)

        # Missing the else statement in the pseudocode.
main()

user2864740 имеет несколько хороших комментариев в своем размещенном решении, просмотрите это, чтобы увидеть некоторые из вещей, которые вы делали неправильно.

Вот код Python (2,7 к сожалению), который делает то, что говорит ваш псевдокод.

val = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}

def main():
    string = str(raw_input('Enter a roman numeral: '))
    string = string.upper()
    total = 0
    while string:
        if len(string) == 1 or val[string[0]] >= val[string[1]]:
            total += val[string[0]]
            string = string[1:]
        else:
            total += val[string[1]] - val[string[0]]
            string = string[2:]
    print total

main()

Обратите внимание, что указанный псевдокод НЕ правильно. Обратите внимание, что он будет делать для ввода 'IIV'. Он вычитает 1 из 1, затем добавляет 5. Но что он должен делать, это вычесть 2 из 5.

Ответ 6

Решение справа налево, которое немного больше Pythonic (без индексов) и относительно короткое.

Алгоритм:

• Отметьте римскую цифру и сопоставьте ее со списком чисел
• Выясните, какие числа следует вычесть, а затем суммировать список

Пример:

'xiv' = > sum(5, -1, 10) = > 14

def parse_roman(s):
    numerals = {'M':1000, 'D':500, 'C':100, 'L':50, 'X':10, 'V':5, 'I':1}
    n = 0
    last_value = 0
    # e.g. convert 'xiv' to (5, 1, 10)
    for value in (numerals[c] for c in reversed(s.upper())):
        # debugging
        v = (value, -value)[value < last_value]
        print('{:6} += {:5}  <== cur, prev = {}, {}'.format(n, v, value, last_value))
        # subtract smaller values that come after larger ones, otherwise add
        n += (value, -value)[value < last_value]
        last_value = value
    return n

Вывод:

parse_roman('MMCMXCVIII')
     0 +=     1  <== cur, prev = 1, 0
     1 +=     1  <== cur, prev = 1, 1
     2 +=     1  <== cur, prev = 1, 1
     3 +=     5  <== cur, prev = 5, 1
     8 +=   100  <== cur, prev = 100, 5
   108 +=   -10  <== cur, prev = 10, 100
    98 +=  1000  <== cur, prev = 1000, 10
  1098 +=  -100  <== cur, prev = 100, 1000
   998 +=  1000  <== cur, prev = 1000, 100
  1998 +=  1000  <== cur, prev = 1000, 1000
2998

Примечание. Было бы неплохо найти (короткий, встроенный) метод изменения знаков последовательности на лету. Например, (5, 1, 10) == > (5, -1, 10).

Обновление: Это так близко, как я до того, как сдался. Он идентичен приведенному выше коду, но использует itertools.tee() с zip() для генерации пар предыдущего и текущего значений, чтобы устранить необходимость в переменных состояния. Единый вызов next(cur) делает этот список короче prev, который является всем состоянием, которое нам необходимо выяснить, добавлять или вычитать текущее значение.

Пример:

cur, prev = (5, 1, 10), (5, 1, 10)
# Take one from cur and zip the rest
next(cur) + sum(... zip(cur, prev))
# 5 + ... zip( (1, 10), (5, 1, 10) )  ==>  5 + ... ((1, 5), (10, 1)) 

код:

from itertools import tee

def parse_roman(s):
    numerals = {'M':1000, 'D':500, 'C':100, 'L':50, 'X':10, 'V':5, 'I':1}
    cur, prev = tee(numerals[c] for c in reversed(s.upper()))
    return next(cur) + sum((cur, -cur)[cur < prev] for cur, prev in zip(cur,prev))

Ответ 7

Хорошая компактная версия без внешних библиотек:

def rn_to_int(s):
  d = {'m': 1000, 'd': 500, 'c': 100, 'l': 50, 'x': 10, 'v': 5, 'i': 1}
  n = [d[i] for i in s.lower() if i in d]
  return sum([i if i>=n[min(j+1, len(n)-1)] else -i for j,i in enumerate(n)])


for numeral, expected in [['CLXIV', 164], ['MDCCLXXXIII', 1783], ['xiv', 14]]:
  assert rn_to_int(numeral) == expected

Ответ 8

как насчет этого фрагмента кода

mapping = {'I': 1, 'V': 5, 'X': 10,'L': 50, 'C': 100, 'D': 500, 'M':1000}

def roman_to_dec(roman):
"""
Convert the roman no to decimal
"""
dec = last = 0
for i in range(0, len(roman)):
    no = mapping.get(roman[i])
    # subtract last 2 times cuz one for this pass and another for last pass
    dec = dec + (no - 2 * last) if no > last else dec + no
    last = no
return dec

Ответ 9

Существует очень подробное описание разработки римских цифровых конвертеров в Dive Into Python 3 от Марка Пилигрима. См. 5.3. Тематическое исследование: римские цифры, в котором представлена ​​проблема и детали.

Но это еще не все. См. Глава 9. Модульное тестирование, где продолжается анализ и реализация римских цифровых конвертеров, включая интересную оптимизацию и исключение - тестовое развитие.

Он напрямую связан с ссылкой без ссылки на код в первом комментарии ниже вопроса (код был написан Марк Пилигрим).

Ответ 10

Вот что я придумал с помощью словаря. Это должно быть v.simple. Скажи мне, что ты думаешь. Я должен сказать, что он не обрабатывает римские цифры spoof, написанные в виде MIM (вместо MCMXCIX за 1999 год). Это только для действительных римских цифр.

import re
s = 0;
a = dict();
b = dict();
r = "MMCMXCVIII"

a['CM'] = 900;
a['IX'] = 9;
a ['IV'] = 4;
a ['XL'] = 40;
a ['CD'] = 400;
a ['XC'] = 90;

b['M'] = 1000;
b['C'] = 100;
b['D'] = 500;
b['X'] = 10;
b['V'] = 5;
b['L'] = 50;
b['I'] = 1;

# Handle the tricky 4 and 9 first and remove them from the string

for key in a:
        if key in r: 
            r = re.sub(key,'',r)
            s+=a[key];
# Then straightforward multiplication of the not-so-tricky ones by their count.

for key in b:
         s+= r.count(key) * b[key];

print s; # This will print 2998

Ответ 11

Вы можете использовать этот код:

def roman_integer(roman):
    roman = roman.upper() # for taking care of upper or lower case letters
    integer_rep = 0
    roman_to_integer_map = tuple()
    roman_to_integer_map = (('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))
    roman_numeral_pattern = re.compile("""
    ^                   # beginning of string
    M{0,4}              # thousands - 0 to 4 M's
    (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
                        #            or 500-800 (D, followed by 0 to 3 C's)
    (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
                        #        or 50-80 (L, followed by 0 to 3 X's)
    (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
                        #        or 5-8 (V, followed by 0 to 3 I's)
    $                   # end of string
    """ ,re.VERBOSE)

    if not roman_numeral_pattern.search(roman):
        return 0
    index = 0
    for numeral, integer in roman_to_integer_map:
        while roman[index:index+len(numeral)] == numeral:
            #print numeral, integer, 'matched'
            integer_rep += integer
            index += len(numeral)
    return integer_rep

Ответ 12

Работайте справа налево от римской цифры, чтобы добавить или вычесть значения. Легко.

def rome(roman_num):
     d = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
     nl = list(roman_num)
     sum = d[nl[len(nl)-1]]
     for i in range(len(nl)-1,0,-1):
             if d[nl[i]]>d[nl[i-1]]:
                     sum -= d[nl[i-1]]
             else:
                     sum += d[nl[i-1]]       
     return sum

Ответ 13

roman_conver=[  (1,'I'),
                (5,'V'),
                (10,'X'),
                (50,'L'),
                (100,'C'),
                (500,'D'),
                (1000,'M'),
                    ]
def romantonumeral(roman):
    tot = 0
    for i in range(0,len(roman)):
        for each in roman_conver:
            if roman[i]==each[1]:
                if each[0]>tot:
                    tot = each[0] - tot
                else:
                    tot = tot + each[0]
    return tot

Ответ 14

Это один из вопросов Leetcode.

def romanToInt(s):
    sum=0
    dict={'M':1000,'D':500,'C':100,'L':50,'X':10,'V':5,'I':1}

    for i in range(len(s)):
        if i==0:
            sum=sum+dict[s[i]]
        else:
            if s[i]=='M':
                sum=sum+1000
                if s[i-1]=='C':
                    sum=sum-200      

            elif s[i]=='D':
                sum=sum+500
                if s[i-1]=='C':
                    sum=sum-200

            elif s[i]=='C':
                sum=sum+100
                if s[i-1]=='X':
                    sum=sum-20

            elif s[i]=='L':
                sum=sum+50
                if s[i-1]=='X':
                    sum=sum-20

            elif s[i]=='X':
                sum=sum+10
                if s[i-1]=='I':
                    sum=sum-2

            elif s[i]=='V':
                sum=sum+5
                if s[i-1]=='I':
                    sum=sum-2
            elif s[i]=='I':
                sum=sum+1
    return (sum)

Ответ 15

попробуйте следующее:

def translate(string):
    values = {"i":1, "v":5, "x":10, "l":50, "c":100, "m":1000}
    return sum(map(lambda x: values[x], string))

Лямбда означает однострочную функцию. Вот почему они называются анонимными функциями. Вам не нужно определять их outide с помощью def и всей этой формальности.

Вы можете ввести что-то вроде этого в оболочке:

  

f = lambda x: x + 3     F (3)         6         или     f = lambda x, y: x + y     f ( "foo", "bar" )         'Foobar'

  

Im, используя map, чтобы применить мою новорожденную функцию к каждому элементу итерабельного. В этом случае итерабельна одна строка, такая как "mclvii". Сделав это, я создал список, в котором каждое значение имеет его значение rersepective. См. Пример lambda для вычисления квадратов:

>>> a = [1,2,3,4]
>>> square = lambda x: x**2
>>> l = map(square, a)
>>> l = [1,4,9,16]

Итак, он лямбда, когда вам нужна функция "на лету", и сопоставьте, когда вы хотите применить функцию ко всем элементам в списке.

Теперь пример использования рекурсии:

def translate2(string):
    values = {"i":1, "v":5, "x":10, "l":50, "c":100, "m":1000}
    if not string:
        return 0
    return values[string[0]] + translate2(string[1:])