2021年07月11日习题

发表于 分类于 ， ， Waline： 本文字数： 16k 阅读时长 ≈ 14 分钟

1、输入一个3位的整型数，输入其百位、十位及个位数；

SplitInteger.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 输入一个3位的整型数，输入其百位、十位及个位数；
 */
public class SplitInteger {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int hundredDigit, tenDigit, singleDigits;
        int input = scanner.nextInt();
        // 除以100，取出百位数
        hundredDigit = input / 100;
        // 减去百位数，剩下十位数和个位数，再除以10，取出十位数。
        tenDigit = (input - hundredDigit * 100) / 10;
        // 求余10，取出个位数
        singleDigits = input % 10;
        System.out.println(input + "的百位数:" + hundredDigit + ",十位数:" + tenDigit + ",个位数:" + singleDigits);
    }
}

2、判断一个数是否是素数？

质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数；

参考资料

https://oi-wiki.org/math/prime/
https://blog.csdn.net/adamjy/article/details/23514531

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * 判断一个数是否是质数
 * 
 * @param n 一个整数
 * @return 如果n是质数，则返回true，否则返回false
 */
public static boolean isPrime(int n) {
    // 2和3都是质数
    if (n <= 3) {
        // 质数都要大于1
        return n > 1;
    }
    int sqrt = (int) Math.sqrt(n);
    for (int i = 2; i <= sqrt; i++) {
        // 如果n能被小于等于sqrt(n)的整数整除的话，不符合质数的定义，则说明不是质数
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

3、百分制转成等级制（ 利用 if 和 swtich 两种语句格式写）

利用if

ConvertPercentileScoresToGradedScoresByIf.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * 百分制转成等级制-利用 if
 */
public class ConvertPercentileScoresToGradedScoresByIf {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int scores = scanner.nextInt();
        if (scores > 100) {
            System.out.println("成绩必须小于100");
        } else if (scores >= 90) {
            System.out.println("A");
        } else if (scores >= 80) {
            System.out.println("B");
        } else if (scores >= 70) {
            System.out.println("C");
        } else if (scores >= 60) {
            System.out.println("D");
        } else if (scores >= 0) {
            System.out.println("E");
        } else {
            System.out.println("成绩必须大于0");
        }
    }
}

利用switch

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
/**
 * 百分制转成等级制-利用switch
 */
public class ConvertPercentileScoresToGradedScoresBySwitch {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int scores = scanner.nextInt();
        if (scores >= 0 && scores <= 100) {
            switch (scores / 10) {
            case 10:
            case 9:
                System.out.println("A");
                break;
            case 8:
                System.out.println("B");
                break;
            case 7:
                System.out.println("C");
                break;
            case 6:
                System.out.println("D");
                break;
            default:
                System.out.println("E");
            }
        } else {
            System.out.println("请输入[1,100]区间内的数");
        }
    }
}

5、企业发放的奖金根据利润提成。

企业发放的奖金根据利润提成。利润(I)

  • 低于或等于10万元时，奖金可提10%；

  • 利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可可提 成7.5%；

  • 20万到40万之间时，高于20万元的部分，可提成5%；

  • 40万到60万之间时高于 40万元的部，可提成3%；

  • 60万到100万之间时，高于60万元的部分，可提成1.5%，

  • 高于 100万元时，超过100万元的部分按1%提成，

从键盘输入当月利润I，求应发放奖金总数？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static void main(String[] args) {
    // Scanner scanner = new Scanner(System.in);
    int lirun;
    // lirun = scanner.nextInt();
    lirun = 600;
    double jiangjin = 0;
    if (lirun <= 10) {
        jiangjin += lirun * 0.1;
    } else if (lirun < 20) {
        jiangjin += 0.1 + (lirun - 10) * 0.075;
    } else if (lirun < 40) {
        jiangjin += 0.1 + (lirun - 10) * 0.075 + (lirun - 20) * 0.05;
    } else if (lirun < 60) {
        jiangjin += 0.1 + (lirun - 10) * 0.075 + (lirun - 20) * 0.05 + (lirun - 40) * 0.03;
    } else if (lirun < 100) {
        jiangjin += 0.1 + (lirun - 10) * 0.075 + (lirun - 20) * 0.05 + (lirun - 40) * 0.03 + (lirun - 60) * 0.015;
    } else {
        jiangjin += 0.1 + (lirun - 10) * 0.075 + (lirun - 20) * 0.05 + (lirun - 40) * 0.03 + (lirun - 60) * 0.015
                + (lirun - 100) * 0.01;
    }
    System.out.println(jiangjin);
}

7、判断101-200之间有多少个素数，并输出所有素数。

