专题——编程案例

🕗 发布于 2024-11-09 23:21 java android 开发语言

一、目的

复习前面所学的编程知识，能够利用所学的知识来解决问题
①变量、数组
②运算符：+ - * /、== >=、&&、||、！
③程序流程控制：if、switch；for、while、死循环…
④跳转关键字：break、continue、return
⑤方法
…
积攒大家的代码量，以训练并提升大家的编程能力、编程思维

编程思维	提升编程思维和能力的建议
使用所学的 Java 技术解决问题的思维方式和编写代码实现出来的能力	1. 编程思维、编程能力不是一朝一夕形成的，需要大量思考，练习和时间的沉淀
使用所学的 Java 技术解决问题的思维方式和编写代码实现出来的能力	2. 具体措施：前期，建议先模仿；后期自然就能创新了；勤于联系代码。勤于思考，孰能生巧。

二、案例

1、案例：买机票

需求：用户购买机票时，机票原价会按照淡季、旺季，头等舱还是经济舱的情况来进行相应的优惠，优惠方案如下：5-10 月为旺季，头等舱 9 折，经济舱 8.5 折；11 月到来年 4 月为淡季，头等舱 7 折，经济舱 6.5 折，请开发程序计算出用户当前机票的优惠价。
分析：
①方法是否需要接收数据？需要接收机票原价、当前月份、舱位类型；
②方法是否需要返回数据？需要返回计算出的机票优惠价
③方法内部：先使用 if 判断月份是旺季还是淡季，然后使用 switch 分支判断是头等舱还是经济舱
解决：
代码：

//主程序：买机票
    public static void main(String[] args) {
        System.out.println("欢迎使用机票购买系统！");
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入机票原价：");
        int ariTicket = scanner.nextInt();
        System.out.print("请输入当前月份：（1-12月）");
        int month = scanner.nextInt();
        System.out.print("请输入舱位类型：（头等舱/经济舱）");
        String seatType = scanner.next();

        double pirce = ticketPrice(ariTicket, month, seatType);
        System.out.println("您的机票价格为：" + pirce);

    }
    //方法：计算机票价格
    public static double ticketPrice(int ariTicket, int month, String seatType) {
        double price = 0;
        if (month >= 5 || month <= 10) {
            switch (seatType) {
                case "头等舱":
                    price = ariTicket * 0.9;
                    break;
                case "经济舱":
                    price = ariTicket * 0.85;
                    break;
            }
        } else if (month >= 11 || month <= 12 || month >= 1 || month <= 4) {
            switch (seatType) {
                case "头等舱":
                    price = ariTicket * 0.7;
                    break;
                case "经济舱":
                    price = ariTicket * 0.65;
                    break;
            }
        } else {
            System.out.println("输入月份错误！");
        }
        return price;
    }

回顾：
1、遇到需要通过判断数据在哪个区间，来决定执行哪个业务，应该用什么实现？
应该使用 if 分支结构实现
2、遇到需要通过判断数据匹配哪个值，来决定执行哪个业务，应该用什么实现？
应该使用 switch 分支结构实现

2、案例：开发验证码

需求：开发一个程序，可以生成指定位数的验证码，每位可以是数字、大小写字母。（扩展：当验证错误时重新输入，输入超过三次重新生成验证码，只有验证码输入正确时结束执行）。
分析：
①方法是否需要接收数据？需要接收一个整数，控制生成验证码的位数。
②方法是否需要返回数据？需要返回生成的验证码。
③方法内部的业务：使用 for 循环依次生成每位随机字符，并使用一个 String 类的变量把每个字符连接起来，最后返回该变量即可。
解决：
代码：

