/*
    2. 从键盘读入学生成绩，找出最高分，
    并输出学生成绩等级。
    成绩>=最高分-10 等级为’A’
    成绩>=最高分-20 等级为’B’
    成绩>=最高分-30 等级为’C’
    其余 等级为’D’
    提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
     */

package com.jerry.exer;
import java.util.Arrays;
import java.util.Scanner;
/**
 * @author jerry_jy
 * @create 2022-09-21 11:02
 */
public class Exer2 {
    public static void main(String[] args) {
        System.out.println("请输入学生人数：");
        Scanner scanner1 = new Scanner(System.in);
        int stu = scanner1.nextInt();
        System.out.println("请输入学生的成绩：");
        int[] arr = new int[stu];
        for (int i = 0; i < 5; i++) {
            Scanner scanner = new Scanner(System.in);
            int score = scanner.nextInt();
            arr[i] = score;
        }
        String s = Arrays.toString(arr);
        System.out.println(s);
        Arrays.sort(arr);
        int maxScore = arr[arr.length - 1];
        System.out.println("最高分" + maxScore);
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] >= maxScore - 10) {
                System.out.println("你的分数是：" + arr[i] + "，对应的等级是：A");
            }
            if (arr[i] >= maxScore - 20 && arr[i] < maxScore - 10) {
                System.out.println("你的分数是：" + arr[i] + "，对应的等级是：B");
            }
            if (arr[i] >= maxScore - 30 && arr[i] < maxScore - 20) {
                System.out.println("你的分数是：" + arr[i] + "，对应的等级是：C");
            }
            if (arr[i] < maxScore - 30) {
                System.out.println("你的分数是：" + arr[i] + "，对应的等级是：D");
            }
        }
}

    /*
    使用二维数组打印一个 10 行杨辉三角。
    【提示】
    1. 第一行有 1 个元素, 第 n 行有 n 个元素
    2. 每一行的第一个元素和最后一个元素都是 1
    3. 从第三行开始, 对于非第一个元素和最后一个元
    素的元素。即：
    yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
     */

        int[] arr = new int[6];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 29 + 1);
            if (i >= 1 && arr[i] == arr[i - 1]) {
                arr[i] = (int) (Math.random() * 29 + 1);
            }
        }
        String s = Arrays.toString(arr);
        System.out.println(s);

    /*
    定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
    然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
    要求：所有随机数都是两位数。
    提示；
    [0,1) * 90 [0,90) + 10  [10,100) [10,99]
    (int)(Math.random() * 90 + 10)
    */

        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 90 + 10);
        }
        Arrays.sort(arr);
        System.out.println("最大值: " + arr[arr.length-1]);
        System.out.println("最小值: " + arr[0]);
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("和值: " + sum);
        double avg = (double) sum / arr.length;
        System.out.println("平均值: " + avg);
        String s = Arrays.toString(arr);
        System.out.println(s);

    /*
    练习 6
    使用简单数组
    (1)创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，
    他们是int[]类型的数组。
    (2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
    (3)显示array1的内容。
    (4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值
    (如array[0]=0,array[2]=2)。打印出array1。
    思考：array1和array2是什么关系？
    拓展：修改题目，实现array2对array1数组的复制
     */

        int[] arr1,arr2 = new int[0];
        arr1= new int[]{2, 3, 5, 7, 11, 13, 17, 19};
        String s1 = Arrays.toString(arr1);
        System.out.println(s1);
        arr2=arr1;
        Arrays.fill(arr2, 0,1,0);
        Arrays.fill(arr2, 2,3,2);
        Arrays.fill(arr2, 4,5,4);
        Arrays.fill(arr2, 7,8,8);
        String s2 = Arrays.toString(arr2);
        System.out.println(s2);

        String[] stringArray = new String[3]; // 各元素的值默认为null
        for (int i = 0; i < stringArray.length; i++) { // 对各元素进行初始化，但没有赋值。
//            stringArray[i] = new String();
            System.out.println(stringArray[i]); //空  （有别于null）
        }

    /*
    回形数格式方阵的实现
    从键盘输入一个整数（1~20）
    则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如： 输入数字2，则程序输出：
    1 2
    4 3
    输入数字3，则程序输出：
    1 2 3
    8 9 4
    7 6 5
    输入数字4， 则程序输出：
    1   2   3   4
    12  13  14  5
    11  16  15  6
    10   9  8    7
     */

        System.out.println("请输入一个整数（1~20）：");
        Scanner scanner = new Scanner(System.in);
        int len = scanner.nextInt();
        int[][] arr = new int[len][len];
        int s = len * len;
        /*
         * k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上
         */
        int k = 1;
        int i = 0, j = 0;
        for (int m = 1; m <= s; m++) {
            if (k == 1) {
                if (j < len && arr[i][j] == 0) {
                    arr[i][j++] = m;
                } else {
                    k = 2;
                    i++;
                    j--;
                    m--;
                }
            } else if (k == 2) {
                if (i < len && arr[i][j] == 0) {
                    arr[i++][j] = m;
                } else {
                    k = 3;
                    i--;
                    j--;
                    m--;
                }
            } else if (k == 3) {
                if (j >= 0 && arr[i][j] == 0) {
                    arr[i][j--] = m;
                } else {
                    k = 4;
                    i--;
                    j++;
                    m--;
                }
            } else if (k == 4) {
                if (i >= 0 && arr[i][j] == 0) {
                    arr[i--][j] = m;
                } else {
                    k = 1;
                    i++;
                    j++;
                    m--;
                }
            }
        }
        // 遍历
        for (int m = 0; m < arr.length; m++) {
            for (int n = 0; n < arr[m].length; n++) {
                System.out.print(arr[m][n] + "\t");
            }
            System.out.println();
        }

    /*
    下面数组定义正确的有：
    A.String strs[] = { ‘a’ ‘b’ ‘c’};
    B.String[] strs = {“a”, “b”, “c”};
    C.String[] strs = new String{“a” ”b” ”c”};
    D.String strs[] = new String[]{“a”, “b”, “c”};
    E.String[] strs = new String[3]{“a”, “b”, “c”};
     */

        String foo = "blue";
        boolean[] bar = new boolean[2];
