Rust 练习（二）

2024-11-30 · 16 分钟阅读 · Rust ·

复制链接:

从键盘输入一个n，代表一维数组包含的元素数，从键盘读入一个由数字字符和空格组成的字符串，并将它们转换成int型存入到一维数组中。如果得到的数字不足n位，剩余的几个数组元素由0补足，如果超过n位截取前n位组成的数组，并输出该数组。

example:

input:

2 3 1 7 10 15

output:

[2, 3, 1, 7, 10]

input:

10 2

output:

[10, 2, 0, 0]

 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 n: i32 = input.trim().parse().expect("Failed to parse input");
 7
 8    input.clear();
 9    stdin().read_line(&mut input).expect("Failed to read line");
10    let mut nums: Vec<i32> = input
11        .split_whitespace()
12        .map(|s| s.parse().expect("Failed to parse input"))
13        .collect();
14
15    if nums.len() >= n as usize {
16        println!("{:?}", &nums[..n as usize]);
17    } else {
18        nums.extend(vec![0; n as usize - nums.len()]);
19        println!("{:?}", nums);
20    }
21}

从键盘接收一个由数字字符和空格组成的字符串，将其转换为整型数据存储在一维数组中。判断该一维数组中是否存在重复元素，如果有重复元素，输出False，否则输出True。

example:

input:

3 2 1 7 5 6 8 0

output:

True

input:

2 2 1 3 4 3 8 6

output:

False

 1use std::collections::HashSet;
 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 nums: Vec<i32> = input
 8        .split_whitespace()
 9        .map(|s| s.parse().expect("Failed to parse input"))
10        .collect();
11
12    let nums_set: HashSet<i32> = nums.iter().cloned().collect();
13    if nums_set.len() == nums.len() {
14        println!("True");
15    } else {
16        println!("False");
17    }
18}

从键盘输入一个n，创建一个n * n的二维数组，在二维数组中，第0行的值为1，第1行的值为2，以此类推，第n-1的值为n。输出此二维数组。

example:

input:

output:

[[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4], [5, 5, 5, 5, 5]]

 1use std::io::stdin;
 2
 3fn main() {
 4    let mut input = String::new();
 5    stdin().read_line(&mut input).unwrap();
 6    let num: i32 = input.trim().parse().unwrap();
 7
 8    let mut mat: Vec<Vec<i32>> = Vec::new();
 9
10    for i in 0..num {
11        mat.push(vec![i + 1; num as usize]);
12    }
13    println!("{:?}", mat);
14}

输出第三题得到的二维数组的转置数组。

example:

input:

output:

[[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]

input:

output:

[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]

 1use std::io::stdin;
 2
 3fn get_mat(n: i32) -> Vec<Vec<i32>> {
 4
 5    let mut mat: Vec<Vec<i32>> = Vec::new();
 6
 7    for i in 0..n {
 8        mat.push(vec![i + 1; n as usize]);
 9    }
10    mat
11}
12
13fn main() {
14    let mut input = String::new();
15    stdin().read_line(&mut input).unwrap();
16    let num: i32 = input.trim().parse().unwrap();
17
18    let mat = get_mat(num);
19    let mut result: Vec<Vec<i32>> = vec![vec![0; num as usize]; num as usize];
20    for i in 0..num as usize {
21        for j in 0..num as usize {
22            result[j][i] = mat[i][j];
23        }
24    }
25
26    println!("{:?}", result);
27
28}

从键盘输入一个n，代表二维数组的行和列，依次读入n行由空格和数字字符组成的字符串，将字符串中的每个数字字符转换成整形数据，存成二维数组的一行，如果输入的数字字符数目少于n个，以0补足，如果超过n个，截取前n位。

example:

input:

3 2 1 7 6 8

11 2 4 12 5

4 3 1

7 6 5

output:

[[3, 2, 1, 7, 6], [11, 2, 4, 12, 5], [4, 3, 1, 0, 0], [7, 6, 5, 0, 0], [1, 0, 0, 0, 0]]

 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 n: i32 = input.trim().parse().expect("Failed to parse input");
 7    input.clear();
 8
 9    let mut mat: Vec<Vec<i32>> = Vec::new();
10    for _ in 0..n {
11        input.clear();
12        stdin().read_line(&mut input).expect("Failed to read line");
13        let mut row: Vec<i32> = input
14            .trim()
15            .split_whitespace()
16            .map(|x| x.parse().expect("Failed to parse input"))
17            .collect();
18        if row.len() >= n as usize {
19            mat.push(row[..n as usize].to_vec());
20        } else {
21            row.extend(vec![0; n as usize - row.len()]);
22            mat.push(row);
23        }
24    }
25    println!("{:?}", mat);
26}

