day7-综合练习-CSDN博客

本文链接：https://blog.csdn.net/2402_83779820/article/details/145885760

1.卖飞机票

需求：机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或者经济舱。

按照如下规则进行计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折；淡季（11月到来年4月）头等舱7折，经济舱6.5折。


import java.util.Scanner;

public class Text0 {
    public static void main(String[] args) {
        /*机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
        按照如下规则计算机票价格:旺季(5-10月)头等舱9折，经济舱8.5折，淡季(11月到来年4月)头等舱7折，经济舱6.5折。*/

        //分析:
        //1.键盘录入机票原价、月份、头等舱或经济舱
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入机票的原价");
        int ticket = sc.nextInt();
        System.out.println("请输入当前的月份");
        int month = sc.nextInt();
        System.out.println("请输入当前购买的舱位 0 头等舱 1 经济舱");
        int seat = sc.nextInt();
        //2.先判断月份是旺季还是淡季
        //ctrl + alt + M 自动抽取方法
        if (month >= 5 && month <= 10) {
            //旺季 //3.继续判断当前机票是经济舱还是头等舱
            if (seat == 0) {
                //头等舱
                ticket = (int)(ticket * 0.9);
            } else if (seat == 1) {
                //经济舱
                ticket = (int)(ticket * 0.85);
            } else {
                System.out.println("没有这个舱位");
            }

        }else if ((month >= 1 && month <= 4)|| (month >= 11 && month <= 12)){
            //淡季
            if (seat == 0){
                //头等舱
                ticket = (int)(ticket * 0.7);
            }else if(seat == 1){
                //经济舱
                ticket = (int)(ticket * 0.65);
            }else{
                System.out.println("没有这个舱位");
            }

        }else {
            //表示键盘录入的月份是一个非法数据
            System.out.println("键盘录入的月份不合法");
        }

        //4.根据实际情况计算出对应的价格
        System.out.println(ticket);
    }
}

2、找质数

判断101~200之间有多少个素数，并输出所有素数。


public class Text2 {
    public static void main(String[] arg) {
        //判断 101 ~ 200 之间有多少个素数，并打印所有素数

        //思路一:2~99
        //定义变量i ，赋值100
        //判断i是否为质数

        //定义一个变量来统计有多少质数
        int count = 0;
        //外循环：遍历101~200的这个范围，依次得到这个范围之内的每一个数字
        for (int i = 101; i <= 200; i++) {
            //i 依次表示循环中的每一个数字
            //继续判断i是否为一个质数
            boolean flag = true;
            //判断当前数字是否为一个质数
            for (int j = 2; j < i; j++) {  //此行表示要从2开始，到这个数字 - 1结束，这样才可以判断当前数字是否为一个质数
                //j 表示2~99之间的每一个数字
                if (i % j == 0) {
                    flag = false;
                    break;//跳出单层循环，内循环
                }
            }
            if (flag) {
                System.out.println("当前数字" + i + "是质数");
                count++;
            }
        }
        System.out.println("一共有"+count+"个质数");
    }
}

3.开发验证码

需求：定义方法实现随机产生一个5位的验证码。验证码格式为：长度为5，前4位是大写或者小写字母，最后一位是数字。

//方法：
在以后如果我们要在一堆没有什么规律的数据中随机抽取，可以先把这些数据放到数组当中，再随机抽取一个索引

package lishuqiang;
 
import java.util.Random;
 
public class sss {
    public static void main(String[] arg) {
        String result = "";//定义一个字符串类型的变量，用来记录最终的结果
 
        //1、把大写字母和小写字母放到数组当中
        char[] chs = new char[52];    //定义字符型数组，用来存储大小写字母
        for (int i = 0; i < chs.length; i++) {
            if(i<=25){      //i的范围为0~25
                //添加小写字母。ASCLL码表中a对应97
                chs[i]=(char)(97+i);
            } else{     //i的范围为26~52
                //添加大写字母。ASCLL码表中A对应65
                chs[i]=(char)(65 + i - 26);
            }
        }
        //2、随机抽取四次
        //随机抽取数组中的索引
        Random r = new Random();
        for (int i = 0; i <4 ; i++) {       //多次抽取，要利用循环
            //随机抽取一个元素，将对应的字母赋值给变量randomchar
            int randomchar = r.nextInt(chs.length);
            result = result + chs[randomchar];  //字符串+字符的拼接 结果为字符串
        }
        //3、随机抽取一个数字，赋值给变量randomNumber
        int randomNumber = r.nextInt(10);   //获取一个0~9之间的随机数
        result = result + randomNumber;     //字符串拼接
        System.out.println(result);
    }
}

