• Java编程练习题：Demo96 - Demo105（多维数组）

    目录

    Demo96. (代数方面：两个矩阵相乘）编写两个矩阵相乘的方法。

    Demo97. (距离最近的两个点）程序清单8-3给出找到二维空间中距离最近的两个点的程序。 修改该程序,让程序能够找出在三维空间上距离最近的两个点。

    Demo98. (最大的行和列)编写一个程序，在一个4×4的矩阵中随机填人0和1， 打印该矩阵，找到第一个具有最多1的行和列。

    Demo99. (游戏:九个正面和背面) 编写一个程序，提示用户输入一个在0到511之间的数字，然后显示用字符H和T表示的对应的矩阵。

    Demo100. (模式识别:连续的四个相等的数）编写下面的方法，测试一个二维数组是否有四个连续的数字具有相同的值， 这四个数可以是水平方向的、垂直方向的或者对角线方向的。

    Demo101. (游戏:四子连）四子连是一个两个人玩的棋盘游戏，在游戏中， 玩家轮流将有颜色的棋子放在一个六行七列的垂直悬挂的网格中，如下所示。 这个游戏的目的是在对手实现一行、一列或者一条对角线上有四个相同颜色的棋子之前， 你能先做到。

    Demo102. (马尔科夫矩阵)一个n×n的矩阵被称为一个正马尔科夫矩阵，当且仅当每个元素都是正数， 并且每列的元素的和为1。编写下面的方法来检测一个矩阵是否是一个马尔科夫矩阵。

    Demo103. (几何:三角形面积)编写一个方法，使用下面的方法头，返回一个三角形的面积

    Demo104. (几何:多边形的子面积)一个具有四个顶点的凸多边形被分为四个三角形，编写一个程序，提示用户输入四个顶点的坐标，然后以升序显示四个三角形的面积。

    Demo105. (拉丁正方形)拉丁正方形是一个n×n的数组，由n个不同的拉丁字母填充，每个拉丁字母恰好只在每行和每列中出现一次。编写一个程序，提示用户输人数字n以及字符数组，如示例输出所示，检测该输出数组是否是一个拉丁正方形。字符是从A开始的前面n个字符。

    Demo96. (代数方面：两个矩阵相乘）编写两个矩阵相乘的方法。

    方法头如下: public static double[][] multiplyMatrix(double[][] a，double[][] b) 为了使矩阵a能够和矩阵b相乘，矩阵a的列数必须与矩阵b的行数相同，并且两个矩阵的元素要具有相同或兼容的数据类型。 假设矩阵c是相乘的结果，而a的列数是n，那么每个元素cij就是ai1 x b1j + ai2 x b2j +…+ ain x bnj。 例如，对于两个3×3的矩阵a和 b，c就有: cij = ai1 x b1j + ai2 x b2j + ai3 x b3j。 编写一个测试程序，提示用户输人两个3×3的矩阵，然后显示它们的乘积。下面是一个运行示例：

    1. package Exer2;
    2.  
    3. import java.math.BigDecimal;
    4. import java.text.DecimalFormat;
    5. import java.util.Scanner;
    6.  
    7. public class Demo96 {
    8.     /*
    9.     (代数方面:两个矩阵相乘）编写两个矩阵相乘的方法。方法头如下:
    10.     public static double[][] multiplyMatrix(double[][] a，double[][] b)
    11.     为了使矩阵a能够和矩阵b相乘，矩阵a的列数必须与矩阵b的行数相同，并且两个矩阵的元素要具有相同或兼容的数据类型。
    12.     假设矩阵c是相乘的结果，而a的列数是n，那么每个元素cij就是ai1 x b1j + ai2 x b2j +…+ aim x bnj。
    13.     例如，对于两个3×3的矩阵a和 b，c就有: cij = ai1 x b1j + ai2 x b2j + ai3 x b3j。
    14.     编写一个测试程序，提示用户输人两个3×3的矩阵，然后显示它们的乘积。下面是一个运行示例:
    15.     1 2 3 4 5 6 7 8 9
    16.     0 2 4 1 4.5 2.2 1.1 4.3 5.2
    17.      */
    18.     public static void main(String[] args) {
    19.         Scanner scan = new Scanner(System.in);
    20.         System.out.print("Enter matrix1：");
    21.         double[][] a = new double[3][3];
    22.         for (int i = 0; i < a.length; i++) {
    23.             for (int j = 0; j < a[i].length; j++) {
    24.                 a[i][j] = scan.nextDouble();
    25.             }
    26.         }
    27.         double[][] b = new double[3][3];
    28.         System.out.print("Enter matrix2：");
    29.         for (int i = 0; i < b.length; i++) {
    30.             for (int j = 0; j < b[i].length; j++) {
    31.                 b[i][j] = scan.nextDouble();
    32.             }
    33.         }
    34.  
    35.         System.out.println("The multiplication of the matrices is：");
    36.         for (int i = 0; i < a.length; i++) {
    37.             for (int j = 0; j < a[0].length; j++) {
    38.                 System.out.print(new DecimalFormat("#.##").format(a[i][j]) + "\t");
    39.             }
    40.             System.out.print(i == 1 ? "\t+\t" : "\t\t");
    41.             for (int j = 0; j < a[0].length; j++) {
    42.                 System.out.print(new DecimalFormat("#.##").format(b[i][j]) + "\t");
    43.             }
    44.             System.out.print(i == 1 ? "\t=\t" : "\t\t");
    45.             for (int j = 0; j < a[0].length; j++) {
    46.                 // new DecimalFormat("#.##").format(double d) 让小数点后为0的显示为整数，不为零的显示为double
    47.                 System.out.print(new DecimalFormat("#.##").format(multiplyMatrix(a, b)[i][j]) + "\t");
    48.             }
    49.             System.out.println();
    50.         }
    51.         scan.close();
    52.     }
    53.  
    54.     public static double[][] multiplyMatrix(double[][] a, double[][] b){
    55.         double[][] c = new double[3][3];
    56.         for (int i = 0; i < c.length; i++) {
    57.             for (int j = 0; j < c[i].length; j++) {
    58.                 c[i][j] = BigDecimal.valueOf(a[i][0]).multiply(BigDecimal.valueOf(b[0][j]))
    59.                         .add(BigDecimal.valueOf(a[i][1]).multiply(BigDecimal.valueOf(b[1][j]))
    60.                         .add(BigDecimal.valueOf(a[i][2]).multiply(BigDecimal.valueOf(b[2][j]))))
    61.                         .doubleValue();
    62.             }
    63.         }
    64.         return c;
    65.     }
    66. }

    结果：

    Demo97. (距离最近的两个点）程序清单8-3给出找到二维空间中距离最近的两个点的程序。 修改该程序,让程序能够找出在三维空间上距离最近的两个点。

    使用一个二维数组表示这些点。使用下面的点来测试这个程序: double[][] points = {{-1,0,3},{-1,-1,-1},{4,1,1},{2,0.5,9},{3.5,2,-1},{3,1.5,3},{-1.5,4,2},{5.5,4,-0.5}}; 计算两个点(x1,y1,z1)和(x2,y2,z2)之间距离的公式是√((x2-x1)²+(y2-y1)²+(z2-z1)²)。

    1. package Exer2;
    2.  
    3. public class Demo97 {
    4.     /*
    5.     (距离最近的两个点）程序清单8-3给出找到二维空间中距离最近的两个点的程序。
    6.     修改该程序,让程序能够找出在三维空间上距离最近的两个点。使用一个二维数组表示这些点。使用下面的点来测试这个程序:
    7.     double[][] points = {{-1,0,3},{-1,-1,-1},{4,1,1},{2,0.5,9},{3.5,2,-1},{3,1.5,3},{-1.5,4,2},{5.5,4,-0.5}};
    8.     计算两个点(x1,y1,z1)和(x2,y2,z2)之间距离的公式是√((x2-x1)²+(y2-y1)²+(z2-z1)²)。
    9.      */
    10.     public static void main(String[] args) {
    11.         double[][] points = {{-1, 0, 3}, {-1, -1, -1}, {4, 1, 1}, {2, 0.5, 9},
    12.                 {3.5, 2, -1}, {3, 1.5, 3}, {-1.5, 4, 2}, {5.5, 4, -0.5}};
    13.         // System.out.println(Arrays.deepToString(minDistance(points)));
    14.         System.out.printf("距离最近的两个点为：(%s, %s, %s), (%s, %s, %s)%n",
    15.                 minDistance(points)[0][0], minDistance(points)[0][1], minDistance(points)[0][2],
    16.                 minDistance(points)[1][0], minDistance(points)[1][1], minDistance(points)[1][2]);
    17.     }
    18.  
    19.     private static double[][] minDistance(double[][] points) {
    20.         double[][] twoPoints = new double[2][3];
    21.         double minD = Double.MAX_VALUE;
    22.         for (int i = 0; i < points.length - 1; i++) {
    23.             for (int j = i + 1; j < points.length; j++) {
    24.                 double d = Math.sqrt(Math.pow(points[j][0] - points[i][0], 2)
    25.                         + Math.pow(points[j][1] - points[i][1], 2) + Math.pow(points[j][1] - points[i][1], 2));
    26.                 if (d < minD) {
    27.                     minD = d;
    28.                     twoPoints[0] = points[i];
    29.                     twoPoints[1] = points[j];
    30.                 }
    31.             }
    32.         }
    33.         return twoPoints;
    34.     }
    35. }

    结果：

    Demo98. (最大的行和列)编写一个程序，在一个4×4的矩阵中随机填人0和1， 打印该矩阵，找到第一个具有最多1的行和列。

    下面是一个程序的运行示例:

    1. package Exer2;
    2.  
    3. import java.util.Random;
    4.  
    5. public class Demo98 {
    6.     /*
    7.     (最大的行和列)编写一个程序，在一个4×4的矩阵中随机填人0和1，
    8.     打印该矩阵，找到第一个具有最多1的行和列。下面是一个程序的运行示例:
    9.     0011
    10.     0011
    11.     1101
    12.     1010
    13.     The largest row index：2
    14.     The largest column index：2
    15.      */
    16.     public static void main(String[] args) {
    17.         int[][] nums = new int[4][4];
    18.         for (int i = 0; i < nums.length; i++) {
    19.             for (int j = 0; j < nums[i].length; j++) {
    20.                 nums[i][j] = new Random().nextInt(2);
    21.             }
    22.         }
    23.         for (int[] arr : nums) {
    24.             for (int num : arr) {
    25.                 System.out.print(num + " ");
    26.             }
    27.             System.out.println();
    28.         }
    29.         int rowIndex = 0, columnIndex = 0;
    30.  
    31.         int largestRow = 0;
    32.         int largestColumn = 0;
    33.         // int[][] largest = new int[2][2];
    34.  
    35.         for (int i = 0; i < nums.length; i++) {
    36.             int rowSum = 0, ColumnSum = 0;
    37.             for (int  j = 0; j < nums[i].length; j++) {
    38.                 rowSum += nums[i][j];
    39.                 ColumnSum += nums[j][i];
    40.                 if (ColumnSum > largestColumn) {
    41.                     columnIndex = j;
    42.                     largestColumn = ColumnSum;
    43.                 }
    44.             }
    45.             if (rowSum > largestRow) {
    46.                 rowIndex = i;
    47.                 largestRow = rowSum;
    48.             }
    49.         }
    50.         System.out.println("The largest row index：" + rowIndex);
    51.         System.out.println("The largest column index：" + columnIndex);
    52.     }
    53. }

    结果：

    Demo99. (游戏:九个正面和背面) 编写一个程序，提示用户输入一个在0到511之间的数字，然后显示用字符H和T表示的对应的矩阵。

    一个3×3的矩阵中放置了9个硬币，这些硬币有些面向上，有些面向下。 可以使用3×3的矩阵中的0(正面)或1(反面）表示硬币的状态。下面是一些例子:

    每个状态都可以使用一个二进制数表示。例如，前面的矩阵对应到数字: 000010000 101001100 110100001 101110100 100111110 总共会有512种可能性。所以，可以使用十进制数0，1，2，3，...，511来表示这个矩阵的所有状态。下面是一个运行示例:

    1. package Exer2;
    2.  
    3. import java.util.Scanner;
    4.  
    5. public class Demo99 {
    6.     /*
    7.     (游戏:九个正面和背面)一个3×3的矩阵中放置了9个硬币，这些硬币有些面向上，有些面向下。
    8.     可以使用3×3的矩阵中的0(正面)或1(反面）表示硬币的状态。下面是一些例子:
    9.     0 0 0   1 0 1   1 1 0   1 0 1   1 0 0
    10.     0 1 0   0 0 1   1 0 0   1 1 0   1 1 1
    11.     0 0 0   1 0 0   0 0 1   1 0 0   1 1 0
    12.     每个状态都可以使用一个二进制数表示。例如，前面的矩阵对应到数字:
    13.     000010000 101001100 110100001 101110100 100111110
    14.     总共会有512种可能性。所以，可以使用十进制数0，1，2，3，...，511来表示这个矩阵的所有状态。
    15.     编写一个程序，提示用户输入一个在0到511之间的数字，然后显示用字符H和T表示的对应的矩阵。下面是一个运行示例:
    16.      */
    17.     public static void main(String[] args) {
    18.         Scanner scan = new Scanner(System.in);
    19.         System.out.print("Enter a number between 0 and 511：");
    20.         int number = scan.nextInt();
    21.         int[][] binaryArr = toBinaryArr(number);
    22.         // System.out.println(Arrays.deepToString(binaryArr));
    23.         for (int[] nums : binaryArr) {
    24.             for (int n : nums) {
    25.                 if (n == 0) {
    26.                     System.out.print("H ");
    27.                 } else {
    28.                     System.out.print("T ");
    29.                 }
    30.             }
    31.             System.out.println();
    32.         }
    33.         scan.close();
    34.     }
    35.  
    36.     private static int[][] toBinaryArr(int number) {
    37.         int[][] arr = new int[3][3];
    38.         for (int i = arr.length - 1; i >= 0; i--) {
    39.             for (int j = arr[i].length - 1; j >= 0; j--) {
    40.                 if (number > 0) {
    41.                     arr[i][j] = number % 2;
    42.                     number /= 2;
    43.                 }
    44.             }
    45.         }
    46.         return arr;
    47.     }
    48. }

     结果：

    Demo100. (模式识别:连续的四个相等的数）编写下面的方法，测试一个二维数组是否有四个连续的数字具有相同的值， 这四个数可以是水平方向的、垂直方向的或者对角线方向的。

    public static boolean isConsecutiveFour(int[][]values) 编写一个测试程序，提示用户输人一个二维数组的行数、列数以及数组中的值。 如果这个数组有四个连续的数字具有相同的值，就显示true;否则，显示false。下面是结果为true的一些例子:

    这里我只做出来水平方向：

    1. package Exer2;
    2.  
    3. import java.util.Arrays;
    4. import java.util.Scanner;
    5.  
    6. public class Demo100 {
    7.     /*
    8.     (模式识别:连续的四个相等的数）编写下面的方法，测试一个二维数组是否有四个连续的数字具有相同的值，
    9.     这四个数可以是水平方向的、垂直方向的或者对角线方向的。
    10.     public static boolean isConsecutiveFour(int[][]values)
    11.     编写一个测试程序，提示用户输人一个二维数组的行数、列数以及数组中的值。
    12.     如果这个数组有四个连续的数字具有相同的值，就显示true;否则，显示false。下面是结果为true的一些例子:
    13.      */
    14.     public static void main(String[] args) {
    15.         Scanner scan = new Scanner(System.in);
    16.         System.out.println("请输入一个二维数组的行数、列数以及数组中的值(前两个数分别表示行、列)：");
    17.         int row = scan.nextInt();
    18.         int column = scan.nextInt();
    19.         int[][] values = new int[row][column];
    20.         for (int i = 0; i < values.length; i++) {
    21.             for (int j = 0; j < values[i].length; j++) {
    22.                 values[i][j] = scan.nextInt();
    23.             }
    24.         }
    25.         // 6 7 0 1 0 3 1 6 1 0 1 6 8 6 0 1 5 6 2 1 8 2 9 6 5 6 1 1 9 1 1 3 6 1 4 0 7 3 3 3 3 4 0 7
    26.         System.out.println(Arrays.deepToString(values));
    27.         System.out.println(isConsecutiveFour(values));
    28.     }
    29.     public static boolean isConsecutiveFour(int[][] values) {
    30.         if (values.length < 4 || values[0].length < 4) {
    31.             return false;
    32.         }
    33.         int rowCount = 1, columnCount = 1, count = 1, antiCount = 1;
    34.         for (int i = 1; i < values.length; i++) {
    35.             for (int j = 1; j < values[i].length; j++) {
    36.                 // 判断行
    37.                 if (values[i - 1][j - 1] == values[i - 1][j] || values[i][j - 1] == values[i][j]){
    38.                     rowCount++;
    39.                 } else {
    40.                     rowCount = 1;
    41.                 }
    42.                 // 判断列
    43.                 if (values[i - 1][j - 1] == values[i][j - 1] || values[i - 1][j] == values[i][j]){
    44.                     columnCount++;
    45.                 } else {
    46.                     columnCount = 0;
    47.                 }
    48.                 // 副对角线
    49.                 if (i >= 3) {
    50.                     // TODO
    51.                 }
    52.                 // 主对角线
    53.                 if (j <= 3) {
    54.                     // TODO
    55.                 }
    56.                 if (rowCount >= 4 || columnCount >= 4) {
    57.                     return true;
    58.                 }
    59.             }
    60.         }
    61.         return false;
    62.     }
    63. }

    Demo101. (游戏:四子连）四子连是一个两个人玩的棋盘游戏，在游戏中， 玩家轮流将有颜色的棋子放在一个六行七列的垂直悬挂的网格中，如下所示。 这个游戏的目的是在对手实现一行、一列或者一条对角线上有四个相同颜色的棋子之前， 你能先做到。

    程序提示两个玩家交替地下红子Red或黄子Yellow。 当放下一子时，程序在控制台重新显示这个棋盘，然后确定游戏的状态(赢、平局还是继续)。

    下面是一个运行示例:

    1. package Exer2;
    2.  
    3. import java.util.Scanner;
    4.  
    5. public class Demo101 {
    6.     /*
    7.     (游戏:四子连）四子连是一个两个人玩的棋盘游戏，在游戏中，
    8.     玩家轮流将有颜色的棋子放在一个六行七列的垂直悬挂的网格中，如下所示。
    9.     这个游戏的目的是在对手实现一行、一列或者一条对角线上有四个相同颜色的棋子之前，
    10.     你能先做到。程序提示两个玩家交替地下红子Red或黄子Yellow。
    11.     当放下一子时，程序在控制台重新显示这个棋盘，然后确定游戏的状态(赢、平局还是继续)。下面是一个运行示例:
    12.      */
    13.     static Scanner in = new Scanner(System.in);
    14.  
    15.     public static void main(String[] args) {
    16.  
    17.         char[][] chess = new char[6][15];
    18.         for (int i = 0; i < chess.length; i++)    //初始化棋盘
    19.         {
    20.             for (int j = 0; j < chess[i].length; j++) {
    21.                 if (j % 2 == 0)
    22.                     chess[i][j] = '|';
    23.                 else
    24.                     chess[i][j] = ' ';
    25.             }
    26.         }
    27.  
    28.         beginGame(chess);
    29.  
    30.         in.close();
    31.     }
    32.  
    33.  
    34.     //开始比赛
    35.     public static void beginGame(char[][] chess) {
    36.         char disk;
    37.         for (int i = 0; i < 42; i++) {
    38.             if (i % 2 == 0)
    39.                 disk = 'R';
    40.             else
    41.                 disk = 'Y';
    42.             printChessBoard(chess);
    43.             System.out.println("——————————————");
    44.             if (dropDisk(chess, disk) == 0) {
    45.                 i--;
    46.                 continue;
    47.             }
    48.             if (judge(chess) == 0) {
    49.                 System.out.println("The red player won");
    50.                 return;
    51.             } else if (judge(chess) == 1) {
    52.                 System.out.println("The yellow player won");
    53.                 return;
    54.             }
    55.         }
    56.         System.out.println("No winner");
    57.     }
    58.  
    59.  
    60.     //落子
    61.     public static int dropDisk(char[][] chess, char disk) {
    62.         if (disk == 'R')
    63.             System.out.print("Drop a red disk at column(0-6):");
    64.         else
    65.             System.out.print("Drop a yellow disk at column(0-6):");
    66.         int key = in.nextInt();
    67.         if (key < 0 || key > 6) {
    68.             System.out.println("Enter error!");
    69.             return 0;
    70.         }
    71.         key = key * 2 + 1;
    72.         for (int row = chess.length - 1; row >= 0; row--) {
    73.             if (chess[row][key] == ' ') {
    74.                 chess[row][key] = disk;
    75.                 return 1;
    76.             }
    77.         }
    78.         System.out.println("This colum is no more position!");
    79.         return 0;
    80.     }
    81.  
    82.  
    83.     //打印棋盘
    84.     public static void printChessBoard(char[][] chess) {
    85.         for (int i = 0; i < chess.length; i++) {
    86.             for (int j = 0; j < chess[i].length; j++)
    87.                 System.out.print(chess[i][j]);
    88.             System.out.println();
    89.         }
    90.     }
    91.  
    92.  
    93.     //判断输赢,返回0'R'赢,返回1'Y'赢,返回2未分出胜负
    94.     public static int judge(char[][] chess) {
    95.         if (judgeRow(chess) != 2)
    96.             return judgeRow(chess);
    97.         if (judgeCol(chess) != 2)
    98.             return judgeCol(chess);
    99.         if (judgeMainDiagonal(chess) != 2)
    100.             return judgeMainDiagonal(chess);
    101.         if (judgeSubDiagonal(chess) != 2)
    102.             return judgeSubDiagonal(chess);
    103.         return 2;
    104.     }
    105.  
    106.  
    107.     //判断行是否有四个相等的
    108.     public static int judgeRow(char[][] chess) {
    109.         for (int i = 0; i < chess.length; i++)
    110.             for (int j = 1; j < chess[i].length - 6; j += 2) {
    111.                 if (chess[i][j] == chess[i][j + 2] && chess[i][j] == chess[i][j + 4] && chess[i][j] == chess[i][j + 6] && chess[i][j] != ' ')
    112.                     if (chess[i][j] == 'R')
    113.                         return 0;
    114.                     else
    115.                         return 1;
    116.             }
    117.         return 2;
    118.     }
    119.  
    120.  
    121.     //判断列是否有四个相等的
    122.     public static int judgeCol(char[][] chess) {
    123.         for (int i = 0; i < chess.length - 3; i++)
    124.             for (int j = 1; j < chess[i].length; j += 2) {
    125.                 if (chess[i][j] == chess[i + 1][j] && chess[i][j] == chess[i + 2][j] && chess[i][j] == chess[i + 3][j] && chess[i][j] != ' ')
    126.                     if (chess[i][j] == 'R')
    127.                         return 0;
    128.                     else
    129.                         return 1;
    130.             }
    131.         return 2;
    132.     }
    133.  
    134.  
    135.     //判断主对角线是否有四个相等的
    136.     public static int judgeMainDiagonal(char[][] chess) {
    137.         for (int i = 0; i < chess.length - 3; i++)//主对角线
    138.             for (int j = 1; j < chess[i].length - 6; j += 2) {
    139.                 if (chess[i][j] == chess[i + 1][j + 2] && chess[i][j] == chess[i + 2][j + 4] && chess[i][j] == chess[i + 3][j + 6] && chess[i][j] != ' ')
    140.                     if (chess[i][j] == 'R')
    141.                         return 0;
    142.                     else
    143.                         return 1;
    144.             }
    145.         return 2;
    146.     }
    147.  
    148.  
    149.     //判断副对角线是否有四个相等的
    150.     public static int judgeSubDiagonal(char[][] chess) {
    151.         for (int i = 3; i < chess.length; i++)//副对角线
    152.             for (int j = 1; j < chess[i].length - 6; j += 2) {
    153.                 if (chess[i][j] == chess[i - 1][j + 2] && chess[i][j] == chess[i - 2][j + 4] && chess[i][j] == chess[i - 3][j + 6] && chess[i][j] != ' ')
    154.                     if (chess[i][j] == 'R')
    155.                         return 0;
    156.                     else
    157.                         return 1;
    158.             }
    159.         return 2;
    160.     }
    161. }

    结果：

    Demo102. (马尔科夫矩阵)一个n×n的矩阵被称为一个正马尔科夫矩阵，当且仅当每个元素都是正数， 并且每列的元素的和为1。编写下面的方法来检测一个矩阵是否是一个马尔科夫矩阵。

    public static boolean isMarkovMatrix(double[][] m) 编写一个测试程序，提示用户输人一个3×3的double值的矩阵，测试它是否是一个马尔科夫矩阵。下面是一个运行示例:

    1. package Exer2;
    2.  
    3. import java.util.Arrays;
    4. import java.util.Scanner;
    5.  
    6. public class Demo102 {
    7.     /*
    8.     (马尔科夫矩阵)一个n×n的矩阵被称为一个正马尔科夫矩阵，当且仅当每个元素都是正数，
    9.     并且每列的元素的和为1。编写下面的方法来检测一个矩阵是否是一个马尔科夫矩阵。
    10.     public static boolean isMarkovMatrix(double[][] m)
    11.     编写一个测试程序，提示用户输人一个3×3的double值的矩阵，测试它是否是一个马尔科夫矩阵。下面是一个运行示例:
    12.      */
    13.     /*
    14.     0.15 0.875 0.375
    15.     0.55 0.005 0.225
    16.     0.30 0.12 0.4
    17.      */
    18.     public static void main(String[] args) {
    19.         Scanner scan = new Scanner(System.in);
    20.         double[][] m = new double[3][3];
    21.         System.out.println("Enter a 3-by-3 matrix row by row：");
    22.         for (int i = 0; i < m.length; i++) {
    23.             for (int j = 0; j < m[i].length; j++) {
    24.                 m[i][j] = scan.nextDouble();
    25.             }
    26.         }
    27.         System.out.println(Arrays.deepToString(m));
    28.         if (isMarkovMatrix(m)) {
    29.             System.out.println("It is a Markov matrix");
    30.         } else {
    31.             System.out.println("It is not a Markov matrix");
    32.         }
    33.     }
    34.  
    35.     public static boolean isMarkovMatrix(double[][] m) {
    36.         double sum = 0;
    37.         for (int i = 0; i < m.length; i++) {
    38.             for (int j = 0; j < m[i].length; j++) {
    39.                 sum += m[j][i];
    40.                 if (m[i][j] <= 0) {
    41.                     return false;
    42.                 }
    43.             }
    44.             if (sum != 1) {
    45.                 return false;
    46.             } else {
    47.                 sum = 0;
    48.             }
    49.         }
    50.         return true;
    51.     }
    52. }

    结果：

    Demo103. (几何:三角形面积)编写一个方法，使用下面的方法头，返回一个三角形的面积

    public static double getTriangleArea(double[][] points)

    点保存在一个3×2的二维矩阵points中，其中 ( points[0][0]，points[0][1])代表(x1， y1)。三角形面积的计算可以使用编程练习题2.19中的公式。如果三个点在一条直线上，方法返回0。编写一个程序，提示用户输入三角形的三个点，然后显示三角形的面积。下面是一个运行示例。

    1. package Exer2;
    2.  
    3. import java.util.Scanner;
    4.  
    5. public class Demo103 {
    6.     /*
    7.     (几何:三角形面积)编写一个方法，使用下面的方法头，返回一个三角形的面积
    8.     public static double getTriangleArea(double[][] points)
    9.     点保存在一个3×2的二维矩阵points中，其中 ( points[0][0]，points[0][1])代表(x1， y1)。
    10.     三角形面积的计算可以使用编程练习题2.19中的公式。如果三个点在一条直线上，方法返回0。
    11.     编写一个程序，提示用户输入三角形的三个点，然后显示三角形的面积。下面是一个运行示例。
    12.     计算三角形面积的公式是：
    13.         s = (边1 + 边2 + 边3 ) / 2
    14.         面积 = √(s(s - 边1)(s - 边2)(s - 边3))
    16.     2.5 2 5 -1.0 4.0 2.0
    17.      */
    18.     public static void main(String[] args) {
    19.         Scanner scan = new Scanner(System.in);
    20.         System.out.println("Enter x1, y1, x2, y2, x3, y3：");
    21.         double[][] points = new double[3][2];
    22.         for (int i = 0; i < points.length; i++) {
    23.             for (int j = 0; j < points[i].length; j++) {
    24.                 points[i][j] = scan.nextDouble();
    25.             }
    26.         }
    27.         scan.close();
    28.         if (getTriangleArea(points) == 0) {
    29.             System.out.println("The three points are on the same Line");
    30.         } else {
    31.             System.out.printf("The ares of the triangle is %.2f", getTriangleArea(points));
    32.         }
    33.     }
    34.  
    35.     public static double getTriangleArea(double[][] points) {
    36.         double area = 0;
    37.         double d1 = Math.pow(Math.pow(points[1][0] - points[0][0], 2) + Math.pow(points[1][1] - points[0][1], 2), 0.5);
    38.         double d2 = Math.pow(Math.pow(points[2][0] - points[1][0], 2) + Math.pow(points[2][1] - points[1][1], 2), 0.5);
    39.         double d3 = Math.pow(Math.pow(points[2][0] - points[0][0], 2) + Math.pow(points[2][1] - points[0][1], 2), 0.5);
    40.         // double d1 = Math.pow(((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)), 0.5);
    41.         // double d2 = Math.pow(((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3)), 0.5);
    42.         // double d3 = Math.pow(((x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3)), 0.5);
    43.  
    44.         if (d1 <= d2 + d3 || d1 >= Math.abs(d2 - d3)) {
    45.             double s = (d1 + d2 + d3) / 2;
    46.             area = Math.pow(s * (s - d1) * (s - d2) * (s - d3), 0.5);
    47.         } else {
    48.             return 0;
    49.         }
    50.         return area;
    51.     }
    52. }

    结果：注意精度问题，double运算时，失之毫厘，缪之千里

    Demo104. (几何:多边形的子面积)一个具有四个顶点的凸多边形被分为四个三角形，编写一个程序，提示用户输入四个顶点的坐标，然后以升序显示四个三角形的面积。

    下面是一个运行示例。

    1. package Exer2;
    2.  
    3. import java.util.Arrays;
    4. import java.util.Scanner;
    5.  
    6. public class Demo104 {
    7.     public static void main(String[] args) {
    8.         /*
    9.         Enter x1, y1, x2, y2, x3, y3, x4, y4：
    10.         -2.5 2 4 4 3 -2 -2 -3.5
    11.         The areas are 6.17 7.96 8.08 10.42
    12.          */
    13.         //1. 获取四个点的坐标，使用数组读入
    14.         Scanner scan = new Scanner(System.in);
    15.         System.out.println("Enter x1, y1, x2, y2, x3, y3, x4, y4：");
    16.         double[][] points = new double[4][2];
    17.         for (int i = 0; i < points.length; i++) {
    18.             for (int j = 0; j < points[i].length; j++) {
    19.                 points[i][j] = scan.nextDouble();
    20.             }
    21.         }
    22.         scan.close();
    23.  
    24.         //2. 求v1v3和v2v4线的交点坐标
    25.         double[] crossPoint = intersection(points);
    26.  
    27.         //3. 自定义方法求三角形面积（传入数组、下标、交点坐标数组），使用数组接收
    28.         double[] areas = new double[4];
    29.         for (int i = 0 ; i < 4 ; i++){
    30.             areas[i] = getTriangleArea(points, i, crossPoint);
    31.         }
    32.         Arrays.sort(areas);
    33.         System.out.print("The areas are ");
    34.         for (double area : areas) {
    35.             System.out.printf("%.2f ", area);
    36.         }
    37.     }
    38.  
    39.     // 求v1v3和v2v4线的交点坐标
    40.     public static double[] intersection(double[][] arr) {
    41.         double[] feedback = new double[2];
    42.         double k02 = (arr[2][1] - arr[0][1]) / (arr[2][0] - arr[0][0]);
    43.         double k13 = (arr[3][1] - arr[1][1]) / (arr[3][0] - arr[1][0]);
    44.         double b02 = arr[0][1] - k02 * arr[0][0];
    45.         double b13 = arr[1][1] - k13 * arr[1][0];
    46.  
    47.         double x = (b02 - b13) / (k13 - k02);
    48.         double y = (b02 * k13 - b13 * k02) / (k13 - k02);
    49.         feedback[0] = x;
    50.         feedback[1] = y;
    51.         return feedback;
    52.     }
    53.  
    54.     // 求三角形面积
    55.     public static double getTriangleArea(double[][] points, int index, double[] crossPoint) {
    56.         double area = 0;
    57.         int index1 = (index + 1) % 4;
    58.         double d1 = Math.pow(Math.pow(points[index1][0] - points[index][0], 2) + Math.pow(points[index1][1] - points[index][1], 2), 0.5);
    59.         double d2 = Math.pow(Math.pow(points[index1][0] - crossPoint[0], 2) + Math.pow(points[index1][1] - crossPoint[1], 2), 0.5);
    60.         double d3 = Math.pow(Math.pow(points[index][0] - crossPoint[0], 2) + Math.pow(points[index][1] - crossPoint[1], 2), 0.5);
    61.         double s = (d1 + d2 + d3) / 2;
    62.         area = Math.pow(s * (s - d1) * (s - d2) * (s - d3), 0.5);
    63.         return area;
    64.     }
    65. }

    结果：

    Demo105. (拉丁正方形)拉丁正方形是一个n×n的数组，由n个不同的拉丁字母填充，每个拉丁字母恰好只在每行和每列中出现一次。编写一个程序，提示用户输人数字n以及字符数组，如示例输出所示，检测该输出数组是否是一个拉丁正方形。字符是从A开始的前面n个字符。

    1. package Exer2;
    2.  
    3. import java.util.HashSet;
    4. import java.util.Scanner;
    5.  
    6. public class Demo105 {
    7.     /*
    8.     (拉丁正方形)拉丁正方形是一个n×n的数组，由n个不同的拉丁字母填充，每个拉丁字母恰好只在每行和每列中出现一次。
    9.     编写一个程序，提示用户输人数字n以及字符数组，如示例输出所示，检测该输出数组是否是一个拉丁正方形。字符是从A开始的前面n个字符。
    10.     Enter number n：4
    11.     Enter 4 rows of letters separated by spaces：
    12.     A B C D
    13.     B A D C
    14.     C D B A
    15.     D C A B
    16.     The input array is a Latin square
    17.      */
    18.     public static void main(String[] args) {
    19.         Scanner scan = new Scanner(System.in);
    20.         System.out.print("Enter number n：");
    21.         int number = scan.nextInt();
    22.         System.out.printf("Enter %s rows of letters separated by spaces：%n", number);
    23.         char[][] latin = new char[number][number];
    24.         for (int i = 0; i < number; i++) {
    25.             for (int j = 0; j < number; j++) {
    26.                 latin[i][j] = scan.next().charAt(0);
    27.                 if (latin[i][j] > ('A' - 1 + number)) {
    28.                     System.out.println("Wrong input: the letters must be from A to " + (char) ('A' - 1 + number));
    29.                     System.exit(1);
    30.                 }
    31.             }
    32.         }
    33.         if (isLatin(latin)) {
    34.             System.out.println("The input array is a Latin square");
    35.         } else {
    36.             System.out.println("The input array is not a Latin square");
    37.         }
    38.     }
    39.  
    40.     private static boolean isLatin(char[][] latin) {
    41.         HashSet set1 = new HashSet<>();
    42.         HashSet set2 = new HashSet<>();
    43.         for (int i = 0; i < latin.length; i++) {
    44.             set1.clear();
    45.             set2.clear();
    46.             for (int j = 0; j < latin[i].length; j++) {
    47.                 if (!set1.add(latin[i][j]) || !set2.add(latin[j][i])) {
    48.                     return false;
    49.                 }
    50.             }
    51.         }
    52.         return true;
    53.     }
    54. }

    结果：

  • 相关阅读:
    Mybatis01、Mybatis简介
    【算法与数据结构】450、LeetCode删除二叉搜索树中的节点
    主成分分析（机器学习）
    中通IM测试实践
    图像处理--平滑
    怎么压缩视频？最新压缩技巧大分享
    网页期末作业 基于HTML+CSS中国传统节日【清明节】带论文8000字
    UDP服务端丢包-发送频率过高导致丢包
    I/O软件层次结构（用户层软件，设备独立性软件，设备驱动程序，中断处理程序，硬件）
    php单独使用laravel数据库
  • 原文地址：https://blog.csdn.net/weixin_51612062/article/details/126428681