以第五题方法读入一个n * n的二维数组，输出该二维数组与其转置数组乘积后得到的新数组。

example:

input:

3 2 1 7 6 8

11 2 4 12 5

4 3 1

7 6 5

output:

[[99, 155, 19, 38, 3], [155, 310, 54, 109, 11], [19, 54, 26, 51, 4], [38, 109, 51, 110, 7], [3, 11, 4, 7, 1]]

 1use std::io::stdin;
 2
 3fn get_mat(n: i32) -> Vec<Vec<i32>> {
 4    let mut input = String::new();
 5    let mut mat: Vec<Vec<i32>> = Vec::new();
 6    for _ in 0..n {
 7        input.clear();
 8        stdin().read_line(&mut input).expect("Failed to read line");
 9        let mut row: Vec<i32> = input
10            .trim()
11            .split_whitespace()
12            .map(|x| x.parse().expect("Failed to parse input"))
13            .collect();
14        if row.len() >= n as usize {
15            mat.push(row[..n as usize].to_vec());
16        } else {
17            row.extend(vec![0; n as usize - row.len()]);
18            mat.push(row);
19        }
20    }
21    return mat;
22}
23
24fn get_transpose(mat: &Vec<Vec<i32>>, n: i32) -> Vec<Vec<i32>> {
25    let mut result: Vec<Vec<i32>> = vec![vec![0; n as usize]; n as usize];
26    for i in 0..n as usize {
27        for j in 0..n as usize {
28            result[j][i] = mat[i][j];
29        }
30    }
31    return result;
32}
33
34fn mat_multiply(mat_a: &Vec<Vec<i32>>, mat_b: &Vec<Vec<i32>>, n: i32) -> Vec<Vec<i32>> {
35    let mut result: Vec<Vec<i32>> = vec![vec![0; n as usize]; n as usize];
36    for i in 0..n as usize {
37        for j in 0..n as usize {
38            for k in 0..n as usize {
39                result[i][j] += mat_a[i][k] * mat_b[k][j];
40            }
41        }
42    }
43    return result;
44}
45
46fn main() {
47    let mut input = String::new();
48    stdin().read_line(&mut input).expect("Failed to read line");
49    let n: i32 = input.trim().parse().expect("Failed to parse input");
50
51    let original = get_mat(n);
52    let transposed = get_transpose(&original, n);
53
54    let result: Vec<Vec<i32>> = mat_multiply(&original, &transposed, n);
55
56    println!("{:?}", result);
57}

从键盘读入一个n，代表n位同学，依次读入n组由数字字符和空格组成的字符串，将其存储为一个 3 * n的二维数组。二维数组中每一项为一个浮点型数据，代表一位同学同一门课的三次考试的成绩（test1，test2，test3）。给定一个一维数组，代表每次考试的权值，该一维数组为[0.25, 0.25, 0.5]，计算每个同学的最终得分，并输出统计这n个同学最终成绩的一维数组。（每个同学的成绩保留小数点后两位小数）。

example:

input:

87 75 60

66 98 100

70 65 72

67 77.5 80

output:

[70.5, 91.0, 69.75, 76.12]

 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 n: i32 = input.trim().parse().expect("Failed to parse input");
 7    input.clear();
 8
 9    let mut result: Vec<f64> = Vec::new();