与第2题重复了，见第二题

8、计算s＝1+2+…+100。

Sum1to100.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * 计算s＝1+2+…+100。
 */
public class Sum1to100 {
    public static void main(String[] args) {
        int sum=0;
        for(int i=1;i<=100;i++)
        {
            sum+=i;
        }
        System.out.println(sum);
    }
}

9、打印出所有的“水仙花数”

所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数 本身。例如：153是一个“水仙花数”，因为153=1的三次方＋5的三次方＋3的三次方。

NarcissisticNumber.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * 求100到999的水仙花数
 * 例如： 153 = 1*1*1 + 5*5*5 + 3*3*3.
 */
public class NarcissisticNumber {
    public static void main(String[] args) {
        int hundreds, tens, ones;
        System.out.print("水仙花数:");
        for (int i = 100; i < 999; i++) {
//            除以100得到百位数
            hundreds = (i / 100);
//            求余100得到十位数和个位数，再除以10得到十位数
            tens = i % 100 / 10;
//            求余10得到十位数
            ones = i % 10;
            if (i == (hundreds * hundreds * hundreds + tens * tens * tens + ones * ones * ones)) {
                System.out.print(i+" ");
            }
        }
    }
}

10 找出1000以内的所有完数

一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3.编程找出1000以内的所有完数

如果一个数恰好等于它的真因子之和，则称该数为“完全数”。第一个完全数是6，第二个完全数是28，第三个完全数是496，后面的完全数还有8128、33550336等等。截至2018年，相关研究者已经找到51个完全数。

性质

所有的完全数都是三角形数。例如：6=1+2+3；28=1+2+3+…+6+7；496=1+2+3+…+30+31；8128=1+2+3…+126+127。

三角形数

第n个三角形数的公式是n(n+1)/2或者(2n+1)^(2)-1/8。

PerfectNumber.java

PerfectNumber.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class PerfectNumber {
    public static void main(String[] args) {
        for (int i = 2,sumOfFactors=0; i < 1000; i++) {
//            因子的和
            sumOfFactors=0;
            for(int j=1;j<i;j++) {
//                如果j是i的因子
                if(i%j==0) {
//                    因子累加
                    sumOfFactors+=j;
                }
            }
//            如果一个数恰好等于它的因子之和，那么就是完数
            if(i==sumOfFactors) {
                System.out.println("完数："+i);
            }
        }
    }
}

参考资料

https://baike.baidu.com/item/%E4%B8%89%E8%A7%92%E5%BD%A2%E6%95%B0
http://c.biancheng.net/cpp/html/3324.html

11、求s=a+aa+aaa+aaaa+aa…a的值

