Day7-综合练习

1、卖飞机票

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

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

package lishuqiang;
import java.util.Scanner;

public class sss {
    public static void main(String[] arg){

        //定义折扣后的价格，获取键盘录入
        double endJG = 0.0;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入几机票价格");
        int jiage = sc.nextInt();
        System.out.println("请输入月份");
        int yuefen = sc.nextInt();
        System.out.println("头等舱输入1，经济舱输入2，请输入");
        int xuanze = sc.nextInt();  //1为头等舱，2为经济舱
//ctrl+alt+M：自动抽取方法，选中重复的代码，然后按快捷键即可


        //按月份进行选择
        switch (yuefen){
            case 5:
            case 6:
            case 7:
            case 8:
            case 9:
            case 10:endJG = get(jiage,xuanze,0.9,0.85);break;
            case 11:
            case 12:
            case 1:
            case 2:
            case 3:
            case 4:endJG = get(jiage,xuanze,0.7,0.65);break;
            default:
                System.out.println("输入的月份不合法");
            }
        System.out.println("折扣后的价格为"+ endJG );
        }


        //定义方法来计算折扣后的价格
    public static double get(int jiage,int xuanze,double tou,double jing){
        double end = 0.0;
        if(xuanze==1){
            end = jiage*tou;        //价格*头等舱的折扣
        } else if(xuanze == 2) {
            end = jiage*jing;       //价格*经济舱的折扣
        } else {
            System.out.println("输入不合法");
        }
        return end;     //返回折扣后的价格
    }

}

2、找质数

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

package lishuqiang;
public class sss {
    public static void main(String[] arg) {
        int count = 0;  //用于统计数目
        for (int i = 101; i <=200; i++) {    //利用循环遍历101~200之间的数
            boolean flg = true;     //用flg做标记
            for (int j = 2;j < i; j++) {    //利用循环判断是否为质数
                if (i % j == 0) {
                    flg = false;    //false表示该数不是质数
                    break;
                }
            }
            if(true == flg){
                System.out.print(i + " ");
                count++;
            }
        }
        System.out.println("\n"+"一共有"+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、数组元素的复制

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

package lishuqiang;

public class sss {
    public static void main(String[] arg) {
        int[] arr = {1,2,3,4,5,6,7,8,9};  //定义老数组，并存放元素
        int[] newArr = new int[arr.length];     //定义新数组，长度和老数组相同
        for(int i = 0;i < arr.length;i++){
            newArr[i] = arr[i];
        }
        //打印新数组
        System.out.println("新数组为");
        for (int i = 0; i < newArr.length; i++) {    //打印新获得的数组
            System.out.print(newArr[i]+" ");
        }
    }
}

5、评委打分

需求：

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

package Test03;
import java.util.Scanner;

public class test05 {
    public static void main(String[] arg){
        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、数字加密

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、解密数字

分析如下

package lishuqiang;
public class sss {
    public static void main(String[] arg) {
        //1、让得到的数组，所有数字反转
        int[]arr={8,3,4,6};
        int j = arr.length - 1;
        for (int i = 0 ; i < j ; i++,j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        //2、对取余进行解密
        //由于加密方式是通过对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;   //在原值的基础上加10 
            }
        }

        //3、每一位减去5
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] - 5;
        }

        //4、字符拼接
        String chs = "";
        for (int i = 0; i <arr.length ; i++) {
            chs= chs + arr[i];
        }
        System.out.println("加密后结果为");
        System.out.println(chs);
        }
}

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、双色球彩票系统

package lishuqiang;

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

public class sss {
    public static void main(String[] arg) {
        //1、生成中奖号码
        int[] arr = creatNumber();  //调用方法获取中奖号码
        /*//打印中奖号码
        System.out.println("中奖号码为");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();*/

        //2、用户输入彩票号码（红球+蓝球）
        int[] userInputArr = userInport();

        //打印用户输入的彩票号码
        System.out.println("用户输入的号码为");
        for (int i = 0; i < userInputArr.length; i++) {
            System.out.print(userInputArr[i] + " ");
        }
        System.out.println();

        //红球 蓝球
        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++;
        }
        /*System.out.println("红色中奖个数为" + redCount);
        System.out.println("蓝色中奖个数为" + 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) || (redCount==0 && blueCount==1)) {
            System.out.println("恭喜你中奖5元");
        } else {
            System.out.println("很抱歉没有中奖");
        }
    }


    //定义获取用户输入的方法
    public static int[] userInport(){
        int[] inarr = new int[7];
        Scanner sc = new Scanner(System.in);

        for (int i = 0; i < 6; ) {
            System.out.println("请输入第" + (i+1) + "个红球号码");
            int redNumber = sc.nextInt();

            //redNumber   在1~33  唯一不重复
            if(redNumber >= 1 && redNumber <= 33){
                boolean  flag = contains(inarr,redNumber);
                if(!flag){
                    //不存在
                    //有效的，可以
                    inarr[i] = redNumber;
                    i++;
                } else {
                    //存在
                    System.out.println("当前红球号码已经存在，请重新输入");
                }
            } else{
                System.out.println("输入不合法，请重新输入");
            }

        }

        //让用户输入蓝球号码
        System.out.println("请输入蓝球号码");
        //1~16
        while(true){
            int blueNumber = sc.nextInt();
            if(blueNumber >= 1 && blueNumber <=16){
                inarr[inarr.length - 1] = blueNumber;
                break;
            } else {
                System.out.println("当前号码输入不合法");
            }
        }
        return inarr;      //把用户输入的号码放到数组中返回
    }


    //定义生成中奖号码的方法
    public static int[] creatNumber(){
        //1、创建数组用于添加中奖号码
        //6个红球 1个蓝球 数组长度为7
        int[] zarr = new int[7];

        //2、随机生成号码并添加到数组当中，例如下面的情况
        //红球：不能重复的 1 2 3 4 5 6
        //蓝球：可以跟红球号码重复 5

        //生成红球号码并添加到数组当中
        Random r = new Random();
        for (int i = 0; i < 6; ) {
            //获取红球号码
            int redNumber = r.nextInt(33)+1;
            boolean flag = contains(zarr,redNumber);
//flag的值为false时，表示该数不存在可以添加，为了执行循环，所以取反值为true
            if(!flag){
                zarr[i] = redNumber;
                i++;
            }
        }
        //生成蓝球号码并添加到数组当中
        int blueNumber = r.nextInt(16) + 1;
        zarr[zarr.length - 1] = blueNumber;   //将蓝色号码添加到数组当中的末尾元素
        return zarr;     //将中奖号码放到数组中，返回数组
    }


    //定义判断数组中是否存在该数的方法
    //判断数字是否已经存在，已经存在返回true 不存在返回false
    public static boolean contains(int[] arr,int prize){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == prize){  //判断生成的随机数在数组中是否有重复值
                return true;    //有重复值返回true
            }
        }
        return false;
    }

}