java打印数组、数字加密和双色球系统开发

ZQCJL

已于 2022-07-21 10:57:15 修改

阅读量594

点赞数

文章标签： java 数据结构算法

于 2022-07-19 17:39:32 首次发布

本文链接：https://blog.csdn.net/ZQCJL/article/details/125874644

版权

打印整型数组内容

需求：
设计一个方法用于输出任意整型数组的内容，要求输出成如下格式：
“该数组内容为：[11，22，33，44，55]”
分析：
1.定义一个方法，要求该方法能够接收数组，并输出数组内容。（考虑是否需要参数？是否需要返回值类型申明？）
2.定义一个静态初始化的数组，调用该方法，并传入该数组。

 public static void main(String[] args) {
        int[] arrs = {11, 22, 33, 44, 55};
        change(arrs);
        int[] arrs1 =null;
        change(arrs1);
    }

    public static void change(int[] arr) {
        System.out.print("[");
        //第一种方法
        if (arr !=null && arr.length>0) {
            for (int i = 0; i < arr.length; i++) {
//            if(i== arr.length-1){
//                System.out.print(arr[i]);
//            }else {
//                System.out.print(arr[i]+",");
//            }
//
//        }
                //第二种方法
                System.out.print(i == arr.length - 1 ? arr[i] : arr[i] + ",");
            }
        }
        System.out.println("]");
        }

数字加密

需求：
某系统的数字密码：比如1983，采用加密方式进行传输，规则如下：先得到每位数，然后每位数都加上5，再对10求余，最后将所有数字反转，得到一串新数。
分析：
1.将每位数据存入到数组中去，遍历数组每位数据按照规则进行更改，把更改后的数据从新存入到数组中。
2.将数组的前后元素进行交换，数组中的最终元素就是加密后的结果。

public static void main(String[] args) {
        //1.定义一个数组存入需要加密的数据
        System.out.println("请您输入需要加密的数字个数");
        Scanner sc = new Scanner(System.in);
        int length = sc.nextInt();
        int[] arr = new int[length];

        //2.录入需要加密的数字
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请您输入加密的第"+(i+1)+"个数字");
            int number = sc.nextInt();
            arr[i] = number;
        }

        //3.打印数组内容，调用方法
        printArray(arr);

        //4.核心逻辑：对数组中的数据进行加密
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (arr[i] + 5) % 10;
        }
        //5.核心逻辑，对数组中加密的数据进行反转，才是最终加密的结果 arr=[6,4,3,8]
        //                                                     i      j
        for (int i = 0,j = arr.length-1 ; i < j; i++ , j--) {
            //直接交换两者的位置的值即可
            int temp = arr[j];
            arr[j] = arr[i];
            arr[i] = temp;
        }
        printArray(arr);
    }

    public static void printArray(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(i == arr.length-1 ? arr[i] : arr[i]+",");
        }
        System.out.println("]");
    }

双色球系统开发

随机生成一组中奖号码

分析：
1.中奖号码由6个红球和一个蓝球组成（6个红球要求不能重复）
2.可以定义方法用于返回一组中将号码（7个数据），返回的形式是一个整型数组。

 public static int[] createLuckNumber(){
        //a.定义一个动态初始化的数组，存储7个数字
        int[] numbers = new int[7];//[12,23,0,0,0,0,| 0]
        //                             j     i
        //b.遍历数组，为每个位置生成对应的号码。（注意：遍历前6个位置，生成6个不重复的红球号码，范围是1-33）
        Random r = new Random();
        for (int i = 0; i < numbers.length-1; i++) {
            //为当前位置找出一个不重复的1-33之间的数字
            while (true){
                int data = r.nextInt(33)+1;//1-33===(0-32)+1

                //c.注意：必须判断当前随机的这个号码之前是否出现过，出现过要重新随机一个，直到不重复为止，才可以存入数组中去。
                //定义一个flag变量，默认认为data是没有重复的
                boolean flag = true;
                for (int j = 0; j < i; j++) {
                    if (numbers[j]==data){
                        //data当前这个数据之前出现过，不能用
                        flag = false;
                        break;
                    }
                }
                if (flag){
                    //data这个数据之前没有出现过，可以使用
                    numbers[i]=data;
                    break;
                }
            }
        }
        //d.为第七个位置生成一个1-16的号码作为蓝球号码
        numbers[6] = r.nextInt(16)+1;
        return numbers;
    }

