Rust 练习（三）

calendar 2024-12-04 · 9 分钟阅读 · Rust  ·
复制链接: copy
  1. 已知高斯随机数的公式为：$w=sin(2\pi v)(-21lnu)^{\frac{1}{2}}$,从键盘输入一个（0,1）范围内的u，再输入一个（0,1）范围内的v。计算并输出w的值。

example:

input:

0.2

0.3

output:

5.529082710300016

 1use std::f64::consts::PI;
 2use std::io::stdin;
 3
 4fn main() {
 5    let mut input = String::new();
 6    stdin().read_line(&mut input).expect("Failed to read line");
 7    let u: f64 = input.trim().parse().expect("Failed to parse input");
 8    input.clear();
 9    stdin().read_line(&mut input).expect("Failed to read line");
10    let v: f64 = input.trim().parse().expect("Failed to parse input");
11
12    let w = (2.0 * PI * v).sin() * (-21.0 * u.ln()).powf(0.5);
13    println!("{:2}", w);
14}
  1. 从键盘依次读入两个整数字符，判断一下，他们是否互素。如果互素打印True，不互素打印False。

example:

input：

9

6

output:

False

 1use std::io::stdin;
 2
 3fn gcd(a: i32, b: i32) -> i32 {
 4    if b == 0 {
 5        return a;
 6    }
 7    return gcd(b, a % b);
 8}
 9
10fn main() {
11    let mut input = String::new();
12    stdin().read_line(&mut input).expect("Failed to read line");
13    let a = input.trim().parse::<i32>().unwrap();
14    input.clear();
15    stdin().read_line(&mut input).expect("Failed to read line");
16    let b = input.trim().parse::<i32>().unwrap();
17
18    if gcd(a, b) == 1 {
19        println!("True");
20    } else {
21        println!("False");
22    }
23}
  1. 从键盘接收一个整型数据n，并输出一个n*n的图形，其中第i行和第j列如果满足，i可以整除j，或j可以整除i时，输出一个“*”，否则输出一个“ ”（一个空格）。输入输出如图所示：
1example:
2
3input:
43
5output:
6***
7** 
8* *

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut input = String::new();
 5    stdin().read_line(&mut input).expect("Failed to read line");
 6    let num = input.trim().parse::<i32>().expect("Failed to parse input");
 7
 8    for i in 1..=num {
 9        let mut row = String::new();
10        for j in 1..=num {
11            if i % j == 0 || j % i == 0 {
12                row.push('*');
13            } else {
14                row.push(' ');
15            }
16        }
17        println!("{row}");
18        row.clear();
19    }
20}
  1. 从键盘输入一个n，代表一维数组包含的元素个数。从键盘输入两行由空格分隔的数字字符，代表两个不同的一维数组。如果长度不足n位，用0补足。长度超过n位，只保留n个元素在一维数组中。计算两个向量的欧几里德距离。（即两个向量对应元素差的平方根）

example:

input:

5

1 2 4 3

2 5 6 9 10 11

output:

12.24744871391589

 1use std::io::stdin;
 2
 3fn input_vec(num: i32) -> Vec<i32> {
 4    let mut input = String::new();
 5    stdin().read_line(&mut input).expect("Failed to read line");
 6    let mut vec: Vec<i32> = input
 7        .trim()
 8        .split_whitespace()
 9        .map(|x| x.parse::<i32>().expect("Failed to parse input"))
10        .collect::<Vec<i32>>();
11    vec.resize(num as usize, 0);
12    return vec;
13}
14
15fn main() {
16    let mut input = String::new();
17    stdin().read_line(&mut input).expect("Failed to read line");
18    let num = input.trim().parse::<i32>().expect("Failed to parse input");
19
20    let vec_a = input_vec(num);
21    let vec_b = input_vec(num);
22
23    let result: f64 = vec_a
24        .iter()
25        .zip(vec_b.iter())
26        .map(|(&x, &y)| (x - y).pow(2) as f64)
27        .sum::<f64>()
28        .sqrt();
29    println!("{}", result);
30}
  1. 从键盘接收一个数字，为当前作业执行需要的秒数，将该秒数整理成天小时分秒的形式。

example:

input：

1000

output:

Time is:0days,0hours,16minutes and 40 seconds.

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut input = String::new();
 5    stdin().read_line(&mut input).expect("Failed to read line");
 6    let num = input.trim().parse::<i32>().expect("Failed to parse input");
 7
 8    let days = num / 86400;
 9    let hours = (num % 86400) / 3600;
