impl with Rust

ModernC++ChallengeBook_ch1.rs

#![allow(unused)]

//1.1
fn sum_div3or5(n: u32) -> u32{
    let mut sum = 0;
    for i in 1..(n+1) {
        if i % 3 == 0 || i % 5 == 0 {
            sum += i;
        }
    }
    sum
}
//1.2
fn gcd(a: u32, b:u32) -> u32 {
    if b == 0 {
        a
    }else{
        gcd(b, a%b)
    }
}
//1.3
fn lcm(a: u32, b:u32) -> u32 {
    let h = gcd(a,b);
    if h > 0{
        a*b / h
    }else{
        0
    }
}
//1.4
fn is_prime(n: i32) -> bool {
    if n <= 3 {
        return n > 1
    }else if (n % 2 == 0) || (n % 3 == 0) {
        return false
    }else{
        let mut i = 5;
        loop{
            if i*i > n {
                break
            }
            if n % i == 0 || n % (i+2) == 0 {
                return false
            }
            i += 6;
        }
        return true
    }
}
fn is_prime_(num: i32) -> bool {
    if num <= 3 {
        return num > 1
    }else if num % 2 == 0 || num % 3 == 0 {
        return false
    }else{
        for i in (5..).step_by(6).take_while(|m| m*m <= num) {
            if num % i == 0 || num % (i+2) == 0 {
                return false
            }
        }
        return true
    }
}
//1.5
fn is_sex_prime(num: i32) -> bool{
    if is_prime_(num) && is_prime_(num+6) {
        true
    }else{
        false
    }
}
//1.6
fn sum_proper_divisors(num: i32) -> i32 {
    let mut result = 1;
    let root = (num as f64).sqrt() as i32;
    for i in 2..(root+1){
        if num % i == 0 {
            result += 
            if num/i == i {
                i
            }else{
                i + num/i
            }
        }
    }
    result
}
fn print_abundant(limit: i32) -> () {
    for number in 10..(limit+1) {
        let sum = sum_proper_divisors(number);
        if sum > number {
            println!("{}, abundance= {}", number, sum-number);
        }
    }
}
//1.7
fn print_amicables(limit: i32){
    for number in 4..limit {
        let sum1 = sum_proper_divisors(number);
        if sum1 < limit {
            let sum2 = sum_proper_divisors(sum1);
            if sum2 == number && number != sum1 {
                println!("{}, {}", number, sum1);
            }
        }
    }
}
//1.8
fn print_narcissistics_1()
{
    for a in 1..10 {
        for b in 0..10 {
            for c in 0..10 {
                let abc = a*100 + b*10 + c;
                let arm = a*a*a + b*b*b + c*c*c;
                if abc == arm {
                    println!("{}", arm);
                }
            }
        }
    }
}
//1.9
fn prime_factors(num: u32) -> Vec<u32> {
    let mut factors = Vec::new();
    let mut n = num;
    loop{
        if n % 2 == 0{
            factors.push(2);
            n /= 2;
        }else{
            break;
        }
    }

    let root = (n as f64).sqrt() as u32;
    for i in (3..).step_by(2).take_while(|m| m <= &root) {
        loop{
            if n % i == 0 {
                factors.push(i);
                n /= i;
            }else{
                break;
            }
        }
    }
    if n > 2 {
        factors.push(n);
    }
    
    return factors;
}
//1.10
fn gray_encode(num: u32) -> u32 {
    num ^ (num >> 1)
}
fn gray_decode(g: u32) -> u32 {
    let mut bit = 1<<31;
    let mut gray = g;
    loop{
        if bit == 0 {
            break;
        }
        if gray & bit != 0 {
            gray ^= bit >> 1;
        }
        bit >>= 1;
    }
    gray
}
//1.11
fn to_roman(value: &mut u32) -> String{
    let roman = vec![( 1000, "M" ),( 900, "CM" ), ( 500, "D" ),( 400, "CD" ),
                     ( 100, "C" ),( 90, "XC" ), ( 50, "L" ),( 40, "XL" ),
                     ( 10, "X" ),( 9, "IX" ), ( 5, "V" ),( 4, "IV" ), ( 1, "I" )];
    let mut result = "".to_string();
    
    for r in roman {
        let mut n = r.0;
        let s = r.1;
        while value >= &mut n {
            result += s;
            *value -= n;
        }
    }
    return result;
}
//1.12
use std::convert::TryInto;

