Java-基础练习(1)

一、逢7过

package com.nsys;

/**
 * @Author: nsys
 * @Date: 2021-10-05 15:20
 * @Description: 逢7过
 */
public class MethodDemo6 {
    public static void main(String[] args) {
        sevenSkip();
    }

    public static void sevenSkip() {
        for (int i = 1; i <= 100; i++) {
            /**
             *  7的倍数：i % 7 == 0
             *  数字包含7：
             *      -个位：i %10==7
             *      -十位：i/10%10==7
             *
             */
            if (i % 7 == 0 || i / 10 % 10 == 7 || i % 10 == 7) {
                System.out.println(i + "：过过过");
            } else {
                System.out.println(i);
            }
        }
    }
}

二、不死神兔

package com.nsys;

/**
 * @Author: nsys
 * @Date: 2021-10-05 15:54
 * @Description: 不死兔
 */
public class MethodDemo7 {
    /*
    *   从出生第3个月起，每个月都生一对兔子
    *   小兔子长到第三个月后每个月也生一对兔子
    *   问，第20个月的兔子对数是多少。
    *
    *   用数组模拟规律：
    *   arr[0] = 1;
    *   arr[1] = 1;
    *   arr[2] = a[0] + a[1];
    *   arr[3] = a[1] + a[2];
    *   ...
    * */
    public static void main(String[] args) {
        // 动态初始化数组,数组长度为20
        int[] arr = new int[20];

        // 初始化数组的值
        arr[0] = 1;
        arr[1] = 1;
//        System.out.println(arr[19]);
        System.out.println(arr.length);
        // for循环
        for (int i = 2; i < arr.length ; i++){
            arr[i] = arr[i-2] + arr[i-1];
        }
        System.out.println("第20个月的兔子对数是：" + arr[19]);
    }
}

三、百钱百鸡

package com.nsys;

/**
 * @Author: nsys
 * @Date: 2021-10-05 16:43
 * @Description: 百钱百鸡
 */
public class MethodDemo8 {
    /*
     *   公鸡5块钱，母鸡3块钱，三只小鸡1块钱
     *   100块钱可以买100只鸡
     *   x + y + z =100
     *   5*x + 3*y + 1/3*z =100
     *   取值范围：
     *   0 <= x <= 20
     *   0 <= y <= 33
     *   0 <= z <= 100
     *
     * */
    public static void main(String[] args) {
        for (int x = 0; x <= 20; x++) {
            for (int y = 0; y <= 33; y++) {
                for (int z = 0; z <= 100; z++) {
                    if (x + y + z == 100 && 15 * x + 9 * y + z == 300) {
                        System.out.println("x:" + x + " y:" + y + " z:" + z);
                    }
                }
            }
        }
    }
}

四、数组求和

package com.nsys;

/**
 * @Author: nsys
 * @Date: 2021-10-05 17:06
 * @Description: 数组元素求和
 */
public class MethodDemo9 {
    /*
     *   数组{68,27,95,88,171,966,51,210}
     *   求和，要求元素的个位和十位不能是7，并且只能是偶数
     *
     * */
    public static void main(String[] args) {
        // 静态初始化数组
        int[] arrTest = {68, 27, 95, 88, 171, 996, 51, 210};
        arrCount(arrTest);
    }

    public static void arrCount(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 2 == 0 && arr[i] % 10 != 7 && arr[i] / 10 % 10 != 7) {
                sum += arr[i];
            }
        }
        System.out.println("和为:" + sum);
    }
}

五、数组内容是否相同

package com.nsys;

/**
 * @Author: nsys
 * @Date: 2021-10-05 17:18~2021年10月5日20:01:58
 * @Description: 数组内容是否相同
 */
public class MethodDemo10 {
    /*
    *   先判断数组长度是否相同
    *   再判断数组的值是否相同
    * */
    public static void main(String[] args) {
        // 静态初始化两个数组
        int[] arrTest1 = {11,22,33,44,55};
        int[] arrTest2 = {11,22,33,44,55};
        arrayCom(arrTest1,arrTest2);

    }

    // 创建一个数组对比的方法
    public static void arrayCom(int[] firArr,int[] thirdArr){
        if (firArr.length != thirdArr.length){
            System.out.println("两个数组长度不相等");
        }
        for (int i=0; i<firArr.length;i++) {
            if (firArr[i] != thirdArr[i]) {
                System.out.println("两个数组值不相等");
                break;
            } else if (firArr[i] == thirdArr[i] && i == firArr.length - 1) {
                System.out.println("数组相等");
            }
        }
    }
}

