Rust 练习（一）

2024-11-28 · 14 分钟阅读 · Rust ·

复制链接:

从键盘接收一个整数，判断一下该整数是奇数还是偶数，如果是奇数，输出“odd"，如果是偶数，输出“even”

example:

input:

output:

even

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut num: String = String::new();
 5    stdin().read_line(&mut num).expect("Failed to read line");
 6    let num: i32 = num.trim().parse().expect("Failed to parse number");
 7    if num % 2 == 0 {
 8        println!("even");
 9    } else {
10        println!("odd");
11    }
12}

从键盘输入一个代表年份的四位数，判断一下当前输入的年份是不是闰年，是闰年返回“is leap year”，不是闰年返回“is not leap year”

example:

input:

2024

output:

is leap year

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut year: String = String::new();
 5    stdin().read_line(&mut year).expect("Failed to read line");
 6    let year: i32 = year.trim().parse().expect("Failed to parse year");
 7    if year % 4 == 0 && year % 100 != 0 || year % 400 == 0 {
 8        println!("is leap year");
 9    } else {
10        println!("is not leap year");
11    }
12}

已知斐波那契数列的值依次为：1，1，2，5，8，13，21，34……

有斐波那契数列的公式为：

$$ F(n) = \frac{{\left( \frac{{1 + \sqrt{5}}}{2} \right)^n - \left( \frac{{1 - \sqrt{5}}}{2} \right)^n}}{{\sqrt{5}}} $$

试编写程序，输入一个n，可以得到斐波那契数列第n项的值。

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut n: String = String::new();
 5    stdin().read_line(&mut n).expect("Failed to read line");
 6    let n: f64 = n.trim().parse().expect("Invalid input");
 7    let result = fibonacci(n);
 8    println!("{}", result);
 9}
10
11fn fibonacci(n: f64) -> i32 {
12    let sqrt5 = 5.0f64.sqrt();
13    let phi = (1.0 + sqrt5) / 2.0;
14    let a = phi.powf(n);
15    let b = (1.0 - phi).powf(n);
16    let result = (a - b) / sqrt5;
17    result.round() as i32
18}

输入一个四位数，将四位数的每一位相加后输入结果。例如：

input:3478

output:22

input:1234

output:10

注：即 3 + 4 + 7+ 8 = 22；1+2+3+4=10

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut num: String = String::new();
 5    stdin().read_line(&mut num).expect("Failed to read line");
 6    let result: i32 = num
 7        .chars()
 8        .filter_map(|c| c.to_digit(10))
 9        .map(|d| d as i32)
10        .sum();
11    println!("{}", result);
12}

输入3个不相等的数字，并将三个数字整理成从大到小的顺序输出。

input:

output:

7 6 2

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut nums: Vec<i32> = Vec::new();
 5    for _ in 0..3 {
 6        let mut input = String::new();
 7        stdin().read_line(&mut input).expect("Failed to read line");
 8        let year: i32 = input.trim().parse().expect("Invalid input");
 9        nums.push(year);
10    }
11    nums.sort();
12    nums.reverse();
13    println!("{} {} {}", nums[0], nums[1], nums[2]);
14}

从键盘按照字母，数字，字母，数字的顺序输入4个数据，将字母和字母连接生成新的字符串，数字和数字做加法得到一个新数字，将字符串和数字组合成新的字符输出。例如：

input:

output:

ab12

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut nums: Vec<i32> = Vec::new();
 5    for i in 0..4 {
 6        let mut input = String::new();
 7        stdin().read_line(&mut input).expect("Failed to read line");
 8        if i % 2 == 0 {
 9            let input: char = input.trim().parse().expect("Failed to parse input");
10            nums.push(input as i32);
11        } else {
12            let input: i32 = input.trim().parse().expect("Failed to parse input");
13            nums.push(input);
14        }
15    }
16    println!(
17        "{}{}{}",
18        nums[0] as u8 as char,
19        nums[2] as u8 as char,
20        nums[1] + nums[3]
21    );
22}

求一个四位数的digital root。Digital root是一个1位整数，它的计算方法如下：

The beginning number is 3498

The sum of its digits is 3+4+9+8=24

The number is now 24

The sum of its digits is 2+4=6

Digital root即为6

比如输入为：

3498