//主程序：开发验证码
    public static void main(String[] args) {
        int count = 0;//验证码输入错误次数

        System.out.println("欢迎使用验证码系统！");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入验证码位数：");
        int length = scanner.nextInt();//接收验证码位数

        //死循环，直到输入正确的验证码
        while (true) {
            String code = generateCode(length);//调用方法：生成验证码

            System.out.println("您的新验证码为：");
            System.out.println(code);

            //死循环：知道输入正确验证码 或者 验证码输入错误次数超过3次
            while (true) {
                System.out.println("请输入您获得的验证码：");
                final String inputCode = scanner.next();

                //匹配验证码的条件（输入验证码=生成验证码）
                if (inputCode.equals(code)) {
                    System.out.println("验证码正确！");
                    return;//退出整个方法
                } else {
                    count++;
                    System.out.println("验证码错误" + count + "次！请重新输入！");

                    //验证码输入错误次数超过3次，退出死循环
                    if (count >= 3) {
                        System.out.println("验证码输入错误次数过多，请重新获取验证码！");
                        break;
                    }
                }
            }
        }
    }
    //方法：生成验证码
    public static String generateCode(int length) {
        String code = "";//验证码字符串
        
        //随机生成验证码
        for (int i = 0; i < length; i++) {
            Random random = new Random();
            int classNum = random.nextInt(3);
            
            //随机选择：0(数字)、1(小写字母)、2(大写字母)
            switch (classNum) {
                case 0:
                    Random r = new Random();
                    int num = r.nextInt(10);//随机生成0-9的数字
                    code += num;
                    break;
                case 1:
                    char letter1 = (char) (random.nextInt(26) + 'a');//随机生成小写字母
                    code += letter1;
                    break;
                case 2:
                    char letter2 = (char) (random.nextInt(26) + 'A');//随机生成大写字母
                    code += letter2;
                    break;
            }
        }
        return code;
    }

回顾：随机生成验证码方法的核心实现逻辑是如何进行的？
①定义一个 for 循环，循环多次；
②随机生成 0、1、2 的分类，依次代表当前要生成的字符：数字、小写字母、大写字母；
③把 0、1、2 交给 switch 生成对应类型的随机字符；
④在循环外定义一个 String 类型的变量用来连接生成的随机字符；
⑤循环结束后，返回 String 类型的变量即是生成的随机验证码。

3、案例：评委打分

需求：多名评委要给选手打分，分数是 [0-100] 之间的整数。选手最后得分为：去掉最高分、最低分后剩余分数的平均分，请编写程序能够录入多名评委的分数，并算出选手的最终得分。
分析：
①方法接收数据？需要接收评委的人数和每位评委的分数
②方法返回数据？需要返回计算出选手的最终得分
③方法内部业务？==定义数组，录入评委的分数，录入评委的分数存入到数组中去，接着，我们就需要遍历数组中的分数，计算出总分，并找出最高分、最低分，最后按照这些数据算出选手最终得分并返回即可。
解决：
代码：

//主程序：评委打分案例
    public static void main(String[] args) {
        double average = 0;
        double[] array;

        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入评委人数：");
        int peoples = new Scanner(System.in).nextInt();
        array = new double[peoples];
        for (int i = 0; i < peoples; i++) {
            System.out.println("请输入第" + (i + 1) + "位评委的得分：");
            double score = scanner.nextDouble();
            array[i] = score;
        }
        average = average(array);
        System.out.println("选手最后的平均分为：" + average);
    }
    //方法：计算平均分
    public static double average(double[] array) {
        double sum = 0;
        double min = array[0];
        double max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i] < min) {
                min = array[i];
            }
            if (array[i] > max) {
                max = array[i];
            }
            sum += array[i];
        }
        double average = (sum - min - max) / (array.length-2);
        return average;
    }

回顾：如何实现评委打分案例？
①定义一个动态初始化的数组，用于录入评委打分；
②提前定义三个变量用来记住数组中的最大值、最小值、总和；
③遍历数组中的每个数据，依次找出最大值、最小值、总和；
④遍历结束后，按照计算规则算出选手的最终得分，并返回即可。

4、案例：数字加密

需求：某系统的数字密码是一个四位数，如 1983，为了安全，需要加密后再传输，加密规则是：对密码中的每位数字，都加 5 ，在对 10 求余，最后将所有数字顺序反转，得到一串加密后的新数字，请设计出满足本需求的加密程序！（也可以自己尝试着把解密程序写出来）
分析：
①方法接收数据？需要接收四位数字密码，进行加密处理。
②方法返回数据？需要返回加密的后果。
③方法内部业务？将四位数字密码拆分成一个一个的数字，存入到数组中去，遍历数组中的每个数字，按照题目要求进行加密！最后，再把加密后的数字拼接起来返回即可！
解决：
代码：