其中a是一个数字。例如2+22+222+2222+22222
(此时 共有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
/**
 * 11、求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222 (此时
 * 共有5个数相加)，几个数相加有键盘控制。
 */
public class Sum_a_aa_aaa {
    public static void main(String[] args) {
        int sum=0;
        int a;
        int times;
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入a:");
        a = scanner.nextInt();
        System.out.println("输入个数:");
        times = scanner.nextInt();
        
        System.out.print("sum=");
        for (int i = 0; i <=times; i++) {
            int temp = a;
            for (int j = 1; j < i; j++) {
                temp = temp * 10 + a;
            }
            System.out.print(temp);
            if(i<times) {
                System.out.print("+");
            }
            sum=sum+temp;
        }
        System.out.println("\n   ="+sum);
    }
}

12、有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static void main(String[] args) {
    double fenmu = 1;
    double fenzi = 2;
    double sum = 0.0;
    double temp;
    for (int i = 0; i < 20; i++) {
        if (i > 0)
            System.out.print(" + ");
        System.out.print((int)fenzi + "/" + (int)fenmu);
        // 求和
        sum += fenzi / fenmu;
        // 记下分母的值
        temp = fenmu;
        // 前一个的分子作为下次计算的分母
        fenmu = fenzi;
        // 前一个分子的值加上前一个分母的值作为下次计算的分子
        fenzi = fenzi + temp;
        if((i+1)%5==0) {
            System.out.println();
        }
    }
    System.out.println("=" + sum);
}

运行结果：

1
2
3
4
5
2/1 + 3/2 + 5/3 + 8/5 + 13/8
 + 21/13 + 34/21 + 55/34 + 89/55 + 144/89
 + 233/144 + 377/233 + 610/377 + 987/610 + 1597/987
 + 2584/1597 + 4181/2584 + 6765/4181 + 10946/6765 + 17711/10946
=32.66026079864164

13、一个5位数，判断它是不是回文数。

14、输入一个数，判断它是不是回文数。

设n是一任意自然数。若将n的各位数字==反向排列==所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。
注意：
1.偶数个的数字也有回文数124421

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
/**
 * 判断一个整数是不是回文数.
 * 
 * @param n 整数
 * @return 如果是回文数的话，就返回true,否则返回false.
 */
private static boolean isPalindromeNumberPerfect(int n) {
    // 如果把这个整数倒序之后还是和这个数相等的话，那么它就是回文数。
    return n == reverseInt(n);
}

/**
 * 反转一个整数，例如12345，反转后变成54321
 * 
 * @param m 一个整数
 * @return 反转后的整数
 */
private static int reverseInt(int m) {
    // 保存反转之后的数值
    int inversion = 0;
    // 余数
    int remainder;
    do {
        remainder = m % 10;
        m = m / 10;
        // 根据10的余数，计算出反转的数值
        inversion = inversion * 10 + remainder;
    } while (m > 0);
    // System.out.println(inversion);
    // 返回反转后的数值
    return inversion;
}

测试：输出10到10000内的所有回文数

1
2
3
4
5
6
7
8
9
boolean isNotFirst = false;
for (int i = 10; i < 10000; i++) {
    if (isPalindromeNumberPerfect(i)) {
        if (isNotFirst)
            System.out.print(",");
        System.out.print(i);
        isNotFirst = true;
    }
}

运行结果：

1
11,22,33,44,55,66,77,88,99,101,111,121,131,141,151,161,171,181,191,202,212,222,232,242,252,262,272,282,292,303,313,323,333,343,353,363,373,383,393,404,414,424,434,444,454,464,474,484,494,505,515,525,535,545,555,565,575,585,595,606,616,626,636,646,656,666,676,686,696,707,717,727,737,747,757,767,777,787,797,808,818,828,838,848,858,868,878,888,898,909,919,929,939,949,959,969,979,989,999,1001,1111,1221,1331,1441,1551,1661,1771,1881,1991,2002,2112,2222,2332,2442,2552,2662,2772,2882,2992,3003,3113,3223,3333,3443,3553,3663,3773,3883,3993,4004,4114,4224,4334,4444,4554,4664,4774,4884,4994,5005,5115,5225,5335,5445,5555,5665,5775,5885,5995,6006,6116,6226,6336,6446,6556,6666,6776,6886,6996,7007,7117,7227,7337,7447,7557,7667,7777,7887,7997,8008,8118,8228,8338,8448,8558,8668,8778,8888,8998,9009,9119,9229,9339,9449,9559,9669,9779,9889,9999

15、输入2个正整数m,n，求其最大公约数和最小公倍数。

参考资料

辗转相除法 求最大公约数

https://zhuanlan.zhihu.com/p/31824895

辗转相除法， 又名欧几里得算法（Euclidean algorithm），目的是求出两个正整数的最大公约数。它是已知最古老的算法， 其可追溯至公元前300年前。

这条算法基于一个定理：两个正整数a和b（a>b），它们的最大公约数等于a除以b的余数c和b之间的最大公约数。比如10和25，25除以10商2余5,那么10和25的最大公约数，等同于10和5的最大公约数。

有了这条定理，求出最大公约数就简单了。我们可以使用递归的方法来把问题逐步简化。

首先，我们先计算出a除以b的余数c，把问题转化成求出b和c的最大公约数；然后计算出b除以c的余数d，把问题转化成求出c和d的最大公约数；再然后计算出c除以d的余数e，把问题转化成求出d和e的最大公约数……

以此类推，逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，直到两个数可以整除，或者其中一个数减小到1为止。

求最小公倍数

两个正整数A、B，他们的最大公约数和最小公倍数的乘积就等于这两个数的乘积(A*B)。

最小公倍数=(A*B)/最大公约数
最小公倍数=两整数的乘积÷最大公约数

程序 辗转相除法求最大公约数

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
public class GreatestCommonDivisor {
    public static void main(String[] args) {
        int a, b;
        a = 1;
        b = 2;
        int gcd = getGCD(a, b);
        System.out.println(a + "和" + b + "的最大公约数为：" + gcd + ",最小公倍数为:" + (a * b) / gcd);
    }
 
    /**
     * 辗转相除法求最大公约数入口
     * 
     * @param a
     * @param b
     * @return
     */
    private static int getGCD(int a, int b) {
        if (a > b) {
            return gcd(a, b);
        } else {
            return gcd(b, a);
        }
    }

    /**
     * 辗转相除法求最大公约数
     * 
     * @param bigNumber   两个数中大的数
     * @param smallNumber 两个数之中小的数
     * @return 最大公约数的值
     */
    private static int gcd(int bigNumber, int smallNumber) {
        int remainder = bigNumber % smallNumber;
        if (remainder == 0) {
            return smallNumber;
        } else {
            return gcd(smallNumber, remainder);
        }
    }
}

https://baike.baidu.com/item/%E6%9C%80%E5%A4%A7%E5%85%AC%E7%BA%A6%E6%95%B0

16、请编程序打印出以下数列：1、1、2、3、5、8、13、…的前40项。每行输出4个数。（斐波那契数列）

https://zh.wikipedia.org/wiki/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0

在数学上，斐波那契数是以递归的方法来定义：

$$
\begin{cases}
F_{0}=0 \\
F_{1}=1 \\
F_{n}=F_{n-1}+F_{n-2} (n \ge 2)
\end{cases}
$$

https://baike.baidu.com/item/%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97

斐波那契数列由0和1开始，之后的斐波那契数就是由之前的两数相加而得出。首几个斐波那契数是：

1
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377 ,610, 987

特别指出：0不是第一项，而是第零项。

求斐波那契数列第n项 递归实现

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * 求第n项斐波那契数列的值，递归实现
 * 
 * @param n 第几项斐波那契数列的值，n从1开始。
 * @return 第n项斐波那契数列的值
 */
public static int fibonacciRecursive(int n) {
    if (n <= 2) {
        return 1;
    }
    return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2);
}

