LeetCode problem: 13. Roman to Integer

Author: borrelunde

src/main/java/com/bl/roman_to_integer/README.md

@@ -0,0 +1,62 @@
+# 13. Roman to Integer
+
+Difficulty: `Easy`  
+Topics: `Hash Table`, `Math`, `String`
+
+Roman numerals are represented by seven different symbols: `I`, `V`, `X`, `L`, `C`, `D` and `M`.
+
+```
+Symbol       Value  
+I             1
+V             5
+X             10  
+L             50  
+C             100  
+D             500  
+M             1000  
+```
+
+For example, `2` is written as `II` in Roman numeral, just two ones added together. `12` is written as `XII`, which is
+simply `X + II`. The number `27` is written as `XXVII`, which is `XX + V + II`.
+
+Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not `IIII`.
+Instead, the number four is written as `IV`. Because the one is before the five we subtract it making four. The same
+principle applies to the number nine, which is written as `IX`. There are six instances where subtraction is used:
+
+* `I` can be placed before `V` (5) and `X` (10) to make 4 and 9.
+* `X` can be placed before `L` (50) and `C` (100) to make 40 and 90.
+* `C` can be placed before `D` (500) and `M` (1000) to make 400 and 900.
+
+Given a roman numeral, convert it to an integer.
+
+**Example 1:**
+
+````text
+Input: s = "III"
+Output: 3
+Explanation: III = 3.
+Example 2:
+````
+
+**Example 2:**
+
+```text
+Input: s = "LVIII"
+Output: 58
+Explanation: L = 50, V= 5, III = 3.
+Example 3:
+```
+
+**Example 3:**
+
+```text
+Input: s = "MCMXCIV"
+Output: 1994
+Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
+```
+
+**Constraints:**
+
+* `1 <= s.length <= 15`
+* `s` contains only the characters (`I`, `V`, `X`, `L`, `C`, `D`, `M`).
+* It is guaranteed that `s` is a valid roman numeral in the range `[1, 3999]`.

src/main/java/com/bl/roman_to_integer/Solution.java

@@ -0,0 +1,69 @@
+package com.bl.roman_to_integer;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * This is the solution to the LeetCode problem: 13. Roman to Integer
+ *
+ * @author Børre A. Opedal Lunde
+ * @since 2024.01.23
+ */
+class Solution {
+
+	// A map of roman numeral symbols by value.
+	static final Map<Character, Integer> ROMAN_NUMERAL_SYMBOLS_BY_VALUE = new HashMap<>();
+
+	// Initialize the map.
+	static {
+		ROMAN_NUMERAL_SYMBOLS_BY_VALUE.put('I', 1);
+		ROMAN_NUMERAL_SYMBOLS_BY_VALUE.put('V', 5);
+		ROMAN_NUMERAL_SYMBOLS_BY_VALUE.put('X', 10);
+		ROMAN_NUMERAL_SYMBOLS_BY_VALUE.put('L', 50);
+		ROMAN_NUMERAL_SYMBOLS_BY_VALUE.put('C', 100);
+		ROMAN_NUMERAL_SYMBOLS_BY_VALUE.put('D', 500);
+		ROMAN_NUMERAL_SYMBOLS_BY_VALUE.put('M', 1000);
+	}
+
+	public int romanToInt(String romanNumberAsString) {
+
+		// The sum of the roman numeral symbols.
+		int sum = 0;
+
+		// Convert the roman numeral string to a character array that we can
+		// iterate over.
+		final char[] characters = romanNumberAsString.toCharArray();
+
+		// The value of the current roman numeral symbol (used in the loop).
+		int currentValue;
+
+		// The value of the previous roman numeral symbol (used in the loop).
+		int previousValue = 0;
+
+		// Iterate over the roman numeral symbols in reverse order. That way we
+		// can traverse the roman numeral symbols in "ascending" order.
+		for (int i = characters.length - 1; i >= 0; i--) {
+
+			// This is the current character we're iterating over.
+			final char character = characters[i];
+
+			// Retrieve the value of the roman numeral symbol.
+			currentValue = ROMAN_NUMERAL_SYMBOLS_BY_VALUE.get(character);
+
+			// If the previous value is greater than the current value, we need
+			// to subtract the current value from the sum. Otherwise, we need to
+			// add the current value to the sum.
+			if (previousValue > currentValue) {
+				sum -= currentValue;
+			} else {
+				sum += currentValue;
+			}
+
+			// Set the previous value to the current value.
+			previousValue = currentValue;
+		}
+
+		// Return the sum.
+		return sum;
+	}
+}

src/test/java/com/bl/roman_to_integer/SolutionTest.java

@@ -0,0 +1,56 @@
+package com.bl.roman_to_integer;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * This is the test to the LeetCode problem: 13. Roman to Integer
+ *
+ * @author Børre A. Opedal Lunde
+ * @since 2024.01.23
+ */
+@DisplayName("Roman to Integer")
+class SolutionTest {
+
+	@Test
+	@DisplayName("Example one")
+	void exampleOne() {
+		String s = "III";
+		int expected = 3;
+		assertEquals(expected, new Solution().romanToInt(s));
+	}
+
+	@Test
+	@DisplayName("Example two")
+	void exampleTwo() {
+		String s = "LVIII";
+		int expected = 58;
+		assertEquals(expected, new Solution().romanToInt(s));
+	}
+
+	@Test
+	@DisplayName("Example three")
+	void exampleThree() {
+		String s = "MCMXCIV";
+		int expected = 1994;
+		assertEquals(expected, new Solution().romanToInt(s));
+	}
+
+	@Test
+	@DisplayName("Roman IV")
+	void romanIv() {
+		String s = "IV";
+		int expected = 4;
+		assertEquals(expected, new Solution().romanToInt(s));
+	}
+
+	@Test
+	@DisplayName("Roman VII")
+	void romanVii() {
+		String s = "VII";
+		int expected = 7;
+		assertEquals(expected, new Solution().romanToInt(s));
+	}
+}