目录
Demo82. (计算数字的出现次数) 编写程序，读取在1到100之间的整数，然后计算每个数出现的次数，假定输入是以0结束的。
Demo88. (游戏:豆机) 编写程序模拟豆机。程序应该提示用户输入球的个数以及机器的槽数。打印每个球的路径模拟它的下落。
Demo89. (完全相同的数组）编写一个测试程序，提示用户输人两个整数列表，然后显示这两个列表是否完全相同。
Demo81. 递归解决汉诺塔问题
import java.util.Scanner;
public class Demo81 {
/*
递归解决汉诺塔问题
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("请输入有几个方块：");
int n = scan.nextInt();
System.out.println("最少的步数：" + towerHanoi(n));
System.out.println("最少的步数：" + towerHanoi1(n));
scan.close();
}
/*
n 0 1 2 3 4 5
0 1 3 7 15 31
0 0+2^0 1+2^1
*/
// 递归
private static int towerHanoi1(int n) {
if (n == 0) {
return 0;
}
return towerHanoi(n - 1) + (int)Math.pow(2, n - 1);
}
// 最简单的解法
private static int towerHanoi(int n) {
if (n == 0) {
return 0;
}
return (int)Math.pow(2, n) - 1;
}
}结果：
如果要显示移动的方法：
public class Demo81 {
/*
递归解决汉诺塔问题
*/
public static void main(String[] args) {
hanoi(4, 'A', 'B', 'C');
}
/**
* @param n 盘子的数目
* @param origin 源座
* @param assist 辅助座
* @param destination 目的座
*/
public static void hanoi(int n, char origin, char assist, char destination) {
if (n == 1) {
move(origin, destination);
} else {
hanoi(n - 1, origin, destination, assist); // 挪动最大圆盘上方的其他圆盘到辅助座上
move(origin, destination); // 挪动最大圆盘到目标座
hanoi(n - 1, assist, origin, destination); // 挪动最大圆盘上方的其他圆盘到目标座上
}
}
// Print the route of the movement
private static void move(char origin, char destination) {
System.out.println("Direction:" + origin + "--->" + destination);
}
}
Demo82. (计算数字的出现次数) 编写程序，读取在1到100之间的整数，然后计算每个数出现的次数，假定输入是以0结束的。
下面是这个程序的一个运行示例：
注意：如果一个数出现的次数大于一次，就在输出时使用复数“times”。
package Exer2;
import java.util.Arrays;
import java.util.Scanner;
public class Demo82 {
/*
(计算数字的出现次数) 编写程序，读取在1到100之间的整数，然后计算每个数出现的次数，假定输入是以0结束的。
注意：如果一个数出现的次数大于一次，就在输出时使用复数“times”。
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("Enter the integers between 1 and 100：");
int[] arr = {};
while (true) {
int num = scan.nextInt();
if (num == 0) {
break;
}
arr = Arrays.copyOf(arr, arr.length + 1);
arr[arr.length - 1] = num;
}
// System.out.println(Arrays.toString(arr));
scan.close();
countNum(arr);
}
private static void countNum(int[] arr) {
bubbleSort(arr);
// System.out.println(Arrays.toString(arr));
int count = 1, num = arr[0];
for (int i = 1; i < arr.length; i++) {
if (num == arr[i]) {
count++;
} else {
System.out.println(num + " occurs " + count + (count == 1 ? " time" : " times"));
num = arr[i];
count = 1;
}
}
System.out.println(num + " occurs " + count + (count == 1 ? " time" : " times"));
}
private static void bubbleSort(int[] 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];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}结果：
Demo83. (打印不同的数) 编写一个程序，读入10个数并且显示互不相同的数（即一个数出现多次，但仅显示一次)。(提示，读人一个数，如果它是一个新数，则将它存储在数组中。如果该数已经在数组中，则忽略它。)输入之后，数组包含的都是不同的数。
下面是这个程序的运行示例:
package Exer2;
import java.util.Arrays;
import java.util.Scanner;
public class Demo83 {
/*
(打印不同的数) 编写一个程序，读入10个数并且显示互不相同的数（即一个数出现多次，但仅显示一次)。
(提示，读人一个数，如果它是一个新数，则将它存储在数组中。如果该数已经在数组中，则忽略它。)
输入之后，数组包含的都是不同的数。
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("Enter ten number：");
int i = 1;
int[] nums = {scan.nextInt()};
while (i <= 9) {
int num = scan.nextInt();
boolean isFlag = true;
for (int j : nums) {
if (j == num) {
isFlag = false;
break;
}
}
if (isFlag) {
nums = Arrays.copyOf(nums, nums.length + 1);
nums[nums.length - 1] = num;
}
i++;
}
System.out.println("The number of distinct number is " + nums.length);
System.out.print("The distinct number are：");
for (int j: nums) {
System.out.print(j + " ");
}
}
}结果：
除此之外我们还可以使用HashSet来解决这道题
Set set = new HashSet<>();
for (int i = 0; i < 10; i++) {
int num = scan.nextInt();
set.add(num);
}
System.out.println("The number of distinct number is " + set.size());
System.out.print("The distinct number are：");
for (Object j: set) {
System.out.print(j + " ");
}Demo84. (求数组的平均值) 编写两个重载的方法，使用下面的方法头返回一个数组的平均数：public static int average(int[] array)，public static double average(double[] array)，编写测试程序，提示用户输人10个double型值，调用这个方法，然后显示平均值。
package Exer2;
import java.util.Scanner;
public class Demo84 {
/*
(求数组的平均值) 编写两个重载的方法，使用下面的方法头返回一个数组的平均数：
public static int average(int[] array)
public static double average(double[] array)，
编写测试程序，提示用户输人10个double型值，调用这个方法，然后显示平均值。
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入10个小数：");
double[] nums = new double[10];
for (int i = 0; i < nums.length; i++) {
double num = scan.nextDouble();
nums[i] = num;
}
double aver = average(nums);
System.out.println("平均值为：" + aver);
}
public static int average(int[] array){
int sum = 0;
for (int i : array) {
sum += i;
}
return sum /array.length;
}
public static double average(double[] array){
double sum = 0;
for (double i : array) {
sum += i;
}
return sum /array.length;
}
}结果：
Demo85. (计算gcd)编写一个方法，返回个数不确定的整数的最大公约数。指定这个方法头如下所示：public static int gcd(int... numbers)，编写测试程序，提示用户输人5个数字，调用该方法找出这些数的最大公约数，并显示这个最大公约数。
package Exer2;
import java.util.Scanner;
public class Demo85 {
/*
(计算gcd)编写一个方法，返回个数不确定的整数的最大公约数。
指定这个方法头如下所示：public static int gcd(int... numbers)，
编写测试程序，提示用户输人5个数字，调用该方法找出这些数的最大公约数，并显示这个最大公约数
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入5个数：");
int[] nums = new int[5];
for (int i = 0; i < nums.length; i++) {
int num = scan.nextInt();
nums[i] = num;
}
System.out.println(gcd(nums));
}
public static int gcd(int... numbers) {
int min = numbers[0];
for (int i : numbers){
if (min > i) {
min = i;
}
}
for (int i = min; i > 0; i--) {
boolean isFlag = true;
for (int j : numbers) {
if (j % i != 0) {
isFlag = false;
break;
}
}
if (isFlag) {
return i;
}
}
return 1;
}
}
结果：
Demo86. (消除重复) 使用下面的方法头编写方法，消除数组中重复出现的值：public static int[] eliminateDuplicates(int[] list)，编写一个测试程序，读取10个整数，调用该方法，然后显示结果。
下面是程序的运行示例:
package Exer2;
import java.util.Arrays;
import java.util.Scanner;
public class Demo86 {
/*
(消除重复) 使用下面的方法头编写方法，消除数组中重复出现的值：
public static int[] eliminateDuplicates(int[] list)，
编写一个测试程序，读取10个整数，调用该方法，然后显示结果。
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("请输入10个数：");
int[] nums = new int[10];
for (int i = 0; i < nums.length; i++) {
int num = scan.nextInt();
nums[i] = num;
}
nums = eliminateDuplicates(nums);
for (int i : nums) {
System.out.print(i + " ");
}
scan.close();
}
public static int[] eliminateDuplicates(int[] list){
int[] arr = {list[0]};
for (int j : list) {
boolean isFlag = true;
for (int i = 0; i < arr.length; i++) {
if (j == arr[i]) {
isFlag = false;
break;
}
}
if (isFlag) {
arr = Arrays.copyOf(arr, arr.length + 1);
arr[arr.length - 1] = j;
}
}
return arr;
}
}结果：
Demo87. (是否排好序了?) 编写以下方法，如果参数中的list数组已经按照升序排好了，则返回true。public static boolean isSorted(int[] list)，编写一个测试程序，提示用户输入一个列表，显示该列表是否已经排好序。
下面是一个运行示例。注意，输入中的第一个数表示列表中的元素个数。该数不是列表的一部分。
package Exer2;
import java.util.Scanner;
public class Demo87 {
/*
(是否排好序了?) 编写以下方法，如果参数中的list数组已经按照升序排好了，则返回true。
public static boolean isSorted(int[] list)，
编写一个测试程序，提示用户输入一个列表，显示该列表是否已经排好序。
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入数字元素的个数和每一个元素：");
int n = scan.nextInt();
int[] list = new int[n];
for (int i = 0; i < n; i++) {
list[i] = scan.nextInt();
}
if (isSorted(list)) {
System.out.println("The list is already sorted");
} else {
System.out.println("The list is not sorted");
}
}
public static boolean isSorted(int[] list){
for (int i = 0; i < list.length - 1; i++) {
if (list[i] > list[i + 1]) {
return false;
}
}
return true;
}
}
结果：
Demo88. (游戏:豆机) 编写程序模拟豆机。程序应该提示用户输入球的个数以及机器的槽数。打印每个球的路径模拟它的下落。
豆机，也称为梅花瓶或高尔顿瓶，它是一个用来做统计实验的设备，是用英国科学家瑟弗兰克斯高尔顿的名字来命名的。它是一个三角形状的均匀放置钉子(或钩子)的直立板子，如图7-13所示。
球都是从板子口落下的。每当球碰到钉子，它就有50%的机会落向左边或落向右边。在板子底部的槽子中都会累积一堆球。例如:在图7-13b中球的路径是LLRRLLR，而在图7-13c中球的路径是RLRRLRR。使用条形图显示槽中球的最终储备量。下面是程序的一个运行示例：
提示：创建一个名为slots的数组。数组slots中的每个元素存储的是一个槽中球的个数。每个球都经过一条路径落入一个槽中。路径上R的个数表示球落下的槽的位置。例如;对于路径LRLRLRR而言，球落到slots[4]中，而对路径RRLLLLL而言，球落到slots[2]中。
package Exer2;
import java.util.Scanner;
public class Demo88 {
/*
(游戏:豆机) 编写程序模拟豆机。程序应该提示用户输入球的个数以及机器的槽数。打印每个球的路径模拟它的下落。
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("请输入球的个数：");
int ballNum = scan.nextInt();
System.out.print("请输入机器的槽数：");
int slotNum = scan.nextInt();
int[] slots = new int[slotNum];
simulator(ballNum, slotNum, slots);
}
private static void simulator(int ballNum, int slotNum, int[] slots) {
for (int i = 0; i < ballNum; i++) {
int count = 0;
for (int j = 1; j < slotNum; j++) {
String way = Math.random() >= 0.5 ? "L" : "R";
if (way.equals("L")) {
count++;
}
System.out.print(way + " ");
}
slots[slots.length - 1 - count] += 1;
System.out.println();
// System.out.println(count);
}
System.out.println();
int max = findMax(slots);
while (max > 0) {
for (int i = 0; i < slots.length; i++) {
if (slots[i] == max) {
System.out.print("0 ");
slots[i]--;
} else {
System.out.print(" ");
}
}
max--;
System.out.println();
}
}
private static int findMax(int[] slots) {
int max = slots[0];
for (int i : slots) {
if (max < i) {
max = i;
}
}
return max;
}
}
结果：
Demo89. (完全相同的数组）编写一个测试程序，提示用户输人两个整数列表，然后显示这两个列表是否完全相同。
如果两个数组list1和list2的长度相同，而且对于每个i，list1[i]都等于list2[i]，那么认为list1和list2是完全相同的。使用下面的方法头编写一个方法，如果list1和list2完全相同，那么这个方法返回true，public static boolean equals(int[] list1,int[] list2)，注意，输入的第一个数字表明列表中元素的个数。该数字不是列表的一部分。
package Exer2;
import java.util.Scanner;
public class Demo89 {
/*
(完全相同的数组）编写一个测试程序，提示用户输人两个整数列表，然后显示这两个列表是否完全相同。
如果两个数组list1和list2的长度相同，而且对于每个i，list1[i]都等于list2[i]，那么认为list1和list2是完全相同的。
使用下面的方法头编写一个方法，如果list1和list2完全相同，那么这个方法返回true，
public static boolean equals(int[] 1ist1,int[] list2)
注意，输入的第一个数字表明列表中元素的个数。该数字不是列表的一部分。
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("请输入第1个列表的长度和每一个元素：");
int len1 = scan.nextInt();
int[] list1 = new int[len1];
for (int i = 0; i < list1.length; i++) {
list1[i] = scan.nextInt();
}
// System.out.println(Arrays.toString(list1));
System.out.print("请输入第2个列表的长度和每一个元素：");
int len2 = scan.nextInt();
int[] list2 = new int[len2];
for (int i = 0; i < list2.length; i++) {
list2[i] = scan.nextInt();
}
// System.out.println(Arrays.toString(list2));
if (equals(list1, list2)) {
System.out.println("列表1和列表2完全相同");
}else{
System.out.println("列表1和列表2不完全相同");
}
scan.close();
}
public static boolean equals(int[] list1,int[] list2) {
if (list1.length == list2.length) {
for (int i = 0; i < list1.length; i++) {
if (list1[i] != list2[i]) {
return false;
}
}
return true;
}
return false;
}
}
结果：
Demo90. (模式识别方面:四个连续相等的数) 编写下面的方法，测试某个数组是否有四个连续的值相同的数字。public static boolean isConsecutiveFour(int[] values)，编写测试程序，提示用户输入一个整数列表，如果这个列表中有四个连续的具有相同值的数，那就显示true；否则，显示false。程序应该首先提示用户键入输入的大小，即列表中值的个数。
这里是一个运行示例。
package Exer2;
import java.util.Scanner;
public class Demo90 {
/*
(模式识别方面:四个连续相等的数) 编写下面的方法，测试某个数组是否有四个连续的值相同的数字。
public static boolean isConsecutiveFour(int[] values)，
编写测试程序，提示用户输入一个整数列表，如果这个列表中有四个连续的具有相同值的数，那就显示true；
否则，显示false。程序应该首先提示用户键入输入的大小，即列表中值的个数。
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("Enter the number of values：");
int len = scan.nextInt();
int[] values = new int[len];
System.out.print("Enter the values：");
for (int i = 0; i < values.length; i++) {
values[i] = scan.nextInt();
}
// System.out.println(Arrays.toString(values));
if (isConsecutiveFour(values)) {
System.out.println("This list has consecutive fours");
} else {
System.out.println("This list has no consecutive fours");
}
}
public static boolean isConsecutiveFour(int[] values) {
int count = 1, maxCount = count, currNum = values[0];
for (int i = 1; i < values.length; i++) {
if (currNum == values[i]) {
count++;
} else {
currNum = values[i];
count = 1;
}
if (maxCount < count) {
maxCount = count;
}
}
return maxCount >= 4;
}
}结果：
Demo91. (合并两个有序列表) 编写下面的方法，将两个有序列表合并成一个新的有序列表。public static int[] merge(int[] list1，int[] list2)，只进行list1.length+list2.length次比较来实现该方法。编写一个测试程序，提示用户输人两个有序列表，然后显示合并的列表。下面是一个运行示例。注意，输入的第一个数字表示列表中元素的个数。该数字不是列表的一部分。
package Exer2;
import java.util.Arrays;
import java.util.Scanner;
public class Demo91 {
/*
(合并两个有序列表) 编写下面的方法，将两个有序列表合并成一个新的有序列表。
public static int[] merge(int[] list1，int[] list2)，
只进行list1.length+list2.length次比较来实现该方法。
编写一个测试程序，提示用户输人两个有序列表，然后显示合并的列表。
下面是一个运行示例。注意，输入的第一个数字表示列表中元素的个数。该数字不是列表的一部分。
*/
public static void main(String[] args) {
System.out.print("Enter list1：");
Scanner scanner = new Scanner(System.in);
int len1 = scanner.nextInt();
int[] list1 = new int[len1];
for (int i = 0; i < list1.length; i++) {
list1[i] = scanner.nextInt();
}
System.out.print("Enter list2：");
int len2 = scanner.nextInt();
int[] list2 = new int[len2];
for (int i = 0; i < list2.length; i++) {
list2[i] = scanner.nextInt();
}
System.out.println("The merged list is ：" + Arrays.toString(merge(list1, list2)));
scanner.close();
}
// 双指针法：
public static int[] merge(int[] list1, int[] list2) {
int[] list = new int[list1.length + list2.length];
int i1 = 0, i2 = 0;
for (int i = 0; i < list.length; i++) {
if (i1 < list1.length && i2 < list2.length) {
if (list1[i1] < list2[i2]) {
list[i] = list1[i1++];
}else {
list[i] = list2[i2++];
}
} else if (i1 == list1.length) {
list[i] = list2[i2++];
} else if (i2 == list2.length) {
list[i] = list1[i1++];
}
}
return list;
}
}结果：
如果这道题不要求只进行list1.length+list2.length次比较来实现该方法，我们可使用插入排序法求解
// 插入排序
public static int[] merge1(int[] list1, int[] list2) {
int[] list = Arrays.copyOf(list1, list1.length + list2.length);
int k = 0;
for (int i = list1.length - 1; i < list.length - 1; i++) {
if (k < list2.length) {
for (int j = i + 1; j > 0; j--) {
if (list2[k] < list[j - 1]) {
list[j] = list[j - 1];
list[j - 1] = list2[k];
}
}
}
k++;
}
return list;
}Demo92. (游戏:猜字游戏) 编写一个猜字游戏。随机产生一个单词，提示用户一次猜测一个字母，如运行示例所示。单词中的每个字母显示为一个星号。当用户猜测正确后，正确的字母显示出来当用户猜出一个单词，显示猜错的次数，并且询问用户是否继续对另外一个单词进行游戏。声明一个数组来存储单词，如下所示：
/ / Add any words you wish in this array
String[] words = { "write", "that", ...};
package Exer2;
import java.util.Random;
import java.util.Scanner;
public class Demo92 {
/*
(游戏:猜字游戏) 编写一个猜字游戏。随机产生一个单词，提示用户一次猜测一个字母，如运行示例所示。
单词中的每个字母显示为一个星号。当用户猜测正确后，正确的字母显示出来当用户猜出一个单词，
显示猜错的次数，并且询问用户是否继续对另外一个单词进行游戏。声明一个数组来存储单词，如下所示：
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String[] words = {"write", "that", "where"};
while (true) {
String word = words[new Random().nextInt(words.length)];
// System.out.println(word);
String str = word;
for (int i = 0; i < word.length(); i++) {
str = str.replace(str.charAt(i), '*');
}
StringBuilder gsWord = new StringBuilder(str);
// System.out.println(gsWord);
int count = 0;
while (true) {
System.out.print("(Guess) Enter a letter in word " + gsWord + "> ");
char letter = scan.next().charAt(0);
if (gsWord.toString().contains(letter + "")) {
System.out.println(letter + " is already in the word");
continue;
}
boolean change = false;
for (int i = 0; i < word.length(); i++) {
if (letter == word.charAt(i)) {
change = true;
gsWord.replace(i, i + 1, letter + "");
}
}
if (!change) {
count++;
System.out.println(letter + " is not in the word");
continue;
}
if (gsWord.toString().equals(word)) {
System.out.printf("This word is %s. You missed %d time%n", word, count);
System.out.println("Dou you want to guess another word? Enter y or n：");
if ("y".equals(scan.next())) {
break;
} else {
System.exit(1);
}
}
}
}
}
}
结果：
Demo93. (求矩阵中各列数字的和)编写一个方法，求整数矩阵中特定列的所有元素的和，使用下面的方法头: public static double sumColumn(double[][] m, int columnIndex)，编写一个测试程序，读取一个3×4的矩阵，然后显示每列元素的和。
下面是一个运行示例:
package Exer2;
import java.util.Scanner;
public class Demo93 {
/*
(求矩阵中各列数字的和)编写一个方法，求整数矩阵中特定列的所有元素的和，使用下面的方法头:
public static double sumColumn(double[][] m, int columnIndex)，
编写一个测试程序，读取一个3×4的矩阵，然后显示每列元素的和。
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("Enter a 3-by-4 matrix row by row：");
double[][] m = new double[3][4];
int len = 0;
while (len < m.length) {
for (int i = 0; i < m[len].length; i++) {
m[len][i] = scan.nextDouble();
}
len++;
}
for (int i = 0; i < 4; i++) {
System.out.println("Sum of the elements at column " + i + " is " + sumColumn(m, i));
}
scan.close();
}
public static double sumColumn(double[][] m, int columnIndex) {
double sum = 0.0;
for (double[] doubles : m) {
sum += doubles[columnIndex];
}
return sum;
}
}
结果：
Demo94. (求矩阵主对角线元素的和) 编写一个方法，求n × n的double类型矩阵中主对角线上所有数字的和，使用下面的方法头：public static double sumMajorDiagonal (double[][] m)，编写一个测试程序，读取一个4x4的矩阵，然后显示它的主对角线上的所有元素的和。
下面是一个运行示例：
package Exer2;
import java.util.Scanner;
public class Demo94 {
/*
Demo94. (求矩阵主对角线元素的和) 编写一个方法，求n × n的double类型矩阵中主对角线上所有数字的和，
使用下面的方法头：public static double sumMajorDiagonal (double[][] m)，
编写一个测试程序，读取一个4x4的矩阵，然后显示它的主对角线上的所有元素的和。
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("Enter a 4-by-4 matrix row by row：");
double[][] m = new double[4][4];
int len = 0;
while (len < m.length) {
for (int i = 0; i < m[len].length; i++) {
m[len][i] = scan.nextDouble();
}
len++;
}
System.out.println("Sum of the elements in major diagonal is " + sumMajorDiagonal(m));
}
public static double sumMajorDiagonal (double[][] m) {
double sum = 0;
for (int i = 0; i < m.length; i++) {
sum += m[i][i];
}
return sum;
}
}
结果：
Demo95. (代数方面:两个矩阵相加）编写两个矩阵相加的方法。方法头如下：public static double[][] addMatrix(double[][] a，double[][] b)，为了能够进行相加，两个矩阵必须具有相同的维数，并且元素具有相同或兼容的数据类型。假设c表示最终的矩阵，每个元素c,就是ag+by。例如，对于两个3×3的矩阵a和b，c就有：
编写一个测试程序，提示用户输入两个3×3的矩阵，然后显示它们的和。下面是一个运行示例:
package Exer2;
import java.util.Scanner;
public class Demo95 {
/*
Demo95.(代数方面:两个矩阵相加）编写两个矩阵相加的方法。
方法头如下：public static double[][] addMatrix(double[][] a，double[][] b)，
为了能够进行相加，两个矩阵必须具有相同的维数，并且元素具有相同或兼容的数据类型。
假设c表示最终的矩阵，每个元素c,就是ag+by。例如，对于两个3×3的矩阵a和b，c就有
*/
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.print("Enter matrix1：");
double[][] a = new double[3][3];
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
a[i][j] = scan.nextDouble();
}
}
double[][] b = new double[3][3];
System.out.print("Enter matrix2：");
for (int i = 0; i < b.length; i++) {
for (int j = 0; j < b[i].length; j++) {
b[i][j] = scan.nextDouble();
}
}
// 二维数组打印deepToString
// System.out.println("The matrices are added as follow：" + Arrays.deepToString(addMatrix(a, b)));
System.out.println("The matrices are added as follow：");
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[0].length; j++) {
System.out.print(a[i][j] + " ");
}
System.out.print(i == 1 ? "\t+\t" : "\t\t");
for (int j = 0; j < a[0].length; j++) {
System.out.print(b[i][j] + " ");
}
System.out.print(i == 1 ? "\t=\t" : "\t\t");
for (int j = 0; j < a[0].length; j++) {
System.out.print(addMatrix(a, b)[i][j] + " ");
}
System.out.println();
}
scan.close();
}
public static double[][] addMatrix(double[][] a, double[][] b) {
double[][] c = new double[3][3];
for (int i = 0; i < c.length; i++) {
for (int j = 0; j < c[i].length; j++) {
c[i][j] = a[i][j] + b[i][j];
}
}
return c;
}
}
结果：
391
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
