Roman Numerals Conversion

Roman numerals, like its arabian counter part, have the largest number on the left hand side and the lowest on the right hand side. However roman numerals have caveat which it sometimes implies subtraction. For example the roman numerals for number 4 is IV which is 5 (represented as V) subtracted by 1 (represented as I). This also happen in number 9 which represented as IX.

How we construct a program that takes string of valid roman numerals e.g. III, IV, XIV to its arabic numerals.

We can begin by creating an empty function

    package roman

    func romanNumerals(roman string) int {
        return 0
    }

or in python we can write

    def roman_numerals(roman :string) int:
        return 0

One of the approach we can take is creating a Map between roman numerals to its arabic counter part. You can choose to use Rune data type but for now I use regular string

    var romanMap = map[string]int{
        "I": 1,
        "X": 10,
    }

for python, we can use built in dictionary data type to map roman numerals to arabic numerals.

    roman_map = {
        "I": 1,
        "X": 10,
    }

The first instinct we have is to iterate the string from first to end. In each of its character, we translate it to arabic numerals and sum it to get the final number.

    package roman

    var romanMap = map[string]int{
        "I": 1,
        "X": 10,
    }

    func romanNumerals(roman string) int {
        final := 0
        for _, value := roman {
            final += romanMap[string(value)]
        }
        return final
    }

    roman_map = {
        "I": 1,
        "X": 10,
    }
    def roman_numerals(roman :string) int:
        final = 0
        for char in roman:
            final += roman_map[char]
        return final

It is a straight answer but we need to handle the subtraction part. If we plug IX to the program, it wont return the right answer; it would return 11 instead of 9. So how we handle the subtraction part?

There subtraction require additional knowledge that a regular for loop does not have. It require to know whether the next character arabic representation is larger than current one. If the next character is larger, then we the current one is a minus to the sum.

In programming languange, there is risk that we access the index that larger than the array length itself; an out of bound error. Since we want to access the next char, we need to know whether at the end or not to avoid out of bond.

    package roman

    var romanMap = map[string]int{
        "I": 1,
        "X": 10,
    }

    func romanNumerals(roman string) int {
        final := 0
        totalLength := len(roman)
        for index, value := roman {
            next := index + 1
            num := romanMap[string(value)]
            if next == len(roman) {
                final += num
                break
            }
            nextNum := romanMap[string(roman[next])]
            if num > nextNum {
                final += num
            } else {
                final -= num
            }
        }
        return final
    }

To handle next array, there are two additional ifs, first if to handle if we at the last digit and we need to avoid out of bond error. The next if is the one handle if the current character is larger that next one. We translate the current character to num with romanMap[string(value)] and next character to num with romanMap[string(roman[next])]. We can do this in python

    roman_map = {
        "I": 1,
        "X": 10,
    }
    def roman_numerals(roman :string) int:
        final = 0
        for (index, char) in enumerate(roman):
            next_index = index + 1
            num := roman_map[char]
            if next_index == len(roman):
                final += num
                break
            next_num := romanMap[roman[next_index]]
            if num > next_num:
                final += num
            else:
                final -= num
        return final