Java 练习（二）

calendar 2024-12-29 · 11 分钟阅读 · Java  ·
复制链接: copy
  1. 从键盘接收两个数据，一个代表鸡和兔子的头数，一个代表，鸡和兔子的腿数。编写一个程序，计算有多少只鸡，多少只兔子。如果无解，则输出：No solution.
 1input:
 235
 394
 4
 5output:
 6rabbit: 12 chicken: 23
 7
 8input:
 920
1040
11
12output:
13only have chicken: 20
14
15input:
1615
1760
18
19output:
20only have rabbit: 15
21
22input:
2310
24100
25
26output:
27No solution

 1import java.util.Scanner;
 2
 3public class Main {
 4    public static void main(String[] args) {
 5        try (Scanner scanner = new Scanner(System.in)) {
 6            int heads = scanner.nextInt();
 7            int legs = scanner.nextInt();
 8
 9            if (legs == 4 * heads) {
10                System.out.println(String.format("Only %d rabbits.", heads));
11            } else if (legs == 2 * heads) {
12                System.out.println(String.format("Only %d chickens.", heads));
13            } else if (legs < 2 * heads || legs > 4 * heads | legs % 2 != 0) {
14                System.out.println("No soluion.");
15            } else {
16                int tmp = legs - heads * 2;
17                int rabbits = tmp / 2;
18                int chickens = heads - rabbits;
19                System.out.println(String.format("Rabbit: %d, Chicken: %d", rabbits, chickens));
20            }
21        }
22    }
23}
  1. 从键盘输入一个n的值，输出斐波那契数列的前n项。已知菲波那切数列的第一项和第二项都为1，其余项为：$f(n) = f(n-1) + f(n-2)$。
 1input:
 25
 3
 4output:
 51 1 2 3 5
 6
 7input:
 82
 9
10output:
111 1

 1import java.util.Scanner;
 2
 3public class Main {
 4    public static void main(String[] args) {
 5        try (Scanner scanner = new Scanner(System.in)) {
 6            int n = scanner.nextInt();
 7            int a = 1, b = 1, c;
 8            for (int i = 0; i < n; i++) {
 9                if (i == 0 || i == 1) {
10                    System.out.print(String.format("%d ", 1));
11                } else {
12                    c = a + b;
13                    System.out.print(String.format("%d ", c));
14                    a = b;
15                    b = c;
16                }
17            }
18        }
19    }
20}
  1. “今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二”问物几何。出自——孙子算经。

（有一个数，不知道是多少，但是它除3余数是2，除5余数是3，除7余数是2，问这个数是多少？）

请输出满足条件的最小正整数：

 1public class Main {
 2    public static void main(String[] args) {
 3        boolean found = false;
 4        int n = 2;
 5        while (!found) {
 6            n += 7;
 7            if (n % 3 == 2 && n % 5 == 3) {
 8                found = true;
 9            }
10        }
11        System.out.println(n);
12    }
13}
  1. 奇数偶数贩售机。创建一个程序，判断输入数据是奇数还是偶数， 并输出该数字后连续的9个奇数或偶数，例如：输入2，返回"Even"并输出2 4 6 8 10 12 14 16 18

输入1，返回"Odd"并输出1 3 5 7 9 11 13 15 17

 1input:
 22
 3
 4output:
 5Even
 62 4 6 8 10 12 14 16 18
 7
 8input:
 93
10
11output:
12Odd
133 5 7 9 11 13 15 17 19

 1import java.util.Scanner;
 2
 3public class Main {
 4    public static void main(String[] args) {
 5        try (Scanner scanner = new Scanner(System.in)) {
 6            int n = scanner.nextInt();
 7            System.out.println(n % 2 == 0 ? "Even" : "Odd");
 8            for (int i = n; i < n + 17; i += 2) {
 9                System.out.print(String.format("%d ", i));
10            }
11        }
12    }
13}
  1. 从键盘接收一个十进制整数，将十进制整数转换成二进制的形式输出。
 1example:
 2
 3input:
 411
 5
 6output:
 71011
 8
 9input:
10100
11
12output:
131100100

 1import java.util.Scanner;
 2
 3public class Main {
 4    public static void main(String[] args) {
 5        try (Scanner scanner = new Scanner(System.in)) {
 6            int n = scanner.nextInt();
 7            String binary = Integer.toBinaryString(n); // 转化为二进制字符串
 8            System.out.println(binary);
 9        }
10    }
11}
  1. 编写一个程序，实现如下功能：从键盘读入一个数据n，输出一个n行n列的列表：对第i行和第j列位置，如果i和j的最大公约数是1（即i和j互素），则输出“*”号，其他位置输出“#”号。每打印n个符号后，换行输出新的符号。
 1example:
 2
 3Input:
 44
 5output:
 6****
 7*#*#
 8**#*
 9*#*#
10
11input:
127
13output:
14*******
15*#*#*#*
16**#**#*
17*#*#*#*
18****#**
19*###*#*
20******#

 1import java.util.Scanner;
 2
 3public class Main {
 4    public static void main(String[] args) {
 5        StringBuilder row = new StringBuilder(""); // 创建 StringBuilder 构建字符串
 6        try (Scanner scanner = new Scanner(System.in)) {
 7            int n = scanner.nextInt();
 8            for (int i = 1; i <= n; i++) {
 9                for (int j = 1; j <= n; j++) {
10                    if (gcd(i, j) == 1) {
11                        row.append("*"); // StringBuilder 中追加字符串
12                    } else {
13                        row.append('#'); // StringBuilder 亦可以追加字符类型
14                    }
15                }
16                System.out.println(row.toString()); // 转换为字符串输出
17                row.setLength(0); // 重置 StringBuilder
18            }
19        }
20    }
21
22    public static int gcd(int a, int b) {
23        return b == 0 ? a : gcd(b, a % b); // 三元表达式
24    }
25}
  1. 使用泰勒级数展开是计算正弦函数，展开式的最后一项精度不超过1e-10。其中正弦函数的展开式为：

$$ sinx=x-\frac{x^3}{3!}+\frac{x^5}{5!}-\cdots $$

从键盘输入一个x（x为浮点数），计算x的正弦函数，结果保留小数位数2位（此题不要纠结，数位精度不对也可认为正确）。

 1example:
 2
 3input:
 40.5
 5
 6output:
 70.48
 8
 9input:
101
11
12output:
130.84

 1import java.util.Scanner;
 2
 3public class Main {
 4    public static void main(String[] args) {
 5        try (Scanner scanner = new Scanner(System.in)) {
 6            double x = scanner.nextDouble();
 7            int n = 1;
 8            double sinx = 0.0;
 9            int fac_n;
10
11            while (true) {
12                fac_n = 1;
13                for (int i = 1; i <= n; i++) {
14                    fac_n *= i;
15                }
16                if (Math.pow(x, n) / fac_n > 1e-10) {
17                    if ((n - 1) % 4 == 0) {
18                        sinx += Math.pow(x, n) / fac_n;
19                    } else {
20                        sinx -= Math.pow(x, n) / fac_n;
21                    }
22                } else {
23                    break;
24                }
25                n += 2;
26            }
27
28            System.out.println(String.format("%.2f", sinx));
29        }
30    }
31}
  1. 从键盘读入一个数n，输出小于或等于n的所有素数的个数。
 1example
 2
 3input:
 4100
 5
 6output:
 725
 8
 9input:
