看了一下网上有关Rust的介绍,都说它的学习曲线相当陡峭,曾一度被其吓着,后来发现Rust借鉴了Haskell等函数式编程语言的优点,而我以前专门学习过Haskell,经过一段时间的入门学习,我现在已经喜欢上这门神奇的语言。
入门资料我用官方的《The Rust Programming Language》,非常权威,配合着《Rust by example》这本书一起学习,效果非常不错。
学习任何一项技能最怕没有反馈,尤其是学英语、学编程的时候,一定要“用”,学习编程时有一个非常有用的网站,它就是“欧拉计划”,网址:https://projecteuler.net
这个网站提供了几百道由易到难的数学问题,你可以用任何办法去解决它,当然主要还得靠编程,但编程语言不限,已经有Java、C#、Python、Lisp、Haskell等各种解法,当然直接用google搜索答案就没意思了。
学习Rust最好先把基本的语法和特性看过一遍,然后就可以动手解题了,解题的过程就是学习、试错、再学习、掌握和巩固的过程,学习进度会大大加快。
环境准备
在Windows下安装,用官网上的rustup直接默认安装即可。
安装完成之后,就有了《The Rust Programming Language》这本书的离线HTML版本,直接用命令打开:
rustup doc --book
还要会使用强大的包管理器:cargo
这个cargo好用的另人发指,建项目、编译、运行都得用它:
cargo new euler1
cd euler1
cargo build
cargo run
第一题
问题描述:
求1000以内(不含1000)的所有被3或5整除的整数之和。
直接上答案:
let mut sum = 0;
for i in 1..1000 {
if i % 3 == 0 || i % 5 == 0 {
sum += i;
}
}
println!("{}", sum);
mut关键字(mutable的缩写)是Rust的一大特色,所有变量默认是不可变的,如果想可变,需要mut关键字,否则在 sum += i 时会报编译错误。
println! 后面有一个叹号,表示这是一个宏,Rust里的宏也是非常非常强大!现在还不到了解的时候。
学过Python的列表推导(List Comprehension)语法的感觉这种题完全可以用一行语句搞定,Rust中需要用到filter()和sum()函数。
// 为了方便阅读,分成多行
println!(
"{}",
(1..1000).filter(|x| x % 3 == 0 || x % 5 == 0)
.sum::()
);
.. 这个语法糖表示一个范围,需要注意最后不包括1000,如果想包含1000,需要这样写:(1..=1000)
filter里面的|x|定义了一个闭包函数,关于闭包,又是一个超级复杂的主题。
sum::() 是一个范型函数,这种两个冒号的语法让我好不适应。
还可以用fold()函数,是这样写的:
println!(
"{}",
(1..1000)
.filter(|x| x % 3 == 0 || x % 5 == 0)
.fold(0, |s, a| s + a)
);
把这些数全部打印出来,注意打印语句里的{:?}:
println!(
"{:?}",
(1..1000)
.filter(|x| x % 3 == 0 || x % 5 == 0)
.collect::>()
);// [3, 5, 6, 9, 10, 12, ... 999]
第二题
问题描述:
斐波那契数列中,小于400万的所有偶数之和。
算法并不难,这里的数列以[1, 2]开始,后面每个数是前面2个数字之和:
let mut fib = vec![1, 2];
let mut i = 2; // 已经有2个元素
let mut sum = 2;
loop {
let c = fib[i - 1] + fib[i - 2];
if c >= 4_000_000 {
break;
}
fib.push(c);
if c % 2 == 0 {
sum += c;
}
i += 1;
}
println!("{}", sum);
这里没有使用函数式编程,大量使用了mut,无限循环用loop语法。
rust中关于整数的表示提供了多种数据类型,默认的整数类型是i32,默认浮点类型是f64。
数字类型中比较有特点的是可以用'_'分隔符,让数字更容易读一些,还可以把u32, i64等类型作为后缀来指明类型。
let 赋值语句与其它语言也不一样,还可以改变其类型,这个特性称为隐藏shadowing。
let x = 500u16;
let x = x + 1;
let x = 4_000_000_u64;
let x = "slb";
fib是一个向量,相当于其它语言里的数组、列表。vec! 宏可以对其进行初始化:
let mut fib = vec![1, 2];
上面一行与下面三行等价:
let mut fib = Vec::new();
fib.push(1);
fib.push(2);
push()函数用于给列表增加一个元素。
第三题
问题描述: 找出整数600851475143的最大素数因子。
素数就是只能被1和本身整除的数,首先定义一个函数is_prime(),用于判断是否为素数:
fn is_prime(num: u64) -> bool {
for i in 2..(num / 2 + 1) {
if num % i == 0 {
return false;
}
}
true
}
Rust是强类型语言,看到函数定义里的 -> bool,让我想起了Haskell的语法。
函数最后一行的true孤零零的,没有分号,让人感觉很奇怪。Rust是一个基于表达式的语言,一个语句块的最后是一个表达式,当然也可以用return true;
现在可以查找最大的素数因子了:
let big_num = 600851475143;
for i in (2..=big_num).rev() {
if big_num % i == 0 && is_prime(i) {
println!("{}", i);
break;
}
}
程序编译没问题,但几分钟也运行不出来结果,试着把数字调小一点,比如:600851,不到1秒出来结果,看来程序的效率太差了,主要是有大量的判断素数的运算量,需要优化。
尝试把大数进行素数因子分解,并且把素因子记录下来进行比较,效率得到大幅提升,不到1秒得出结果。
let mut big_num = 600851475143;
let mut max_prime_factor = 2;
while big_num >= 2 {
for i in 2..=big_num {
if big_num % i == 0 && is_prime(i) {
big_num /= i;
if i > max_prime_factor {
max_prime_factor = i;
break;
}
}
}
}
println!("{}", max_prime_factor);
第四题
问题描述:
求两个3位数之积最大的回文数。
所谓回文数,就是两边读都一样的数,比如:698896。
先写一个判断回文数的函数:
fn is_palindromic(n: u64) -> bool {
let s = n.to_string();
s.chars().rev().collect::<String>() == s
}
这里把数字转换成字符串,再把字符串反序,如果两个字符串一样,则是回文数。
Rust中字符串的反序操作好奇怪,竟然不是s.rev(),我用google找到了那个代码片段。
剩下的逻辑并不复杂,用两重循环可以快速搞定。
let mut max = 0;
for x in 100..=999 {
for y in 100..=999 {
let prod = x * y;
if is_palindromic(prod) && prod > max {
max = prod;
// println!("{} x {} = {}", x, y, prod);
}
}
}
println!("{}", max);
我一开始以为只要反序搜索就可以快速找到答案,但找到的数并不是最大,你能发现问题在哪吗?不过,从这个错误代码中,我学会了双重循环如何跳出外层循环的语法。真是没有白走的弯路。
// 错误代码
'outer: for x in (100..=999).rev() {
for y in (100..=999).rev() {
let prod = x * y;
if is_palindromic(prod) {
println!("{} x {} = {}", x, y, prod);
break 'outer;
}
}
}
第五题
问题描述:
找出能够被1, 2, 3, ..., 20整除的最小整数。
代码逻辑很简单,一个一个尝试整除,找到后跳出最外层循环。
let mut x = 2 * 3 * 5 * 7;
'outer: loop {
for f in 2..=20 {
if x % f != 0 {break;}
if f == 20 {
println!("{}", x);
break 'outer;
}
}
x += 2;
}
如果你感觉程序运行效率不够高,可以用下面这个命令行,差别还是非常大的,感觉可以与C程序的效率相媲美:
cargo run --release
第六题
问题描述: 求1到100自然数的“和的平方”与“平方和”的差。
用普通的过程式编程方法,这题太简单,但要尝试一下函数式编程思路,代码可以异常简洁。
let sum_of_squares = (1..=100).map(|x| x*x).sum::();let sum = (1..=100).sum::();println!("{}", sum * sum - sum_of_squares);
另外还有一种使用fold()函数的写法,理解起来更困难一些:
let sum_of_squares = (1..=100).fold(0, |s, n| s + n * n);let sum = (1..=100).fold(0, |s, n| s + n);println!("{}", sum * sum - sum_of_squares);
--- END ---
可以在projecteuler中添加下面这个key,加我为好友,一起学习。
1539870_KBNiIXymh4SnmDEDZmUTg7tu1MTBVlLj
近期文章:
个人公众号开通3周年纪念
读书:《薛兆丰经济学讲义》(1)
定投改变命运(第2周)