10    for _ in 0..n {
11        stdin().read_line(&mut input).expect("Failed to read line");
12        let scores: Vec<f64> = input
13            .split_whitespace()
14            .map(|s| s.parse().unwrap())
15            .collect();
16        let weighted_sum: f64 = scores
17            .iter()
18            .zip(vec![0.25, 0.25, 0.5].iter())
19            .map(|(&w, &v)| format!("{:.2}", w * v).parse::<f64>().unwrap())
20            .sum();
21        result.push(weighted_sum);
22        input.clear();
23    }
24    println!("{:?}", result);
25}

计算小于n的最大素数。输入n的值小于等于2时，输出None

input:

100

output:

input:

200

output:

199

input:

output:

None

 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 input = String::new();
20    stdin().read_line(&mut input).expect("Failed to read line");
21    let n: i32 = input.trim().parse().expect("Failed to parse input");
22
23    if n <= 2 {
24        println!("None");
25    } else {
26        for i in (3..n).rev() {
27            if is_prime(i) {
28                println!("{i}");
29                break;
30            }
31        }
32    }
33}

从键盘输入一个n,代表打印杨辉三角的行数，且n >=3 ,编写一个程序，打印杨辉三角。

input:

output:

[1]

[1, 1]

[1, 2, 1]

input:

output:

[1]

[1, 1]

[1, 2, 1]

[1, 3, 3, 1]

[1, 4, 6, 4, 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 n: i32 = input.trim().parse().expect("Failed to parse input");
 7
 8    let mut current: Vec<i32> = vec![1];
 9
10    println!("{:?}", current);
11    if n == 1 {
12        return;
13    }
14
15    for i in 2..n + 1 {
16        let previous = current.clone();
17        current = vec![1];
18        for j in 1..(i - 1) as usize {
19            current.push(previous[j - 1] + previous[j]);
20        }
21        current.push(1);
22        println!("{:?}", current);
23    }
24}

编写一个函数能够判断两个字符串的最长前缀码，比如：distance和distinct的最长

前缀码为dist，如果输入的两个字符串没有相同的前缀码则返回None。

input:

distance

distinct

output:

dist

input:

student

teacher

output

None

input:

version

versus

output:

vers

 1use std::cmp::min;
 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 word_a: String = input.trim().to_string();
 8    input.clear();
 9    stdin().read_line(&mut input).expect("Failed to read line");
10    let word_b: String = input.trim().to_string();
11
12    let mut result = String::new();
13    let mut matched = true;
14    let mut i = 0;
15    while matched && i < min(word_a.len(), word_b.len()) {
16        if word_a.chars().nth(i).unwrap() == word_b.chars().nth(i).unwrap() {
17            result.push(word_a.chars().nth(i).unwrap());
18            i += 1;
19        } else {
20            matched = false;
21        }
22    }
23
24    if i == 0 {
25        println!("None");
26    } else {
27        println!("{}", result);
28    }
29}

因式分解，输入一个数，判断其实素数还是合数，如果是合数，将所有的因式分解打印出来，如：12=1*12 12=2*6 12=3*4

如果是素数：

input:

output:

17 is Prime

input:

output:

20=1*20 20=2*10 20=4*5

 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 input = String::new();
20    stdin().read_line(&mut input).expect("Failed to read line");
21    let n = input.trim().parse::<i32>().expect("Invalid input");
22
23    if is_prime(n) {
24        println!("{n} is prime");
25        return;
26    }
27
28    for i in 1..(n as f64).sqrt() as i32 + 1 {
29        let p: f64 = n as f64 / i as f64;
30        if p.fract() == 0.0 {
31            print!("{}={}*{} ", n, i, p as i32);
32        }
33    }
34}

编写函数，接收一个正偶数为参数，输出两个素数，并且这两个素数之和等于原来的正偶数。如果存在多组符合条件的素数，则全部输出。

如果输入的不是正偶数，打印输入错误。

input:

output:

20=3+17

20=7+13

20=13+7

20=17+3

input:

output:

input error!

 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 input = String::new();
20    stdin().read_line(&mut input).expect("Failed to read line");
21    let n = input.trim().parse::<i32>().expect("Invalid input");
22
23    if n % 2 != 0 {
24        println!("Input Error!");
25        return;
26    }
27
28    for i in 3..n - 2 {
29        if is_prime(i) && is_prime(n - i) {
30            println!("{}={}+{}", n, i, n - i);
31        }
32    }
33}

