Integer To Roman

                                            
class Solution {
public:
    string intToRoman(int num) {
        string result = "";
        vector<int> values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        vector<string> symbols = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
        
        for (int i = 0; i < values.size(); i++) {
            while (num >= values[i]) {
                num -= values[i];
                result += symbols[i];
            }
        }
        
        return result;
    }
};

                                            
class Solution {
    public String intToRoman(int num) {
        // create arrays to store the Roman numeral symbols and their corresponding values
        String[] romanSymbols = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
        int[] romanValues = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        
        // create a StringBuilder to store the result
        StringBuilder sb = new StringBuilder();
        
        // iterate through the arrays to construct the Roman numeral
        for (int i = 0; i < romanValues.length; i++) {
            while (num >= romanValues[i]) {
                sb.append(romanSymbols[i]);
                num -= romanValues[i];
            }
        }
        
        return sb.toString();
    }
}

                                            
class Solution(object):
    def intToRoman(self, num):
        """
        :type num: int
        :rtype: str
        """
        val = [
            1000, 900, 500, 400,
            100, 90, 50, 40,
            10, 9, 5, 4,
            1
        ]
        syms = [
            "M", "CM", "D", "CD",
            "C", "XC", "L", "XL",
            "X", "IX", "V", "IV",
            "I"
        ]
        
        res = ''
        for i in range(len(val)):
            while num >= val[i]:
                num -= val[i]
                res += syms[i]
                
        return res

                                            
