Skip to main content

number_utilities/
parse.rs

1#![allow(clippy::result_unit_err)]
2
3pub fn parse_binary(on: &str) -> Result<usize, ()> {
4    let mut value = 0usize;
5    for byte in on.bytes() {
6        value <<= 1;
7        if let b'0' | b'1' = byte {
8            value |= (byte == b'1') as usize;
9        } else {
10            return Err(());
11        }
12    }
13    Ok(value)
14}
15
16pub fn parse_denary(on: &str) -> Result<usize, ()> {
17    let mut value = 0usize;
18    for byte in on.bytes() {
19        value *= 10;
20        if let b'0'..=b'9' = byte {
21            value += usize::from(byte - b'0')
22        } else {
23            return Err(());
24        }
25    }
26    Ok(value)
27}
28
29pub fn parse_hex(on: &str) -> Result<usize, ()> {
30    let mut value = 0usize;
31    for byte in on.bytes() {
32        value <<= 4; // log2(16) = 4
33        let code = match byte {
34            b'0'..=b'9' => usize::from(byte - b'0'),
35            b'a'..=b'f' => usize::from(byte - b'a') + 10,
36            // also include uppercase
37            b'A'..=b'F' => usize::from(byte - b'A') + 10,
38            _byte => {
39                return Err(());
40            }
41        };
42        value |= code;
43    }
44    Ok(value)
45}
46
47pub fn parse_english(on: &str) -> Result<usize, &str> {
48    fn parse_item(item: &str) -> Result<usize, &str> {
49        let prefix_magnitude = item
50            .rsplit_once(" ")
51            .and_then(|(lhs, rhs)| parse_magnitude(rhs).map(|rhs| (lhs, rhs)));
52
53        if let Some((left, right)) = item.rsplit_once(" and ")
54            && (left.contains(" and ") || prefix_magnitude.is_none())
55        {
56            let left = parse_item(left)?;
57            let right = parse_item(right)?;
58            Ok(left + right)
59        } else if let Some((prefix, magnitude)) = prefix_magnitude {
60            let prefix = if let Some((left, right)) = prefix.split_once(" and ") {
61                if left.ends_with(" hundred") {
62                    let left = parse_possible_pair(left)?;
63                    let right = parse_possible_pair(right)?;
64                    left + right
65                } else {
66                    let left = parse_item(left)?;
67                    let right = parse_item(right)?;
68                    let value = left + right * magnitude;
69                    return Ok(value);
70                }
71            } else {
72                parse_possible_pair(prefix)?
73            };
74            Ok(prefix * magnitude)
75        } else {
76            parse_possible_pair(item)
77        }
78    }
79
80    fn parse_magnitude(item: &str) -> Option<usize> {
81        match item {
82            "quadrillion" => Some(1_000_000_000_000_000),
83            "trillion" => Some(1_000_000_000_000),
84            "billion" => Some(1_000_000_000),
85            "million" => Some(1_000_000),
86            "thousand" => Some(1_000),
87            "hundred" => Some(100),
88            _ => None,
89        }
90    }
91
92    fn parse_possible_pair(item: &str) -> Result<usize, &str> {
93        if let Some((left, right)) = item.rsplit_once(" ") {
94            parse_pair(left, right)
95        } else {
96            under_one_hundred_to_usize(item)
97        }
98    }
99
100    fn parse_pair<'a>(left: &'a str, right: &'a str) -> Result<usize, &'a str> {
101        let left = under_one_hundred_to_usize(left)?;
102        if let Some(magnitude) = parse_magnitude(right) {
103            Ok(left * magnitude)
104        } else {
105            let right = under_one_hundred_to_usize(right)?;
106            Ok(left + right)
107        }
108    }
109
110    fn under_one_hundred_to_usize(item: &str) -> Result<usize, &str> {
111        Ok(match item {
112            "zero" => 0,
113            "one" => 1,
114            "two" => 2,
115            "three" => 3,
116            "four" => 4,
117            "five" => 5,
118            "six" => 6,
119            "seven" => 7,
120            "eight" => 8,
121            "nine" => 9,
122            "ten" => 10,
123            "eleven" => 11,
124            "twelve" => 12,
125            "thirteen" => 13,
126            "fourteen" => 14,
127            "fifthteen" => 15,
128            "sixteen" => 16,
129            "seventeen" => 17,
130            "eighteen" => 18,
131            "nineteen" => 19,
132            "twenty" => 20,
133            "thirty" => 30,
134            "fourty" => 40,
135            "fifty" => 50,
136            "sixty" => 60,
137            "seventy" => 70,
138            "eighty" => 80,
139            "ninety" => 90,
140            number => {
141                return Err(number);
142            }
143        })
144    }
145
146    let mut acc: usize = 0;
147    for block in on.split(',') {
148        let block = block.trim();
149        let item = parse_item(block)?;
150        acc += item;
151    }
152    Ok(acc)
153}
154
155pub fn parse_roman_numeral(on: &str) -> Result<usize, ()> {
156    let mut acc = 0;
157    for chr in on.chars() {
158        let letter = match chr.to_ascii_uppercase() {
159            'M' => 1000,
160            'D' => 500,
161            'C' => 100,
162            'L' => 50,
163            'X' => 10,
164            'V' => 5,
165            'I' => 1,
166            _chr => {
167                return Err(());
168            }
169        };
170
171        acc += letter;
172        acc -= 2 * (acc % letter);
173    }
174    Ok(acc)
175}
176
177#[cfg(test)]
178mod tests {
179    #[test]
180    fn parse_binary() {
181        assert_eq!(super::parse_binary("0"), Ok(0));
182        assert_eq!(super::parse_binary("1"), Ok(1));
183        assert_eq!(super::parse_binary("001"), Ok(1));
184        assert_eq!(super::parse_binary("101"), Ok(5));
185        assert_eq!(super::parse_binary("110101"), Ok(1 + 4 + 16 + 32));
186    }
187
188    #[test]
189    fn parse_denary() {
190        assert_eq!(super::parse_denary("0"), Ok(0));
191        assert_eq!(super::parse_denary("5"), Ok(5));
192        assert_eq!(super::parse_denary("17"), Ok(17));
193        assert_eq!(super::parse_denary("160"), Ok(160));
194        assert_eq!(super::parse_denary("999999"), Ok(999999));
195    }
196
197    #[test]
198    fn parse_hex() {
199        assert_eq!(super::parse_hex("2"), Ok(2));
200        assert_eq!(super::parse_hex("a3"), Ok(163));
201        assert_eq!(super::parse_hex("1b4"), Ok(436));
202    }
203}