用户输入一组双色球号码

分析：
1.定义一个方法，该方法可以录入用户输入的6个红球和1个蓝球号码。
2.该方法最终需要返回一个数组，数组中就是用户录入的号码（7位）。

public static int[] userInputNumbers(){
        //a.定义一个数组存储7个数据
        int[] numbers = new int[7];
        //b.让用户录入6个红球号码
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < numbers.length-1; i++) {
            System.out.println("请您输入第"+(i + 1)+"个红球号码（1-33），要求不重复");
            int data = sc.nextInt();
            //c.把当前输入的数据存入到数组中去
            numbers[i] = data;
        }

        //d.单独录入一个蓝球号码
        System.out.println("请您输入蓝球号码（1-16）：");
        numbers[6] = sc.nextInt();
        return numbers;
    }

判断中奖情况

分析
1.定义一个方法，可以接收中奖号码的数组，用户选号的数组。
2.根据命中红球数和蓝球数判断最终的中奖情况并输出详情和中奖金额。

public static void judge(int[] LuckyNumbers,int[] userNumbers) {
        //判断是否中奖了
        //随便举个例子 LuckyNumbers=[12,23,8,16,15,32,  9]
        //           userNumbers=[23,13,18,6,8,33     10]
        //1.定义2个变量分别存储红球命中个数，以及蓝球命中的个数。
        int redHitNumbers = 0;
        int blueHitNumbers = 0;

        //2.判断红球命中了几个，开始统计
        for (int i = 0; i < userNumbers.length - 1; i++) {
            for (int j = 0; j < LuckyNumbers.length - 1; j++) {
                //每次找到了相等了，意味着当前号码命中了
                if (userNumbers[i] == LuckyNumbers[i]) {
                    redHitNumbers++;
                    break;
                }
            }
        }
        blueHitNumbers = LuckyNumbers[6] == userNumbers[6] ? 1 : 0;

        System.out.println("中奖号码是：");
        printArray(LuckyNumbers);
        System.out.println("您投注号码是：");
        printArray(userNumbers);
        System.out.println("您命中了几个红球："+redHitNumbers);
        System.out.println("您是否命中蓝球："+(blueHitNumbers ==1 ? "是":"否"));

        if (blueHitNumbers == 1 && redHitNumbers < 3) {
            System.out.println("恭喜您，中了5元小奖");
        } else if (blueHitNumbers == 1 && redHitNumbers == 3
                || blueHitNumbers == 0 && redHitNumbers == 4) {
            System.out.println("恭喜您，中了10元小奖");
        } else if (blueHitNumbers == 1 && redHitNumbers == 4
                || blueHitNumbers == 0 && redHitNumbers == 5) {
            System.out.println("恭喜您，中了200元");
        } else if (blueHitNumbers == 1 && redHitNumbers == 5) {
            System.out.println("恭喜您，中了3000元大奖");
        } else if (blueHitNumbers == 0 && redHitNumbers == 6) {
            System.out.println("恭喜您，中了500万大奖");
        } else if (blueHitNumbers == 1 && redHitNumbers == 6) {
            System.out.println("恭喜您，中了1000万元大奖");
        }else {
            System.out.println("感谢您为福利事业做出的突出贡献！");
        }
    }

    public static void printArray(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.println();//换行
    }

