# 通过欧拉计划学习Rust编程语言(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);
```

```let mut fib = vec![1, 2];

let mut sum = 2;
for i in 2.. {
let c = fib[i - 1] + fib[i - 2];
if c >= 4_000_000 {
break;
}
fib.push(c);
if c % 2 == 0 {
sum += c;
}
}
println!("{}", sum);
```

```let mut fib = vec![1, 2];
for i in 2.. {
let c = fib[i - 1] + fib[i - 2];
if c >= 4_000_000 { break; }
fib.push(c);
}
println!("{}", fib.iter().filter(|&x| x % 2 == 0).sum::<u32>());
```

## 第7题

```let max_number_to_check = 1_000_000;

let mut prime_mask = vec![true; max_number_to_check];

let mut total_primes_found = 0;

const FIRST_PRIME_NUMBER: usize = 2;
for p in FIRST_PRIME_NUMBER..max_number_to_check {
// println!("{}", p);
total_primes_found += 1;
if total_primes_found == 10001 {
println!("the 10001st prime number is : {}", p);
break;
}
let mut i = 2 * p;
while i < max_number_to_check {
i += p;
}
}
}
```

```const FIRST_PRIME_NUMBER : usize = 2;
```

## 第8题

```let digits = vec![
"73167176531330624919225119674426574742355349194934",
"96983520312774506326239578318016984801869478851843",
"85861560789112949495459501737958331952853208805511",
"12540698747158523863050715693290963295227443043557",
"66896648950445244523161731856403098711121722383113",
"62229893423380308135336276614282806444486645238749",
"30358907296290491560440772390713810515859307960866",
"70172427121883998797908792274921901699720888093776",
"65727333001053367881220235421809751254540594752243",
"52584907711670556013604839586446706324415722155397",
"53697817977846174064955149290862569321978468622482",
"83972241375657056057490261407972968652414535100474",
"82166370484403199890008895243450658541227588666881",
"16427171479924442928230863465674813919123162824586",
"17866458359124566529476545682848912883142607690042",
"24219022671055626321111109370544217506941658960408",
"07198403850962455444362981230987879927244284909188",
"84580156166097919133875499200524063689912560717606",
"05886116467109405077541002256983155200055935729725",
"71636269561882670428252483600823257530420752963450",
].concat();
```

```let x = &digits[i .. i + 13];
```

```x.chars()
.map(|c| c.to_digit(10).unwrap())
.fold(1u64, |p, a| p * a as u64);
```

to_digit(10) 可用于将字符转换为数字，例如'9'转换为9，需要注意这里的转换有可能出现异常，而rust处理异常的方式很特别，要重点学习 Option<T> 的用法。

```const ADJACENT_NUMBERS: usize = 13;

let mut max = 0;
for i in 0..digits.len() - ADJACENT_NUMBERS {
let x = &digits[i..i + ADJACENT_NUMBERS];
let prod = x
.chars()
.map(|c| c.to_digit(10).unwrap())
.fold(1u64, |p, a| p * a as u64);
if prod > max {
println!("index: {}   x: {}   prod: {}", i, x, prod);
max = prod;
}
}

```

## 第9题

```for a in 1..1000 {
for b in a..1000 {
let c = 1000 - a - b;
if c > 0 && a*a + b*b == c*c {
println!("{} = {} x {} x {}", a*b*c, a, b, c);
return;
}
}
}
```

`print([a*b*(1000-a-b) for a in range(1,1000 ) for b in range(a,1000) if 1000-a-b>0 and a*a+b*b==(1000-a-b)*(1000-a-b)])`

## 第10题

```let max_number_to_check = 2_000_000;

let mut prime_mask = vec![true; max_number_to_check];

let mut sum: u64 = 0;