//主程序：数字加密
    public static void main(String[] args) {
        System.out.println("请输入需要加密的数字：");
        Scanner scanner = new Scanner(System.in);
        int encryptNum = scanner.nextInt();
        String encryptResult = encrypt(encryptNum);//调用数字加密方法
        System.out.println("加密后的数字为：");
        System.out.println(encryptResult);

        System.out.println("请输入需要解密的数字");
        int dncryptNum = scanner.nextInt();
        String decryptResult = decrypt(dncryptNum);//调用数字解密方法
        System.out.println("解密后的数字为：");
        System.out.println(decryptResult);
    }

    //方法：数字加密
    public static String encrypt(int num) {
        int a = num % 10;//取个位数
        int b = num % 100 / 10;//取十位数
        int c = num % 1000 / 100;//取百位数
        int d = num % 10000 / 1000;//取千位数
        int[] arr = {d, c, b, a};//将四位数字存入数组
        String result = "";

        //加密：每一位加5取余再反转
        int[] temp = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (arr[i] + 5) % 10;
        }
        for (int i = 0; i < arr.length; i++) {
            temp[i] = arr[arr.length - 1 - i];
        }
        arr = temp;
        for (int i = 0; i < arr.length; i++) {
            result += arr[i];
        }
        return result;
    }

    //方法：数字解密
    public static String decrypt(int num) {
        System.out.println("请输入加密后的数字：");

        int a = num % 10;//取个位数
        int b = num % 100 / 10;//取十位数
        int c = num % 1000 / 100;//取百位数
        int d = num % 10000 / 1000;//取千位数
        int[] arr = {d, c, b, a};//将四位数字存入数组
        String result = "";

        //解密：先反转再每一位减5取余
        int[] temp = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            temp[i] = arr[arr.length - 1 - i];
        }
        arr = temp;
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (arr[i] - 5 + 10) % 10;
            result += arr[i];
        }
        return result;
    }

回顾：
①数组元素的反转、交换是按照什么完成的？反转数组，就是对数组中的元素，按照前后位置，依次交换数据。
②如果一个方法里要做的事比较多，我们在开发中一般会怎么做？一般会把多个事拆成多个方法去完成，也就是独立功能独立成一个方法。

5、案例：数组拷贝

需求：把一个整型数组，控制台输入数据，例如输入[11，22，33]，拷贝出来一个一模一样的数组出来。
分析：
①方法接收数据？需要接收一个整型数组（原数组）
②方法返回数据？需要返回一个新的、一模一样的整型数组
③方法内部业务？==创建一个长度一样的整形数组做为新数组，并把原数组的元素对应位置赋值给新数组，最终返回新数组即可。
解决：
代码：

//主程序：数组拷贝
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入需要拷贝的数组长度：");
        int length = scanner.nextInt();
        System.out.println("请输入需要拷贝的数组：");
        int[] originalArray = new int[length];
        for (int i = 0; i < length; i++) {
            originalArray[i] = scanner.nextInt();
        }
        System.out.println("原始数组为：");
        for (int i = 0; i < length; i++) {
            System.out.print(originalArray[i] + " ");
        }
        System.out.println();
        System.out.println("原始数组的地址为：");
        System.out.println(originalArray);

        //调用数组拷贝方法
        int[] copyArray = copyArray(originalArray);
        //打印拷贝后的数组
        System.out.println("拷贝后的数组为：");
        for (int i = 0; i < length; i++) {
            System.out.print(copyArray[i] + " ");
        }
        System.out.println();
        //打印拷贝后的数组地址
        System.out.println("拷贝后的数组的地址为：");
        System.out.println(copyArray);
    }
    //方法：数组拷贝
    public static int[] copyArray(int[] originalArray) {
        int[] copyArray = new int[originalArray.length];
        for (int i = 0; i < originalArray.length; i++) {
            copyArray[i] = originalArray[i];
        }
        return copyArray;
    }