凯撒密码（Caesar Cypher）是一个比较弱的加密形式，它涉及将单词中的每个字母“轮转”固定数量的位置。轮转一个字母意思是在字母表中移动它，如果需要，再从开头开始。所以‘A’轮转3个位置是’D‘，而’Z‘轮转一个位置是’A‘。

要对一个单词进行轮转操作，对其中每一个字母进行轮转即可。例如，“cheer”轮转7位的结果是“jolly”，而“melon”轮转-10位结果是“cubed”。在电影《2001太空漫游》中，舰载机器人叫作HAL，这个单词正是IBM轮转-1位的结果。

编写一个函数rotate_word，接收一个字符串以及一个整数作为参数，并返回一个新字符串，其中的字母按照给定的整数值“轮转”位置。

input:

izieisie

output:

nenjnxnj

 1use std::io::stdin;
 2
 3fn caesar_encrypt(plaintext: &str, key: i32) -> String {
 4    let mut ciphertext = String::new();
 5    for c in plaintext.chars() {
 6        let base = if c.is_ascii_lowercase() { 'a' } else { 'A' };
 7        let encrypted_char =
 8            (((c as u32 - base as u32 + key as u32) % 26) + base as u32) as u8 as char;
 9        ciphertext.push(encrypted_char);
10    }
11    ciphertext
12}
13
14fn main() {
15    let mut input = String::new();
16    stdin().read_line(&mut input).expect("Failed to read line");
17    let plaintext = input.trim();
18
19    let mut input = String::new();
20    stdin().read_line(&mut input).expect("Failed to read line");
21    let key = input.trim().parse::<i32>().expect("Invalid key");
22
23    let ciphertext = caesar_encrypt(plaintext, key);
24    println!("{}", ciphertext);
25}

从键盘输入一个十进制数n，再输入一个需要转换的进制数，输出十进制转换成对应进制的数。如果输入的转换进制不是2或8或16，输出错误提示。

example:

input:

output:

100000

input:

output:

input:

output:

input:

output:

Error!please input correct number(2 or 8 or 16)

 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 number: i32 = input.trim().parse().expect("Failed to parse input");
 7    input.clear();
 8    stdin().read_line(&mut input).expect("Failed to read line");
 9    let numeration: i32 = input.trim().parse().expect("Failed to parse input");
10
11    match numeration {
12        2 => {
13            println!("{}", format!("{:b}", number));
14        }
15        8 => {
16            println!("{}", format!("{:o}", number));
17        }
18        16 => {
19            println!("{}", format!("{:X}", number));
20        }
21        _ => {
22            println!("Error! Please input correct number(2 or 8 or 16).");
23        }
24    }
25}

从键盘接收一个由空格分隔的字符串如:AAF H D，将其存在数组中，第一个是需要转换进制的数值，第二个是当前的进制，第三个是需要转换的进制。输出转换的结果。（B代表二进制， D代表十进制，O代表八进制，H代表十六进制）

example:

input:

23 D H

output:

input:

1011 B O

output:

input:

1011 H D

output:

4113

 1use std::io::stdin;
 2
 3fn to_decimal(number: &str, base: &str) -> i32 {
 4    match base {
 5        "B" => i32::from_str_radix(number, 2).unwrap(),
 6        "O" => i32::from_str_radix(number, 8).unwrap(),
 7        "D" => number.parse::<i32>().unwrap(),
 8        "H" => i32::from_str_radix(number, 16).unwrap(),
 9        _ => -1,
10    }
11}
12
13fn from_decimal(number: i32, base: &str) -> String {
14    match base {
15        "B" => format!("{:b}", number),
16        "O" => format!("{:o}", number),
17        "D" => number.to_string(),
18        "H" => format!("{:x}", number),
19        _ => String::from("Invalid Base"),
20    }
21}
22
23fn main() {
24    let mut input = String::new();
25    stdin().read_line(&mut input).expect("Failed to read line");
26    let vec: Vec<&str> = input.split_whitespace().collect();
27    let decimal = to_decimal(vec[0], vec[1]);
28    let result = from_decimal(decimal, vec[2]);
29    println!("{}", result);
30}