把所有的合起来最终的代码

  public static void main(String[] args) {
        //1.随机6个红球号码（1-33，不能重复），随机一个蓝球号码（1-16），可以采用数组装起来作为中奖号码
        int[] LuckyNumbers = createLuckNumber();


        //2.调用一个方法让用户输入7个号码，作为用户选号
        int[] userNumbers = userInputNumbers();

        //3.中奖情况
        judge(LuckyNumbers,userNumbers);
    }

    public static void judge(int[] LuckyNumbers,int[] userNumbers) {
        //判断是否中奖了
        //随便举个例子 LuckyNumbers=[12,23,8,16,15,32,  9]
        //           userNumbers=[23,13,18,6,8,33     10]
        //1.定义2个变量分别存储红球命中个数，以及蓝球命中的个数。
        int redHitNumbers = 0;
        int blueHitNumbers = 0;

        //2.判断红球命中了几个，开始统计
        for (int i = 0; i < userNumbers.length - 1; i++) {
            for (int j = 0; j < LuckyNumbers.length - 1; j++) {
                //每次找到了相等了，意味着当前号码命中了
                if (userNumbers[i] == LuckyNumbers[i]) {
                    redHitNumbers++;
                    break;
                }
            }
        }
        blueHitNumbers = LuckyNumbers[6] == userNumbers[6] ? 1 : 0;

        System.out.println("中奖号码是：");
        printArray(LuckyNumbers);
        System.out.println("您投注号码是：");
        printArray(userNumbers);
        System.out.println("您命中了几个红球："+redHitNumbers);
        System.out.println("您是否命中蓝球："+(blueHitNumbers ==1 ? "是":"否"));

        if (blueHitNumbers == 1 && redHitNumbers < 3) {
            System.out.println("恭喜您，中了5元小奖");
        } else if (blueHitNumbers == 1 && redHitNumbers == 3
                || blueHitNumbers == 0 && redHitNumbers == 4) {
            System.out.println("恭喜您，中了10元小奖");
        } else if (blueHitNumbers == 1 && redHitNumbers == 4
                || blueHitNumbers == 0 && redHitNumbers == 5) {
            System.out.println("恭喜您，中了200元");
        } else if (blueHitNumbers == 1 && redHitNumbers == 5) {
            System.out.println("恭喜您，中了3000元大奖");
        } else if (blueHitNumbers == 0 && redHitNumbers == 6) {
            System.out.println("恭喜您，中了500万大奖");
        } else if (blueHitNumbers == 1 && redHitNumbers == 6) {
            System.out.println("恭喜您，中了1000万元大奖");
        }else {
            System.out.println("感谢您为福利事业做出的突出贡献！");
        }
    }

    public static void printArray(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
        System.out.println();//换行
    }

    public static int[] userInputNumbers(){
        //a.定义一个数组存储7个数据
        int[] numbers = new int[7];
        //b.让用户录入6个红球号码
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < numbers.length-1; i++) {
            System.out.println("请您输入第"+(i + 1)+"个红球号码（1-33），要求不重复");
            int data = sc.nextInt();
            //c.把当前输入的数据存入到数组中去
            numbers[i] = data;
        }

        //d.单独录入一个蓝球号码
        System.out.println("请您输入蓝球号码（1-16）：");
        numbers[6] = sc.nextInt();
        return numbers;
    }

    public static int[] createLuckNumber(){
        //a.定义一个动态初始化的数组，存储7个数字
        int[] numbers = new int[7];//[12,23,0,0,0,0,| 0]
        //                             j     i
        //b.遍历数组，为每个位置生成对应的号码。（注意：遍历前6个位置，生成6个不重复的红球号码，范围是1-33）
        Random r = new Random();
        for (int i = 0; i < numbers.length-1; i++) {
            //为当前位置找出一个不重复的1-33之间的数字
            while (true){
                int data = r.nextInt(33)+1;//1-33===(0-32)+1

                //c.注意：必须判断当前随机的这个号码之前是否出现过，出现过要重新随机一个，直到不重复为止，才可以存入数组中去。
                //定义一个flag变量，默认认为data是没有重复的
                boolean flag = true;
                for (int j = 0; j < i; j++) {
                    if (numbers[j]==data){
                        //data当前这个数据之前出现过，不能用
                        flag = false;
                        break;
                    }
                }
                if (flag){
                    //data这个数据之前没有出现过，可以使用
                    numbers[i]=data;
                    break;
                }
            }
        }
        //d.为第七个位置生成一个1-16的号码作为蓝球号码
        numbers[6] = r.nextInt(16)+1;
        return numbers;
    }