回顾：拷贝数组的意思是创建出一个与原数组一模一样的数组出来。

6、案例：抢红包

需求：一个抢红包的活动，分别有：1、22、333、4、5555 五个红包。请模拟有人来抽奖，按照先来先得，随机抽取，抽完即止，注意：一个红包只能被抽一次，先抽或后抽哪一个红包是随机的，示例如下（不一定是下面的顺序）
分析：
①方法接收数据？需要接收一个数组来表示五个红包
②方法返回数据？不需要
③方法内部业务？
–第一种：写个 for 循环控制抽奖，每一次都从数据中数据找一个金额，如果该金额不是 0，则代表抽中，接着用 for 循环控制抽奖，然后继续下一个粉丝的抽奖；如果抽中的金额发现是 0，代表该位置处的奖已经被抽走，则重新从数组中随机找出一个金额继续判断！直至抽中的金额不是 0 ！
–第二种：先把数组里面的 5 个金额打乱顺序，打乱后的顺序就认为是中将顺序；接着，写个 for 循环，执行 5 次，每次都提示抽奖；每次抽奖，都依次取出数组中的每个位置处的金额作为中奖金额即可。
解决：（哇靠，我自己干了两个点，要学习的东西还是太多了）
代码：

//主程序：抢红包
    public static void main(String[] args) {
        int[] redPacket1 = {1, 22, 333, 4, 5555};
        int[] redPacket2 = {1, 22, 333, 4, 5555};

        System.out.println("调用方法1抢到的红包如下：");
        getRedPacket1(redPacket1);//调用方法1：抢红包

        System.out.println("---------------分割线----------------");

        System.out.println("调用方法2抢到的红包如下：");
        getRedPacket2(redPacket2);//调用方法2：抢红包
    }
    //方法1：抢红包
    public static void getRedPacket1(int[] redPacket) {
        int[] temp1 = new int[redPacket.length];
        for (int i = 0; i < redPacket.length; i++) {
            Random random = new Random();
            int num = random.nextInt(redPacket.length);
            while (redPacket[num] == 0) {
                num = random.nextInt(redPacket.length);
            }
            temp1[i] = redPacket[num];
            redPacket[num] = 0;
            System.out.println("恭喜" + (i + 1) + "号抽到了红包" + temp1[i] + "元！");
        }
    }
    //方法2：抢红包
    public static void getRedPacket2(int[] redPacket) {
        Random random = new Random();
        int[] temp2 = new int[redPacket.length];
        for (int i = 0; i < redPacket.length; i++) {
            int index = random.nextInt(redPacket.length);
            while (redPacket[index] == 0) {
                index = random.nextInt(redPacket.length);
            }
            temp2[i] = redPacket[index];
            redPacket[index] = 0;
            System.out.println("恭喜" + (i + 1) + "号抽到了红包" + temp2[i] + "元！");
        }
    }

回顾：抢红包的两种实现方案，哪种方式可能更好一些？
①第1种：每次抽奖都从数组中，随机找出一个金额，如果该金额不是0，就输出该金额，然后用0替换该位置处的金额；如果该位置是0，则重复上一步操作！
②第2种：打乱奖金的顺序，再依次发给粉丝。遍历数组中的每个位置，每遍历到一个位置，都随机一个索引值出来，让当前位置与该索引位置处的数据进行交换。

7、案例：找素数

需求：判断 101-200 之间有多少个素数，并输出所有素数。（说明：除了 1 和它本身以外，不能被其他正常整数整除，就叫素数，比如 3、7 就是素数，而 9、21 等等不是素数）
分析：
①方法接收数据？需要接收 101 以及 200，以便找该区间中的素数
②方法返回数据？需要返回找到的素数个数
③方法内部业务？使用 for 循环来产生如 101 到 200 之间的每个数；每拿到一个数，判断该数是否是素数；判断规则是：从 2 开始遍历到该数的一半的数据，看是否有数据可以整除它，有则不是素数，没有则是素数；根据判定的结果来决定是否输出这个数据（是素数则输出）；最后还需要统计素数的个数并返回
解决：
代码：

