Optimize roman to int and adde int to roman (#353)

Co-authored-by: Andrii Siriak <[email protected]>

Author: brandenc40

conversion/integertoroman.go

@@ -0,0 +1,36 @@
+package conversion
+
+import (
+	"errors"
+)
+
+var (
+	// lookup arrays used for converting from an int to a roman numeral extremely quickly.
+	r0 = []string{"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"} // 1 - 9
+	r1 = []string{"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"} // 10 - 90
+	r2 = []string{"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"} // 100 - 900
+	r3 = []string{"", "M", "MM", "MMM"}                                       // 1,000 - 3,000
+)
+
+// IntToRoman converts an integer value to a roman numeral string. An error is
+// returned if the integer is not between 1 and 3999.
+func IntToRoman(n int) (string, error) {
+	if n < 1 || n > 3999 {
+		return "", errors.New("integer must be between 1 and 3999")
+	}
+	// Concatenate strings for each of 4 lookup array categories.
+	//
+	// Key behavior to note here is how math with integers is handled. Values are floored to the
+	// nearest int, not rounded up. For example, 26/10 = 2 even though the actual result is 2.6.
+	//
+	// For example, lets use an input value of 126:
+	// `r3[n%1e4/1e3]` --> 126 % 10_000 = 126 --> 126 / 1_000 = 0.126 (0 as int) --> r3[0] = ""
+	// `r2[n%1e3/1e2]` --> 126 % 1_000 = 126 --> 126 / 100 = 1.26 (1 as int) --> r2[1] = "C"
+	// `r1[n%100/10]` --> 126 % 100 = 26 --> 26 / 10 = 2.6 (2 as int) --> r1[2] = "XX"
+	// `r0[n%10]` --> 126 % 10 = 6 --> r0[6] = "VI"
+	// FINAL --> "" + "C" + "XX" + "VI" = "CXXVI"
+	//
+	// This is efficient in Go. The 4 operands are evaluated,
+	// then a single allocation is made of the exact size needed for the result.
+	return r3[n%1e4/1e3] + r2[n%1e3/1e2] + r1[n%100/10] + r0[n%10], nil
+}

conversion/integertoroman_test.go

@@ -0,0 +1,30 @@
+package conversion
+
+import "testing"
+
+func TestIntToRoman(t *testing.T) {
+	for expected, input := range romanTestCases {
+		out, err := IntToRoman(input)
+		if err != nil {
+			t.Errorf("IntToRoman(%d) returned an error %s", input, err.Error())
+		}
+		if out != expected {
+			t.Errorf("IntToRoman(%d) = %s; want %s", input, out, expected)
+		}
+	}
+	_, err := IntToRoman(100000)
+	if err == nil {
+		t.Errorf("IntToRoman(%d) expected an error", 100000)
+	}
+	_, err = IntToRoman(0)
+	if err == nil {
+		t.Errorf("IntToRoman(%d) expected an error", 0)
+	}
+}
+
+func BenchmarkIntToRoman(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_, _ = IntToRoman(3999)
+	}
+}

conversion/romantointeger.go

@@ -6,17 +6,52 @@
 
 package conversion
 