则输出为：

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut num = String::new();
 5    stdin().read_line(&mut num).expect("Failed to read line");
 6    let num: i32 = num.trim().parse().expect("Failed to parse number");
 7    let mut result = num;
 8    while result > 9 {
 9        result = digital_root(result);
10    }
11    println!("{}", result);
12}
13
14fn digital_root(num: i32) -> i32 {
15    num.to_string()
16        .chars()
17        .filter_map(|c| c.to_digit(10))
18        .map(|d| d as i32)
19        .sum()
20}

李姓家族有一笔￥100000的遗产分配。已知家族遗产管理者需要留存遗产的1.5%。遗产继承人由三部分组成：1.旁支亲属。每人可以继承剩余遗产份额的为1。2.子女。每人可继承剩余遗产的份额为100。3.配偶，可以继承剩余遗产份额为200.配偶为1人。

从键盘依次属于亲属的人数；子女数。

遗产份额根据能继承遗产的总数来计算。如：有一位亲属，一位子女，一位配偶，则遗产划分的份额为1+100+200=301，即可继承的遗产划分为301份。亲属1份，子女100份，配偶200份。

依次输出遗产管理者获得钱数；每名旁支亲属可以获取的钱数；每名子女可以获得的钱数；配偶可以获得的钱数。（钱数只能为整数，并且不允许四舍五入；配偶的钱为其他人取完之后剩余的所有钱数）

example:

input:

output:

1500 244 24400 48968

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut rel_num: String = String::new();
 5    let mut kid_num: String = String::new();
 6
 7    stdin().read_line(&mut rel_num).expect("Failed to read line");
 8    stdin().read_line(&mut kid_num).expect("Failed to read line");
 9
10    let rel_num: i32 = rel_num.trim().parse().expect("Invalid input");
11    let kid_num: i32 = kid_num.trim().parse().expect("Invalid input");
12
13    let mng: i32 = 15800;
14    let rest: i32 = 100000 - 1500;
15    let weight: i32 = rel_num * 1 + kid_num * 100 + 200;
16    let peow: f64 = (rest as f64) / (weight as f64);
17
18    let rel: i32 = peow.floor() as i32;
19    let kid: i32 = rel * 100;
20    let spo = rest - rel - kid;
21
22    println!("{mng} {rel} {kid} {spo}");
23}

鸡尾酒瓶由三个圆锥体部分组成。高度为 h，顶部和底部的半径为 r1 和 r2 的圆锥体的容积为 V 鸡尾酒瓶及容积计算公式如下所示。

$$ V = \pi\frac{(r_1^2 + r_1r_2 + r_2^2)h}{3} $$

试编写程序，输入鸡尾酒瓶的高度h和顶部底部的半径，计算鸡尾酒瓶的容积。

example:

input:

output:

293.21531433504737

 1use std::f64::consts::PI;
 2use std::io::stdin;
 3
 4fn main() {
 5    let mut h: String = String::new();
 6    let mut r1: String = String::new();
 7    let mut r2: String = String::new();
 8
 9    stdin().read_line(&mut h).unwrap();
10    stdin().read_line(&mut r1).unwrap();
11    stdin().read_line(&mut r2).unwrap();
12
13    let h: f64 = h.trim().parse().unwrap();
14    let r1: f64 = r1.trim().parse().unwrap();
15    let r2: f64 = r2.trim().parse().unwrap();
16
17    let v: f64 = (PI / 3.0) * (r1.powf(2.0) + r1 * r2 + r2.powf(2.0)) * h;
18
19    println!("{}", v);
20}

编写一个程序，以军用格式如（0900、1730）读取两个时间，并打印两个时间之间相差的小时和分钟数。

example:

input:

0900

1730

output:

8 hours 30 minutes

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut start_time = String::new();
 5    let mut end_time = String::new();
 6
 7    stdin().read_line(&mut start_time).unwrap();
 8    stdin().read_line(&mut end_time).unwrap();
 9
10    let start_minute: i32 = start_time.trim()[..2].parse::<i32>().unwrap() * 60
11        + start_time.trim()[2..].parse::<i32>().unwrap();
12    let end_minute: i32 = end_time.trim()[..2].parse::<i32>().unwrap() * 60
13        + end_time.trim()[2..].parse::<i32>().unwrap();
14
15    let duration_minute = end_minute - start_minute;
16
17    let result_minute = duration_minute % 60;
18    let result_hour = (duration_minute - result_minute) / 60;
19
20    println!("{result_hour} hours {result_minute} minutes");
21}

