test: linter test

Author: Ang-m4

algorithms/12-integer-to-roman/IntegerToRoman.cpp

@@ -0,0 +1,21 @@
+/**
+ * Solution class for converting an integer to a Roman numeral.
+ */
+
+class Solution {
+    public String intToRoman(int num) {
+        StringBuilder roman = new StringBuilder();
+        int[] values = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+        String[] symbols = {
+            "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]) {
+                roman.append(symbols[i]);
+                num -= values[i];
+            }
+        }
+        return roman.toString();
+    }
+}

algorithms/12-integer-to-roman/README.md

@@ -0,0 +1,74 @@
+# Integer to Roman
+
+Seven different symbols represent Roman numerals with the following values:
+
+| Symbol | Value |
+|--------|-------|
+| I      | 1     |
+| V      | 5     |
+| X      | 10    |
+| L      | 50    |
+| C      | 100   |
+| D      | 500   |
+| M      | 1000  |
+
+Roman numerals are formed by appending the conversions of decimal place values from highest to lowest. Converting a decimal place value into a Roman numeral follows these rules:
+
+- If the value does **not** start with 4 or 9, select the symbol of the maximal value that can be subtracted from the input, append that symbol to the result, subtract its value, and convert the remainder to a Roman numeral.
+- If the value **starts with 4 or 9**, use the subtractive form representing one symbol subtracted from the following symbol. For example:
+    - 4 is 1 (I) less than 5 (V): **IV**
+    - 9 is 1 (I) less than 10 (X): **IX**
+- Only the following subtractive forms are used: 4 (**IV**), 9 (**IX**), 40 (**XL**), 90 (**XC**), 400 (**CD**), and 900 (**CM**).
+- Only powers of 10 (**I**, **X**, **C**, **M**) can be appended consecutively at most 3 times to represent multiples of 10.
+- You cannot append 5 (**V**), 50 (**L**), or 500 (**D**) multiple times. If you need to append a symbol 4 times, use the subtractive form.
+
+Given an integer, convert it to a Roman numeral.
+
+---
+
+## Examples
+
+### Example 1
+
+**Input:** `num = 3749`  
+**Output:** `"MMMDCCXLIX"`
+
+**Explanation:**
+- 3000 = MMM as 1000 (M) + 1000 (M) + 1000 (M)
+- 700 = DCC as 500 (D) + 100 (C) + 100 (C)
+- 40 = XL as 10 (X) less than 50 (L)
+- 9 = IX as 1 (I) less than 10 (X)
+
+> Note: 49 is not 1 (I) less than 50 (L) because the conversion is based on decimal places.
+
+---
+
+### Example 2
+
+**Input:** `num = 58`  
+**Output:** `"LVIII"`
+
+**Explanation:**
+- 50 = L
+- 8 = VIII
+
+---
+
+### Example 3
+
+**Input:** `num = 1994`  
+**Output:** `"MCMXCIV"`
+
+**Explanation:**
+- 1000 = M
+- 900 = CM
+- 90 = XC
+- 4 = IV
+
+---
+
+## Constraints
+
+```
+1 <= num <= 3999
+```

algorithms/12-integer-to-roman/integer_to_roman.py

@@ -0,0 +1,53 @@
+"""
+Module for converting integers to Roman numerals.
+
+This module contains a Solution class with a method intToRoman that converts
+an integer to its corresponding Roman numeral representation.
+"""
+
+class Solution(object):
+    def intToRoman(self, num):
+        """
+        :type num: int
+        :rtype: str
+        """
+        roman_str = ""
+        potencies = [1000, 100, 10, 1]
+        roman_equivalences = {
+            1: 'I',
+            5: 'V',
+            10: 'X',
+            50: 'L',
+            100: 'C',
+            500: 'D',
+            1000: 'M',
+        }
+
+        for power in potencies:
+            # Gets the digit at the current power (e.g. 4532, power=1000 -> 4)
+            digit = int(num / power)
+             # Gets the value at the current power (e.g. 4*1000=4000)
+            power_digit = digit * power
+            # Removes the processed digit from num (e.g. 4532 % 1000 = 532)
+            num = num % power
+
+            # Skip if there is no digit at this power
+            if digit == 0:
+                continue
+            # Direct mapping exists (e.g. 1000, 500, 100, etc.)
+            if power_digit in roman_equivalences:
+                roman_str += roman_equivalences[power_digit]
+                continue
+            # Handle subtractive notation (e.g. 4=IV, 9=IX, 40=XL, etc.)
+            if digit in (4, 9):
+                prefix = roman_equivalences[power]
+                roman_str += (prefix + roman_equivalences[power * (digit + 1)])
+                continue
+             # For digits 6-8, add the '5' symbol and repeat the '1' symbol as needed
+            if digit > 5:
+                roman_str += roman_equivalences[power * 5]
+                digit -= 5
+
+            # Append the '1' symbol as many times as needed
+            roman_str += roman_equivalences[power] * digit
+        return roman_str