求斐波那契数列第n项 循环实现

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
/**
 * 求斐波那契数列的第n项
 * 
 * @param n 要求斐波那契数列的第几项，n从1开始。
 * @return 斐波那契数列的第n项
 */
private static long fibonacciLoop(int n) {
    if (n <= 1)
        return 1;
    long first = 1;
    long second = 1;
    // System.out.print(first + "," + second + ",");
    long temp;
    for (int i = 2; i < n; i++) {
        // 缓存第1项的值
        temp = first;
        // 第1项的值等于原来第2项的值
        first = second;
        // 第2项等于原来第2项的值加上原来第1项的值
        second = second + temp;
        // if (i > 2)
        // System.out.print(",");
        // System.out.print(second);
    }
    return second;
}

缓存已经计算过得斐波那契数列的项

下次遇到已经计算过斐波那契数列项的直接返回，没有计算过得才计算。

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
/**
 * 斐波那契前n项的缓存数组，已经计算过得第n项保存在这里，
 *  第n项保存在fibBuff[n-]里面
 */
static long[] fibBuff = new long[93];
/**
 * 给斐波那契数列的第1项和第2项赋值。
 */
static {
    fibBuff[1] = 1;
    fibBuff[0] = 1;
}

/**
 * 求斐波那契数列的第n项
 * 
 * @param n 要求斐波那契的第几项，n最小为1,不要传入0
 * @return 斐波那契数列第n项的值
 */