编写一个程序计算c的值，$c=\sqrt{a^2+b^2-2abcosc}$，从键盘输入一个a，一个b,一个r，输出c的值。（保留两位小数）

example:

input:

2.5

3.4

output:

5.04

 1use std::io::stdin;
 2
 3fn input() -> f64 {
 4    let mut input = String::new();
 5    stdin().read_line(&mut input).expect("Failed to read line");
 6    let num: f64 = input.trim().parse().expect("Invalid input");
 7    num
 8}
 9
10fn main() {
11    let a = input();
12    let b = input();
13    let r = input();
14    println!(
15        "{}",
16        format!("{:.2}", (a * a + b * b - 2.0 * a * b * r.cos()).sqrt())
17    );
18}

从键盘输入一组由单词和空格组成的长字符串，统计字符串中不包括元音字母的单词个数。

example:

input:

word by word

output:

 1use std::io::{stdin, BufRead};
 2
 3fn has_vowel(word: &str) -> bool {
 4    let vowels = "aeiouAEIOU";
 5    for c in word.chars() {
 6        if vowels.contains(c) {
 7            return true;
 8        }
 9    }
10    return false;
11}
12
13fn main() {
14    let mut count = 0;
15    for s in stdin()
16        .lock()  // StdinLock<'static>
17        .lines()  // Lines<StdinLock<'static>>
18        .next()  // Option<Result<String, Error>>
19        .unwrap()  // Result<String, Error>
20        .unwrap()  // String
21        .split_whitespace()  // &str
22    {
23        if has_vowel(s) {
24            count += 1;
25        }
26    }
27    println!("{count}");
28}

输入一个由秒组成的字符串例如15678s，转换成小时分秒输出，或输入一个小时组成的字符串3.56h，转换成秒输出。

example:

input:

15678s

output:

Total time is: 4 hour 21 minute 18 second

input:

3.56h

output:

Total second is: 12816

 1use std::io::stdin;
 2
 3fn second2hour(total: i32) -> Vec<i32> {
 4    let second = total % 60;
 5    let minute = (total / 60) % 60;
 6    let hour = total / 3600;
 7    vec![hour, minute, second]
 8}
 9
10fn hour2second(hour: f64) -> i32 {
11    (hour * 3600.0) as i32
12}
13
14fn main() {
15    let mut input = String::new();
16    stdin().read_line(&mut input).expect("Failed to read line");
17    let time = input.trim();
18    if time.chars().last().unwrap() == 's' {
19        let second = time
20            .chars()
21            .take(time.len() - 1)
22            .collect::<String>()
23            .parse::<i32>()
24            .unwrap();
25        let result = second2hour(second);
26        println!(
27            "{} hours {} minutes {} seconds",
28            result[0], result[1], result[2]
29        );
30    } else {
31        let hour = time
32            .chars()
33            .take(time.len() - 1)
34            .collect::<String>()
35            .parse::<f64>()
36            .unwrap();
37        let result = hour2second(hour);
38        println!("{} seconds", result);
39    }
40}

从键盘输入一个n，打印与n相关的图像。具体图形见例子。

 1example:
 2
 3input:
 43
 5output:
 6*
 7**
 8***
 9
10input:
116
12output:
13*
14**
15***
16****
17*****
18******

 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 n = input.trim().parse::<i32>().expect("Invalid input");
 7
 8    let asterisk = "*";
 9    for i in 1..=n as usize {
10        println!("{}", asterisk.repeat(i));
11    }
12}

编写一个程序，从键盘输入一行一维数组，一行符号，一行数字，根据符号，计算一维数组值的改变。输入符号只有四种，分别为“+”“-”“*”“/”，当符号为“/”时，判断一维数组中的每个元素是什么类型，如果每个元素都为int型数据，输出的一维数组中每一项，为整除的结果，即输出的一维数组中每一项的值都为int型，如果一维数组中至少包含一个float型数据，则输出的一维数组中每个元素都为float型数据。