-var romans = map[string]int{"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}
+import (
+	"errors"
+	"strings"
+)
 
-func RomanToInteger(roman string) int {
-	total := 0
-	romanLen := len(roman)
-	for holder := range roman {
-		if holder+1 < romanLen && romans[string(roman[holder])] < romans[string(roman[holder+1])] {
-			total -= romans[string(roman[holder])]
-		} else {
-			total += romans[string(roman[holder])]
+// numeral describes the value and symbol of a single roman numeral
+type numeral struct {
+	val int
+	sym string
+}
+
+// lookup array for numeral values sorted by largest to smallest
+var nums = []numeral{
+	{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"},
+}
+
+// RomanToInteger converts a roman numeral string to an integer. Roman numerals for numbers
+// outside the range 1 to 3,999 will return an error. Nil or empty string return 0
+// with no error thrown.
+func RomanToInteger(input string) (int, error) {
+	if input == "" {
+		return 0, nil
+	}
+	var output int
+	for _, n := range nums {
+		for strings.HasPrefix(input, n.sym) {
+			output += n.val
+			input = input[len(n.sym):]
 		}
 	}
-	return total
+	// if we are still left with input string values then the
+	// input was invalid and the bool is returned as false
+	if len(input) > 0 {
+		return 0, errors.New("invalid roman numeral")
+	}
+	return output, nil
 }

conversion/romantointeger_test.go

@@ -2,28 +2,52 @@ package conversion
 
 import "testing"
 
-type romanToIntegerConversionTest struct {
-	input    string
-	expected int
-	name     string
-}
-
-var romanToIntegerTests = []romanToIntegerConversionTest{
-	{input: "DCCLXXXIX", expected: 789, name: "DCCLXXXIX-789"},
-	{input: "MLXVI", expected: 1066, name: "MLXVI-1066"},
-	{input: "MCMXVIII", expected: 1918, name: "MCMXVIII-1918"},
-	{input: "V", expected: 5, name: "V-5"},
+var romanTestCases = map[string]int{
+	"I": 1, "II": 2, "III": 3, "IV": 4, "V": 5, "VI": 6,
+	"VII": 7, "VIII": 8, "IX": 9, "X": 10, "XI": 11, "XII": 12,
+	"XIII": 13, "XIV": 14, "XV": 15, "XVI": 16, "XVII": 17,
+	"XVIII": 18, "XIX": 19, "XX": 20, "XXXI": 31, "XXXII": 32,
+	"XXXIII": 33, "XXXIV": 34, "XXXV": 35, "XXXVI": 36, "XXXVII": 37,
+	"XXXVIII": 38, "XXXIX": 39, "XL": 40, "XLI": 41, "XLII": 42,
+	"XLIII": 43, "XLIV": 44, "XLV": 45, "XLVI": 46, "XLVII": 47,
+	"XLVIII": 48, "XLIX": 49, "L": 50, "LXXXIX": 89, "XC": 90,
+	"XCI": 91, "XCII": 92, "XCIII": 93, "XCIV": 94, "XCV": 95,
+	"XCVI": 96, "XCVII": 97, "XCVIII": 98, "XCIX": 99, "C": 100,
+	"CI": 101, "CII": 102, "CIII": 103, "CIV": 104, "CV": 105,
+	"CVI": 106, "CVII": 107, "CVIII": 108, "CIX": 109, "CXLIX": 149,
+	"CCCXLIX": 349, "CDLVI": 456, "D": 500, "DCIV": 604, "DCCLXXXIX": 789,
+	"DCCCXLIX": 849, "CMIV": 904, "M": 1000, "MVII": 1007, "MLXVI": 1066,
+	"MCCXXXIV": 1234, "MDCCLXXVI": 1776, "MMXXI": 2021, "MMDCCCVI": 2806,
+	"MMCMXCIX": 2999, "MMM": 3000, "MMMCMLXXIX": 3979, "MMMCMXCIX": 3999,
 }
 
 func TestRomanToInteger(t *testing.T) {
-
-	for _, test := range romanToIntegerTests {
-		convertedValue := RomanToInteger(test.input)
-		if convertedValue != test.expected {
-			t.Errorf(
-				"roman to integer test %s failed. expected '%d' but got '%d'",
-				test.name, test.expected, convertedValue,
-			)
+	for input, expected := range romanTestCases {
+		out, err := RomanToInteger(input)
+		if err != nil {
+			t.Errorf("RomanToInteger(%s) returned an error %s", input, err.Error())
 		}
+		if out != expected {
+			t.Errorf("RomanToInteger(%s) = %d; want %d", input, out, expected)
+		}
+	}
+	_, err := RomanToInteger("IVCMXCIX")
+	if err == nil {
+		t.Error("RomanToInteger(IVCMXCIX) expected an error")
+	}
+
+	val, err := RomanToInteger("")
+	if val != 0 {
+		t.Errorf("RomanToInteger(\"\") = %d; want 0", val)
+	}
+	if err != nil {
+		t.Errorf("RomanToInteger(\"\") returned an error %s", err.Error())
+	}
+}
+
+func BenchmarkRomanToInteger(b *testing.B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_, _ = RomanToInteger("MMMCMXCIX")
 	}
 }