10    let minutes = (num % 3600) / 60;
11    let seconds = num % 60;
12
13    println!(
14        "{} days, {} hours, {} minutes, {} seconds",
15        days, hours, minutes, seconds
16    );
17}
  1. 从键盘输入两个空格隔开的四位数，找到所有满足特殊条件的四位数字。例如1234是一个特殊的四位数，它各个位数之和为10，编程求出所有给定范围里所有特殊的四位数。输出的数字顺序从小到大。输出格式如图所示。每输出5个数字换行一次。

example:

input:

1000 1500

output:

1009 1018 1027 1036 1045

1054 1063 1072 1081 1090

1108 1117 1126 1135 1144

1153 1162 1171 1180 1207

1216 1225 1234 1243 1252

1261 1270 1306 1315 1324

1333 1342 1351 1360 1405

1414 1423 1432 1441 1450

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut input = String::new();
 5    stdin().read_line(&mut input).expect("Failed to read line");
 6    let nums: Vec<i32> = input
 7        .trim()
 8        .split_whitespace()
 9        .map(|s| s.parse().unwrap())
10        .collect();
11
12    let a = nums[0];
13    let b = nums[1];
14
15    let mut row: Vec<i32> = Vec::new();
16
17    for i in a..=b {
18        if i.to_string()
19            .chars()
20            .map(|c| c.to_digit(10).unwrap() as i32)
21            .sum::<i32>()
22            == 10
23        {
24            if row.len() == 5 {
25                println!(
26                    "{}",
27                    row.iter()
28                        .map(|&x| x.to_string())
29                        .collect::<Vec<String>>()
30                        .join(" ")
31                );
32                row.clear();
33            }
34            row.push(i);
35        }
36    }
37    println!(
38        "{}",
39        row.iter()
40            .map(|&x| x.to_string())
41            .collect::<Vec<String>>()
42            .join(" ")
43    );
44}
  1. 请编写一个程序，实现如下功能：读取一个整数序列，删除序列中连续重复数，输出结果序列。

example：

input：

1 2 2 1 5 1 1 7 7 7 7 1 1 1 1 1 1

output：

1 2 1 5 1 7 1

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut input = String::new();
 5    stdin().read_line(&mut input).expect("Failed to read line");
 6    let nums: Vec<i32> = input
 7        .trim()
 8        .split_whitespace()
 9        .map(|s| s.parse().unwrap())
10        .collect();
11    let mut result: Vec<String> = vec![nums[0].to_string()];
12
13    for i in 1..nums.len() {
14        if nums[i].to_string() != result.last().unwrap().to_string() {
15            result.push(nums[i].to_string());
16        }
17    }
18
19    println!("{}", result.join(" "));
20}
  1. 请编写程序，实现以下功能，从键盘输入一个n，创建一个n行n列的布尔型方阵。满足以下条件：如果i和j互素（即两者没有共同因子），则a[i][j]为1，否则为0。打印输出该布尔型矩阵。[注意]：0与任何数均不互素。

example:

input:

3

output:

0 0 0

0 1 1

0 1 0

 1use std::io::stdin;
 2
 3fn gcd(a: i32, b: i32) -> i32 {
 4    if b == 0 {
 5        return a;
 6    } else {
 7        return gcd(b, a % b);
 8    }
 9}
10
11fn main() {
12    let mut input = String::new();
13    stdin().read_line(&mut input).expect("Failed to read line");
14    let n: i32 = input.trim().parse().expect("Failed to parse input");
15    let mut row: Vec<String> = Vec::new();
16
17    for i in 0..n {
18        row.clear();
19        for j in 0..n {
20            if i == 0 && j == 1 || i == 1 && j == 0 {
21                row.push("0".to_string());
22            } else if gcd(i, j) == 1 {
23                row.push("1".to_string());
24            } else {
25                row.push("0".to_string());
26            }
27        }
28        println!("{}", row.join(" "));
29    }
30}
  1. 从键盘输入一个n，代表布尔矩阵的行数。依次读入两个n行空格隔开的数字字符串，将两个nn的矩阵转换成布尔矩阵[注意]:一定要先转换成布尔矩阵。即将非0的数字变为1,数字为0保持不变。从键盘读入一个符号“+”或“”，进行矩阵加法和矩阵乘法运算，[注意]:这里的“+”或“*”代表布尔运算的逻辑加和逻辑乘，逻辑加的运算规则为：1+1 = 1 , 1+ 0 = 1 , 0 + 1 = 1, 0 + 0 = 0，逻辑乘的运算规则为 1 * 1 = 1, 1 * 0 = 0,0 * 1 = 0, 0 * 0 = 0。输出结果同样为一个布尔型矩阵。（假设每一行录入的空格隔开的数字字符均为n个）