4.数组元素的复制

需求：把一个数组的元素复制到另一个新数组中去。

public class Text5 {
    public static void main(String[] args) {
        /*需求:
        把一个数组中的元素复制到另一个新数组中去。*/
        //分析:
        //1.定义一个老数组并存储一些元素
        int[] arr = {1, 2, 3, 4, 5};
        //2.定义一个新数组的长度跟老数组一致
        int[] newArr = new int[arr.length];
        //3.遍历老数组，得到老数组中的每一个元素，依次存入到新数组当中
        for (int i = 0; i < arr.length; i++) {
            //i 表示老数组中的索引。新数组中的每一个索引
            //arr[i] 表示老数组中的元素
            newArr[i] = arr[i];
        }
        //4.新数组中已经存满元素了
        for (int i = 0; i < newArr.length; i++) {
            System.out.println(newArr[i]);
        }
    }
}

5、评委打分

需求：

在唱歌比赛中，有6名评委给选手打分，分数范围是[0~100]之间的整数。选手的最后得分为：去点最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。


import java.util.Scanner;

public class Text6 {
    public static void main(String[] args) {

        int[] arr = new int[6];     //定义新数组，长度和老数组相同

        //1、键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入6个0~100之间的数");
        for(int i = 0;i < arr.length ;){
            int soure = sc.nextInt();
            if(soure>=0 && soure<=100){
                arr[i] = soure;
                i++;    //如果输入不合法，则if语句不会执行，数组下标i的值就不会变
            } else{
                System.out.println("输入不合法，请重新输入");
            }
        }

        //2、求最大值
        int max = arr[0];
        for (int i = 1; i < arr.length ; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
        }
        System.out.println("最大值为" + max);

        //3、求最小值
        int min = arr[0];
        for (int i = 1; i < arr.length ; i++) {
            if(arr[i] < min){
                min = arr[i];
            }
        }
        System.out.println("最小值为" + min);

        //4、求和，然后减去最大值最小值，除以4得出结果
        int sum = 0;
        for (int i = 0; i < arr.length ; i++) {
            sum = sum +arr[i];
        }
        System.out.println("六个评委分数总和" + sum);

        double end = (double)(sum - max - min )/(arr.length - 2);
        System.out.println("最终得分为" + end);
    }
}

6、数字加密和解密

1、数字加密

public class Text6 {
    public static void main(String[] args) {
/*  某系统的数字密码(大于0)。比如1983，采用加密方式进行传输
    规则如下:
        每位数加上5
        再对10求余，
        最后将所有数字反转，
        得到一串新数。
*/


        //分析:
        //1.把整数里面的每一位放到数组当中
        int[] arr = {1, 9, 8, 3};
        //2.加密
        //每位数加上5
        for (int i = 0; i < arr.length; i++) {   //一个循环最好只干一件事
            arr[i] = arr[i] + 5;
        }
        //再对10取余
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] % 10 ;
        }
        //让得到的数组，所有数字反转
        int j = arr.length - 1;
        for (int i = 0;  i < j ; i++,j--) { //此时i为最左边的数字,j为最右边的数字
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        for (int i = 0; i < arr.length; i++) {
            //System.out.print(arr[i] + " ");//打印
        }//8 3 4 6 --> 8346
        //3.把数组里面的每一个数字进行拼接，变成加密之后的结果
        int number=0;
        for (int i = 0;i < arr.length; i++) {
            number = number * 10 + arr[i];
            //System.out.print(number +" ");
        }
        System.out.println(number);

    }
}

另解:

package lishuqiang;
import java.util.Scanner;
 