从键盘输入一个数字n，计算小于n的所有奇数的和。

input:

100

output:

2500

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut num = String::new();
 5    stdin().read_line(&mut num).unwrap();
 6    let num: i32 = num.trim().parse().unwrap();
 7    let mut result = 0;
 8    for i in 1..num {
 9        if i % 2 != 0 {
10            result += i;
11        }
12    }
13    println!("{result}");
14}

已知有公式 $S=\frac{1}{1^2}+\frac{1}{2^2}+\cdots+\frac{1}{n^2}+\cdots$，编写程序计算 S，要求加的最后一项值大于 $10^{-10}$，输出 S 的值。

1fn main() {
2    let mut sum: f64 = 0.0;
3    let mut n: f64 = 1.0;
4    while 1.0 / n.powf(2.0) > 1e-10 {
5        sum += 1.0 / n.powf(2.0);
6        n += 1.0;
7    }
8    println!("{sum}");
9}

输入一个数字，判断一下该数字是不是水仙花数（三位数）。

水仙花数：例如 $153=1^3+5^3+3^3$，即水仙花数。

input:

153

output:

Yes

input:

256

output:

input:

1234

output:

Out scope

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut num = String::new();
 5    stdin().read_line(&mut num).unwrap();
 6    if num.trim().len() != 3 {
 7        println!("Out of Scope");
 8        return;
 9    }
10    let a = num.trim()[0..1].parse::<i32>().unwrap();
11    let b = num.trim()[1..2].parse::<i32>().unwrap();
12    let c = num.trim()[2..3].parse::<i32>().unwrap();
13    let num = num.trim().parse::<i32>().unwrap();
14    if num == a.pow(3) + b.pow(3) + c.pow(3) {
15        println!("Yes");
16    } else {
17        println!("No");
18    }
19}

输入任意两个整数，输出他们的最大公约数和最小公倍数。

input:

output:

3 18

 1use std::io::stdin;
 2
 3fn gcd(a: i32, b: i32) -> i32 {
 4    if b == 0 {
 5        a
 6    } else {
 7        gcd(b, a % b)
 8    }
 9}
10
11fn lcm(a: i32, b: i32) -> i32 {
12    a * b / gcd(a, b)
13}
14
15fn main() {
16    let mut a = String::new();
17    let mut b = String::new();
18    stdin().read_line(&mut a).unwrap();
19    stdin().read_line(&mut b).unwrap();
20    let a: i32 = a.trim().parse().unwrap();
21    let b: i32 = b.trim().parse().unwrap();
22
23    let gcd = gcd(a, b);
24    let lcm = lcm(a, b);
25
26    println!("{gcd} {lcm}");
27}

从键盘接收两个数据，一个代表鸡和兔子的头数，一个代表，鸡和兔子的腿数。编写一个程序，计算有多少只鸡，多少只兔子。如果无解，则输出：No solution.

input:

output:

rabbit: 12 chicken: 23

input:

output:

only have chicken: 20

input:

output:

only have rabbit: 15

input:

100

output:

No solution

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut head = String::new();
 5    let mut leg = String::new();
 6
 7    stdin().read_line(&mut head).unwrap();
 8    stdin().read_line(&mut leg).unwrap();
 9
10    let head: i32 = head.trim().parse().unwrap();
11    let leg: i32 = leg.trim().parse().unwrap();
12
13    if leg == 4 * head {
14        println!("Only {head} rabbits.");
15        return;
16    } else if leg == 2 * head {
17        println!("Only {head} chickens.");
18        return;
19    } else if leg < 2 * head || leg > 4 * head || leg % 2 != 0 {
20        println!("No solution.");
21        return;
22    } else {
23        let tmp = leg - head * 2;
24        let rabbit = tmp / 2;
25        let chicken = head - rabbit;
26        println!("Rabbit: {}, Chicken: {}", rabbit, chicken);
27    }
28
29}

从键盘输入一个n的值，输出斐波那契数列的前n项。已知菲波那切数列的第一项和第二项都为1，其余项为： $f(n)=f(n-1)+f(n-2)$。