example:

input：

2

1 0

1 1

0 0

1 0

+

output:

1 0

1 1

input:

2

1 0

1 1

0 0

1 0

*

output:

0 0

1 0

 1use std::io::stdin;
 2
 3fn mat_add(mat_a: Vec<Vec<bool>>, mat_b: Vec<Vec<bool>>, num: usize) -> Vec<Vec<bool>> {
 4    let mut result = vec![vec![false; num]; num];
 5    for i in 0..mat_a.len() {
 6        for j in 0..mat_a[0].len() {
 7            result[i][j] = mat_a[i][j] || mat_b[i][j];
 8        }
 9    }
10    result
11}
12
13fn mat_mul(mat_a: Vec<Vec<bool>>, mat_b: Vec<Vec<bool>>, num: usize) -> Vec<Vec<bool>> {
14    let mut result = vec![vec![false; num]; num];
15    for i in 0..mat_a.len() {
16        for j in 0..mat_b[0].len() {
17            for k in 0..mat_b.len() {
18                result[i][j] = result[i][j] || (mat_a[i][k] && mat_b[k][j]);
19            }
20        }
21    }
22    result
23}
24
25fn input_mat(num: usize) -> Vec<Vec<bool>> {
26    let mut input = String::new();
27    let mut mat: Vec<Vec<bool>> = Vec::new();
28    for _ in 0..num {
29        stdin().read_line(&mut input).unwrap();
30        let row: Vec<bool> = input.trim().split_whitespace().map(|b| b != "0").collect();
31        input.clear();
32    }
33    mat
34}
35
36fn output_mat(mat: Vec<Vec<bool>>) {
37    for row in mat {
38        let row_str = row
39            .iter()
40            .map(|b| if *b { "1".to_string() } else { "0".to_string() })
41            .collect::<Vec<String>>()
42            .join(" ");
43        println!("{}", row_str);
44    }
45}
46
47fn main() {
48    let mut input = String::new();
49    stdin().read_line(&mut input).unwrap();
50    let num: usize = input.trim().parse().unwrap();
51    input.clear();
52
53    let mat_a = input_mat(num);
54    let mat_b = input_mat(num);
55
56    stdin().read_line(&mut input).unwrap();
57    let op: char = input.trim().chars().next().unwrap();
58
59    match op {
60        '+' => {
61            output_mat(mat_add(mat_a, mat_b, num));
62        }
63        '*' => {
64            output_mat(mat_mul(mat_a, mat_b, num));
65        }
66        _ => {
67            return;
68        }
69    }
70}
  1. 用递归的方式生成n位的格雷码。所谓格雷码的规则为：对于n+1位的编码，先对n位编码按照顺序前面依次加0，生成0开头的n+1位编码，再对n位编码逆序，前面加1，生成1开头的n+1位编码。例如：一位编码为0和1，则二位编码，首先在0和1前面加0，生成00,01两个编码，然后对0和1进行逆序，得到1和0，前面加1，得到新的两位编码为11,10。从而生成所有的二位编码。

从键盘输出一个n，生成n位所有编码，并将编码存储在一个一维数组中输出。

example：

input:

1

output:

['0', '1']

input:

2

output:

['00', '01', '11', '10']

 1use std::io::stdin;
 2
 3fn gray(n: usize) -> Vec<String> {
 4    if n == 0 {
 5        return vec![String::new()];
 6    }
 7
 8    let prev_gray_codes = gray(n - 1);
 9    let mut gray_codes: Vec<String> = Vec::new();
10
11    for code in prev_gray_codes.iter() {
12        gray_codes.push(format!("0{}", code));
13    }
14
15    for code in prev_gray_codes.iter().rev() {
16        gray_codes.push(format!("1{}", code));
17    }
18
19    gray_codes
20}
21
22fn main() {
23    let mut input = String::new();
24    stdin().read_line(&mut input).unwrap();
25    let n: usize = input.trim().parse().unwrap();
26    let gray_codes = gray(n);
27    println!("{:?}", gray_codes);
28}
  1. 《九章算术》是我国古代数学名著，卷七中有题：今有人合伙买羊，每人出5钱，会差45钱，每人出7钱会差3钱，问，合伙人数和钱数各是多少？

