number_utilities/
parse.rs1#![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; 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 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}