const FIRST_PRIME_NUMBER: usize = 2;
for p in FIRST_PRIME_NUMBER..max_number_to_check {
sum += p as u64;
let mut i = 2 * p;
while i < max_number_to_check {
i += p;
}
}
}
println!("{}", sum);
```

## 第11题

```let arr = [
[08,02,22,97,38,15,00,40,00,75,04,05,07,78,52,12,50,77,91,08],
[49,49,99,40,17,81,18,57,60,87,17,40,98,43,69,48,04,56,62,00],
[81,49,31,73,55,79,14,29,93,71,40,67,53,88,30,03,49,13,36,65],
[52,70,95,23,04,60,11,42,69,24,68,56,01,32,56,71,37,02,36,91],
[22,31,16,71,51,67,63,89,41,92,36,54,22,40,40,28,66,33,13,80],
[24,47,32,60,99,03,45,02,44,75,33,53,78,36,84,20,35,17,12,50],
[32,98,81,28,64,23,67,10,26,38,40,67,59,54,70,66,18,38,64,70],
[67,26,20,68,02,62,12,20,95,63,94,39,63,08,40,91,66,49,94,21],
[24,55,58,05,66,73,99,26,97,17,78,78,96,83,14,88,34,89,63,72],
[21,36,23,09,75,00,76,44,20,45,35,14,00,61,33,97,34,31,33,95],
[78,17,53,28,22,75,31,67,15,94,03,80,04,62,16,14,09,53,56,92],
[16,39,05,42,96,35,31,47,55,58,88,24,00,17,54,24,36,29,85,57],
[86,56,00,48,35,71,89,07,05,44,44,37,44,60,21,58,51,54,17,58],
[19,80,81,68,05,94,47,69,28,73,92,13,86,52,17,77,04,89,55,40],
[04,52,08,83,97,35,99,16,07,97,57,32,16,26,26,79,33,27,98,66],
[88,36,68,87,57,62,20,72,03,46,33,67,46,55,12,32,63,93,53,69],
[04,42,16,73,38,25,39,11,24,94,72,18,08,46,29,32,40,62,76,36],
[20,69,36,41,72,30,23,88,34,62,99,69,82,67,59,85,74,04,36,16],
[20,73,35,29,78,31,90,01,74,31,49,71,48,86,81,16,23,57,05,54],
[01,70,54,71,83,51,54,69,16,92,33,48,61,43,52,01,89,19,67,48]
];```

```let mut max = 0;
for i in 0..20 {
for j in 0..20 {
if i+4<=20 {
let p = arr[i][j] * arr[i+1][j] * arr[i+2][j] * arr[i+3][j];
if p > max {
max = p;
println!("下 {} {} {}",i,j, max);
}
}
if j<=20-4 {
let p = arr[i][j] * arr[i][j+1] * arr[i][j+2] * arr[i][j+3];
if p > max {
max = p;
println!("右 {} {} {}",i,j, max);
}
}
if i<=20-4 && j<=20-4 {
let p = arr[i][j] * arr[i+1][j+1] * arr[i+2][j+2] * arr[i+3][j+3];
if p > max {
max = p;
println!("右下 {} {} {}",i,j, max);
}
}
if i<=20-4 && j>=3 {
let p = arr[i][j] * arr[i+1][j-1] * arr[i+2][j-2] * arr[i+3][j-3];
if p > max {
max = p;
println!("左下 {} {} {}",i,j, max);
}
}
}
}
println!("{}", max);
```

```for k in 0..4 {
let mut p = 0;
if k == 0 && i+4<=20 {
p = arr[i][j] * arr[i+1][j] * arr[i+2][j] * arr[i+3][j];
}
if k == 1 && j<=20-4 {
p = arr[i][j] * arr[i][j+1] * arr[i][j+2] * arr[i][j+3];
}
if k == 2 && i<=20-4 && j<=20-4 {
p = arr[i][j] * arr[i+1][j+1] * arr[i+2][j+2] * arr[i+3][j+3];
}
if k == 3 && i<=20-4 && j>=3 {
p = arr[i][j] * arr[i+1][j-1] * arr[i+2][j-2] * arr[i+3][j-3];
}

if p > max {
max = p;
println!("{} {} {}",i,j, max);
}
}
```

## 问题12

```fn factors(num :u32) -> Vec<u32> {
(1..=num).filter(|x| num % x == 0).collect::<Vec<u32>>()
}
```

```fn main() {
for i in 1.. {
let num = (1..=i).sum::<u32>();
let f = factors(num);
if f.len() > 500 {
println!("i:{} num:{} len:{} {:?}", i, num, f.len(), f );
println!("{}", num );
break;
}
}
}
```

```fn main() {
for i in 2.. { // 12375
let num = (1..=i).sum::<u32>();
let f = half_factors(num);
if f.len() * 2 > 500 {
println!("i:{} num:{} len:{} half of factors:{:?}", i, num, 2 * f.len(), f );
println!("{}", num );
break;
}
}
}

fn half_factors(num :u32) -> Vec<u32> {
let s = (num as f32).sqrt() as u32;
(1..=s).filter(|x| num % x == 0).collect::<Vec<u32>>()
}
```

1539870_KBNiIXymh4SnmDEDZmUTg7tu1MTBVlLj

0 条评论

• ### Excel，大多数人只会使用1%的功能

最近，孩子在万门大学上学习了Excel，拿了几道题考考我。我自认为Excel功底还不错，从Office 2000一直用到现在的Office 365，窗口冻结、区...

• ### 用欧拉计划学Rust编程(第67题)

如果知道一个节点的左、右节点的最大路径，可以很容易地计算出当前节点的最大路径，从底层开始，逐层计算每个节点到底部节点的最大路径上一层的最大路径，所以从每一层中最...

• ### 通过欧拉计划学习Rust编程(第17~21题)

最近想学习Libra数字货币的MOVE语言，发现它是用Rust编写的，所以先补一下Rust的基础知识。学习了一段时间，发现Rust的学习曲线非常陡峭，不过仍有快...

• ### 非插件实现WordPress分页导航

本文参考资源：1.http://down.chinaz.com/try/201209/2188_1.htm 2.http://xiedandan.com/wo...

• ### 从高通骁龙855，看当前主流手机芯片之变迁

苹果iPhone XS系列手机自发布以来，“信号差”一直是备受诟病的问题。原因在于，苹果与高通“分手”了。而新一代的iPhone XS系列全部采用的是英特尔的信...

• ### 探索监督式机器学习算法

这周送来一篇python实现的机器学习的相关文章。一起学习吧。能力有限，一切以英文原文为准。里面部分公式改好好久，总是有一些变不过来，这些暂时看英文里面的吧。

• ### cool-certificate, 一个好玩的证书生成工具

前几天同学发过来一张无人机驾驶证的照片，瞬间觉得很高大上，仔细一询问，原来是用软件生成的图片，网址是：http://wx.znl.cn/app/index.ph...

• ### [译] JS 中 service workers 的简介

Service workers是Progressive Web Apps的核心部分，允许缓存资源和Web推送通知等，以创建良好的离线体验。它们充当Web应用程序...

• ### 腾讯优图开发出新算法，能精准识别戴着口罩的人脸

近日，腾讯优图自研了一套口罩佩戴识别专用AI算法，即便戴着口罩也能精确进行人脸识别，准确率高达99.5%。除此之外，腾讯优图官方介绍还称，这套AI算法还能识别出...

• ### 恶意软件Darkleech大肆感染Apache服务器

假设每台服务器十个站点的话，至少有20000个网站被感染，其中包括知名网站如《洛杉矶时报》。 Darkleech主要使用了Apache的模块注入iframe到受...