example:

input:

[1,2,3,4]

output:

[4,5,6,7]

input:

[1,2,3,4]

output:

[3,6,9,12]

input:

[1,2,3,4]

output:

[0,1,1,2]

input:

[1.0,2,3,4]

output:

[0.5, 1.0, 1.5, 2.0]

 1use serde_json; // 第三方 serde_json 库
 2use std::io::stdin;
 3
 4fn main() {
 5    let mut input = String::new();
 6    stdin().read_line(&mut input).unwrap();
 7    let vec_str: String = input.trim().to_string();
 8    input.clear();
 9
10    stdin().read_line(&mut input).unwrap();
11    let sign: String = input.trim().to_string();
12    input.clear();
13
14    stdin().read_line(&mut input).unwrap();
15    let num: i32 = input.trim().parse().unwrap();
16    input.clear();
17
18    if vec_str.contains(".") {
19        let vec: Vec<f64> = serde_json::from_str(&vec_str.trim()).unwrap();
20        println!(
21            "{:?}",
22            vec.iter().map(|f| f / num as f64).collect::<Vec<f64>>()
23        );
24    } else {
25        let vec: Vec<i32> = serde_json::from_str(&vec_str.trim()).unwrap();
26        match sign.as_str() {
27            "+" => {
28                println!("{:?}", vec.iter().map(|i| i + num).collect::<Vec<i32>>());
29            }
30            "-" => {
31                println!("{:?}", vec.iter().map(|i| i - num).collect::<Vec<i32>>());
32            }
33            "*" => {
34                println!("{:?}", vec.iter().map(|i| i * num).collect::<Vec<i32>>());
35            }
36            "/" => {
37                println!("{:?}", vec.iter().map(|i| i / num).collect::<Vec<i32>>());
38            }
39            _ => {
40                return;
41            }
42        }
43    }
44}

某公司有n千万元可以用于对a,b,c三个项目的投资。假设每年投资一个项目，投资的规则是：或者对a投资1千万，或者对b投资2千万，或者对c投资2千万，从键盘输入一个n，代表投资的n千万，输出可以得到的总的方案数有多少个。将该问题转换为递归公式，可以写成：$f(n)=f(n-1)+2f(n-2)$,其中f(1)=1,f(2)=3。

example:

input:

output:

input：

output:

683

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

输入两行数据，第一个包含一个整数n，表示数列中整数的个数。第二行包含n个整数a1,a2,a3,……an,表示给定的数列，相邻的整数之间用一个空格分割。输出一个整数，表示给定的数列有多少段。

example:

input:

8 8 8 0 12 12 8 0

output:

注：8 8 8 是第一段，0 是第二段，12 12 是第三段，8 是第四段，最后一个 0 是第五段。

 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.trim().parse::<i32>().unwrap())
10        .collect();
11
12    let mut count = 1;
13    for i in 1..nums.len() {
14        if nums[i] != nums[i - 1] {
15            count += 1;
16        }
17    }
18    println!("{count}");
19}

从键盘输入一个未排序的一维数组，利用选择排序对其进行排序，输出每一次选择排序后得到的一维数组序列。选择排序的执行原理是扫描整个无序序列，将最小元素与无序序列索引0的位置做交换。第二次选择剩余无序序列中最小的元素与索引是1的位置交换，以此类推，直到最后一次选择剩余无序序列中最小的元素与索引是len-1的位置做交换。

 1example:
 2
 3input:
 4[6,2,7,5,4,1,3]
 5output:
 6[1, 2, 7, 5, 4, 6, 3]
 7[1, 2, 7, 5, 4, 6, 3]
 8[1, 2, 3, 5, 4, 6, 7]
 9[1, 2, 3, 4, 5, 6, 7]