input:

output:

1 1 2 3 5

input:

output:

1 1

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut n = String::new();
 5    stdin().read_line(&mut n).unwrap();
 6    let n: usize = n.trim().parse().unwrap();
 7
 8    let mut fib = vec![1, 1];
 9    for i in 2..n {
10        fib.push(fib[i - 1] + fib[i - 2]);
11    }
12
13    let result = fib
14        .iter()
15        .map(|n| n.to_string())
16        .collect::<Vec<String>>()
17        .join(" ");
18    println!("{}", result);
19}

“今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二”问物几何。出自——孙子算经。

（有一个数，不知道是多少，但是它除3余数是2，除5余数是3，除7余数是2，问这个数是多少？）

请输出满足条件的最小正整数：

 1fn main() {
 2    let mut num = 0;
 3    loop {
 4        if num % 3 == 2 && num % 5 == 3 && num % 7 == 2 {
 5            println!("{num}");
 6            break;
 7        } else {
 8            num += 1;
 9        }
10    }
11}

奇数偶数贩售机。创建一个程序，判断输入数据是奇数还是偶数，并输出该数字后连续的9个奇数或偶数，例如：输入2，返回"Even"并输出2 4 6 8 10 12 14 16 18

输入1，返回"Odd"并输出1 3 5 7 9 11 13 15 17

input:

output:

Even

2 4 6 8 10 12 14 16 18

input:

output:

Odd

3 5 7 9 11 13 15 17 19

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut num = String::new();
 5    stdin().read_line(&mut num).unwrap();
 6    let num: i32 = num.trim().parse().unwrap();
 7
 8    if num % 2 == 0 {
 9        println!("Even");
10    } else {
11        println!("Odd");
12    }
13    let mut result: Vec<i32> = vec![];
14    for i in 0..9 {
15        result.push(num + i * 2);
16    }
17    println!(
18        "{}",
19        result
20            .iter()
21            .map(|n| n.to_string())
22            .collect::<Vec<String>>()
23            .join(" ")
24    );
25}

从键盘接收一个十进制整数，将十进制整数转换成二进制的形式输出。

example:

input:

output:

1011

input:

100

output:

1100100

1use std::io::stdin;
2
3fn main() {
4    let mut num = String::new();
5    stdin().read_line(&mut num).unwrap();
6    let num: i32 = num.trim().parse().unwrap();
7    println!("{}", format!("{:b}", num));
8}

编写一个程序，实现如下功能：从键盘读入一个数据n，输出一个n行n列的列表：对第i行和第j列位置，如果i和j的最大公约数是1（即i和j互素），则输出“*”号，其他位置输出“#”号。每打印n个符号后，换行输出新的符号。

 1example:
 2
 3Input:
 44
 5output:
 6****
 7*#*#
 8**#*
 9*#*#
10
11input:
127
13output:
14*******
15*#*#*#*
16**#**#*
17*#*#*#*
18****#**
19*###*#*
20******#

 1use std::io::stdin;
 2
 3fn gcd(a: i32, b: i32) -> i32 {
 4    if b == 0 {
 5        a
 6    } else {
 7        gcd(b, a % b)
 8    }
 9}
10
11fn main() {
12    let mut num = String::new();
13    stdin().read_line(&mut num).unwrap();
14    let num: i32 = num.trim().parse().unwrap();
15    for i in 0..num {
16        let mut row = String::new();
17        for j in 0..num {
18            if gcd(i + 1, j + 1) == 1 {
19                row.push('*');
20            } else {
21                row.push('#');
22            }
23        }
24        println!("{}", row);
25    }
26}

使用泰勒级数展开是计算正弦函数，展开式的最后一项精度不超过1e-10。其中正弦函数的展开式为：

$$ sinx=x-\frac{x^3}{3!}+\frac{x^5}{5!}-\cdots $$

从键盘输入一个x（x为浮点数），计算x的正弦函数，结果保留小数位数2位（此题不要纠结，数位精度不对也可认为正确）。

example:

input:

0.5

output:

0.48

input:

output:

0.84

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut x = String::new();
 5    stdin().read_line(&mut x).unwrap();
 6    let x: f64 = x.trim().parse().unwrap();
 7
 8    let mut n: f64 = 1.0;
 9    let mut sinx: f64 = 0.0;