fn longest_collatz(limit: usize) -> (u64, usize)  {
    let mut length = 0;
    let mut number = 0;
    let mut cache: Vec<u64> = vec![0;limit+1];

    //let l: u32 = (limit+1).try_into().unwrap();
    let l = limit+1;

    for index in 2..(l) {
        let i = index.try_into().unwrap();
        let mut n = i;
        let mut steps = 0;
        while n != 1 && n >= i {
            if n % 2 == 0 {
                n /= 2;

            }else{
                n = n * 3 + 1;
            }
            steps += 1;
        }
        cache[i] = steps + cache[n];

        if cache[i] > length {
            length = cache[i];
            number = i;
        }
    }
    (number.try_into().unwrap(), length.try_into().unwrap())
}
//1.13
/** https://qiita.com/termoshtt/items/6e2ff724e6da86963aa9
### Edit Cargo.toml ###
[dependencies]
rand = "0.6.5"
*/
use rand::Rng;

fn compute_pi(samples: u32) -> f32 {
    let mut hit = 0.0;
    let mut rng = rand::thread_rng();
    for _ in 0..samples {
        let x: f32 = rng.gen();
        let y: f32 = rng.gen();

        if (x.powf(2.0) + y.powf(2.0)) < 1.0 {
            hit += 1.0;
        }
    }
    return 4.0 * hit / (samples as f32);
}
//1.14
fn validate_isbn(isbn: &str) -> bool {
    let mut sum = 0;

    if isbn.len() == 10 && 
    isbn.chars().fold(true, |s,a| s && a.is_numeric())
    {
        let mut w = 1;

        for s in isbn.chars().rev() {
            sum = sum + w * s.to_digit(10).unwrap();
            w += 1;
        }
    }
    (sum % 11) == 0
}

fn main() {
    //1.14
    assert_eq!(true, validate_isbn("4873118557"));
    assert_eq!(true, validate_isbn("1000000001"));
    assert_eq!(false,validate_isbn("0000000001"));
    //1.13
    //println!("{}", compute_pi(1000000));
    //1.12
    assert_eq!((837799,524), longest_collatz(1000_000));
    //1.11
    assert_eq!("XLII", to_roman(&mut 42));
    assert_eq!("V", to_roman(&mut 5));
    //1.10
    for n in 0..32 {
        let encg = gray_encode(n);
        let decg = gray_decode(encg);
        //println!("{} {} {}", n, encg, decg);
        assert_eq!(n, decg);
    }
    //1.9
    assert_eq!(vec![2,11],  prime_factors(22));
    assert_eq!(vec![2,5],   prime_factors(10));
    assert_eq!(vec![2,3,7], prime_factors(42));
    //1.8
    //print_narcissistics_1();
    //1.7
    //print_amicables(1000);
    //1.6
    assert_eq!(16, sum_proper_divisors(12));
    //print_abundant(100);
    //1.5
    assert_eq!(true, is_sex_prime(5));
    assert_eq!(true, is_sex_prime(13));
    assert_eq!(true, is_sex_prime(7));
    assert_eq!(false, is_sex_prime(8));
    //1.4
    assert_eq!(false, is_prime_(18));
    assert_eq!(true, is_prime_(19));
    assert_eq!(false, is_prime(18));
    assert_eq!(true, is_prime(19));
    //1.3
    assert_eq!(15, lcm(3,5));
    //1.2
    assert_eq!(1, gcd(11,13));
    assert_eq!(5, gcd(15,5));
    //1.1
    assert_eq!(8,  sum_div3or5(5) );// 3+5
    assert_eq!(60, sum_div3or5(15));// 3+5+6+9+10+12+15
                                    // 3+5+12 +10  +  6+9+15
}