Rust语言编程实例

有公子如玉

已于 2023-03-21 16:45:57 修改

阅读量1k

点赞数 1

分类专栏： Rust 文章标签：开发语言 rust

于 2023-03-21 10:47:03 首次发布

本文链接：https://blog.csdn.net/qq_52876054/article/details/129444064

版权

Rust 专栏收录该内容

1 篇文章 1 订阅

订阅专栏

001：

有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？
fn main() {
   let mut a = 0;
   for i in 1..5{
    for j in 1..5{
        for k in 1..5{
            if i !=j && j!=k && i!=k {
                a = a+1;
            }
        }
    }
   }
   println!("{}",a);
}

002：

企业发放的奖金根据利润提成。

利润(I)低于或等于10万元时，奖金可提10%；
利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；
20万到40万之间时，高于20万元的部分，可提成5%；
40万到60万之间时高于40万元的部分，可提成3%；
60万到100万之间时，高于60万元的部分，可提成1.5%；
高于100万元时，超过100万元的部分按1%提成。

从键盘输入当月利润I，求应发放奖金总数？
fn main() {
let i = 34534005.0;

let mut ans: f64;

if i<=100000.0 {
    ans = i*0.1;
}
else if i<=200000.0 {
    ans = 100000.0*0.1;
    ans = ans+(i-100000.0)*0.075;
}
else if i<=400000.0 {
    ans = 100000.0*0.1+100000.0*0.075;
    ans = ans+(i-200000.0)*0.05;
}
else if i<=600000.0 {
    ans = 100000.0*0.1+100000.0*0.075+200000.0*0.05;
    ans = ans+(i-400000.0)*0.03;
}
else if i<=1000000.0 {
    ans = 100000.0*0.1+100000.0*0.075+200000.0*0.05+200000.0*0.03;
    ans =  ans+(i-600000.0)*0.015;
}
else{
    ans = 10_0000.0*0.1+10_0000.0*0.075+20_0000.0*0.05+20_0000.0*0.03+40_0000.0*0.015;
    ans =ans+(i-100_0000.0)*0.01;
}

    println!("{}\n", ans);

}
改了一个小时，没能顺利解决输入的问题

从字符串转到浮点型之后，程序总是异常退出

希望后面可以改进一下

003：

一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？

程序分析：

假设该数为 x。

1、则：x + 100 = n2, x + 100 + 168 = m2

2、计算等式：m2 - n2 = (m + n)(m - n) = 168

3、设置： m + n = i，m - n = j，i * j =168，i 和 j 至少一个是偶数

4、可得： m = (i + j) / 2， n = (i - j) / 2，i 和 j 要么都是偶数，要么都是奇数。

5、从 3 和 4 推导可知道，i 与 j 均是大于等于 2 的偶数。

6、由于 i * j = 168， j>=2，则 1 < i < 168 / 2 + 1。

7、接下来将 i 的所有数字循环计算即可。
fn main() {
    let mut j: u32;
    let mut m: u32;
    let mut x: u32;

    for i in 1..85{
        if 168%i ==0 {
            j = 168/i;
            m = (i+j)/2;
            x = m*m-268;
            println!("{}\n",x);
        }
        else {
            continue;
        }
    }
}

004:

输入某年某月某日，判断这一天是这一年的第几天？