public class sss {
    public static void main(String[] arg) {
        //1、键盘录入，获取想要加密的数字
        Scanner sc = new Scanner(System.in);
        int soure = sc.nextInt();
        int number = soure;
        int te = number;    //设置临时记录te来记录number的值，方便以后使用
 
        //2、求出数组长度
        int count = 0;
        while (number != 0){
            number = number/10;
            count++;
        }
        System.out.println("数组长度为"+count);
        //3、定义数组
        int[] arr2 = new int[count];
 
        //4、把整数上的每一位添加到数组当中
        int index = count-1;    //实现倒着添加
        while (te != 0){
            int ge = te % 10;
            te = te / 10;
            arr2[index] = ge;   //依次添加数组到个、十、百
            index--;
        }
        //打印获取的数组元素
        System.out.println("获取到的数组为");
        for (int i = 0; i <arr2.length ; i++) {
            System.out.print(arr2[i]+" ");
        }
        System.out.println();
 
        System.out.println("-----进行加密过程-----");
 
        //5、数组元素的值加5，对10取余
        for (int i = 0; i <arr2.length ; i++) {
            arr2[i] = ( arr2[i] + 5 ) % 10;
        }
        //打印获取的数组元素
        for (int i = 0; i <arr2.length ; i++) {
            System.out.print(arr2[i]+" ");
        }
 
        //6、让得到的数组，所有数字反转
        int j = arr2.length - 1;
        for (int i = 0 ; i < j ; i++,j--) {
            int temp = arr2[i];
            arr2[i] = arr2[j];
            arr2[j] = temp;
        }
        //7、字符拼接
        String chs = "";
        for (int i = 0; i <arr2.length ; i++) {
            chs= chs + arr2[i];
        }
        System.out.println("加密后结果为");
        System.out.println(chs);
        }
}

2.数字解密

public class Text8 {
    public static void main(String[] args) {
        /*某系统的数字密码(大于0)。比如1983，采用加密方式进行传输，
        规则如下:
            每位数加上5
            再对10求余，
            最后将所有数字反转，
            得到一串新数。
            按照以上规则进行解密:
            比如1983加密之后变成8346，解密之后变成1983
        */

        //1.定义数组记录解密之后的结果
        int[] arr = {8, 3, 4, 6};
        //2.反转
        for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //3.由于加密是通过对10取余的方式进行获取的
        //所以在解密的时候就需要判断，0~4之间+10  5~9数字不变
        for(int i=0;i< arr.length; i++) {
            if (arr[i] >= 0 && arr[i] <= 4) {
                arr[i] = arr[i] + 10;
            }
        }
        //4.每一位 -5
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] - 5;
        }

        //5.获取数组里面的每一位数字拼接成最终的结果
        int number = 0;
        for(int i = 0;i < arr.length; i++) {
            number = number * 10 + arr[i];
        }
            System.out.println(number);


    }
}

7、抽奖的两种实现方式

需求：

一个大V直播抽奖，奖品是现金红包，分别有{2，588，888，1000，10000}五个奖金。请使用代码模拟抽奖，打印出每个奖项，奖项的出现顺序要随机且不重复。

最初代码

package lishuqiang;
import java.util.Random;
 
public class sss {
    public static void main(String[] arg) {
        //1、定义数组表示奖池
        int[] arr = {2,588,888,1000,10000};
        //2、定义新数组用于存储抽奖的结果
        int[] newArr = new int[arr.length];
        //3、抽奖
        Random r = new Random();
        //因为有5个奖项，所以这里要循环5次
        for (int i = 0; i < 5; ) {
            //获取随机索引
            int randomIndex = r.nextInt(arr.length);
            //获取奖项
            int prize = arr[randomIndex];
            //判断当前的奖项是否存在，如果存在则重新抽取，如果不存在，就表示是有效奖项
            boolean flag = contains(newArr,prize);
            if(!flag){
                //把当前抽取到的奖项添加到newArr当中
                newArr[i] = prize;
                //添加完毕后，移动索引
                i++;
            }
        }
        for (int i = 0; i < newArr.length; i++) {
            System.out.println(newArr[i]);
        }
    }
 
    //判断prize在数组中是否存在  存在为true  不存在为false
    public static boolean contains(int[] arr,int prize){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == prize){
                return true;
            }
        }
        return false;
    }
 
}

优化后的代码

package lishuqiang;
 
import java.util.Random;
 
public class sss {
    public static void main(String[] arg) {
        //1、把奖池里面的所有奖项打乱顺序
        int[] arr = {2,588,888,1000,10000};
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            //随机获取索引
            int randomIndex = r.nextInt(arr.length);
            //拿着i跟随即索引randomIndex上的值进行交换
            int temp = arr[i];
            arr[i] = arr[randomIndex];
            arr[randomIndex] = temp;
        }
        //2、遍历奖池，从0索引开始获取每一个奖项
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        }
}

8、双色球彩票系统


import java.util.Random;
import java.util.Scanner;

