proj-eul-rs

q01.rs

fn main() {
    let mut acc = 0;
    for i in (0..1000) {
        if (i % 5 == 0) || (i % 3 == 0) { 
            acc += i;
        }
    }
    println!("{}", acc);
}

q02.rs

fn main() {
    let mut curr = 2;
    let mut prev = 1;
    let mut acc  = 0;
    
    loop {
        if curr > 4_000_000 { break; };
        if curr % 2 == 0 { acc += curr; }
        let tpre = prev;
        prev = curr;
        curr = curr + tpre;
    }
    println!("{}", acc);
}

q03.rs

fn prime_factors(n_orig: i64) -> i64 {
    let mut n = n_orig.clone();
    let mut factors: Vec<i64> = Vec::new();
    let mut d = 2i64;
    
    while n > 1 {
        while n % d == 0 {
            factors.push(d);
            n = n / d;
        }
        d = d + 1;
    }
    factors.iter().max().unwrap().clone()
}

fn main() {
    println!("{:?}", prime_factors(600851475143));
}

q04.rs

fn main() {
    let mut opts: Vec<i32> = Vec::new();
    for d1 in 500..1000 {
        for d2 in 500..1000 {
            let x = d1 * d2;
            let xs = format!("{}", x);
            let chars = xs.chars().collect::<Vec<char>>();
            let mut rev_chars = chars.clone();
            rev_chars.reverse();
            if chars == rev_chars {
                opts.push(x);
            }
        }
    }
    println!("{}", opts.iter().max().unwrap());
}

q05.rs

fn gcd(a: f64, b: f64) -> f64 {
    if b == 0f64 { a } else { gcd(b, a % b) }
}

fn main() {
    let mut mult = 1f64;
    for i in (2..21) {
        mult *= (i as f64) / gcd((i as f64), mult);
    }

    println!("{:?}", mult);
}

q06.rs

fn main() {

    let sum = (1..101).fold(0, |acc, item| acc + (item * item));
    
    let _square = (1..101).fold(0, |acc, item| acc + item);
    let square = _square * _square;
    
    println!("{:?}", square - sum);

}

q07.rs

fn is_prime(n: u64) -> bool {
    if n == 2 { return true; }
    if n < 3 { return false; }
    for it in (2..n) {
        if (it * it) > n { break; }
        if n % it == 0 { return false; }
    }
    true
}

fn main() {
    let mut it = 0;
    let mut prim_it = 0;
    let brk_pt = 10_001;
    loop {
        if is_prime(it) {
            prim_it += 1;
            if prim_it == brk_pt { 
                println!("{:?}", it);
                break;
            }
        }
        it += 1;
    }
}

q08.rs

fn main() {
    let base = "
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450
".replace("\n","");
    let mut results: Vec<i64> = Vec::new();
    let chars = base.chars().collect::<Vec<char>>();
    for win in chars.windows(13) {
        let mut acc = 1i64;
        for char in win {
            let ic = char.to_string().parse::<i64>().unwrap();
            acc *= ic;
        }
        results.push(acc);
    }
    println!("{:?}", results.iter().max().unwrap());
}

q09.rs

fn main() {
    'outer: for a in (0..1001) {
        for b in ((a + 1)..1001) {
            let c = 1000 - a - b;
            if c == b { continue; }
            if (a * a) + (b * b) == (c * c) {
                println!("{:?}", (a * b * c));
                break 'outer;
            }
        }
    }
}

q10.rs

fn is_prime(n: i64) -> bool {
    if n == 2 { return true; }
    if n < 3 { return false; }
    let limit = (n as f64).sqrt() as i64 + 1;
    for it in (2..(limit + 1)) {
        if n % it == 0 { return false; }
    }
    true
}

fn main() {
    let mut acc = 0;
    for i in (0..2_000_000){
        if is_prime(i) { acc += i; }
    }
    println!("{:?}", acc);
}