10200
11
12output:
1346

 1import java.util.Scanner;
 2
 3public class Main {
 4    public static void main(String[] args) {
 5        try (Scanner scanner = new Scanner(System.in)) {
 6            int number = scanner.nextInt();
 7            int result = 0;
 8            for (int i = 2; i <= number; i++) {
 9                if (isPrime(i)) {
10                    result++;
11                }
12            }
13            System.out.println(result);
14        }
15    }
16
17    public static boolean isPrime(int n) {
18        if (n <= 1) {
19            return false;
20        } else {
21            for (int i = 2; i <= Math.sqrt(n); i++) {
22                if (n % i == 0) {
23                    return false;
24                }
25            }
26            return true;
27        }
28    }
29}
  1. 从键盘输入一个正整数n，输出小于n的所有与其互素的数的个数。（即求 $\phi(n)$ 的值）。例如：与10互素的数为：9,7,3,1一共4个。
 1example：
 2
 3input:
 410
 5
 6output:
 74
 8
 9input:
109
11
12output:
136

 1import java.util.Scanner;
 2
 3public class Main {
 4    public static void main(String[] args) {
 5        try (Scanner scanner = new Scanner(System.in)) {
 6            int n = scanner.nextInt();
 7            int result = 0;
 8            for (int i = 1; i < n; i++) {
 9                if (gcd(n, i) == 1) {
10                    result++;
11                }
12            }
13            System.out.println(result);
14        }
15    }
16
17    public static int gcd(int a, int b) {
18        return b == 0 ? a : gcd(b, a % b);
19    }
20}
  1. 从键盘接受一个正整数n，生成一个由1~n的数组。输出一个数组，数组中的每个元素为与前面数组中小于自身的互素的数的个数。
 1example:
 2
 3input:
 410
 5
 6output:
 7[0, 1, 2, 2, 4, 2, 6, 4, 6, 4]
 8
 9input:
1020
11
12output:
13[0, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16, 6, 18, 8]

 1import java.util.Scanner;
 2import java.util.ArrayList; // 导入 ArrayList 类
 3
 4public class Main {
 5    public static void main(String[] args) {
 6        try (Scanner scanner = new Scanner(System.in)) {
 7            int n = scanner.nextInt();
 8            ArrayList<Integer> result = new ArrayList<>(); // 利用 ArrayList 存储结果
 9            for (int i = 1; i <= n; i++) {
10                result.add(coprimeCount(i)); // 向 ArrayList 追加结果
11            }
12            System.out.println(result);
13        }
14    }
15
16    public static int coprimeCount(int n) {
17        int count = 0;
18        for (int i = 1; i < n; i++) {
19            if (gcd(n, i) == 1) {
20                count++;
21            }
22        }
23        return count;
24    }
25
26    public static int gcd(int a, int b) {
27        return b == 0 ? a : gcd(b, a % b);
28    }
29}
  1. 从键盘输入一个n，打印一个等腰三角形。
 1input:
 24
 3output:
 4   *
 5  ***
 6 *****
 7*******
 8
 9input:
107
11output:
12      *
13     ***
14    *****
15   *******
16  *********
17 ***********
18*************

 1import java.util.Scanner;
 2
 3public class Main {
 4    public static void main(String[] args) {
 5        try (Scanner scanner = new Scanner(System.in)) {
 6            int n = scanner.nextInt();
 7            String asterisk = "*", space = " ";
 8
 9            for (int i = 1; i <= n; i++) {
10                System.out.println(
11                        String.format(
12                                "%s%s",
13                                space.repeat(n - i), // 重复字符串
14                                asterisk.repeat(2 * i - 1)));
15            }
16        }
17    }
18}
  1. 从键盘输入一个n，打印如下图形。
 1input:
 24
 3
 4output:
 5   *
 6  ***
 7 *****
 8*******
 9 *****
10  ***
11   *
12
13input:
143
15
16output:
17  *
18 ***
19*****
20 ***
21  *
  1. 从键盘接收一个n，用来确定数组包含的元素个数。并循环读入n个数字字符，将其转换成int型数据，存储在数组中。编写一个程序，让数组中，相邻的两位进行比较，并将比较大的数字交换到后面的位置，将数组中相邻的两位依次比较，确保经过一轮比较后，数组中最大的数字放在索引为n-1的位置上。输出此时最大值在索引最大位置上的数组。
 1example：
 2
 3input:
 45
 53
 67
 76
 84
 92