//主程序：判断是否为素数
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int count = 0;
        System.out.print("请输入第一个正整数：");
        int a = scanner.nextInt();
        System.out.print("请输入第二个正整数：");
        int b = scanner.nextInt();

        //调用方法：判断是否为素数
        count = isPrime(a, b);
        System.out.println("共有" + count + "个素数！");
    }
    //方法：判断是否为素数
    public static int isPrime(int a, int b) {
        int count = 0;
        for (int i = a; i <= b; i++) {
            int flag = 1;
            for (int j = 2; j <= i / 2; j++) {
                if (i % j == 0) {
                    flag = 0;
                    break;
                }
            }
            if (flag == 1) {
                count++;
            }
        }
        return count;
    }

回顾：本次案例中是如何确定出该数是素数的，具体如何实现？
①定义了 flag 标记位
②遍历 2 到该数的一半的数据去判断是否有整除的数据，有则改变 falg 标记位的状态
③最终通过 flag 的状态判断是否是素数。

8、案例：模拟双色球

需求：模拟双色球，投注号码由 6 个红色球号码和 1 个蓝色球号码组成。红色球号码从 1-33 中选择：蓝色球号码从 1-16 中选择。双色球中奖条件和奖金表如下所示：

奖励等级	中奖条件		中奖说明	奖品
奖励等级	红球	蓝球	中奖说明	奖品
一等奖	6个	1个	中 6+1	最高10000万元
二等奖	6个	0个	中 6+0	最高500万元
三等奖	5个	1个	中 5+1	3000元
四等奖	5个	0个	中 5+0	200元
四等奖	4个	1个	中 4+1	200元
五等奖	4个	0个	中 4+0	10元
五等奖	3个	1个	中 3+1	10元
六等奖	2个	1个	中 2+1	5元
	1个	1个	中 1+1
	0个	1个	中 0+1

分析：（这次分析我们换个角度）
①用户投注一组号码；
②随机生成一组中奖号码；
③判断中奖情况。
注意：6 个红球号码的范围是 1-33 之间，且不能重复：1 个蓝色球号码的范围在：1-16 之间。
解决：
代码：

