94 lines
1.9 KiB
Rust
94 lines
1.9 KiB
Rust
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;
|
|
}
|
|
}
|
|
}
|