Java程序设计梁勇第十版第八章编程练习题
（前八章如果您有需要，直接在评论注说，我发给你）本章所有题目代码都是本人自己写的，全部自己运行成功了，可以直接复制粘贴。 这些重要都附加了英文注释，方便解析使大家明白，如果您在此阅读过程中发现程序代码有任何问题（包括代码的命名，代码逻辑，代码风格更好的建议，本人不是计算机科班生所以代码风格存在很大问题，虽然有自学过C/C++，但还是有很多不足，希望大家严格指出来，哪段代码没注释没看懂或注释不清晰，诸如此类等等…）都可以向我提出来。以便大家学习交流
Practice 8-1
/**
* 需求：打印用户输入的数组数据中的每列数字之和
* 步骤：略（以后太简单的题目步骤都省略）
* 作者：小小鱼
* 时间：2019 - 6 - 99号
*/
/** Create main method */
public static void main(String args []) {
// Read two dimensional arrays by getMatrix of method
double[][] matrix = getMatrix();
for (int column = 0; column < matrix[0].length; column++) {
System.out.println("Sum of the elements at column " + column
+ " is " + sumColumn(matrix, column));
}
}
/** Return two dimensional arrays */
public static double[][] getMatrix() {
// Create a Scanner
java.util.Scanner input = new java.util.Scanner(System.in);
// Prompt the user to enter a 3-by-4 matrix row by row
System.out.println("Enter a 3-by-4 matrix row by row: ");
// Create a arrays and row'length is 3, column'length is 4 of the matrix
double [][] matrix = new double[3][4];
// Read and store data into arrays through user input
for (int row = 0; row < matrix.length; row++) {
for (int column = 0; column < matrix[row].length; column++) {
matrix[row][column] = input.nextDouble();
}
}
return matrix;
}
/** Return sum of column's numbers on even column */
public static double sumColumn(double[][] m, int columnIndex) {
// Declare a variable and initialize it to zero
double sumColumn = 0;
// add all numbers in even row of array
for (int row = 0; row < m.length; row++) {
sumColumn += m[row][columnIndex];
}
return sumColumn;
}
Practice 8-2
/**
* 需求：求矩阵对角线数字之和
* 分析: 这道题还是比较简单的前面我们做八皇后那道题相信大家已经懂了对角线上数据的处理
* 首先读入矩阵数据(元素），然后在遍历二维数组,将第n行的matrix[n-1][n-1]元素加起来
* 得到一个条主对角线的和.
* 步骤：略(看分析)
* Time: 0: 30 AM
* write code make :( for someone
* Write code make :) for someone
*/
/** Create main method */
public static void main(String[] args) {
// Read two dimensional arrays by getMatrix of method
double[][] matrix = getMatrix();
// Display result
System.out.println("Sum of the elements in the major diagonal is " + sumMajorDiagonal(matrix));
}
/** Return two dimensional arrays */
// 此方法可以直接引用上面的getMatrix()，但是为了让大家清楚这个程序的编译运行，修改复制一下吧
public static double[][] getMatrix() {
// Create a Scanner
java.util.Scanner input = new java.util.Scanner(System.in);
// Prompt the user to enter a 4-by-4 matrix row by row
System.out.println("Enter a 4-by-4 matrix row by row: ");
// Create a arrays and row'length is 4, column'length is 4 of the matrix
double [][] matrix = new double[4][4];
// Read and store data into arrays through user input
for (int row = 0; row < matrix.length; row++) {
for (int column = 0; column < matrix[row].length; column++) {
matrix[row][column] = input.nextDouble();
}
}
return matrix;
}
/** Return sum of numbers on the major diagonal */
public static double sumMajorDiagonal(double[][] m) {
// Declare a variables and initialize it to zero
double SumMajorDiagonal = 0;
// Compute SumMajorDiagonal
for (int row = 0; row < m.length; row++) {
SumMajorDiagonal += m[row][row];
}
// Return SumMajorDiagonal
return SumMajorDiagonal;
}
各位实在不好意思
Practice 8 - 3 略，真不愿往上翻
Practice 8-3 Omitted
Practice 8-4
/**
* 提醒: 在写每一段程序都要搞清楚程序的需求，这里题干都给了我们需求的解释， 所以我们的需求
* 按照题目来写了，再者我们要对题目进行分析，最好用注释写出步骤，这是学每个计算机语
* 言的很好的习惯。
* 需求：计算每个雇员每周工作得小时数
* 分析：这道题看似两颗星，其实我觉得很简单呀，当然这本书我还没遇到难题，但从程度上来说这
* 道题也就值一个星；前面还是一样读入雇员得每天得工时数，然后计算每位雇员工时数这周
* 得总数，然后进行降序排列
*
* 步骤: 1：读入矩阵(数组)
* 2：遍历数组计算每行得元素和
* 3：将每行得元素和储存到一个新建的数组上去
* 4：最后进行数组降序排序(冒泡排序)
* *：写了这么多是不是很清晰呢，写注释写的我想跳过这题；
*/
/** Create main method */
public static void main(String[] args) {
// Store all employees' weekly hours in a two-dimensional array
int[][] matrix = {{2, 4, 3, 4, 5, 8, 8},
{7, 3, 4, 3, 3, 4, 4},
{3, 3, 4, 3, 3, 2, 2},
{9, 3, 4, 7, 3, 4, 1},
{3, 5, 4, 7, 3, 4, 1},
{3, 4, 4, 6, 3, 4, 4},
{3, 7, 4, 8, 3, 8, 4},
{6, 3, 5, 9, 2, 7, 9}};
int[][] sumHoursArrays = getSumOfPerLine(matrix);
int[][] downArrays = getDownSortArrays(sumHoursArrays);
// Display result
for (int row = 0; row < downArrays.length; row++) {
System.out.println("The employee" + downArrays[row][1] + "'s number of sum of hours are "
+ downArrays[row][0]);
}
}
/** Return getSumOfPerLineArrays*/
public static int[][] getSumOfPerLine(int[][] matrix) {
// Create a two dimensional array
int[][] sumHoursArrays = new int[matrix.length][matrix.length];
// Compute per emplyees's weekly hours and numbering, then Store in new array
for (int row = 0; row < matrix.length; row++) {
int sumHours = 0;
// Compute
for (int col = 0; col < matrix[0].length; col++)
sumHours += matrix[row][col];
// Store sum Of hours
sumHoursArrays[row][0] = sumHours;
// Store employees' numbering
sumHoursArrays[row][1] = row;
}
// Return new array
return sumHoursArrays;
}
/** 这里是要对总小时数据存储的数组进行排序的，但是呢在调用方法排序 然后赋值 是不改变数组内容的，
* 所以我们可以arraycopy复制一个新的数组，利用之前书中提到冒泡排序来进行降序排列，然后返回到
* 主函数去
*/
/** Return down sort hours of method*/
public static int[][] getDownSortArrays(int[][] sumHoursArrays) {
// Create a new array
int[][] downSortHours = new int[sumHoursArrays.length][sumHoursArrays[0].length];
// Copy into new array
System.arraycopy(sumHoursArrays, 0, downSortHours, 0, sumHoursArrays.length);
// Through two-dimensional array, and down sort to elements of per line
for (int row = 0; row < downSortHours.length; row++) {
for (int n = row + 1; n < downSortHours.length - 1; n++) {
if (downSortHours[row][0] > downSortHours[n][0]) { // Use bubble sort
// Two values of sumHours in swap
int temp = downSortHours[row][0];
downSortHours[row][0] = downSortHours[n][0];
downSortHours[n][0] = temp;
// Two values of numbering in swap
int temp1 = downSortHours[row][1];
downSortHours[row][1] = downSortHours[n][1];
downSortHours[n][1] = temp1;
}
}
}
// Return copyArray
return downSortHours;
}
Practice 8-4 Omitted
这道题你们懂得，要略了，我直接写下面第五道题，因为第五题是第四题得变型题，你们要是刚学还是多写一下吧，这道题还是有意义的题
Practice 8 -5
/** 前言：突然感觉要做的事情好多呀，先把这章做完保证三个小时之内，但是要是自己敲就三个小时，还有
* 注释应该的要六个小时，前面三个题目就花了我一个小时 哎这道题其实很简单，我都不想动手了，
* 算了为了伟大初学者觉得我是一个勤奋的人，十分钟解决了
* 注意：本人为了速度，确实题目太多了，没注意优化我的代码，如果你们有好的建议留言跟我说一下，
* 我会有空，保证让大家看到更好的代码环境
* 需求：两个矩阵相乘， 打印题目要求的结果
* 分析：肯定是创建两个输出，把用户需要的数据一一储存在对应的数组，然后用两个数组按照题目给的公
* 式得到第三个矩阵的数据，然后按照要求打印出来（本题稍微难那么一点点点点点点的就是打印部分
* 步骤： 略（看分析，看题目）
* */
/** Create main method */
public static void main(String[] args) {
// Prompt the user to enter elements of matrix_a
System.out.print("Enter matrix1: ");
double[][] matrix1 = getMatrix();
// Prompt the user to enter elements of matrix_b
System.out.print("Enter matrix2: ");
double[][] matrix2 = getMatrix();
// Compute out matrix_c, and store in matrix_3
double[][] matrix3 = multiplyMatrix(matrix1, matrix2);
// Display result
for (int row = 0; row < matrix1.length; row++) {
// Print matrix_a
printDisplay(matrix1, row);
// if loop is going on two times, we should print "+"
if (row == 1)
System.out.print(" * ");
else // Else blank space
System.out.print(" ");
// Print matrix_b
printDisplay(matrix2, row);
// if loop is going on two times, we should print "="
if (row == 1)
System.out.print(" = ");
else // Else blank space
System.out.print(" ");
// Print matrix_c
printDisplay(matrix3, row);
// Blank line on per line
System.out.println();
}
}
/** Return print elements of per line */
public static void printDisplay(double[][] x, int row) {
for(int n = 0; n < 3; n++)
// 这里我要说一下， 要用 printf 统一小数个数，不然打印结果很难看
System.out.printf("%.1f ", x[row][n]);
// Return none;
return;
}
/** Return input elements and store in matrix*/
public static double[][] getMatrix() {
// Create a Scanner
java.util.Scanner input = new java.util.Scanner(System.in);
// Create a 3-by-3 of matrix
double[][] matrix = new double[3][3];
// Store in matrix
for (int row = 0; row < matrix.length; row++) {
for (int col = 0; col < matrix[row].length; col++)
matrix[row][col] = input.nextDouble();
}
// Return matrix
return matrix;
}
/** Return compute out matrix_a multiply matrix_b to result*/
public static double[][] multiplyMatrix(double[][] matrix1, double[][] matrix2) {
// Create same as matrix_a's size of matrix_c
double[][] matrix3 = new double[matrix1.length][matrix1.length];
// Compute out matrix_a multiply matrix_x, and store in matrix_c
for (int row = 0; row < matrix3.length; row++) {
for (int col = 0; col < matrix3[row].length; col++) { // use formula
matrix3[row][col] = matrix1[row][0] * matrix2[0][col] + matrix1[row][1]
* matrix2[1][col] + matrix1[row][2] * matrix2[2][col];
}
}
// Return matrix_c
return matrix3;
}
Practice 8_20
这道题目有更好解法请告知！
public static void main(String[] args) {
Scanner input = new Scanner(System.in); // 这个创建一个Scanner对象，
String[][] array = new String[6][15]; // 这里是创建一个二位数组，colum是一个double数量+1， 因为colum是有 "|"和 " " 组成的，
for (int i = 0; i < array.length; i++) { // 这里对二维数组储存 " | " 和 " " , 形成一个棋盘
for (int j = 0; j < array[i].length; j++) {
if (j % 2 == 0 )
array[i][j] = "|";
else
array[i][j] = " ";
}
}
for (int i = 0; i < array.length; i++) { // 这里是开始之前打印一次棋盘
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]);
}
System.out.println();
}
System.out.println("--------------");
flag: { // 这里一大段先标记一下
for (int count = 0; count <= 42; count++){ //这里很简单利用一个for循环，因为输入只能输入42次，且每次Red和yellow交替
String s = null; // 设置一个String，每次对它来回赋值 (R or Y)
if (count % 2 == 0)
s = "R";
else
s = "Y";
System.out.print("Drop a " + ((s == "R") ? "red" : "yellow")+ " disk at colum(0-6): "); // 打印标题
int number = input.nextInt(); // 输入用户所需的位置的数字
for (int i = array.length - 1; i >= 0; i--) {
/* 这里其实有点难理解，对用户输入的位置进行判断是否为 " " 如果为空，直接进行赋值，如果不为空 i-1，向上一个进行判断
直到 i-n 的位置 为空时，再进行赋值，是一个循环判断过程
*/
if (array[i][number*2+1] == " ") { //这里的 colum 要对应空格，有一个数学规律， 2n+1，这里也是进行判断的条件
array[i][number*2+1] = s; // 如果为空进行赋值
break; //赋值以后之间跳出小循环
}
}
for (int i = 0; i < array.length; i++) { //这里是对每次大循环打印一次棋盘，这里没什么好讲的
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]);
}
System.out.println();
}
System.out.println("--------------");
for (int i = 0; i < array.length ; i++) { // 这里是利用两次小循环是检测过程
for (int j = 1; j < array[i].length; j+=2) {
if (array[i][j] != " ") {
if(newArray(array, i , j)) { // 这里采用一个小方法
System.out.println("The " + ((s == "R") ? "red" : "yellow") + " player won"); // 打印结果
break flag; // 检测完Red或者Yellow 胜负结果就不用执行count的大循环了，这里flag 标记起到了作用，利用flag跳出大循环，结束本程序
}
}
}
}
}
}
}
public static boolean newArray(String[][] array, int i, int j) {
String str = array[i][j];
boolean boo1 = false;
boolean boo2 = false;
boolean boo3 = false;
boolean boo4 = false;
/*
这里检测比较复杂，我们要知道规则就是 成列成行成对角线4个棋子相同则游戏结束
表面上我们要判断八种情况，但其实我们只要判断四种情况
第一种情况：右边 成行
二 : 下面 成列
三和四 : 斜右 对角线 和斜右 对角线
首先要判断 当前输入的棋子输入在什么位置，
再其位置要进行判断，
*/
if (i + 3 < array.length) { // 这里是判断棋子右边是否可以形成 成行或者 成斜右或斜左对角线
if (j + 6 < array[i].length) // 判断斜右对角线
if (array[i][j]==str && array[i+1][j+2]==str && array[i+2][j+4]==str && array[i+3][j+6]==str)
boo1 = true; // 如果能，就返回true
if (j - 6 > 0) // 判断斜左对角线
if (array[i][j]==str && array[i+1][j-2]==str && array[i+2][j-4]==str && array[i+3][j+6]==str)
boo2 = true; // 如果能， 就返回一个true
// 这里是判断是否成行
if (array[i][j]==str && array[i+1][j]==str && array[i+2][j]==str && array[i+3][j]==str)
boo3 = true; // 如果能 ，就返回一个true
}
else { // 这里就是棋子不能成右边成行的情况下，它只有一种检测情况，就是斜左对角线
if (j + 6 < array[i].length)
if (array[i][j]==str && array[i][j+2]==str && array[i][j+4]==str && array[i][j+6]==str)
boo4 = true; // 如果能，就返回一个true
}
// 最终我们只需对四种情况下，我们只要有一种检测情况为true，则返回true，游戏结
return boo1 || boo2 || boo3 || boo4;
}