fn main(){
    println!("请输入年月日，年月日中间用空格隔开：");

    //获取数据
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("failed to read");

    //创建字符串向量
    let string_vec: Vec<&str> = input.trim().split_whitespace().collect();

    //判断输入数据的长度
    if string_vec.len()!=3 {
        println!("输入格式错误");
    }

    //声明年月日的变量
    let y_s = string_vec[0];
    let year;
    let m_s = string_vec[1];
    let month;
    let d_s = string_vec[2];
    let day;

    //判断年月日的合理性
    match y_s.parse::<u32>() {
        Ok(i) => {
            year = i;
        }

        Err(_) => {
            println!("年份格式错误");
            return;
        }
    }
    match m_s.parse::<u32>(){
        Ok(i) => {
            if i<1 || i>12 {
                println!("月份格式错误");
                return ;
            }
            else {
                month = i;
            }
        }
        Err(_) => {
            println!("月份格式错误");
            return;
        }
    }
    match d_s.parse::<u32>(){
        Ok(i) => {
            if i<1 {
                println!("日期格式错误");
                return;
            }
            else {
                day = i;
            }
        }
        Err(_) => {
            return ;
        }
    }

    
    let mut vector = vec![31,28,31,30,31,30,31,31,30,31,30,31];

    //判断闰年
    if year%400 ==0 || (year%4==0 && year%100!=0) {
        vector[1] = 29;
    }
    //输入天数大于月份原有天数，提示错误并退出
    let now_Days = vector[(month-1) as usize];
    if day>now_Days {
        println!("输入天数不得大于当月原有天数");
        return;
    }
    else {
        let mut answer: u32 = 0;
        for i in 1..month{
            answer += vector[(i-1) as usize];
        }
        answer += day;
        println!("{}年{}月{}日 是 {} 年的第 {}天",year,month,day,year,answer);
    }
}

可能是因为语言的规定

总觉得在Java和C当中很简单的代码，到了rust中变得异常复杂

005：

输入三个整数x,y,z，请把这三个数从大到小输出

fn main(){
    println!("请输入三个数，数之间用空格隔开：");

    //获取数据
    let mut input = String::new();
    std::io::stdin().read_line(&mut input).expect("failed to read");

    //创建字符串向量
    let vector: Vec<&str> = input.trim().split_whitespace().collect();

    //判断输入数据的长度
    if vector.len()!=3 {
        println!("输入格式错误");
    }

    let mut x: i32;
    let mut y: i32;
    let mut z: i32;

    if let Ok(data) = vector[0].parse::<i32>(){
        x = data;
    } else {
        println!("输入的第一个数不是整数");
        return;
    }
    if let Ok(data) = vector[1].parse::<i32>(){
        y = data;
    } else {
        println!("输入的第二个数不是整数");
        return;
    }
    if let Ok(data) = vector[2].parse::<i32>(){
        z = data;
    } else {
        println!("输入的第三个数不是整数");
        return;
    }
    //比较大小
    if x<y {
        let t = x;
        x = y;
        y = t;
    }
    if x<z {
        let t = x;
        x = z;
        z = t;
    }
    if y<z {
        let t = y;
        y = z;
        z = t;
    }

    println!("这三个数从大到小排列依次是{}，{}，{}",x,y,z);

}

感觉它的输入和类型转换都好复杂，就不能直接一点搞定吗？

006：

请使用*号输出英文字母C的图案，类似于电子手表屏幕上的C。请使用两种方式实现。
fn main() {
    println!("用 * 号输出字母 C!");
    println!("*****");
    println!("*");
    println!("*");
    println!("*****");
}
感觉这个题没有什么意义

007：

请使用两种方式输出下面的特殊图案，请在rust环境中运行，看一看，Very Beautiful!
fn main(){
        let a: char = '\u{2724}';
        let b: char = '\u{2764}';
    
        println!("{} {} {} {} {}", b, a, a, a, b);
        println!("{} {} {} {} {}", a, b, a, b, a);
        println!("{} {} {} {} {}", a, a, b, a, a);
        println!("{} {} {} {} {}", a, b, a, b, a);
        println!("{} {} {} {} {}", b, a, a, a, b);
    
}
这个题依然意义不大，可能就是让我知道了Unicode字符有非常多。不同字符，图形不一样

附一张在vc中的运行结果

008：

