use std::collections::HashSet;

pub fn prime_factors(number: u64) -> Vec<u64> {
    let mut factors = vec![2];
    let upper: u64 = (number as f64).sqrt().ceil() as u64;
    for i in 3..upper {
        let mut is_prime = true;
        for factor in &factors {
            if i % factor == 0 {
                is_prime = false;
                break;
            }
        }
        if is_prime && number % i == 0 {
            factors.push(i);
        }
    }

    factors
}

pub fn nth_prime(nth: i64) -> Option<i64> {
    let mut primes: Vec<i64> = vec![2];

    let mut i = 3;

    while primes.len() < nth as usize {
        let mut is_prime = true;
        for prime in &primes {
            if i % prime == 0 {
                is_prime = false;
                break;
            }
        }
        if is_prime {
            primes.push(i);
        }
        i += 1;
    }

    primes.pop()
}

pub fn factorial(n: u64) -> u64 {
    let mut result = 1;
    for i in 1..=n {
        result *= i;
    }
    result
}

pub fn binomial(n: u64, k: u64) -> u64 {
    if k > n {
        0
    } else {
        factorial(n) / (factorial(k) * factorial(n - k))
    }
}

pub fn get_divisors(n: u64) -> Vec<u64> {
    let mut divisors = HashSet::from([1]);
    let mut potential_divisor = 2;
    while (potential_divisor * potential_divisor) <= n {
        if n % potential_divisor == 0 {
            divisors.insert(potential_divisor);
            divisors.insert(n / potential_divisor);
        }
        potential_divisor += 1;
    }
    divisors.iter().copied().collect()
}

pub fn fib(n: u64) -> u64 {
    let mut last_two = (1, 1);
    let mut iteration = 1;
    while iteration < n {
        last_two = (last_two.1, last_two.0 + last_two.1);
        iteration += 1;
    }

    last_two.0
}

pub fn gcd(mut a: u64, mut b: u64) -> u64 {
    loop {
        let t = b;
        b = a % b;
        a = t;
        if b == 0 {
            return a;
        }
    }
}