Return to Question

I am starting to learn Rust and it seems pretty awesome but it's way different than any C based language. I want to know how can I make this code more idiomatic and also how can I improve my solution itself.

Euler problem 5.

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

fn near_pow(number:f64, exponent:f64)-> f64
{
 exponent.powf(number.log(exponent).floor())
}
fn is_prime(number:i32) -> bool
{
 use std::ops::Rem;
 
 if number == 2 { return true; }
 if number.rem(2)== 0 { return false; }
 
 let mut i = 3;
 while (i*i) <= number
 {
 if number.rem(i) == 0 {return false;}
 i+= 2;
 }
 true
}
fn euler_problem5(to:i32) -> f64
{
 (1..to+1).filter(|&x| is_prime(x))
 .fold(1f64, |p , x|p * near_pow(to as f64, x as f64)) 
}
fn main() {
 
 let x = euler_problem5(20);
 println!("{}",x);
 
}

Link to playground

I am starting to learn Rust and it seems pretty awesome but it's way different than any C based language. I want to know how can I make this code more idiomatic and also how can I improve my solution itself.

Euler problem 5.

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

fn near_pow(number:f64, exponent:f64)-> f64
{
 exponent.powf(number.log(exponent).floor())
}
fn is_prime(number:i32) -> bool
{
 use std::ops::Rem;
 
 if number == 2 { return true; }
 if number.rem(2)== 0 { return false; }
 
 let mut i = 3;
 while (i*i) <= number
 {
 if number.rem(i) == 0 {return false;}
 i+= 2;
 }
 true
}
fn euler_problem5(to:i32) -> f64
{
 (1..to+1).filter(|&x| is_prime(x))
 .fold(1f64, |p , x|p * near_pow(to as f64, x as f64)) 
}
fn main() {
 
 let x = euler_problem5(20);
 println!("{}",x);
 
}

Link to playground

I am starting to learn Rust and it seems pretty awesome but it's way different than any C based language. I want to know how can I make this code more idiomatic and also how can I improve my solution itself.

Euler problem 5.

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

fn near_pow(number:f64, exponent:f64)-> f64
{
 exponent.powf(number.log(exponent).floor())
}
fn is_prime(number:i32) -> bool
{
 use std::ops::Rem;
 
 if number == 2 { return true; }
 if number.rem(2)== 0 { return false; }
 
 let mut i = 3;
 while (i*i) <= number
 {
 if number.rem(i) == 0 {return false;}
 i+= 2;
 }
 true
}
fn euler_problem5(to:i32) -> f64
{
 let fold_op = |p, x|
 { 
 if is_prime(x)
 {
 p * near_pow(to as f64, x as f64)
 } 
 else { p }
 };
 
  (1..to+1).fold(1f64, fold_op)
}
fn main() {
 
 let x = euler_problem5(20);
 println!("{}",x);
 
}

Link to playground

I am starting to learn Rust and it seems pretty awesome but it's way different than any C based language. I want to know how can I make this code more idiomatic and also how can I improve my solution itself.

Euler problem 5.

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

fn near_pow(number:f64, exponent:f64)-> f64
{
 exponent.powf(number.log(exponent).floor())
}
fn is_prime(number:i32) -> bool
{
 use std::ops::Rem;
 
 if number == 2 { return true; }
 if number.rem(2)== 0 { return false; }
 
 let mut i = 3;
 while (i*i) <= number
 {
 if number.rem(i) == 0 {return false;}
 i+= 2;
 }
 true
}
fn euler_problem5(to:i32) -> f64
{
 (1..to+1).filter(|&x| is_prime(x))
 .fold(1f64, |p , x|p * near_pow(to as f64, x as f64)) 
}
fn main() {
 
 let x = euler_problem5(20);
 println!("{}",x);
 
}

Link to playground

I am starting to learn Rust and it seems pretty awesome but it's way different than any C based language. I want to know how can I make this code more idiomatic and also how can I improve my solution itself.

Project Euler problem 5.

fn near_pow(number:f64, exponent:f64)-> f64
{
 exponent.powf(number.log(exponent).floor())
}
fn is_prime(number:i32) -> bool
{
 use std::ops::Rem;
 
 if number == 2 { return true; }
 if number.rem(2)== 0 { return false; }
 
 let mut i = 3;
 while (i*i) <= number
 {
 if number.rem(i) == 0 {return false;}
 i+= 2;
 }
 true
}
fn euler_problem5(to:i32) -> f64
{
 let fold_op = |p, x|
 { 
 if is_prime(x)
 {
 p * near_pow(to as f64, x as f64)
 } 
 else { p }
 };
 
 (1..to+1).fold(1f64, fold_op)
}
fn main() {
 
 let x = euler_problem5(20);
 println!("{}",x);
 
}

Link to playground

I am starting to learn Rust and it seems pretty awesome but it's way different than any C based language. I want to know how can I make this code more idiomatic and also how can I improve my solution itself.

Euler problem 5.

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

fn near_pow(number:f64, exponent:f64)-> f64
{
 exponent.powf(number.log(exponent).floor())
}
fn is_prime(number:i32) -> bool
{
 use std::ops::Rem;
 
 if number == 2 { return true; }
 if number.rem(2)== 0 { return false; }
 
 let mut i = 3;
 while (i*i) <= number
 {
 if number.rem(i) == 0 {return false;}
 i+= 2;
 }
 true
}
fn euler_problem5(to:i32) -> f64
{
 let fold_op = |p, x|
 { 
 if is_prime(x)
 {
 p * near_pow(to as f64, x as f64)
 } 
 else { p }
 };
 
 (1..to+1).fold(1f64, fold_op)
}
fn main() {
 
 let x = euler_problem5(20);
 println!("{}",x);
 
}

Link to playground