专题——编程案例

一、目的

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

二、案例

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-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。