//        System.out.println("bar:"+bar);
        if (bar[0]) {
            foo = "green";
        }
        System.out.println(foo);//blue

    /*
    下面哪个数组定义是错误的
    并对错误的答案加上单行注释，写出错误的原因。
    A，float[]=new float[3]; //没有定义接受变量
    B, float f2[]=new float[];//没有定义一维数组的长度
    C, float[] f1=new float[3];//对
    D, boolean[] b={"true","false","true"};//要求的是Boolean，提供的数据类型是String，把双引号去掉就行
    E, double f4[]={1,3,5}; //对的
    F, int f5[]=new int[3]{2,3,4}; //
    G, float f4[]={1.2F,3.0,5.4};//数据没有后缀F
     */

    /*
    练习：
    1、从键盘输入本组学员的成绩，放到数组中
    2、用foreach显示所有学员的成绩
    3、排序：从低到高
    4、查找是否有正好60分的，如果有返回位置
    5、复制成绩最低三名构成新数组
    6、用工具类打印成绩最低三名成绩
    */

        System.out.println("请先输入本组学员的的个数：");
        Scanner scanner1 = new Scanner(System.in);
        int num = scanner1.nextInt();
        int[] arr = new int[num];
        System.out.println("从键盘输入本组学员的成绩，放到数组中: ");
        for (int i = 0; i < num; i++) {
            Scanner scanner = new Scanner(System.in);
            int score = scanner.nextInt();
            arr[i] = score;
        }
        System.out.println("本组学员的成绩如下：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("============3、排序：从低到高==============");
        Arrays.sort(arr);
        String s = Arrays.toString(arr);
        System.out.println("排序：从低到高" + s);
        System.out.println("============4、查找是否有正好60分的，如果有返回位置==============");
        int index = Arrays.binarySearch(arr, 60);
        if (index < 0) {
            System.out.println("没有正好60分的");
        } else {
            System.out.println("60分的索引位置：" + index);
        }
        System.out.println("===========5、复制成绩最低三名构成新数组===================");
        // 手动复制
//        int arr1[] = new int[3];
//        arr1[0] = arr[0];
//        arr1[1] = arr[1];
//        arr1[2] = arr[2];
        //Arrays工具类复制
        int[] arr1 = Arrays.copyOfRange(arr, 0, 3);
        System.out.println("========= 6、用工具类打印成绩最低三名成绩=================");
        System.out.println("打印成绩最低三名成绩:  " + Arrays.toString(arr1));

    /*
    数组赋值练习1
    创建一个char类型的26个元素的数组，分别 放置'A'-'Z'。
    使用for循环访问所有元素并打印出来。
     */

        char[] arr = new char[26];
        int j = 65;
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (char) j;
            j++;
        }
        System.out.println("for循环访问所有元素并打印出来: " + Arrays.toString(arr));

    /*
    数组赋值练习2
    创建一个char类型的36个元素的数组，前26个元素放置'A'-'Z',   后10个元素放置'0'-'9'。
    使用for循环访问所有元素并打印出来。
    提示：char类型数据运算 'A'+1 -> 'B'，'0'+1 -> '1'
     */

        char[] arr = new char[36];
        char var1 = 'A';
        char var2 = '0';
        for (int i = 0; i < arr.length; i++) {
            if (i < 26) {
                arr[i] = var1;
                var1++;
            } else {
                arr[i] = var2;
                var2++;
            }
        }
        System.out.println("for循环访问所有元素并打印出来: " + Arrays.toString(arr));

    /*
    数组反转：一维数组a[]，用java代码将数组元素顺序颠倒
     */

        System.out.println("请输入一维数组的长度: ");
        Scanner scanner = new Scanner(System.in);
        int length = scanner.nextInt();
        System.out.println("请输入一维数组： ");
        int[] arr = new int[length];
        for (int i = 0; i < arr.length; i++) {
            Scanner scanner1 = new Scanner(System.in);
            int num = scanner1.nextInt();
            arr[i] = num;
        }
        System.out.println("原始数组： " + Arrays.toString(arr));
        int temp = 0;
        int len = arr.length;
        for (int i = 0; i < len / 2; i++) {
            temp = arr[i];
            arr[i] = arr[len - 1 - i];
            arr[len - 1 - i] = temp;
        }
        System.out.println("反转后的数组： " + Arrays.toString(arr));

        int[] arr = new int[20];
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        System.out.println("斐波那契数列的前20项值: " + Arrays.toString(arr));

        System.out.println("===========先随机产生10个两位整数==================");
        int[] arr = {(int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100)};
        System.out.println("随机产生10个两位整数: " + Arrays.toString(arr));
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println("===========冒泡排序==================");
        System.out.println("按照从小到大的顺序排序：" + Arrays.toString(arr));

   /* 求一个3*3矩阵对角线元素之和
            <提示>程序分析：利用双重for循环控制输入二维数组，再将a[i][i]累加后输出。
    */

                //方式一
        System.out.println("===========先随机产生一个二维数组，每个元素的取值范围在[0,100)之间==================");
        int[][] arr = {{(int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100)},
                {(int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100)},
                {(int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100)}};
        System.out.println("==========打印这个二维数组==============");
