projecteuler.net/057/main.rs

struct Num { rdigits: Vec<u8> }

impl Num {
    pub fn from(s: &String) -> Num {
        let rd: Vec<u8> = s.chars().rev()
                    .map(|c| String::from(c).parse::<u8>().unwrap())
                    .collect();
        Num { rdigits: rd }
    }
    pub fn fromn(n: u32) -> Num {
        let mut rd =  Vec::<u8>::new();
        let mut nn = n;
        while nn > 0 {
            let d = (nn % 10) as u8;
            rd.push(d);
            nn /= 10;
        }
        Num { rdigits: rd }
    }
    pub fn add(&self, n: &Num) -> Num {
        let mut xs = self.rdigits.clone();
        let mut ys = n.rdigits.clone();
        let mut rs: Vec<u8> = Vec::new();

        while xs.len() < ys.len() { xs.push(0); }
        while ys.len() < xs.len() { ys.push(0); }

        let mut rm = 0u8;
        for (a, b) in xs.iter().zip(ys.iter()) {
            if a + b + rm > 9 {
                rs.push((a + b + rm) - 10);
                rm = 1u8;
            } else {
                rs.push(a + b + rm);
                rm = 0u8;
            }
        }
        if rm > 0 { rs.push(1u8); }

        Num { rdigits: rs }
    }
    pub fn mult(&self, n: u32) -> Num {
        let mut res = self.add(&Num::fromn(0));
        for n in 1..n {
            res = res.add(&self);
        }
        return res;
    }
    pub fn print_10(&self) {
        for d in self.rdigits.iter().rev().take(10) { print!("{}", d); }
        //println!("");
    }
}



struct D {
    a: Num,
    b: Num
}

impl D {
    pub fn from(a: Num, b: Num) -> D {
        D { a: a, b: b }
    }
    pub fn print(&self) {
        self.a.print_10();
        print!("/");
        self.b.print_10();
        println!("");

    }
    pub fn add_n(&self, n: u32) -> D {
        let nn = self.b.mult(n);
        return D::from(nn.add(&self.a), self.b.add(&Num::fromn(0)));
    }
    pub fn iter(&self) -> D {
        let mut res = self.add_n(1);
        let dd = D::from(res.b, res.a);
        return dd.add_n(1);
    }
    pub fn bigger(&self) -> bool {
        return self.a.rdigits.len() > self.b.rdigits.len()
    }
}


fn main() {
    let mut d = D::from(Num::fromn(1), Num::fromn(2));
    let mut count = 0;
    d = d.add_n(1);
    //d.print();
    for n in 0..1000 {
        d = d.iter();
        //d.print();
        if d.bigger() {
            count += 1;
        }
    }
    println!("{}", count);
}