10
11    loop {
12        let mut fac_n = 1.0;
13        for i in 1..(n + 1.0) as i32 {
14            fac_n *= i as f64;
15        }
16        if x.powf(n) / fac_n > 1e-10 {
17            if (n - 1.0) % 4.0 == 0.0 {
18                sinx += x.powf(n) / fac_n;
19            } else {
20                sinx -= x.powf(n) / fac_n;
21            }
22        } else {
23            break;
24        }
25        n += 2.0;
26    }
27
28    println!("{:.2}", sinx);
29}

输入一个大于等于2的整数，判断其是素数还是不是素数，是素数输出True，否则输出False。

input:

output:

False

input:

output:

True

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut num = String::new();
 5    stdin().read_line(&mut num).unwrap();
 6    let num = num.trim().parse::<i32>().unwrap();
 7
 8    println!("{}", is_prime(num).to_string());
 9}
10
11fn is_prime(n: i32) -> bool {
12    if n <= 1 {
13        return false;
14    } else if n == 2 {
15        return true;
16    } else {
17        for i in 2..(n as f64).sqrt() as i32 {
18            if n % i == 0 {
19                return false;
20            }
21        }
22        return true;
23    }
24}

从键盘读入一个数n，输出小于或等于n的所有素数的个数。

example

input:

100

output:

input:

200

output:

 1use std::io::stdin;
 2
 3fn is_prime(n: i32) -> bool {
 4    if n <= 1 {
 5        return false;
 6    } else if n == 2 {
 7        return true;
 8    } else {
 9        for i in 2..(n as f64).sqrt() as i32 + 1 {
10            if n % i == 0 {
11                return false;
12            }
13        }
14        return true;
15    }
16}
17
18fn main() {
19    let mut count = 0;
20    let mut num = String::new();
21    stdin().read_line(&mut num).expect("Failed to read line");
22    let num: i32 = num.trim().parse().expect("Failed to parse number");
23
24    for i in 2..num + 1 {
25        if is_prime(i) {
26            count += 1;
27        }
28    }
29
30    println!("{count}");
31}

从键盘输入一个正整数n，输出小于n的所有与其互素的数的个数。（即求（n）的值）。例如：与10互素的数为：9,7,3,1一共4个。

example:

input:

output:

input:

output:

 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 count = 0;
12    let mut num = String::new();
13    stdin().read_line(&mut num).expect("Failed to read line");
14    let num: i32 = num.trim().parse().expect("Failed to parse number");
15
16    for i in 1..num {
17        if gcd(i, num) == 1 {
18            count += 1;
19        }
20    }
21
22    println!("{count}");
23}

从键盘接受一个正整数n，生成一个由1~n的数组。输出一个数组，数组中的每个元素为与前面数组中小于自身的互素的数的个数。

example:

input:

output:

[0, 1, 2, 2, 4, 2, 6, 4, 6, 4]

input:

output:

[0, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16, 6, 18, 8]

 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 judge(n: i32) -> i32 {
11    let mut result = 0;
12    for i in 0..n {
13        if gcd(i, n) == 1 {
14            result += 1;
15        }
16    }
17    return result;
18}
19
20fn main() {
21    let mut num = String::new();
22    stdin().read_line(&mut num).expect("Failed to read line");
23    let n: i32 = num.trim().parse().expect("Failed to parse input");
24
25    let mut result: Vec<i32> = Vec::from([0]);
26    for i in 2..n + 1 {
27        result.push(judge(i));
28    }
29
30    println!("{result:?}");
31}

从键盘输入一个n，打印一个等腰三角形。

 1input:
 24
 3output:
 4   *
 5  ***
 6 *****
 7*******
 8
 9input:
107
11output:
12      *
13     ***
14    *****
15   *******
16  *********
17 ***********
18*************

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut n = String::new();
 5    stdin().read_line(&mut n).expect("Failed to read line");
 6    let n: i32 = n.trim().parse().expect("Failed to parse input");
 7
 8    let asterisk: &str = "*";
 9    let space: &str = " ";
10
11    for i in 1..n + 1 {
12        println!(
13            "{}{}",
14            space.repeat((n - i) as usize),
15            asterisk.repeat((2 * i - 1) as usize)
16        )
17    }
18}

