Summary Files Commits Branches @commit @diff @stats
path: root / Year 4 / Programming with Rust / hw01 / src / lib.rs
blob: ca7845ba99c833c93c483929e617089674c789ba (plain) (blame)
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
pub struct FibIter {
    f0: u32,
    f1: u32,
}

impl FibIter {
    pub fn new() -> FibIter {
        FibIter { f0: 1, f1: 1, }
    }

    pub fn next(&mut self) -> u32 {
        let f0 = self.f0;
        // 1 2 |-> 2 3
        self.f0 = self.f1;
        self.f1 += f0;
        f0
    }

    pub fn rev(self) -> RevFibIter {
        RevFibIter { f0: self.f1 - self.f0, f1: self.f0 }
    }

    fn inc(&mut self) -> Option<usize> {
        Option::Some(self.next() as usize)
    }
}

struct Split {
    start: usize,
    end:   usize,
    count: u32,
    fib:   Option<FibIter>,
    rfib:  Option<RevFibIter>,
    n:         u32,
    symmetric: bool,
}

impl Split {
    fn new(n: u32, symmetric: bool) -> Split {
        let mut fib = FibIter::new();
        Split { start: 0, end: fib.inc().unwrap(), count: 0, fib: Option::Some(fib), rfib: Option::None, n: n, symmetric: symmetric }
    }

    fn inc(&mut self) {
        if self.symmetric && self.n == self.count {
            self.rfib = Option::Some(self.fib.take().unwrap().rev());
        }

        self.start  = self.end;
        self.end   += match self.fib {
            Some(_) => self. fib.as_mut().unwrap().inc().unwrap(),
            None    => self.rfib.as_mut().unwrap().inc().unwrap()
        };
        self.count += 1;
    }
}

fn _fib_split(text: &str, n: u32, panic: bool, symmetric: bool) -> (Vec<String>, &str) {
    let mut out: Vec<String> = Vec::new();

    let mut sp = Split::new(n, symmetric);
    //                            ( panic -> sp.count < n)
    while sp.end <= text.len() && (!panic || sp.count < n) {
        out.push(text[sp.start..sp.end].to_string());
        sp.inc();
    }

    if panic && sp.count < n {
        panic!("Split into {} our of {} words!", sp.count, n);
    }

    (out, &text[sp.start..])
}

pub fn fib_split(text: &str) -> Vec<String> {
    _fib_split(text, 0, false, false).0
}

pub fn fib_split_n(text: &str, n: u32) -> (Vec<String>, &str) {
    _fib_split(text, n, true, false)
}

pub struct RevFibIter {
    f0: u32,
    f1: u32,
}

impl RevFibIter {
    pub fn next(&mut self) -> Option<u32> {
        if self.f1 == 1 {
            return Option::None;
        }

        // 2 3 |-> 1 2
        let f0 = self.f0;
        self.f0 = self.f1 - self.f0;
        self.f1 = f0;

        Option::Some(self.f1)
    }

    fn inc(&mut self) -> Option<usize> {
        let val = self.next();
        match val {
            Option::Some(_) => Option::Some(val.unwrap() as usize),
            Option::None    => Option::None,
        }
    }
}

pub fn fib_split_n_symmetric(text: &str, n: u32) -> (Vec<String>, &str) {
    _fib_split(text, n, true, true)
}

#[test]
fn test_basic() {
    let mut fib_iter = FibIter::new();
    fib_iter.next();

    let mut rev_fib_iter: RevFibIter = fib_iter.rev();
    rev_fib_iter.next();

    let _words: Vec<String> = fib_split("Fibonacci words!");

    let (_words, _rest): (Vec<String>, &str) =
        fib_split_n("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 1);

    let (_words, _rest): (Vec<String>, &str) =
        fib_split_n_symmetric("Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 1);
}