Efficient Integer to Roman Numeral Conversion in Python

This article explores two Python methods for converting integers to Roman numerals. We’ll examine a straightforward iterative approach and a more efficient method utilizing integer division.

Table of Contents

1. Iterative Approach to Integer-to-Roman Conversion
2. Efficient Conversion Using Integer Division

Iterative Approach to Integer-to-Roman Conversion

This method uses a dictionary mapping Roman numerals to their integer values and iterates through it to build the Roman numeral representation. Subtractive notation (like IV for 4) is handled explicitly.

def int_to_roman_iterative(num):
    """Converts an integer to its Roman numeral representation using iteration.

    Args:
        num: The integer to convert (must be between 1 and 3999 inclusive).

    Returns:
        The Roman numeral representation of the integer, or None if the input is invalid.
    """
    if not 1 <= num = value:
            result += symbol
            num -= value
    return result

# Example Usage
print(int_to_roman_iterative(3))   # Output: III
print(int_to_roman_iterative(4))   # Output: IV
print(int_to_roman_iterative(9))   # Output: IX
print(int_to_roman_iterative(58))  # Output: LVIII
print(int_to_roman_iterative(1994)) # Output: MCMXCIV
print(int_to_roman_iterative(4000)) # Output: None

This approach is easy to understand but may be less efficient for larger numbers due to the repeated subtractions within the while loop.

Efficient Conversion Using Integer Division

This method uses integer division and the modulo operator to efficiently handle larger integers. It iterates through the Roman numeral mapping only once.

def int_to_roman_division(num):
    """Converts an integer to its Roman numeral representation using division.

    Args:
        num: The integer to convert (must be between 1 and 3999 inclusive).

    Returns:
        The Roman numeral representation of the integer, or None if the input is invalid.
    """
    if not 1 <= num <= 3999:
        return None

    roman_map = { 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'}

    result = ""
    for value, symbol in roman_map.items():
        result += symbol * (num // value)
        num %= value
    return result

# Example Usage
print(int_to_roman_division(3))   # Output: III
print(int_to_roman_division(4))   # Output: IV
print(int_to_roman_division(9))   # Output: IX
print(int_to_roman_division(58))  # Output: LVIII
print(int_to_roman_division(1994)) # Output: MCMXCIV
print(int_to_roman_division(4000)) # Output: None

This division-based approach offers improved performance, particularly for larger input numbers, by minimizing redundant operations.