input：

None

output:

people:XX

money:XX

 1fn main() {
 2    let mut people: i32 = 0;
 3
 4    loop {
 5        people += 1;
 6        if people * 5 + 45 == people * 7 + 3 {
 7            println!("people: {people}");
 8            println!("money: {}", people * 7 + 3);
 9            break;
10        }
11    }
12}
  1. 问题描述

　　给定两个仅由大写字母或小写字母组成的字符串(长度介于1到10之间)，它们之间的关系是以下4中情况之一： 　　1：两个字符串长度不等。比如 Beijing 和 Hebei 　　2：两个字符串不仅长度相等，而且相应位置上的字符完全一致(区分大小写)，比如 Beijing 和 Beijing 　　3：两个字符串长度相等，相应位置上的字符仅在不区分大小写的前提下才能达到完全一致（也就是说，它并不满足情况2）。比如 beijing 和 BEIjing 　　4：两个字符串长度相等，但是即使是不区分大小写也不能使这两个字符串一致。比如 Beijing 和 Nanjing 　　编程判断输入的两个字符串之间的关系属于这四类中的哪一类，给出所属的类的编号。

输入格式

　　包括两行，每行都是一个字符串

输出格式

　　仅有一个数字，表明这两个字符串的关系编号

样例输入

BEIjing

beiJing

样例输出

3

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut input = String::new();
 5    stdin().read_line(&mut input).expect("Failed to read line");
 6    let str_a = input.trim().to_string();
 7    input.clear();
 8    stdin().read_line(&mut input).expect("Failed to read line");
 9    let str_b = input.trim().to_string();
10
11    if str_a.len() != str_b.len() {
12        println!("1");
13    } else if str_a == str_b {
14        println!("2");
15    } else if str_a.to_lowercase() == str_b.to_lowercase() {
16        println!("3");
17    } else {
18        println!("4");
19    }
20}
  1. 连续字符，输入一个字符串，求出此字符串中最长连续字符的长度。

例：

input:

abbcccddddeeeeedcba

output:

5

input:

hooraaaaaaaaaaay

ouput:

11

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut input = String::new();
 5    stdin().read_line(&mut input).expect("Failed to read line");
 6    let s = input.trim().to_string();
 7
 8    let mut count = 0;
 9    let mut maxi = i32::MIN;
10
11    for i in 1..s.len() {
12        if s.chars().nth(i) == s.chars().nth(i - 1) {
13            count += 1;
14        } else if count > maxi {
15            maxi = count;
16            count = 1;
17        }
18    }
19    println!("{maxi}");
20}
  1. 给你一个整数 n(n>=2) ，请你判断 n 是否为 丑数 。如果是，返回 True ；否则，返回False 。

丑数 就是只包含质因数 2、3 和或 5 的正整数。

input:

6

output:

True

input:

14

output:

False

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut input = String::new();
 5    stdin().read_line(&mut input).expect("Failed to read line");
 6    let mut num = input.trim().parse::<i32>().expect("Failed to parse input");
 7
 8    while num % 2 == 0 {
 9        num /= 2;
10    }
11    while num % 3 == 0 {
12        num /= 3;
13    }
14    while num % 5 == 0 {
15        num /= 5;
16    }
17
18    println!("{}", num == 1);
19}
  1. Collatz猜想是一个未经证明的数学猜想，它说以下算法总是停止:

给定一个整数输入:

如果数字是1，停止。

如果数字是偶数，就除以2。使用这个新值作为输入并重新启动。

如果数字是奇数，就乘以3再加1。使用这个新值作为输入并重新启动。

从键盘输入一个n，使用递归完成这个collatz程序。

example:

input:

12

output:

12

6

3

10

5

16

8

4

2

1

input:

11

output:

11

34

17

52

26

13

40

20

10

5

16

8

4

2

1

 1use std::io::stdin;
 2
 3fn collatz(n: i32) {
 4    println!("{n}");
 5    if n == 1 {
 6        return;
 7    } else if n % 2 == 0 {
 8        collatz(n / 2);
 9    } else {
10        collatz(3 * n + 1);
11    }
12}
13
14fn main() {
15    let mut n = String::new();
16    stdin().read_line(&mut n).expect("Failed to read line");
17    let n: i32 = n.trim().parse().expect("Invalid input");
18    collatz(n);
19}

相关系列文章