public class Text11{
    public static void main(String[] args) {
        //1.生成中奖号码,用数组存 长度7
        int[] arr = creatNumber();// 123456  7


        System.out.println("=======================");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

        System.out.println("=======================");

        //2.用户输入彩票号码(红球 + 蓝球)//654321 只要存在就中奖,不需要位置一样
      int[]userInputArr = userInputNumber();

      for (int i = 0; i < userInputArr.length; i++) {
          //System.out.print(userInputArr[i]+ " ");
      }

      //判断用户的中奖情况
        //红球 蓝球
        int redCount = 0;
        int blueCount = 0;

        //判断红球
        for (int i = 0; i < userInputArr.length - 1; i++) {
           int redNumber = userInputArr[i];
            for (int j = 0; j < arr.length - 1; j++) {
                if(redNumber == arr[j]){
                    redCount++;
                    //如果找到了,那么后面的数字就没有必要继续比较了
                    //跳出内循环,继续判断下一个红球号码是否中奖
                    break;
                }
            }
        }


        //判断蓝球
        int blueNumber = userInputArr[userInputArr.length - 1];
        if (blueNumber == arr[arr.length - 1]){
            blueCount++;
        }


        //根据红球的个数以及蓝球的个数来判断中奖情况
        if (redCount == 6 && blueCount == 1){
            System.out.println("恭喜你,中奖1000万");
        }else if (redCount == 6 && blueCount == 0){
            System.out.println("恭喜你,中奖500万");
        }else if (redCount == 5 && blueCount == 1) {
            System.out.println("恭喜你,中奖3000块");
        }else if ((redCount == 5 && blueCount == 0) || (redCount == 4 && blueCount == 1) ) {
            System.out.println("恭喜你,中奖200块");
        }else if ((redCount == 4 && blueCount == 0) || (redCount == 3 && blueCount == 1) ) {
            System.out.println("恭喜你,中奖10块");
        }else if ((redCount == 2 && blueCount == 1) || (redCount == 1 && blueCount == 1) ) {
            System.out.println("恭喜你,中奖5块");
        }else{
            System.out.println("谢谢参与");
        }
    }

    public static int[]userInputNumber(){
        //1.创建数组用于添加用户购买的彩票号码
        //6个红球 1个蓝球 数组长度:7
        int[] arr = new int[7];

        //2.利用键盘录入让用户输入
        Scanner sc = new Scanner(System.in);
        //让用户输入红球号码
        for (int i = 0; i < 6;) {
            System.out.println("请输入第"+ (i+ 1)+"个红球号码");//因为从0开始,所以要+1
            int redNumber = sc.nextInt();
            //redNumber  在1~33 唯一不重复
            if (redNumber >= 1 && redNumber<=33){
                 boolean flag = contains(arr,redNumber);
                 if (!flag){
                     //不存在
                     //有效的,可以添加到数组当中
                     arr[i] = redNumber; //将redNumber添加到数组当中
                     i++;
                 }else{
                     //存在
                     System.out.println("当前红球号码已经存在,请重新输入");
                 }
            }else{
                System.out.println("当前红球号码已经超出范围");
            }
        }

        //让用户输入蓝球号码
        System.out.println("请输入蓝球号码");
        //1~16
        while (true) {        //crtl + alt + t
            int blueNumber = sc.nextInt();
            if (blueNumber >= 1 && blueNumber <= 16){
               arr[arr.length-1] = blueNumber;
               break;
            }else {
                System.out.println("当前蓝球号码超出范围");
            }
        }

        return arr;
    }









    public static int[] creatNumber() {
        //1.创建数组用于添加中奖号码
        //6个红球,1个蓝球 数组长度:7
        int[] arr = new int[7];

        //2.随机生成号码并添加到数字当中
        //红球:不能重复   1 2 3 4 5 6
        //蓝球:可以跟红球号码重复 5

        //生成红球号码并添加到数组当中
        Random r = new Random();
        for (int i = 0; i < 6; ) {//相当于把红球号码添加到0~5索引上
            //获取红球号码
            int redNumber = r.nextInt(33) + 1;//1~33
            boolean flag  = contains(arr, redNumber);
            if (!flag){//flag不存在
                // 把红球号码添加到数组当中
                arr[i] = redNumber;
                i++;
            }
        }

        //生成蓝球号码并添加到数组当中
        int blueNumber = r.nextInt(16) + 1;
        arr[arr.length - 1]= blueNumber;
        return  arr;
    }

    //用于判断数组在数组是否存在
    public static boolean contains(int []arr , int number){
        for(int i = 0;i < arr.length;i++){
            if (arr[i] == number){
                return true;
            }
        }
        return false;
    }


}