//        System.out.println(Arrays.toString(arr));
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }

        //方式二
        int[][] arr = new int[3][3];
        System.out.println("请从键盘输入一个3*3矩阵：");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                Scanner scanner = new Scanner(System.in);
                int num = scanner.nextInt();
                arr[i][j]=num;
            }
        }
        System.out.println("循环遍历输出这个3*3矩阵：");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
        System.out.println("将a[i][i]累加后输出: " + (arr[0][0] + arr[1][1] + arr[2][2]));

    /*
    有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
    <提示>程序分析：首先判断此数是否大于最后一个数，然后再考虑插入中间的数的情况，插入后此元素之后的数，依次后移一个位置。
     */

        int[] arr = {(int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100)};
        Arrays.sort(arr);
        System.out.println("已经排好序的数组: " + Arrays.toString(arr));
        System.out.println("现输入一个数: ");
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        int[] newArr = new int[arr.length + 1];
        newArr = Arrays.copyOfRange(arr, 0, newArr.length);
        if (num > arr[arr.length - 1]) {
            newArr[newArr.length - 1] = num;
        } else {
            newArr = Arrays.copyOfRange(arr, 0, newArr.length);
            for (int i = newArr.length - 2; i > 0; i--) {
                if (num > newArr[i]) {
                    int temp = newArr[i+1];
                    newArr[i+1]=num;
                    newArr[i+2]=temp;
                    break;
                }
            }
        }
        System.out.println("插入后的数组是：" + Arrays.toString(newArr));

/*
利用随机数生成一个整数数组，数组中有10个元素，每个元素的值都在1-30之间，且要求各个数值不能相同。打印该数组。
 */

        System.out.println("随机数生成一个10个元素整数数组:");
