integer_to_roman.go

// Package 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 has the following 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 and 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.
//
// Constraints:
//
// 1 <= num <= 3999
package integer_to_roman

import "strings"

var (
	glyphs = [7]string{"M", "D", "C", "L", "X", "V", "I"}
	vals   = [7]int{1000, 500, 100, 50, 10, 5, 1}
)

// calculate
func calculate(num int) string {
	b := strings.Builder{}

	for i, val := range vals {
		if num < val {
			continue
		}

		currentN := num / val
		num %= val

		if currentN == 1 {
			if i < (len(vals)-1) && num/vals[i+1] == 4 && val/vals[i+1] == 5 {
				num += val
				continue
			} else {
				b.WriteString(glyphs[i])
				continue
			}
		}
		if currentN <= 3 && val != 500 && val != 50 && val != 5 {
			b.WriteString(strings.Repeat(glyphs[i], currentN))
			continue
		}
		if currentN == 9 {
			b.WriteString(glyphs[i])
			b.WriteString(glyphs[i-2])
			continue
		}
		if currentN == 4 {
			b.WriteString(glyphs[i])
			b.WriteString(glyphs[i-1])
			continue
		}
	}

	return b.String()
}

//choose
//func choose(num int) string {
//}