讷讷！讷讷！

Java实践课1

  • ~4.54K 字
  1. 1. （选择结构练习）编写程序实现解一元二次方程的韦达定理求根公式
  2. 2. （循环结构练习）利用迭代法求某正数a的平方根
  3. 3. （循环结构练习）编写一个计算矩阵乘积的程序，完成对一个3×4矩阵和一个4× 5矩阵的乘法运算
  4. 4. （循环结构练习）《孙子算经》卷下第二十六题
  5. 5. main函数

简单写了一下，算法及其低效

目录结构

（选择结构练习）编写程序实现解一元二次方程的韦达定理求根公式

代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

import java.util.ArrayList;

public class Q1 {

    private static double calculateDelta(double a,double b,double c) {
        return Math.sqrt(b*b-4*a*c);
    }

    public static ArrayList getAns(double a, double b, double c){
        double delta = calculateDelta(a,b,c);
        double ans1 = (-b+delta)/2*a;
        double ans2 = (-b-delta)/2*a;
        ArrayList<Double> result = new ArrayList<>();
        result.add(ans1);
        result.add(ans2);
        return result;
    }

}

（循环结构练习）利用迭代法求某正数a的平方根

计算公式为xn+1=(xn+a/xn)/2，试编写程序实现这个算法。
其中：初始值为x0=a/2
当xn+1与xn的差的绝对值小于一个正数 数值z时，即可以认为xn+1是所求的平方根。

代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.ArrayList;

public class Q2 {

    private static double calculateNext0(double a, double xNow, int depthMax, int depthNow) {
        double xNew = (xNow + a / xNow) / 2;
        if (Math.abs(xNow - xNew) < 0.00001||depthNow>depthMax) {
            return xNew;
        } else
            return calculateNext0(a, xNew, depthMax, depthNow + 1);
    }

    public static double getAns(double a, int depth) {
        return calculateNext0(a,a/2,depth,0);
    }


}

（循环结构练习）编写一个计算矩阵乘积的程序，完成对一个3×4矩阵和一个4× 5矩阵的乘法运算

代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

import java.util.Collection;
import java.util.List;

public class Q3 {
    public static void main(String[] args) {

        int[][] matrix1 = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12},
        };
        int[][] matrix2 = {
                {1, 2, 3, 4, 5},
                {6, 7, 8, 9, 10},
                {11, 12, 13, 14, 15},
                {16, 17, 18, 19, 20},
        };
        System.out.println("Ans3:");
        Q3.calculateNext0(matrix1, matrix2);
    }
    public static void calculateNext0(int[][]/*(3,4)*/ matrix1, int[][]/*(4,5)*/ matrix2) {
        int[][] res = new int[3][5];
        for (int row = 0; row < 3; row++) {
            for (int column = 0; column < 5; column++) {
                for (int k = 0; k < 4; k++) {
                    res[row][column] += matrix1[row][k] * matrix2[k][column];
                }
            }
        }
        printMatrix(res);
    }

    private static void printMatrix(int[][] res) {
        for (int[] row : res) {
            for (int item : row) {
                System.out.print(item+", ");
            }
                System.out.println();
        }
    }


}

（循环结构练习）《孙子算经》卷下第二十六题

今有物不知其数， 三三数之剩二；五五数之剩三；七七数之剩二。问物几何?”
这是一个著名的不定方程问题，意思是说有一个正整数，
被3除的余数是2，被5除的余 数是3，被7除的余数是2，求这个数。
试编写程序计算这个正整数,范围限定于105以内。

代码
1
2
3
4
5
6
7
8
9
10
11
12
public class Q4 {

    public static int getAns() {
        int n =0;
        while (n%3!=2||n%5!=3||n%7!=2){
            n++;
        }
        return n;
    }


}

main函数

为了方便读取输入，写了个工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import java.util.Scanner;

public class ConsoleUtils {
    static Scanner scanner = new Scanner(System.in);
    public static double nextDouble(){
        while (true){
            try {
                return Double.parseDouble(scanner.nextLine());
            } catch (Exception _) {
                System.out.println("not a double!!!");
                continue;
            }
        }
    }
}
代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        separator();
        System.out.println("please input a,b,c in separate lines");
        System.out.println("Ans1 = " + Q1.getAns(ConsoleUtils.nextDouble(), ConsoleUtils.nextDouble(), ConsoleUtils.nextDouble()));
        separator();

        System.out.println("please input a");
        System.out.println("Ans2 = " + Q2.getAns(ConsoleUtils.nextDouble(), 100));
        separator();

        int[][] matrix1 = {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12},
        };
        int[][] matrix2 = {
                {1, 2, 3, 4, 5},
                {6, 7, 8, 9, 10},
                {11, 12, 13, 14, 15},
                {16, 17, 18, 19, 20},
        };
        System.out.println("Ans3:");
        Q3.calculateNext0(matrix1, matrix2);
        separator();

        System.out.println("Ans4 = " + Q4.getAns());
        separator();

    }

    private static void separator() {
        System.out.println("---------------------------------------");
    }
}
本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可
,