//主程序：模拟双色球
    public static void main(String[] args) {
        int[] userNumbers = userSelectNumbers();
        int[] luckNumbers = createLuckNumbers();
        judge(userNumbers, luckNumbers);
    }
    //方法：用户选择号码，用于让用户投注一组号码（前 6 个是红球，最后 1 个是蓝球），并返回用户投注的号码
    public static int[] userSelectNumbers() {
        System.out.println("欢迎来到双色球！");
        System.out.println("双色球规则为：每注由 6 个红球号码和 1 个蓝球号码组成，共 7 个号码。请注意：6 个红球号码的范围是在 1-33 之间，且不能重复；1个蓝球号码的范围是在 1-16 之间。");
        int[] userNumbers = new int[7];
        int redflag = 0;
        int repeatflag = 0;
        int blueflag = 0;

        Scanner scanner = new Scanner(System.in);


        System.out.println("请输入您要投注的6个红球号码：");
        int[] redUserNumbers = new int[6];
        Scanner redUserScanner = new Scanner(System.in);
        //判断用户输入的红球号码是否有效
        while (redflag == 0 || repeatflag == 0) {
            for (int i = 0; i < 6; i++) {
                redUserNumbers[i] = redUserScanner.nextInt();
            }
            //判断红球是否在有效范围内
            for (int i = 0; i < 6; i++) {
                if (redUserNumbers[i] < 1 || redUserNumbers[i] > 33) {
                    System.out.println("输入的红球号码有误，请重新输入！");
                    redflag = 0;
                    break;
                } else {
                    redflag = 1;
                }
            }
            //判断红球是否有重复的号码
            if (isRepeat(redUserNumbers) == 1) {
                System.out.println("输入的红球号码有重复，请重新输入！");
                repeatflag = 0;
            } else {
                repeatflag = 1;
            }
        }
        for (int i = 0; i < redUserNumbers.length; i++) {
            userNumbers[i] = redUserNumbers[i];
        }

        System.out.println("请输入您要投注的1个蓝球号码：");
        int blueUserNumber = 0;
        //判断用户输入的蓝球号码是否有效
        while (blueflag == 0) {
            blueUserNumber = scanner.nextInt();
            if (blueUserNumber < 1 || blueUserNumber > 16) {
                System.out.println("输入的蓝球号码有误，请重新输入！");
                blueflag = 0;
            } else {
                blueflag = 1;
            }
        }
        userNumbers[6] = blueUserNumber;

        System.out.println("您投注的号码为：");
        for (int i = 0; i < userNumbers.length; i++) {
            System.out.print(userNumbers[i] + " ");
        }
        System.out.println();
        return userNumbers;
    }
    //方法：生成随机号码，系统生成一组随机的号码（前 6 个是红球，最后 1 个事蓝球），并返回这组中奖号码
    public static int[] createLuckNumbers() {
        int[] luckNumbers = new int[7];
        int redflag = 0;
        int repeatflag = 0;
        int blueflag = 0;

        Random random = new Random();

        //生成红球号码
        int[] redLuckNumbers = new int[6];
        //判断用户输入的红球号码是否有效
        while (redflag == 0 || repeatflag == 0) {
            for (int i = 0; i < 6; i++) {
                redLuckNumbers[i] = random.nextInt(33) + 1;
            }
            //判断红球是否在有效范围内
            for (int i = 0; i < 6; i++) {
                if (redLuckNumbers[i] < 1 || redLuckNumbers[i] > 33) {
                    redflag = 0;
                    break;
                } else {
                    redflag = 1;
                }
            }
            //判断红球是否有重复的号码
            if (isRepeat(redLuckNumbers) == 1) {
                repeatflag = 0;
            } else {
                repeatflag = 1;
            }
        }
        //生成蓝球号码
        int blueLuckNumber = 0;
        //判断用户输入的蓝球号码是否有效
        while (blueflag == 0) {
            blueLuckNumber = random.nextInt(16) + 1;
            if (blueLuckNumber < 1 || blueLuckNumber > 16) {
                blueflag = 0;
            } else {
                blueflag = 1;
            }
        }
        //将红球号码和蓝球号码存入数组
        for (int i = 0; i < 6; i++) {
            luckNumbers[i] = redLuckNumbers[i];
        }
        luckNumbers[6] = blueLuckNumber;

        System.out.println("系统生成的号码为：");
        for (int i = 0; i < luckNumbers.length; i++) {
            System.out.print(luckNumbers[i] + " ");
        }
        System.out.println();
        return luckNumbers;
    }
    //方法：判断两组号码，用来判断用户投注号码的中奖情况，并输出结果
    public static void judge(int[] userNumbers, int[] luckNumbers) {
         int redCount = 0;
         int blueCount = 0;

         //判断红球
         for (int i = 0; i < 6; i++) {
             for (int j = 0; j < 6; j++) {
                 if (userNumbers[i] == luckNumbers[j]) {
                     redCount++;
                 }
             }
         }
         //判断蓝球
         if (userNumbers[6] == luckNumbers[6]) {
             blueCount = 1;
         }
         //输出结果
        if (redCount == 6 && blueCount == 1) {
            System.out.println("恭喜您获得一等奖！奖品10000万元！");
        } else if (6 == redCount && 0 == blueCount) {
            System.out.println("恭喜您获得二等奖！奖品500万元！");
        } else if (5 == redCount && 1 == blueCount) {
            System.out.println("恭喜您获得三等奖！奖品3000元！");
        } else if ((5 == redCount && 0 == blueCount) || (4 == redCount && 1 == blueCount)) {
            System.out.println("恭喜您获得四等奖！奖品200元！");
        } else if ((4 == redCount && 0 == blueCount) || (3 == redCount && 1 == blueCount)) {
            System.out.println("恭喜您获得五等奖！奖品10元！");
        } else if ((2 == redCount && 1 == blueCount) || (1 == redCount && 1 == blueCount) || (0 == redCount && 1 == blueCount)) {
            System.out.println("恭喜您获得六等奖！奖品5元！");
        } else {
            System.out.println("很遗憾，您没有中奖！");
        }
    }
    //方法：判断红球中是否有重复的号码
    public static int isRepeat(int[] redNumbers) {
        int repeatFlag = 0;
        for (int i = 0; i < redNumbers.length; i++) {
            for (int j = i + 1; j < redNumbers.length; j++) {
                if (redNumbers[i] == redNumbers[j]) {
                    repeatFlag = 1;
                    break;
                }
            }
        }
        return repeatFlag;
    }