//        int[] arr = {(int) (Math.random() * 30 + 1),(int) (Math.random() * 30 + 1),(int) (Math.random() * 30 + 1),(int) (Math.random() * 30 + 1),(int) (Math.random() * 30 + 1),(int) (Math.random() * 30 + 1),(int) (Math.random() * 30 + 1),(int) (Math.random() * 30 + 1),(int) (Math.random() * 30 + 1),(int) (Math.random() * 30 + 1)};
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 30 + 1);
            for (int j = 0; j < i; j++) {
                if (arr[i] == arr[j]) {
                    arr[i] = (int) (Math.random() * 30 + 1);
                    break;
                }
            }
        }
        System.out.println(Arrays.toString(arr));

    /*
    将一个数组逆序输出。 
    <提示>程序分析：用第一个与最后一个交换。
     */

        System.out.println("随机数生成一个10个元素整数数组:");
        int[] arr = {(int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100)};
        System.out.println("原始数组：" + Arrays.toString(arr));
        int len = arr.length;
        for (int i = 0; i < len; i++) {
            for (int j = len-i-1; j > i; j--) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                break;
            }
        }
        System.out.println("数组翻转：" + Arrays.toString(arr));

        System.out.println("随机数生成一个10个元素整数数组:");
        int[] arr = {(int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100), (int) (Math.random() * 100)};
        System.out.println("原始数组：" + Arrays.toString(arr));
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
                System.out.println("最大的元素是：" + max + " ,下标是：" + i);
                if (i != 0) {
                    int temp = arr[0];
                    arr[0] = max;
                    max = temp;
                }
            }
        }
        int min = arr[0];
        for (int j = 0; j < arr.length; j++) {
            if (min > arr[j]) {
                min = arr[j];
                System.out.println("最小的元素是：" + min + " ,下标是：" + j);
                if (j != arr.length - 1) {
                    int temp = arr[arr.length - 1];
                    arr[arr.length - 1] = min;
                    min = temp;
                }
            }
        }
        System.out.println("输出数组: " + Arrays.toString(arr));

        System.out.println("4行4列的二维数组，逐个从键盘输入值: ");
        int[][] arr = new int[4][4];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                Scanner scanner = new Scanner(System.in);
                int num = scanner.nextInt();
                arr[i][j]=num;
            }
        }
        System.out.println("遍历输出原始的4行4列的二维数组：");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
        //开始交换数组
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                //将第1行和第4行的数据进行交换
                if (i==0){
                    int temp = arr[0][j];
                    arr[0][j]=arr[3][j];
                    arr[3][j]=temp;
                }
                //将第2行和第3行的数据进行交换
                if (i==1){
                    int temp = arr[1][j];
                    arr[1][j]=arr[2][j];
                    arr[2][j]=temp;
                }
            }
        }
        System.out.println("遍历输出交换后的4行4列的二维数组：");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }

        System.out.println("3行4列的二维数组，逐个从键盘输入值: ");
        int[][] arr = new int[3][4];
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                Scanner scanner = new Scanner(System.in);
                int num = scanner.nextInt();
                arr[i][j] = num;
            }
        }
        System.out.println("遍历输出原始的3行4列的二维数组：");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
        //四周的数据清0
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                if (i == 0) {
                    Arrays.fill(arr[0], 0);
                }
                if (i == 1) {
                    Arrays.fill(arr[1], 0, 1, 0);
                    Arrays.fill(arr[1], 3, 4, 0);
                }
                if (i == 2) {
                    Arrays.fill(arr[2], 0);
                }
            }
        }
        System.out.println("遍历输出交换后的3行4列的二维数组：");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }

        System.out.println("4行4列的二维数组，逐个从键盘输入值: ");
        int[][] arr = new int[4][4];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                Scanner scanner = new Scanner(System.in);
                int num = scanner.nextInt();
                arr[i][j] = num;
            }
        }
        System.out.println("遍历输出原始的4行4列的二维数组：");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }
        //开始将对角线的值清0
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (i==0&&j==0){
                    Arrays.fill(arr[0],0,1,0);
                }
                if (i==1&&j==1){
                    Arrays.fill(arr[1],1,2,0);
                }
                if (i==2&&j==2){
                    Arrays.fill(arr[2],2,3,0);
                }
                if (i==3&&j==3){
                    Arrays.fill(arr[3],3,4,0);
                }
            }
        }
        System.out.println("遍历输出交换后的4行4列的二维数组：");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(arr[i][j] + "\t");
            }
            System.out.println();
        }