char* intToRoman(int num) {
    char* roman_numerals[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
    int values[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};

    char* result = (char*)malloc(20 * sizeof(char));
    result[0] = '\0';

    for (int i = 0; i < 13; i++) {
        while (num >= values[i]) {
            strcat(result, roman_numerals[i]);
            num -= values[i];
        }
    }

    return result;
}

                                            
public class Solution {
    public string IntToRoman(int num) {
        StringBuilder result = new StringBuilder();
        int[] values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
        string[] romans = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
        
        for (int i = 0; i < values.Length; i++) {
            while (num >= values[i]) {
                num -= values[i];
                result.Append(romans[i]);
            }
        }
        
        return result.ToString();
    }
}

                                            
function intToRoman(num: number): string {
    const romanNumerals: [number, string][] = [
        [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'],
    ];

    let result = '';

    for (const [value, symbol] of romanNumerals) {
        while (num >= value) {
            result += symbol;
            num -= value;
        }
    }

    return result;
};

                                            
class Solution {
    /**
     * @param Integer $num
     * @return String
     */
    function intToRoman($num) {
        $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 = "";
        
        foreach ($map as $value => $roman) {
            while ($num >= $value) {
                $result .= $roman;
                $num -= $value;
            }
        }
        
        return $result;
    }
}

                                            
class Solution {
    func intToRoman(_ num: Int) -> String {
        let values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
        let romanNumerals = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
        
        var result = ""
        var num = num
        
        for i in 0..<values.count {
            while num >= values[i] {
                result += romanNumerals[i]
                num -= values[i]
            }
        }
        
        return result
    }
}

                                            
class Solution {
    fun intToRoman(num: Int): String {
        val values = intArrayOf(1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1)
        val symbols = arrayOf("M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I")
        var result = StringBuilder()
        var remaining = num

        for (i in values.indices) {
            while (remaining >= values[i]) {
                result.append(symbols[i])
                remaining -= values[i]
            }
        }

        return result.toString()
    }
}

                                            
class Solution {
  String intToRoman(int num) {
    List<String> romanNumerals = [
      "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"
    ];
    List<int> numbers = [
      1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1
    ];

    String result = "";
    for (int i = 0; i < romanNumerals.length; i++) {
      while (num >= numbers[i]) {
        result += romanNumerals[i];
        num -= numbers[i];
      }
    }

    return result;
  }
}

                                            
func intToRoman(num int) string {
    roman := ""
    
    numerals := []int{1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1}
    symbols := []string{"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"}
    
    for i := 0; i < len(numerals); i++ {
        for num >= numerals[i] {
            num -= numerals[i]
            roman += symbols[i]
        }
    }
    
    return roman
}

                                            
# @param {Integer} num
# @return {String}
def int_to_roman(num)
    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"
    }
    
    roman = ""
    
    roman_map.each do |value, letter|
        while num >= value
            roman += letter
            num -= value
        end
    end
    
    return roman
end

                                            
object Solution {
    def intToRoman(num: Int): String = {
        val romanNumerals = Array(
            "M", "CM", "D", "CD", "C", "XC",
            "L", "XL", "X", "IX", "V", "IV", "I"
        )
        val decimalValues = Array(
            1000, 900, 500, 400, 100, 90,
            50, 40, 10, 9, 5, 4, 1
        )

        var result = ""
        var remaining = num

        for (i <- decimalValues.indices) {
            while (remaining >= decimalValues(i)) {
                result += romanNumerals(i)
                remaining -= decimalValues(i)
            }
        }

        result
    }
}

                                            
impl Solution {
    pub fn int_to_roman(num: i32) -> String {
        let mut num = num;
        let values = vec![1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
        let symbols = vec!["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"];
        let mut result = String::new();

        for i in 0..values.len() {
            while num >= values[i] {
                result.push_str(symbols[i]);
                num -= values[i];
            }
        }

        result
    }
}

                                            
(define/contract (int-to-roman num)
  (-> exact-integer? string?)
  (define 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")))
  (define (int-to-roman-helper num numerals)
    (cond
      [(null? numerals) ""]
      [(>= num (caar numerals))
       (string-append (cdar numerals) (int-to-roman-helper (- num (caar numerals)) numerals))]
      [else (int-to-roman-helper num (cdr numerals))]))
  (int-to-roman-helper num numerals)
  )

                                            
defmodule Solution do
  @spec int_to_roman(num :: integer) :: String.t
  def int_to_roman(num) do
    roman_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"}
    ]
    
    convert(num, roman_numerals, "")
  end
  
  defp convert(0, _roman_numerals, result), do: result
  defp convert(num, roman_numerals, result) do
    [{value, roman} | tail] = roman_numerals
    
    if num >= value do
      convert(num - value, roman_numerals, result <> roman)
    else
      convert(num, tail, result)
    end
  end
end

To solve this coding challenge of converting an integer to its corresponding Roman numeral representation, it is essential to understand how Roman numerals work and the rules that guide their formation. Here, we are given specific rules:

Symbols such as I, V, X, L, C, D, and M represent the values 1, 5, 10, 50, 100, 500, and 1000 respectively.
There are specific combinations for numbers like 4, 9, 40, 90, 400, and 900, using a subtractive notation where a smaller numeral appears before a larger numeral.
A numeral can appear consecutively at most three times unless a subtractive form is used.

Explanation

Given these conditions, the main idea is to progressively subtract the largest possible value from the number until we reach zero, appending the corresponding Roman numeral symbols as we go along. Let’s break down the process:

Define the Mapping : Create two lists that will store the values and their corresponding Roman numeral symbols. These lists will be ordered from the largest to the smallest so that we can check from the highest place value down to the lowest.
Initialize Result Storage : Initialize an empty string that will store the resultant Roman numeral representation.
Iterate and Convert : Using a loop, iterate through the values from largest to smallest. For each value, as long as the given number (num) is greater than or equal to the value:

* Subtract the value from num.

* Append the corresponding Roman numeral symbol to the result string.

* Continue this process until the entire number is converted.

The pseudocode below details this algorithm step-by-step:

Detailed Steps in Pseudocode

Initialization :

Create lists
values

holding
[1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]

.
Create lists
symbols

holding
["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]

.
Initialize an empty string
result

to build the final Roman numeral.

Conversion Logic :

Loop through each value in
values

with an index.
As long as
num

is greater than or equal to the current value:

Subtract the value from
num

.
Append the corresponding Roman numeral from
symbols

to
result

.

This process ensures that the higher place values are accounted for first, forming the Roman numeral in sequence from the largest to the smallest parts. Here's the detailed pseudocode:

                                            
# Define the mapping from integer values to their corresponding Roman numeral symbols
values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
symbols = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]

# Initialize the result string to build the Roman numeral representation
result = ""

# Iterating through the values list along with their indices
FOR i FROM 0 TO LENGTH OF values - 1:
    # While the current number (num) is greater than or equal to the current value
    WHILE num >= values[i]:
        # Subtract the current value from the number
        num = num - values[i]
        # Append the corresponding Roman numeral symbol to the result string
        result = result + symbols[i]

# Return the final result string which is the Roman numeral representation of the input number
RETURN result

Each line within the pseudocode is annotated with comments to clarify its role in the overall logic. By following this pseudocode, we can convert any given integer (within the valid range of 1 to 3999) into its corresponding Roman numeral representation accurately.