peuler 0.1.0

A Rust crate with solutions to the Project Euler problems
Documentation 
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
106
107
108
109
110
111
112

use crate::Solution;

problem!(Problem0089, 89, "Roman Numerals");

impl Solution for Problem0089 {
    fn solve(&self) -> String {
        const INPUT: &str = include_str!("0089_roman.txt");
        let mut saved_chars = 0;

        for roman_numeral in INPUT.lines() {
            saved_chars += roman_numeral.chars().count();
            saved_chars -= int_2_roman(roman_2_int(roman_numeral)).chars().count();
        }

        saved_chars.to_string()
    }
}

fn int_2_roman(mut num: u16) -> String {
    let mut roman = String::with_capacity(4);

    for _ in 0..num / 1000 {
        roman.push('M');
    }
    num %= 1000;

    let hundreds = num / 100;
    num %= 100;
    match hundreds {
        9 => roman.push_str("CM"),
        5..=8 => {
            roman.push('D');
            (5..hundreds).for_each(|_| roman.push('C'));
        }
        4 => roman.push_str("CD"),
        _ => (0..hundreds).for_each(|_| roman.push('C')),
    }

    let tens = num / 10;
    num %= 10;
    match tens {
        9 => roman.push_str("XC"),
        5..=8 => {
            roman.push('L');
            (5..tens).for_each(|_| roman.push('X'));
        }
        4 => roman.push_str("XL"),
        _ => (0..tens).for_each(|_| roman.push('X')),
    }

    match num {
        9 => roman.push_str("IX"),
        5..=8 => {
            roman.push('V');
            (5..num).for_each(|_| roman.push('I'));
        }
        4 => roman.push_str("IV"),
        _ => (0..num).for_each(|_| roman.push('I')),
    }

    roman
}

fn roman_2_int(roman: &str) -> u16 {
    let mut integer = 0;

    let mut iter = roman.chars().peekable();
    while let Some(c) = iter.next() {
        match c {
            'I' => match iter.peek() {
                Some('V') => {
                    integer += 4;
                    iter.next();
                }
                Some('X') => {
                    integer += 9;
                    iter.next();
                }
                _ => integer += 1,
            },
            'V' => integer += 5,
            'X' => match iter.peek() {
                Some('L') => {
                    integer += 40;
                    iter.next();
                }
                Some('C') => {
                    integer += 90;
                    iter.next();
                }
                _ => integer += 10,
            },
            'L' => integer += 50,
            'C' => match iter.peek() {
                Some('D') => {
                    integer += 400;
                    iter.next();
                }
                Some('M') => {
                    integer += 900;
                    iter.next();
                }
                _ => integer += 100,
            },
            'D' => integer += 500,
            'M' => integer += 1000,
            _ => (),
        }
    }

    integer
}