六、查找

package com.nsys;

/**
 * @Author: nsys
 * @Date: 2021-10-05 20:03
 * @Description: 查找数组中的数据，返回索引
 */
public class MethodDemo11 {
    public static void main(String[] args) {
        arrayFind(18);

    }
    // 定义一个方法查找
    public static void arrayFind(int num){
        // 初始化静态数组
        int[] arr = {18,22,33,11,33};
        for (int i=0;i<arr.length;i++){
            if (arr[i] == num){
                System.out.println("找到数组的值，索引为:" + i);
            }
        }
    }
}

七、反转

package com.nsys;

/**
 * @Author: nsys
 * @Date: 2021-10-05 20:10
 * @Description: 反转
 */
public class MethodDemo12 {
    public static void main(String[] args) {
        // 静态数组初始化
        int[] arrTest = {1, 2, 3, 4, 5};
        // 打印最开始的数组
        printArray(arrTest);
        // 打印倒换的数组
        reverse(arrTest);


    }

    /*
     *   打印数组的方法
     * */
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            if (i == 0) {
                System.out.print("[" + arr[i] + ",");
            } else if (i == arr.length - 1) {
                System.out.println(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ",");
            }
        }
    }

    /*
     *   数组位置交换
     * */
    public static void reverse(int[] arr) {
        // for循环将数组值输出来
        for (int i = 0; i < arr.length; i++) {
            // 判定，当开始值小于等于结束值时，进行数值交换
            if (i <= arr.length - i - 1) {
                int temp = arr[i];
                arr[i] = arr[arr.length - i - 1];
                arr[arr.length - i - 1] = temp;
            }
        }
        // for循环结束后，调用打印数组方法
        printArray(arr);
    }

    /*
        数组位置交换，方式2，简洁点
     */
    public static void reverse2(int[] arr) {
        for (int start=0,end=arr.length-1;start<=end;start++,end--){
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        // for循环结束后，调用打印数组方法
        printArray(arr);
    }
}

八、评委打分

package com.nsys;

import java.util.Scanner;

/**
 * @Author: nsys
 * @Date: 2021-10-05 21:13
 * @Description: 评委打分
 */
public class MethodDemo13 {
    /*
        评委打分：
            6名评委打分，0-100
            去掉最高分，去掉最低分，取平均值

        心路历程：
            本题难点在于处理数组中的最值，
            在Python中可以直接把对应值移除掉，
            但是Java不知道有没有类似方法，反正目前还没有学到，
            所以，最开始的想法是，拿到最值后，重新动态初始化数组，再赋值
            但是这样太麻烦了，
            后面想到不如拿到最值的索引值，在计算平均值时跳过最值的索引。

        写完了：
            突然发现，其实我获取到了最值，最后求和再把最值减去也可
     */
    public static void main(String[] args) {

        // 测试数据
        //int[] arrTest = {99,96,98,95,98,96};

        // 动态初始化数组
        int[] arrTest = new int[6];
        // 创建Scanner对象
        Scanner sc = new Scanner(System.in);
        // for循环接收数据
        for (int i=0;i<arrTest.length;i++){
            System.out.println((i + 1) + "号评委，请输入评分：");
            arrTest[i] = sc.nextInt();
        }

        giveScore(arrTest);

    }

    // 最大值索引
    public static int maxScore(int[] arr) {
        int maxNum = arr[0];
        int maxNumIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > maxNum) {
                maxNum = arr[i];
                maxNumIndex = i;
            }
        }
        return maxNumIndex;
    }
    // 最小值索引
    public static int minScore(int[] arr) {
        int minNum = arr[0];
        int minNumIndex = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < minNum) {
                minNum = arr[i];
                minNumIndex = i;
            }
        }
        return minNumIndex;
    }



    // 处理数组
    public static void giveScore(int[] arr) {
        // 接收数组的最值索引值
        int maxNumIndex = maxScore(arr);
        int minNumIndex = minScore(arr);

        // 初始化总评分
        int count = 0;
        for (int i=0 ; i < arr.length;i++){
            // 判断，跳过最值求和计算
            if (i !=maxNumIndex && i!=minNumIndex){
                count += arr[i];
            }
        }
        // arr.length-2，长度减2的好处是，以后再增加评委就不用改这里了
        System.out.println("6位评审，去掉最高分，去掉最低分，平均分为：" + count/(arr.length-2));
    }
}