1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! # Description
//!
//! Roman numerals are represented by seven different symbols: `I`, `V`, `X`, 
//! `L`, `C`, `D` and `M`.
//! 
//! ```plain
//! 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:
//! 
//! ```plain
//! Input: s = "III"
//! Output: 3
//! Explanation: III = 3.
//! ```
//! 
//! Example 2:
//! 
//! ```plain
//! Input: s = "LVIII"
//! Output: 58
//! Explanation: L = 50, V= 5, III = 3.
//! ```
//! 
//! Example 3:
//! 
//! ```plain
//! Input: s = "MCMXCIV"
//! Output: 1994
//! Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
//! ```
//!  
//! Constraints:
//! 
//! - `1 $\leqslant$ s.length $\leqslant$ 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]`.
//!
//! Sources: <https://leetcode.com/problems/roman-to-integer/description/>

////////////////////////////////////////////////////////////////////////////////

/// Integer to Roman
///
/// # Arguments
/// * `s` - input string
pub fn roman_to_int(s: String) -> i32 {
    let mut val = 0;
    let mut last_val = 0;
    let mut temp_digit = 0;

    for ch in s.as_bytes().iter() {
        let this_val = match *ch {
            b'I' => 1,
            b'V' => 5,
            b'X' => 10,
            b'L' => 50,
            b'C' => 100,
            b'D' => 500,
            b'M' => 1000,
            _ => 0,
        };
        if last_val == 0 {
            temp_digit = this_val;
        } else if this_val == last_val {
            temp_digit += this_val;
        } else if this_val < last_val {
            val += temp_digit;
            temp_digit = this_val;
        } else {
            val += this_val - temp_digit;
            temp_digit = 0;
        }
        last_val = this_val;
    }
    val += temp_digit;
    val
}