从键盘输入一个n，打印如下图形。

 1input:
 24
 3output:
 4   *
 5  ***
 6 *****
 7*******
 8 *****
 9  ***
10   *
11
12input:
133
14output:
15  *
16 ***
17*****
18 ***
19  *

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut n = String::new();
 5    stdin().read_line(&mut n).expect("Failed to read line");
 6    let n: i32 = n.trim().parse().expect("Failed to parse input");
 7
 8    let asterisk: &str = "*";
 9    let space: &str = " ";
10
11    for i in 1..n + 1 {
12        println!(
13            "{}{}",
14            space.repeat((n - i) as usize),
15            asterisk.repeat((2 * i - 1) as usize)
16        )
17    }
18
19    for i in (1..n).rev() {
20        println!(
21            "{}{}",
22            space.repeat((n - i) as usize),
23            asterisk.repeat((2 * i - 1) as usize)
24        )
25    }
26}

从键盘接收一个n，用来确定数组包含的元素个数。并循环读入n个数字字符，将其转换成int型数据，存储在数组中。编写一个程序，让数组中，相邻的两位进行比较，并将比较大的数字交换到后面的位置，将数组中相邻的两位依次比较，确保经过一轮比较后，数组中最大的数字放在索引为n-1的位置上。输出此时最大值在索引最大位置上的数组。

example:

input:

output:

[3, 6, 4, 2, 7]

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut n = String::new();
 5    stdin().read_line(&mut n).expect("Failed to read line");
 6    let n: i32 = n.trim().parse().expect("Failed to parse input");
 7
 8    let mut nums: Vec<i32> = Vec::new();
 9    for _ in 0..n {
10        let mut k = String::new();
11        stdin().read_line(&mut k).expect("Failed to read line");
12        let k: i32 = k.trim().parse().expect("Failed to parse input");
13        nums.push(k);
14    }
15
16    for i in 0..n - 1 {
17        if nums[i as usize] > nums[(i + 1) as usize] {
18            nums.swap(i as usize, (i + 1) as usize);
19        }
20    }
21
22    println!("{:?}", nums)
23}

从键盘接收一个n，代表当前数组中包含的元素个数。依次从键盘读入n个数据，并转换成int型，保存在数组中。按照上题的方法整理数组中的元素，将数组中元素整理为从小到大有序的数组输出。（注：不允许使用内置的排序函数，或方法）

input:

output:

[2, 3, 4, 6, 7]

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut n = String::new();
 5    stdin().read_line(&mut n).expect("Failed to read line");
 6    let n: i32 = n.trim().parse().expect("Failed to parse input");
 7
 8    let mut nums: Vec<i32> = Vec::new();
 9    for _ in 0..n {
10        let mut k = String::new();
11        stdin().read_line(&mut k).expect("Failed to read line");
12        let k: i32 = k.trim().parse().expect("Failed to parse input");
13        nums.push(k);
14    }
15
16    for i in 0..n - 1 {
17        for j in i + 1..n {
18            if nums[i as usize] > nums[j as usize] {
19                nums.swap(i as usize, j as usize);
20            }
21        }
22    }
23
24    println!("{:?}", nums);
25}

从键盘接收一个m，代表二维数组的行数，再从键盘接收一个n，代表二维数组的列数。利用循环读入二维数组所有的数值，并转换为int类型，存在数组中。输出该二维数组。

example:

input:

output:

[[1, 4, 7], [2, 5, 8]]

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut row = String::new();
 5    let mut col = String::new();
 6
 7    stdin().read_line(&mut row).expect("Failed to read row");
 8    stdin().read_line(&mut col).expect("Failed to read col");
 9
10    let row: i32 = row.trim().parse().expect("Invalid row input");
11    let col: i32 = col.trim().parse().expect("Invalid col input");
12
13    let mut mat: Vec<Vec<i32>> = Vec::new();
14    let mut input = String::new();
15
16    for _i in 0..row {
17        let mut row_vec: Vec<i32> = Vec::new();
18        for _j in 0..col {
19            input.clear();
20            stdin().read_line(&mut input).expect("Failed to read input");
21            let num: i32 = input.trim().parse().expect("Invalid input");
22            row_vec.push(num);
23        }
24        mat.push(row_vec);
25    }
26
27    println!("{:?}", mat);
28}

Rust 练习（一）

相关系列文章