乘法口诀（也叫“九九歌”）在我国很早就已产生。远在春秋战国时代，九九歌就已经广泛地被人们利用着。常用的乘法口诀有两种，一种是45句的，通常称为小九九；还有一种是81句的，通常称为大九九。你能用Rust输出99乘法口诀（小九九）吗。输出时格式要对齐。
fn main(){
        for i in 1..10{
                for j in 1..=i{
                        let k = i*j;
                        print!("{}*{}={}\t",i,j,k);
                }
                println!();
        }
}
注意第二个循环处的 “ = ”

009：

国际象棋（Chess），又称西洋棋，是一种二人对弈的棋类游戏。棋盘为正方形，由64个黑白（深色与浅色）相间的格子组成；棋子分黑白（深色与浅色）两方共32枚，每方各16枚。虽然汉语称之为西洋棋或国际象棋，但是实际上它起源于亚洲，后由阿拉伯人传入欧洲，成为国际通行棋种，也是一项智力竞技运动，曾一度被列为奥林匹克运动会正式比赛项目。你能输出国际象棋棋盘吗。提示：白块的Unicode字符是\u+25a0，黑块的Unicode字符是\u+25a1。
fn main(){
        let s1: char = '\u{25a0}';
        let s2: char = '\u{25a1}';

        for i in 1..9{
                for j in 1..9{
                        if (i+j)%2 == 0 {
                                print!("{}",s1);
                        }
                        else {
                                print!("{}",s2);
                        }
                }
                println!();
        }
}
其实这种题目也不是完全没有意义，至少学习一下Unicode和char

010：

现在人们的生活水平逐步提高，越来越多的人住进了楼房。楼房中必须存在的那就是楼梯了。现在有个需求，要求你打印一个有6个台阶的楼梯，同时从上向下数，在楼梯的第4节台阶有个足球。

提示：台阶使用Unicode字符\u+2591表示，足球的Unicode字符是\u+26bd。
fn main() {
    let a = '\u{2591}';
    let football = '\u{26bd}';

    for i in 1..=6 {
        for _ in 1..=i {
            print!("{}", a);
        }
        // 打印足球
        if i == 3 {
            print!("{}", football);
        }
        println!()
    }
}
考理解的题吧

011：

古典问题（兔子生崽）：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？（输出前40个月即可）

输出格式：每行4个数，共10行。
fn main(){
        let mut f1: u32 = 1;
        let mut f2: u32 = 1;
        print!("{}\t",f1);
        print!("{}\t",f2);

        let mut k = 2;
        for i in 3..41{
                print!("{}\t",f1+f2);
                let t = f2;
                f2 = f2+f1;
                f1 = t;
                k += 1;
                if k==4 {
                        println!();
                }
        }
}
看到这种题目都不应该动脑子，斐波那契数列

012：

题目：质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数。判断101到200之间的质数。

输出格式：每行只有5个数，总共输出5行，注意数据对齐。
fn main(){
        let mut k = 0;
        for i in 101..200{
                let mut t = 1;
                for j in 2..=i-1{
                       if i%j==0 {
                        t = 0;
                        break;
                       } 
                }
                if t==1 {
                        k += 1;
                        print!("{}\t",i);
                }
                if k==5 {
                        println!();
                        k = 0;
                }
        }
}

013：

Rust语言编程题目：经典水仙花数问题。打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。

程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。

输出格式：每个数占一行。
fn main(){
        for i in 100..1000{
                let x = i/100;
                let y = (i-x*100)/10;
                let z = i%10;

                if x*x*x+y*y*y+z*z*z == i {
                        println!("{}",i);
                }
        }
}
这个题目也是很经典了，rust没有幂运算，“^”是按位异或

怎么说，感觉花里胡哨的东西学多了，反而忘记了本质

还想什么字符串切割之类的搞一通，哭

014：

将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。输出136的质因数。
fn main(){
       let mut m = 136;

       while m!=1 {
           for i in 2..=m{
              if m%i==0 {
                     println!("{}",i);
                     m = m/i;
                     break;
              }
           }
       }
}
之前写这个，写了一个死循环，看答案和自己的思路很不一样

