Java 练习（四）
- 从键盘接收一个长字符串，统计其中的元音字母（包括大写和小写的），并按照字母表的顺序，把元音和元音的个数组成一个一位数组元素存在二维数组中。假设元音a的个数为0个，应该在数组中添加元素["a", 0]。（注意：大写和小写的元音，统一转换为小写字母计算元音个数）
1example:
2
3input:
4diwisniisiaidiengiowiwiOAIANAIDID
5
6output:
7[['a', 4], ['e', 1], ['i', 13], ['o', 2], ['u', 0]]
1package com.jackgdn;
2
3import java.util.Scanner;
4import java.util.Map;
5import java.util.TreeMap;
6import java.util.List;
7import java.util.ArrayList;
8
9public class Main {
10 public static void main(String[] args) {
11 String s;
12 try (Scanner scanner = new Scanner(System.in)) {
13 s = scanner.nextLine();
14 }
15
16 Map<Character, Integer> result = new TreeMap<>(); // TreeMap 将 key 按字典序排序
17 for (char c : new char[] { 'a', 'e', 'i', 'o', 'u' }) {
18 result.put(c, 0);
19 }
20
21 for (char c : s.toCharArray()) {
22 switch (Character.toLowerCase(c)) {
23 case 'a':
24 result.put('a', result.get('a') + 1);
25 break;
26 case 'e':
27 result.put('e', result.get('e') + 1);
28 break;
29 case 'i':
30 result.put('i', result.get('i') + 1);
31 break;
32 case 'o':
33 result.put('o', result.get('o') + 1);
34 break;
35 case 'u':
36 result.put('u', result.get('u') + 1);
37 break;
38 default:
39 break;
40 }
41 }
42
43 List<List<Object>> resultList = new ArrayList<>();
44 for (Map.Entry<Character, Integer> entry : result.entrySet()) { // 遍历 Map 的 entry
45 List<Object> entryList = new ArrayList<>();
46 entryList.add(entry.getKey());
47 entryList.add(entry.getValue());
48 resultList.add(entryList);
49 }
50
51 System.out.println(resultList);
52 }
53}
- 从键盘输入一个n，代表要输入的整数个数，再输入一行用单个空格隔开的非零整数，每个整数各不相同。输出一个整数，是n个非零整数中包含的相反数共有多少对。（注: 1和-1就是一对相反数）
1example:
2
3input:
45
51 2 3 -1 -2
6
7output:
82
1package com.jackgdn;
2
3import java.util.Scanner;
4import java.util.Map;
5import java.util.HashMap;
6
7public class Main {
8 public static void main(String[] args) {
9 Scanner scanner = new Scanner(System.in);
10 int n = scanner.nextInt();
11 Map<Integer, Integer> map = new HashMap<>();
12 for (int i = 0; i < n; i++) {
13 map.put(scanner.nextInt(), 1);
14 }
15 scanner.close();
16
17 int count = 0;
18 for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
19 if (map.containsKey(1 - entry.getKey())) {
20 count++;
21 }
22 }
23
24 System.out.println(count / 2);
25 }
26}
- 利用递归编写程序。
$$ f(a,b)=\begin{cases}b:a=0 \\ a:b=0 \\ f(a/2,b)+2a:a>b\space and\space a\neq0\space and\space b \neq0 \\ f(a,b/2)+2b:b>a\space and\space a\neq0\space and\space b \neq0 \\ f(a-1,b+1):otherwise\end{cases} $$
从键盘输入a,b的值。输出f(a,b)的值。
1example:
2
3input:
43
54
6
7output:
820
9
10input：
114
120
13
14output：
154
1package com.jackgdn;
2
3import java.util.Scanner;
4
5public class Main {
6 public static void main(String[] args) {
7 try (Scanner scanner = new Scanner(System.in)) {
8 int a = scanner.nextInt();
9 int b = scanner.nextInt();
10 System.out.println(f(a, b));
11 }
12 }
13
14 public static int f(int a, int b) {
15 if (a == 0) {
16 return b;
17 } else if (b == 0) {
18 return a;
19 } else if (a > b && a != 0 && b != 0) {
20 return f(a / 2, b) + 2 * a;
21 } else if (b > a && a != 0 && b != 0) {
22 return f(a, b / 2) + 2 * b;
23 } else {
24 return f(a - 1, b + 1);
25 }
26 }
27}
- 从键盘输入一个一维数组，一维数组中 包含多个数字，将这些数字中包含9的数字从一维数组中删掉。输出由剩下数字组成的一维数组。
1example:
2
3input:
4[589775, 677017, 34439, 48731548, 782295632, 181967909]
5
6output:
7[677017, 48731548]
8
9input:
10[292069010, 73980, 8980155, 921545108, 75841309, 6899644]
11
12output:
13[]
1package com.jackgdn;
2
3import java.util.Scanner;
4import java.util.List;
5import java.util.ArrayList;
6
7public class Main {
8 public static void main(String[] args) {
9 String numsArrayString;
10 try (Scanner scanner = new Scanner(System.in)) {
11 numsArrayString = scanner.nextLine();
12 }
13 String[] numsStringsArray = numsArrayString.substring(1, numsArrayString.length() - 1)
14 .split("\\s*,\\s*");
15
16 List<String> resultNumsStrings = new ArrayList<>();
17 for (String numString : numsStringsArray) {
18 if (!numString.contains("9")) {
19 resultNumsStrings.add(numString);
20 }
21 }
22 System.out.println(resultNumsStrings);
23 }
24}
- 二维列表的输入和垂直对称变换。形如
[[1,2,3],[4,5,6],[7,8,9]]的列表，被称为二维列表（列表的一重嵌套）。请您：
①先读入矩（数）阵的行和列，并依次将矩（数）阵的元素存入到二维列表的对应位置上；
②在此基础上，实现垂直对称变换；
③按照先行后列的顺序将二维列表中的每一个元素添加到一个一维列表中，并输出该一维列表。
1比如：
2
3输入为：
42 3
51 2 3
64 5 6
7
8变换后，二维列表中存储的矩阵形式如下：
94 5 6
101 2 3
11
12输出为：
13[4, 5, 6, 1, 2, 3]
1package com.jackgdn;
2
3import java.util.Scanner;
4import java.util.Arrays;
5
6public class Main {
7 public static void main(String[] args) {
8 Scanner scanner = new Scanner(System.in);
9 int rows = scanner.nextInt();
10 int cols = scanner.nextInt();
11 int[][] matrix = new int[rows][cols];
12 for (int i = 0; i < rows; i++) {
13 for (int j = 0; j < cols; j++) {
14 matrix[i][j] = scanner.nextInt();
15 }
16 }
17 scanner.close();
18
19 int[] result = new int[rows * cols];
20 for (int i = rows; i > 0; i--) {
21 for (int j = 0; j < cols; j++) {
22 result[(rows - i) * cols + j] = matrix[i - 1][j];
23 }
24 }
25
26 System.out.println(Arrays.toString(result));
27 }
28}
- 编写一个程序计算c的值，$c=\sqrt{a^2+b^2-2abcosr}$，从键盘输入一个a，一个b,一个r，输出c的值。（保留两位小数）
1example:
2
3input:
42.5
53.4
690
7
8output:
95.04
1package com.jackgdn;
2
3import java.util.Scanner;
4
5public class Main {
6 public static void main(String[] args) {
7 double a, b, r;
8 try (Scanner scanner = new Scanner(System.in)) {
9 a = scanner.nextDouble();
10 b = scanner.nextDouble();
11 r = scanner.nextDouble();
12 }
13
14 double c = Math.sqrt(a * a + b * b - 2 * a * b * Math.cos(r));
15 System.out.println(String.format("%.2f", c));
16 }
17}
- 从键盘输入一组由单词和空格组成的长字符串，统计字符串中不包括元音字母的单词个数。
1example:
2
3input：
4word by word
5
6output：
71
1package com.jackgdn;
2
3import java.util.Scanner;
4
5public class Main {
6 public static void main(String[] args) {
7 String sentence;
8 try (Scanner scanner = new Scanner(System.in)) {
9 sentence = scanner.nextLine();
10 }
11 String[] words = sentence.trim().split("\\s+");
12
13 int count = 0;
14 for (String word : words) {
15 if (!containsVowel(word)) {
16 count++;
17 }
18 }
19
20 System.out.println(count);
21 }
22
23 public static boolean containsVowel(String word) {
24 String vowels = "aeiouAEIOU";
25 for (char c : word.toCharArray()) {
26 if (vowels.indexOf(c) != -1) {
27 return true;
28 }
29 }
30 return false;
31 }
32}
- 输入一个由秒组成的字符串例如15678s，转换成小时分秒输出，或输入一个小时组成的字符串3.56h，转换成秒输出。
1example:
2
3input:
415678s
5
6output:
7Total time is: 4 hour 21 minute 18 second
8
9input:
103.56h
11
12output:
13Total second is: 12816
1package com.jackgdn;
2
3import java.util.Scanner;
4
5public class Main {
6 public static void main(String[] args) {
7 String timeString;
8 try (Scanner scanner = new Scanner(System.in)) {
9 timeString = scanner.nextLine();
10 }
11
12 String result = parseTime(timeString);
13 System.out.println(result);
14 }
15
16 public static String parseTime(String timeString) {
17 if (timeString.charAt(timeString.length() - 1) == 's') {
18 int second = Integer.parseInt(timeString.substring(0, timeString.length() - 1));
19 return secondToHour(second);
20 } else {
21 double hour = Double.parseDouble(timeString.substring(0, timeString.length() - 1));
22 return hourToSecond(hour);
23 }
24 }
25
26 public static String secondToHour(int s) {
27 int hour = s / 3600;
28 int minute = (s % 3600) / 60;
29 int second = s % 60;
30 return hour + " hours " + minute + " minutes " + second + " seconds";
31 }
32
33 public static String hourToSecond(double h) {
34 int second = (int) (h * 3600);
35 return second + " seconds";
36 }
37}
- 从键盘输入一个n，打印与n相关的图像。具体图形见例子。
1example：
2
3input:
43
5
6output:
7*
8**
9***
10
11input:
126
13
14output:
15*
16**
17***
18****
19*****
20******
1package com.jackgdn;
2
3import java.util.Scanner;
4
5public class Main {
6 public static void main(String[] args) {
7 try (Scanner scanner = new Scanner(System.in)) {
8 int n = scanner.nextInt();
9 for (int i = 1; i <= n; i++) {
10 System.out.println("*".repeat(i));
11 }
12 }
13 }
14}
- 编写一个程序，从键盘输入一行一维数组，一行符号，一行数字，根据符号，计算一维数组值的改变。输入符号只有四种，分别为“+”“-”“*”“/”，当符号为“/”时，判断一维数组中的每个元素是什么类型，如果每个元素都为int型数据，输出的一维数组中每一项，为整除的结果，即输出的一维数组中每一项的值都为int型，如果一维数组中至少包含一个float型数据，则输出的一维数组中每个元素都为float型数据。
1example:
2
3input:
4[1,2,3,4]
5+
63
7
8output:
9[4,5,6,7]
10
11input:
12[1,2,3,4]
13*
143
15
16output:
17[3,6,9,12]
18
19input:
20[1,2,3,4]
21/
222
23
24output:
25[0,1,1,2]
26
27input:
28[1.0,2,3,4]
29/
302
31
32output:
33[0.5, 1.0, 1.5, 2.0]
1package com.jackgdn;
2
3import java.util.Scanner;
4import com.google.gson.Gson;
5import java.util.Arrays;
6
7public class Main {
8 public static void main(String[] args) {
9
10 String numsArrayString;
11 char operator;
12 int operand;
13 try (Scanner scanner = new Scanner(System.in)) {
14 numsArrayString = scanner.nextLine();
15 operator = scanner.nextLine().charAt(0);
16 operand = scanner.nextInt();
17 }
18
19 Gson gson = new Gson();
20 if (numsArrayString.contains(".")) {
21 Double[] numsArray = gson.fromJson(numsArrayString, Double[].class);
22 switch (operator) {
23 case '+':
24 for (int i = 0; i < numsArray.length; i++) {
25 numsArray[i] += operand;
26 }
27 break;
28 case '-':
29 for (int i = 0; i < numsArray.length; i++) {
30 numsArray[i] -= operand;
31 }
32 break;
33 case '*':
34 for (int i = 0; i < numsArray.length; i++) {
35 numsArray[i] *= operand;
36 }
37 break;
38 case '/':
39 for (int i = 0; i < numsArray.length; i++) {
40 numsArray[i] /= operand;
41 }
42 break;
43 default:
44 System.out.println("Invalid operator");
45 return;
46 }
47 System.out.println(Arrays.toString(numsArray));
48 } else {
49 Integer[] numsArray = gson.fromJson(numsArrayString, Integer[].class);
50 switch (operator) {
51 case '+':
52 for (int i = 0; i < numsArray.length; i++) {
53 numsArray[i] += operand;
54 }
55 break;
56 case '-':
57 for (int i = 0; i < numsArray.length; i++) {
58 numsArray[i] -= operand;
59 }
60 break;
61 case '*':
62 for (int i = 0; i < numsArray.length; i++) {
63 numsArray[i] *= operand;
64 }
65 break;
66 case '/':
67 for (int i = 0; i < numsArray.length; i++) {
68 numsArray[i] /= operand;
69 }
70 break;
71 default:
72 System.out.println("Invalid operator");
73 return;
74 }
75 System.out.println(Arrays.toString(numsArray));
76 }
77 }
78}
- 某公司有n千万元可以用于对a,b,c三个项目的投资。假设每年投资一个项目，投资的规则是：或者对a投资1千万，或者对b投资2千万，或者对c投资2千万，从键盘输入一个n，代表投资的n千万，输出可以得到的总的方案数有多少个。 将该问题转换为递归公式，可以写成：$f(n)=f(n-1)+2f(n-2)$，其中f(1) = 1,f(2) = 3。
1example:
2
3input:
43
5
6output:
75
8
9input：
1010
11
12output:
13683
1package com.jackgdn;
2
3import java.util.Scanner;
4
5public class Main {
6 public static void main(String[] args) {
7 try (Scanner scanner = new Scanner(System.in)) {
8 int n = scanner.nextInt();
9 System.out.println(f(n));
10 }
11 }
12
13 public static int f(int n) {
14 if (n == 1) {
15 return 1;
16 } else if (n == 2) {
17 return 3;
18 } else {
19 return f(n - 1) + 2 * f(n - 2);
20 }
21 }
22}
- 输入两行数据，第一个包含一个整数n，表示数列中整数的个数。第二行包含n个整数a1,a2,a3,……an,表示给定的数列，相邻的整数之间用一个空格分割。输出一个整数，表示给定的数列有多少段。
1example:
2
3input:
48
58 8 8 0 12 12 8 0
6
7output:
85
9
10（注：8 8 8 是第一段，0 是第二段， 12 12 是第三段 ， 8 是第四段，最后一个0 是第五段。）
1package com.jackgdn;
2
3import java.util.Scanner;
4
5public class Main {
6 public static void main(String[] args) {
7 try (Scanner scanner = new Scanner(System.in)) {
8 int n = scanner.nextInt();
9 int count = 1;
10 int previous = scanner.nextInt();
11 if (n == 1) {
12 System.out.println(count);
13 return;
14 }
15
16 for (int i = 1; i < n; i++) {
17 int current = scanner.nextInt();
18 if (current != previous) {
19 count++;
20 }
21 previous = current;
22 }
23 System.out.println(count);
24 }
25 }
26}
- 从键盘输入一个未排序的一维数组，利用选择排序对其进行排序，输出每一次选择排序后得到的一维数组序列。选择排序的执行原理是扫描整个无序序列，将最小元素与无序序列索引0的位置做交换。第二次选择剩余无序序列中最小的元素与索引是1的位置交换，以此类推，直到最后一次选择剩余无序序列中最小的元素与索引是len-1的位置做交换。
1example:
2
3input:
4[6,2,7,5,4,1,3]
5
6output:
7[1, 2, 7, 5, 4, 6, 3]
8[1, 2, 7, 5, 4, 6, 3]
9[1, 2, 3, 5, 4, 6, 7]
10[1, 2, 3, 4, 5, 6, 7]
11[1, 2, 3, 4, 5, 6, 7]
12[1, 2, 3, 4, 5, 6, 7]
13
14input:
15[22,8,16,5,14,17]
16
17output:
18[5, 8, 16, 22, 14, 17]
19[5, 8, 16, 22, 14, 17]
20[5, 8, 14, 22, 16, 17]
21[5, 8, 14, 16, 22, 17]
22[5, 8, 14, 16, 17, 22]
1package com.jackgdn;
2
3import java.util.Scanner;
4import com.google.gson.Gson;
5import java.util.Arrays;
6
7public class Main {
8 public static void main(String[] args) {
9 String numsArrayString;
10 try (Scanner scanner = new Scanner(System.in)) {
11 numsArrayString = scanner.nextLine();
12 }
13 Gson gson = new Gson();
14 int[] numsArray = gson.fromJson(numsArrayString, int[].class);
15 slectionSort(numsArray);
16 }
17
18 public static void slectionSort(int[] array) {
19 for (int i = 0; i < array.length - 1; i++) {
20 int key = i;
21 for (int j = i + 1; j < array.length; j++) {
22 if (array[j] < array[key]) {
23 key = j;
24 }
25 }
26 int temp = array[key];
27 array[key] = array[i];
28 array[i] = temp;
29 System.out.println(Arrays.toString(array));
30 }
31 }
32}
- 问题描述
求出区间[a,b]中所有整数的质因数分解。其中：b > a > 1，且a,b皆为正整数。
输入格式
输入两个整数a，b。
输出格式
每行输出一个数的分解。
1样例输入
23 10
3
4样例输出
53=3
64=2*2
75=5
86=2*3
97=7
108=2*2*2
119=3*3
1210=2*5
1package com.jackgdn;
2
3import java.util.Scanner;
4import java.util.List;
5import java.util.ArrayList;
6import java.util.stream.Collectors;
7
8public class Main {
9 public static void main(String[] args) {
10 int a, b;
11 try (Scanner scanner = new Scanner(System.in)) {
12 a = scanner.nextInt();
13 b = scanner.nextInt();
14 }
15
16 for (int i = a; i <= b; i++) {
17 System.out.println(String.format("%d=%s", i,
18 primeFactors(i).stream().map(String::valueOf).collect(Collectors.joining("*"))));
19 }
20 }
21
22 public static List<Integer> primeFactors(int n) {
23 List<Integer> factors = new ArrayList<>();
24 while (!isPrime(n) && n > 1) {
25 for (int i = 2; i < n; i++) {
26 if (n % i == 0 && isPrime(i)) {
27 factors.add(i);
28 n /= i;
29 break;
30 }
31 }
32 }
33 factors.add(n);
34 return factors;
35 }
36
37 public static boolean isPrime(int n) {
38 if (n < 2) {
39 return false;
40 } else {
41 for (int i = 2; i * i <= n; i++) {
42 if (n % i == 0) {
43 return false;
44 }
45 }
46 return true;
47 }
48 }
49}
- 请编写程序，实现一下功能：从键盘输入一个n，代表二维数组的行和列，输入n行数列，每行的数列中包括n个数字。判断该矩阵是不是交错矩阵，如果是交错矩阵返回一个True，否则返回Flase。所谓交错矩阵，就是当前矩阵与它的转置矩阵的和为零矩阵。例如：
$$ \begin{bmatrix} 0 & -3 & 7 \\ 3 & 0 & 9 \\ -7 & -9 & 0 \end{bmatrix} \quad \text{与} \quad \begin{bmatrix} 0 & 3 & -7 \\ -3 & 0 & -9 \\ 7 & 9 & 0 \end{bmatrix} $$
互为交错矩阵，它们的转置矩阵与自身的和为全零的矩阵。
1example：
2
3input：
43
50 -3 7
63 0 9
7-7 -9 0
8output：
9True
10
11input：
123
130 3 7
143 0 9
157 9 0
16output：
17False
1package com.jackgdn;
2
3import java.util.Scanner;
4
5public class Main {
6 public static void main(String[] args) {
7 Scanner scanner = new Scanner(System.in);
8 int n = scanner.nextInt();
9 int[][] matrix = new int[n][n];
10 for (int i = 0; i < n; i++) {
11 for (int j = 0; j < n; j++) {
12 matrix[i][j] = scanner.nextInt();
13 }
14 }
15 scanner.close();
16 boolean isZigZag = true;
17 outerLoop: // 定义标签
18 for (int i = 0; i < n; i++) {
19 for (int j = 0; j < n; j++) {
20 if (matrix[i][j] + matrix[j][i] != 0) {
21 isZigZag = false;
22 break outerLoop; // 跳出两层循环
23 }
24 }
25 }
26 System.out.println(isZigZag);
27 }
28}
- 从键盘输入一组数据，以0结尾，0不作为一个数据进行排序，将该组数据整理为，奇数从小到大，偶数从小到大的列表输出。
1input:
21
32
43
54
60
7
8output:
9[1, 3, 2, 4]
1package com.jackgdn;
2
3import java.util.Scanner;
4import java.util.List;
5import java.util.ArrayList;
6import java.util.Collections;
7
8public class Main {
9 public static void main(String[] args) {
10 Scanner scanner = new Scanner(System.in);
11 List<Integer> oddNums = new ArrayList<>();
12 List<Integer> evenNums = new ArrayList<>();
13 int n = scanner.nextInt();
14 while (n != 0) {
15 if (isOdd(n)) {
16 oddNums.add(n);
17 } else {
18 evenNums.add(n);
19 }
20 n = scanner.nextInt();
21 }
22 scanner.close();
23
24 Collections.sort(oddNums);
25 Collections.sort(evenNums);
26 oddNums.addAll(evenNums);
27 System.out.println(oddNums);
28 }
29
30 public static boolean isOdd(int num) {
31 return num % 2 != 0;
32 }
33}
- 已知有公式 $\frac\pi4=1-\frac13+\frac15-\frac17+\cdots+(-1)^{n+1}\frac1{2n-1}$，从键盘输入一个n，m，计算所得到的 $\pi$ 值，其中n表示要计算到的整数，m表示要保留的精度。
1example:
2
3input:
410
52
6
7output:
83.04
1package com.jackgdn;
2
3import java.util.Scanner;
4
5public class Main {
6 public static void main(String[] args) {
7 double n;
8 int m;
9 try (Scanner scanner = new Scanner(System.in)) {
10 n = scanner.nextDouble();
11 m = scanner.nextInt();
12 }
13
14 double sum = 0;
15 for (int i = 1; i <= n; i++) {
16 double term = calculateTerm(i);
17 sum += term;
18 }
19
20 System.out.println(String.format("%." + m + "f", sum * 4));
21 }
22
23 public static double calculateTerm(double n) {
24 return Math.pow(-1, n + 1) * 1 / (2 * n - 1);
25 }
26}
- 从键盘输入一个n，表示给定整数的个数。再输入一行包含n个数的不相等整数序列。输出值正好相差1的数对的个数。
1example:
2
3input:
46
510 2 6 3 7 8
6
7output:
83
9
10(注：其中相差1的数对为（2,3）、（6,7）、（7,8）)
1package com.jackgdn;
2
3import java.util.Scanner;
4import java.util.Map;
5import java.util.HashMap;
6import java.util.Map.Entry;
7
8public class Main {
9 public static void main(String[] args) {
10 Scanner scanner = new Scanner(System.in);
11 int n = scanner.nextInt();
12 Map<Integer, Boolean> nums = new HashMap<>();
13 for (int i = 0; i < n; i++) {
14 nums.put(scanner.nextInt(), true);
15 }
16 scanner.close();
17
18 int count = 0;
19 for (Entry<Integer, Boolean> entry : nums.entrySet()) {
20 if (nums.containsKey(entry.getKey() + 1)) {
21 count++;
22 }
23 if (nums.containsKey(entry.getKey() - 1)) {
24 count++;
25 }
26 }
27
28 System.out.println(count / 2);
29 }
30}
- 问题描述
FJ在沙盘上写了这样一些字符串：
A1 = “A”
A2 = “ABA”
A3 = “ABACABA”
A4 = “ABACABADABACABA”
… …
你能找出其中的规律并写所有的数列AN吗？
输入格式
仅有一个数：N ≤ 26。
输出格式
请输出相应的字符串AN，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
1样例输入
23
3
4样例输出
5ABACABA
1package com.jackgdn;
2
3import java.util.Scanner;
4
5public class Main {
6 public static void main(String[] args) {
7 Scanner scanner = new Scanner(System.in);
8 int n = scanner.nextInt();
9 scanner.close();
10
11 String s = "";
12 for (int i = 0; i < n; i++) {
13 s = s + (char) ('A' + i) + s;
14 }
15
16 System.out.println(s);
17 }
18}