回顾：
①案例中是如何去保证用户投注的 6 个红球号码不重复的？每次用户投注红球号码后，都去判断一下是否有号码重复，如果有重复，让用户重新选号。
②案例中是如何去保证随机的 6 个中奖的红球号码不重复的？每次随机 1-33 之间的红球号码后，都去判断这个号码是否有重复，如果有重复，让用户重新选号。
③案例中是如何去统计用户投注的红球的命中数量的？遍历用户选择的每个红色号码，每遍历一个红球号码时，都去遍历中奖号码数组中的全部红球号码，看当前选的红球号码是否在中奖号码中存在，存在则红球命中数量加1。

原文地址：https://blog.csdn.net/fengguu/article/details/143499288

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：在CentOS 7上安装Alist
下一篇：信息宣传投稿栽跟头不可怕，关键是你要能再站起来

FPGA 第7讲简单组合逻辑译码器
经过验证对比发现两种方法虽然最后实现的功能是一样的，而所得到的 RTL 视图差别较大，但最后的逻辑资源使用却是相同的（时序逻辑中不一定相同），说明综合器进行了适当的优化。if-else 的这种写法是存
阅读更多2024-11-16
梧桐杯初赛入围（人工智能赛道） 15 / 100
本项目开发了一套先进的医疗问答系统，该系统融合了 Reinforced Attention Generator (RAG) 技术与大模型，旨在通过精确的知识检索和问答生成技术，显著提升心理健康咨询系统
阅读更多2024-11-16
faiss 提供了多种索引类型
faiss 多种索引类型
阅读更多2024-11-16
物联网低功耗广域网LoRa开发(二)：LoRa开发环境搭建及驱动移植
【代码】物联网低功耗广域网LoRa开发(二)：LoRa开发环境搭建及驱动移植。
阅读更多2024-11-16
【隐私计算】隐私计算的应用场景探索(大模型隐私计算、隐私数据存储计算、Web3、隐私物联网等)
隐私计算、隐私保护、大模型安全、大模型隐私推理、数据安全、数据隐私、web3、分布式网络、去中心化网络、隐私数据存储、大厂数据保护、隐私计算应用探索
阅读更多2024-11-16
EHOME视频平台EasyCVR多品牌摄像机视频平台监控视频编码H.265与Smart 265的区别？
Smart 265和Smart 264的区别是一个是在H.264编码基础上，一个是在H.265编码基础上，其作用都是在当前码率参数下进一步节省码流，如果你摄像头图像上运动画面越少，静止画面越多，则码率
阅读更多2024-11-16
软件测试基础二十九（接口测试 mock）
软件测试基础之接口测试 mock
阅读更多2024-11-16
《FreeRTOS任务基础知识以及任务创建相关函数》
FreeRTOS学习日志（4）--FreeRTOS任务基础知识以及任务创建相关函数
阅读更多2024-11-16
dlopen: cannot load any more object with static TLS & sklearn, HPOBench, smac3
成功解决：升级glibc版本到2.23。
阅读更多2024-11-16
2024年11月15日Github流行趋势
项目名称：MinerU项目名称：exo项目名称：nvm项目名称：kotaemon项目名称：VideoLingo项目名称：motion项目名称：primeng项目名称：bbot项目名称：es-toolk
阅读更多2024-11-16

专题——编程案例

一、目的

二、案例

1、案例：买机票

2、案例：开发验证码

3、案例：评委打分

4、案例：数字加密

5、案例：数组拷贝

6、案例：抢红包

7、案例：找素数

8、案例：模拟双色球

相关文章