public static long fibBuffRec(int n) {
    // 第1项和第2项斐波那契数列的值都是1，直接返回预定的值。
    if (n <= 2 && n > 0) {
        return fibBuff[n - 1];
    }
    // 如果数组中没有保存过斐波那契数列的第n项
    if (fibBuff[n - 1] == 0) {
        // 先计算出斐波那契数列的第n项
        fibBuff[n - 1] = fibBuffRec(n - 1) + fibBuffRec(n - 2);
    }
    // 返回斐波那契数列的第n项
    return fibBuff[n - 1];
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 打印前40项斐波那契数列
for (int i = 1; i <= 40; i++) {
    if (i > 1)
        System.out.print(",");
    System.out.print(fibonacciLoop(i));
}
System.out.println();
for (int i = 1; i <= 40; i++) {
    if (i > 1)
        System.out.print(",");
    System.out.print(fibonacciRecursive(i));
}
System.out.println();

System.out.println(fibBuffRec(40));
for (int i = 0; i < fibBuff.length; i++) {
    if (i > 0)
        System.out.print(",");
    System.out.print(fibBuff[i]);
}

运行结果

1
2
3
4
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155
102334155
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

17、输入x值，按照公式计算cos(x)的值，直到最后一项小于10^(-6)为止。

$$
\cos (x)=1-\frac{x^{2}}{2!}+\frac{x^{4}}{4!}-\frac{x^{6}}{6!}+…
$$

特殊cos值

$$
\cos 30^{\circ}=\cos \dfrac{\pi}{6}=\dfrac{\sqrt{3}}{2} \approx 0.8660254038
$$

$$
\cos 45^{\circ}=\cos \dfrac{\pi}{4}=\dfrac{\sqrt{2}}{2} \approx 0.7071067812
$$

$$
\cos 60^{\circ}=\cos \dfrac{\pi}{3}=\dfrac{1}{2}=0.5
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
private static double cos(double x) {
    double cos = 1.0;
    int sign = -1;
    // 通项公式分母的求阶乘的初始值
    int n = 2;
    double fenzi = 1.0;
    double fenmu = 1.0;
    // 当通项还大于10的-6次方，则继续计算
    while (fenzi / fenmu >= 1e-6) {
        // 计算乘方
        fenzi = fenzi * x * x;
        // 计算阶乘
        fenmu = fenmu * n * (n - 1);
        cos = cos + sign * fenzi / fenmu;
        // 分母继承的最大数加2
        n = n + 2;
        // 改变符号
        sign = -sign;
    }
    return cos;
}

测试

1
2
3
System.out.println(cos(Math.PI / 6));
System.out.println(cos(Math.PI / 4));
System.out.println(cos(Math.PI / 3));

运行结果：

1
2
3
0.8660254042103523
0.7071067810719247
0.4999999963909432

18 、输入2个正整数m,n，求其最大公约数和最小公倍数。

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
45
46
/**
 * 辗转相除法求最大公约数入口
 * 
 * @param a 整数a
 * @param b 整数b
 * @return 整数a和整数b的最大公约数.
 */
private static int getGCD(int a, int b) {
    if (a > b) {
        return gcd(a, b);
    } else {
        return gcd(b, a);
    }
}

/**
 * 辗转相除法求最大公约数
 * 
 * @param big 两个数中大的数
 * @param small 两个数之中小的数
 * @return 最大公约数的值
 */
private static int gcd(int big, int small) {
    // 求余数
    int remainder = big % small;
    // 如果余数为0,说明small就是最大公约数
    if (remainder == 0) {
        return small;
    } else {
        // 等价于求小的数和余数的最大公约数
        return gcd(small, remainder);
    }
}

/**
 * 求最小公倍数
 * 
 * @param a 整数
 * @param b 另一个整数
 * @param gcd a和b的最大公约数
 * @return a和b的最小公倍数
 */
private static int lcm(int a, int b, int gcd) {
    // 两个数的乘积除以最大公约数就是最小公倍数
    return (a * b) / gcd;
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int a, b, gcd;
a = 5;
b = 10;
gcd = getGCD(a, b);
System.out.println(a + "和" + b + "的最大公约数为：" + gcd + ",最小公倍数为:" + lcm(a, b, gcd));

a = 5;
b = 6;
gcd = getGCD(a, b);
System.out.println(a + "和" + b + "的最大公约数为：" + gcd + ",最小公倍数为:" + lcm(a, b, gcd));

a = 2;
b = 1;
gcd = getGCD(a, b);
System.out.println(a + "和" + b + "的最大公约数为：" + gcd + ",最小公倍数为:" + lcm(a, b, gcd));

运行结果

1
2
3
5和10的最大公约数为：5,最小公倍数为:10
5和6的最大公约数为：1,最小公倍数为:30
2和1的最大公约数为：1,最小公倍数为:2

19、编写一个程序，求如下值：

$$
1-\dfrac{1}{2}+\dfrac{1}{3}-\dfrac{1}{4}+\cdots+\dfrac{1}{99}-\dfrac{1}{100}
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class HW_19_Sum {
    public static void main(String[] args) {
        System.out.println(sumXX(1));
        System.out.println(sumXX(2));
        System.out.println(sumXX(3));
        System.out.println(sumXX(4));
        System.out.println(sumXX(100));
    }
    private static double sumXX(int times) {
        double sum = 1.0;
        double sign = -1;
        for (int i = 2; i <= times; i++) {
            sum = (sum + sign / i);
            sign = -sign;
        }
        return sum;
    }
}

运行结果：

1
2
3
4
5
1.0
0.5
0.8333333333333333
0.5833333333333333
0.688172179310195

20、编写一个程序，求e的值。

$$
e \approx 1+\dfrac{1}{1 !}+\dfrac{1}{2 !}+\cdots+\dfrac{1}{n !}
$$

1
2
3
4
5
6
7
8
9
10
11
12
13
14
double e = 1;
// 阶乘的最大一项
int n = 1;
int jieCheng = 1;
while (Math.abs(1.0 / jieCheng) >= 1e-6) {
    // 求阶乘
    jieCheng = jieCheng * n;
    // 求各项的和
    e = e + 1.0 / jieCheng;
    // 阶乘的最大一项加一
    n++;
}
System.out.println(e);
System.out.println(Math.E);

运行结果：

1
2
2.7182818011463845
2.718281828459045