10
11output:
12[3, 6, 4, 2, 7]

 1import java.util.Scanner;
 2import java.util.Arrays;
 3
 4public class Main {
 5    public static void main(String[] args) {
 6        try (Scanner scanner = new Scanner(System.in)) {
 7            int n = scanner.nextInt();
 8            int[] numbers = new int[n];
 9            for (int i = 0; i < n; i++) {
10                numbers[i] = scanner.nextInt();
11            }
12            bubbleSortRound(numbers);
13            System.out.println(Arrays.toString(numbers)); // 数组不能直接打印，需要用 Arrays.toString() 转化为字符串
14        }
15    }
16
17    public static void bubbleSortRound(int[] numbers) {
18        int n = numbers.length; // length 为数组的属性而非方法
19        for (int i = 0; i < n - 1; i++) {
20            if (numbers[i] > numbers[i + 1]) {
21                int temp = numbers[i];
22                numbers[i] = numbers[i + 1];
23                numbers[i + 1] = temp;
24            }
25        }
26    }
27}
  1. 从键盘接收一个n，代表当前数组中包含的元素个数。依次从键盘读入n个数据，并转换成int型，保存在数组中。按照上题的方法整理数组中的元素，将数组中元素整理为从小到大有序的数组输出。（注：不允许使用内置的排序函数，或方法）
 1input:
 25
 33
 47
 56
 64
 72
 8
 9output:
10
11[2, 3, 4, 6, 7]

 1import java.util.Scanner;
 2import java.util.Arrays;
 3
 4public class Main {
 5    public static void main(String[] args) {
 6        try (Scanner scanner = new Scanner(System.in)) {
 7            int n = scanner.nextInt();
 8            int[] numbers = new int[n];
 9            for (int i = 0; i < n; i++) {
10                numbers[i] = scanner.nextInt();
11            }
12            bubbleSort(numbers);
13            System.out.println(Arrays.toString(numbers)); // 数组不能直接打印，需要用 Arrays.toString() 转化为字符串
14        }
15    }
16
17    public static void bubbleSort(int[] numbers) {
18        int n = numbers.length; // length 为数组的属性而非方法
19        for (int i = 0; i < n - 1; i++) {
20            for (int j = 0; j < n - i - 1; j++) {
21                if (numbers[j] > numbers[j + 1]) {
22                    int temp = numbers[j];
23                    numbers[j] = numbers[j + 1];
24                    numbers[j + 1] = temp;
25                }
26            }
27        }
28    }
29}
  1. 从键盘接收一个m，代表二维数组的行数，再从键盘接收一个n，代表二维数组的列数。利用循环读入二维数组所有的数值，并转换为int类型，存在数组中。输出该二维数组。
 1example：
 2
 3input:
 42
 53
 61
 74
 87
 92
105
118
12
13output:
14[[1, 4, 7], [2, 5, 8]]

 1import java.util.Scanner;
 2import java.util.Arrays;
 3
 4public class Main {
 5    public static void main(String[] args) {
 6        try (Scanner scanner = new Scanner(System.in)) {
 7            int row, col;
 8            row = scanner.nextInt();
 9            col = scanner.nextInt();
10
11            int[][] matrix = new int[row][col];
12            for (int i = 0; i < row; i++) {
13                for (int j = 0; j < col; j++) {
14                    matrix[i][j] = scanner.nextInt();
15                }
16            }
17            System.out.println(Arrays.deepToString(matrix)); // 使用 Arrays.deepToString() 打印矩阵和二维数组
18        }
19    }
20}
  1. 从键盘输入一个n，代表一维数组包含的元素数，从键盘读入一个由数字字符和空格组成的字符串，并将它们转换成int型存入到一维数组中。如果得到的数字不足n位，剩余的几个数组元素由0补足，如果超过n位截取前n位组成的数组，并输出该数组。
 1example:
 2
 3input:
 45
 52 3 1 7 10 15
 6
 7output:
 8[2, 3, 1, 7, 10]
 9