10[1, 2, 3, 4, 5, 6, 7]
11[1, 2, 3, 4, 5, 6, 7]
12
13input:
14[22,8,16,5,14,17]
15output:
16[5, 8, 16, 22, 14, 17]
17[5, 8, 16, 22, 14, 17]
18[5, 8, 14, 22, 16, 17]
19[5, 8, 14, 16, 22, 17]
20[5, 8, 14, 16, 17, 22]

 1use serde_json;
 2use std::io::stdin;
 3
 4fn main() {
 5    let mut input = String::new();
 6    stdin().read_line(&mut input).unwrap();
 7    let mut vec: Vec<i32> = serde_json::from_str(&input).unwrap();
 8
 9    for i in 0..vec.len() - 1 {
10        let min = vec[i..].iter().min().unwrap();
11        let min_index = vec[i..].iter().position(|i| i == min).unwrap() + i;
12        vec.swap(i, min_index);
13        println!("{:?}", vec);
14    }
15}

问题描述

　　求出区间[a,b]中所有整数的质因数分解。其中：b > a > 1，且a,b皆为正整数。

输入格式

　　输入两个整数a，b。

输出格式

　　每行输出一个数的分解，形如k=a1a2a3...(a1<=a2<=a3...，k也是从小到大的)(具体可看样例)

 1样例输入
 2
 33 10
 4
 5样例输出
 6
 73=3
 84=2*2
 95=5
106=2*3
117=7
128=2*2*2
139=3*3
1410=2*5

 1use std::io::stdin;
 2
 3fn is_prime(n: i32) -> bool {
 4    if n < 2 {
 5        return false;
 6    } else {
 7        for i in 2..n {
 8            if n % i == 0 {
 9                return false;
10            }
11        }
12        return true;
13    }
14}
15
16fn pfd(num: i32) -> Vec<i32> {
17    let mut n = num;
18    let mut result = Vec::new();
19    while !is_prime(n) && n > 1 {
20        for i in 2..n {
21            if n % i == 0 && is_prime(i) {
22                result.push(i);
23                n /= i;
24                break;
25            }
26        }
27    }
28    result.push(n);
29    return result;
30}
31
32fn main() {
33    let mut input = String::new();
34    stdin().read_line(&mut input).unwrap();
35    let tmp: Vec<i32> = input
36        .split_whitespace()
37        .map(|s| s.parse::<i32>().unwrap())
38        .collect();
39    let a = tmp[0];
40    let b = tmp[1];
41    for i in a..b + 1 {
42        print!("{i}=");
43        let factors: Vec<String> = pfd(i).iter().map(|i| i.to_string()).collect();
44        print!("{}\n", factors.join("*"));
45    }
46}

请编写程序，实现一下功能：从键盘输入一个n，代表二维数组的行和列，输入n行数列，每行的数列中包括n个数字。判断该矩阵是不是交错矩阵，如果是交错矩阵返回一个True，否则返回Flase。所谓交错矩阵，就是当前矩阵与它的转置矩阵的和为零矩阵。例如：

$$ \begin{bmatrix} 0 & -3 & 7 \\ 3 & 0 & 9 \\ -7 & -9 & 0 \end{bmatrix} \quad \text{与} \quad \begin{bmatrix} 0 & 3 & -7 \\ -3 & 0 & -9 \\ 7 & 9 & 0 \end{bmatrix} $$

互为交错矩阵，它们的转置矩阵与自身的和为全零的矩阵。

 1example：
 2
 3input：
 43
 50 -3 7
 63 0 9
 7-7 -9 0
 8output：
 9True
10
11input：
123
130 3 7
143 0 9
157 9 0
16output：
17False

 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 odr: i32 = input.trim().parse().unwrap();
 7
 8    let mut mat: Vec<Vec<i32>> = Vec::new();
 9    for _ in 0..odr {
10        input.clear();
11        stdin().read_line(&mut input).expect("Failed to read line");
12        let row: Vec<i32> = input
13            .trim()
14            .split_whitespace()
15            .map(|x| x.parse().unwrap())
16            .collect();
17        mat.push(row);
18    }
19
20    for i in 0..odr as usize {
21        for j in 0..odr as usize {
22            if mat[i][j] + mat[j][i] != 0 {
23                println!("False");
24                return;
25            }
26        }
27    }
28    println!("True");
29}

Rust 练习（二）

相关系列文章