我死脑筋的觉得一定要先判断因子是不是质数

但它每次被整除之后都是从2重新开始找新的因子，所以不需要判断

因为如果它被4整除，它一定先被2整除，被6整除，一定先被2和3整除

上班的路上突然想通了，这是个数学题。。。

015：

利用条件运算表达式来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
fn main{    
    let score = 59;
    let grade = if score >= 90 { 'A' } else { if score >= 60 { 'B' } else { 'C' } };
    println!("{} 分的等级是 {}", score, grade);
}
学习一下人家这个函数的写法，感觉有点像Java的三字表达式

016：

给定两个正整数m=128和n=60，求其最大公约数和最小公倍数。

fn main(){
        let m = 128;
        let n = 60;

        let mut m1 = 128;
        let mut n1 = 60;
        let mut temp = m1%n1;
        while temp!=0 {
            m1 = n1;
            n1 = temp;
            temp = m1%n1;
        }

        println!("{}",n1);
        println!("{}",m*n/n1);
}

017：

在控制台随便输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数

fn main(){
       let mut s = String::new();

       std::io::stdin().read_line(&mut s).expect("read is error!");

       let mut letter = 0;
       let mut space = 0;
       let mut num = 0;
       let mut other = 0;
       

       for x in s.trim().chars() {
        if (x>'a' && x<'z') || (x>'A' && x<'Z') {
                letter += 1;
        }
        else if x>'0' && x<'9'{
                num += 1;
        }
        else if x==' ' {
            space += 1;
        }
        else {
            other += 1;
        }
       }

       println!("{},{},{},{}",letter,space,num,other);
}

018：

求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由n确定，加的数是几由m确定。求当m = 3， n = 6时的值。
fn main(){
       let m = 3;
       let n = 6;
       let mut ans = 0;
       let mut temp = m;
       let mut x = 0;

       for _ in 1..=n {
        ans += temp+x;
        x += temp;
        temp *= 10;
       }

       println!("{}",ans);
}
当for循环“=n”时，是[1,n]，否则是[1,n-1）

019：

一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数。

fn main(){
       const N: i32 = 1000;

       for i in 2..=N {
              let mut sum = 1;
              let mut array: Vec<i32> = Vec::new();
              array.push(1);

              for j in 2..=i/2 {
                     if i%j==0 {
                            sum += j;
                            array.push(j);
                     }
              }

              if i==sum {
                     print!("{} = ",i);
                     let result: Vec<String> = array.iter().map(|x| x.to_string()).collect();
                     println!("{}",result.join(" + "));
              }
       }
}

Rust 迭代器适配map()_rust map_小泽泽泽ya的博客-CSDN博客

020:

一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
fn main(){
       let mut ans: f64 = 100.0;
       let mut h: f64 = 50.0;
       
       for i in 1..10 {
              ans += 2.0*h;
              h /= 2.0;
       }

       println!("{},{}",ans,h);
}
注意加".0"参与浮点数运算

021：

猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个，第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下，的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。请使用循环和递归两种方式解决此问题。

循环：
fn main(){
      let mut ans = 1;

      for _ in 1..10 {
       ans = (ans+1)*2;
      }

      println!("{}",ans);
}
递归：
fn main(){
    println!("{}",peach(1));
}

fn peach(day: i32) -> i32 {
       if day == 10 {
              return 1;
       }
       else {
              return (peach(day+1)+1)*2;
       }
}

未完待续~

有公子如玉

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Rust语言编程实例

求当m = 3， n = 6时的值。古典问题（兔子生崽）：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？现在有个需求，要求你打印一个有6个台阶的楼梯，同时从上向下数，在楼梯的第4节台阶有个足球。4、可得： m = (i + j) / 2， n = (i - j) / 2，i 和 j 要么都是偶数，要么都是奇数。3、设置： m + n = i，m - n = j，i * j =168，i 和 j 至少一个是偶数。
复制链接

扫一扫