10input:
114
1210 2
13
14output:
15[10, 2, 0, 0]

 1import java.util.Scanner;
 2import java.util.Arrays;
 3
 4public class Main {
 5    public static void main(String[] args) {
 6        Scanner scanner = new Scanner(System.in);
 7        int n = scanner.nextInt();
 8        scanner.nextLine();
 9        String numsString = scanner.nextLine();
10        scanner.close();
11
12        String[] numsStringArray = numsString.split("\\s+");
13        int[] nums = new int[n];
14        for (int i = 0; i < n; i++) {
15            if (i < numsStringArray.length) {
16                nums[i] = Integer.parseInt(numsStringArray[i]);
17            } else {
18                nums[i] = 0;
19            }
20        }
21
22        System.out.println(Arrays.toString(nums));
23    }
24}
  1. 从键盘接收一个由数字字符和空格组成的字符串，将其转换为整型数据存储在一维数组中。判断该一维数组中是否存在重复元素，如果有重复元素，输出False，否则输出True。
 1example:
 2
 3input：
 43 2 1 7 5 6 8 0
 5
 6output：
 7True
 8
 9input:
102 2 1 3 4 3 8 6
11
12output:
13False

 1import java.util.Scanner;
 2import java.util.Arrays;
 3
 4public class Main {
 5    public static void main(String[] args) {
 6        Scanner scanner = new Scanner(System.in);
 7        String numsString = scanner.nextLine();
 8        scanner.close();
 9
10        String[] numsStringsArray = numsString.split("\\s+");
11        int len = numsStringsArray.length;
12        int[] nums = new int[len];
13
14        for (int i = 0; i < len; i++) {
15            nums[i] = Integer.parseInt(numsStringsArray[i]);
16        }
17
18        int[] uniqueNums = Arrays
19                .stream(nums) // 转化为流
20                .distinct() // 去重
21                .toArray(); // 转化为数组
22
23        System.out.println(uniqueNums.length == len);
24    }
25}
  1. 从键盘输入一个n，创建一个n * n的二维数组，在二维数组中，第0行的值为1，第1行的值为2，以此类推，第n-1的值为n。输出此二维数组。
1example:
2
3input:
45
5
6output:
7[[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4], [5, 5, 5, 5, 5]]

 1import java.util.Scanner;
 2import java.util.Arrays;
 3
 4public class Main {
 5    public static void main(String[] args) {
 6        try (Scanner scanner = new Scanner(System.in)) {
 7            int n = scanner.nextInt();
 8            int[][] matrix = new int[n][n];
 9            for (int i = 0; i < n; i++) {
10                for (int j = 0; j < n; j++) {
11                    matrix[i][j] = i + 1;
12                }
13            }
14            System.out.println(Arrays.deepToString(matrix));
15        }
16    }
17}
  1. 输出上一题得到的二维数组的转置数组。
 1example:
 2
 3input:
 45
 5
 6output:
 7[[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]
 8
 9input:
104
11
12output:
13[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]

 1import java.util.Scanner;
 2import java.util.Arrays;
 3
 4public class Main {
 5    public static void main(String[] args) {
 6        try (Scanner scanner = new Scanner(System.in)) {
 7            int n = scanner.nextInt();
 8            int[][] matrix = new int[n][n];
 9            for (int i = 0; i < n; i++) {
10                for (int j = 0; j < n; j++) {
11                    matrix[i][j] = j + 1;
12                }
13            }
14            System.out.println(Arrays.deepToString(matrix));
15        }
16    }
17}

相关系列文章