java编写一个类demol 编写一个demo.java程序

转载

mob6454cc788ee7 2024-06-08 09:48:47

文章标签 java编写一个类demol java 开发语言 System 完全数 文章分类 Java 后端开发

Demo41. (显示金字塔）编写程序，提示用户输入一个在1到15之间的整数，然后显示一个金字塔形状的图案，如下面的运行示例所示:

Demo42. (使用循环语句打印4个图案)使用嵌套的循环语句，用四个独立的程序打印下面的图案：

Demo43. (打印金字塔形的数字)编写一个嵌套的for循环，打印下面的输出

Demo44. (打印2到1000之间的素数）修改程序清单5-15，打印2到1000之间、包括2和1000的所有素数，每行显示8个素数。数字之间用一个空格字符隔开。

Demo45. (数列求和)编写程序，计算下面数列的和：1/3 + 3/5 + 5/7 + 7/9 + 9/11 + 11/13 + ... + 95/97 + 97/99

Demo46. (计算π)使用下面的数列可以近似计算π:

Demo47. 使用下面的数列可以近似的计算e：

Demo48. (完全数)编写程序，找出这四个完全数。

Demo49. (游戏:石头、剪刀、布）编程练习题Demo24，给出玩石头-剪刀-布游戏的程序。修改这个程序,让用户可以连续地玩这个游戏，直到用户或者计算机赢对手两次以上为止。

Demo50. (十进制到二进制）编写程序，提示用户输人一个十进制整数，然后显示对应的二进制值。在这个程序中不要使用Java的Interger.toBinaryString(int)方法。

Demo41. (显示金字塔）编写程序，提示用户输入一个在1到15之间的整数，然后显示一个金字塔形状的图案，如下面的运行示例所示:

java编写一个类demol 编写一个demo.java程序_完全数

import java.util.Scanner;

public class Demo41 {
    /*
    (显示金字塔）编写程序，提示用户输入一个在1到15之间的整数，
    然后显示一个金字塔形状的图案，如下面的运行示例所示:
                1
              2 1 2
            3 2 1 2 3
          4 3 2 1 2 3 4
        5 4 3 2 1 2 3 4 5
      6 5 4 3 2 1 2 3 4 5 6
    7 6 5 4 3 2 1 2 3 4 5 6 7
     */
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入一个整数(1-15)：");
		int num = scan.nextInt();
		pyramid(num);
	}

	public static void pyramid(int num) {
		for (int i = 1; i <= num; i++) {
			for (int j = 0; j < 2 * (num - i); j++) {
				System.out.print(" ");
			}
			for (int k = 0; k < i; k++) {
				System.out.print(i-k + " ");
			}
			for (int k = 2; k <= i; k++) {
				System.out.print(k + " ");
			}
			System.out.println("");
		}
	}
}

结果：

java编写一个类demol 编写一个demo.java程序_System_02

Demo42. (使用循环语句打印4个图案)使用嵌套的循环语句，用四个独立的程序打印下面的图案：

java编写一个类demol 编写一个demo.java程序_开发语言_03

public class Demo42 {
	/*
	(使用循环语句打印4个图案)使用嵌套的循环语句，用四个独立的程序打印下面的图案
	*/
	public static void main(String[] args) {
		// 图案1
		printPattern1();
		System.out.println();
		// 图案2
		printPattern2();
		System.out.println();
		// 图案3
		printPattern3();
		System.out.println();
		// 图案4
		printPattern4();
	}
	
	/*
	1
	1 2
	1 2 3
	1 2 3 4
	1 2 3 4 5
	1 2 3 4 5 6
	*/
	public static void printPattern1() {
		for (int i = 1; i <= 6; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print(j + " ");
			}
			System.out.println();
		}
	}
	
	/*
	1 2 3 4 5 6
	1 2 3 4 5
	1 2 3 4
	1 2 3
	1 2
	1
	*/
	public static void printPattern2() {
		for (int i = 0; i < 6; i++) {
			for (int j = 1; j <= 6 - i; j++) {
				System.out.print(j + " ");
			}
			System.out.println();
		}
	}
	
	/*
	          1
			2 1
		  3 2 1
		4 3 2 1
	  5 4 3 2 1
	6 5 4 3 2 1
	*/
	public static void printPattern3() {
		for (int i = 1; i <= 6; i++) {
			for (int k = 0; k < 2 * (6 - i); k++) {
				System.out.print(" ");
			}
			for (int j = i; j > 0; j--) {
				System.out.print(j + " ");
			}
			System.out.println();
		}
	}
	
	/*
	1 2 3 4 5 6
	  1 2 3 4 5
		1 2 3 4
		  1 2 3
			1 2
			  1
	*/
	public static void printPattern4() {
		for (int i = 1; i <= 6; i++) {
			for (int k = 0; k < 2 * (i - 1); k++) {
				System.out.print(" ");
			}
			for (int j = 1; j <= 7 - i; j++) {
				System.out.print(j + " ");
			}
			System.out.println();
		}
	}
}

结果：

java编写一个类demol 编写一个demo.java程序_java编写一个类demol_04

Demo43. (打印金字塔形的数字)编写一个嵌套的for循环，打印下面的输出

java编写一个类demol 编写一个demo.java程序_java编写一个类demol_05

public class Demo43 {

    /*
    (打印金字塔形的数字)编写一个嵌套的for循环，打印下面的输出
    */
    public static void main(String[] args) {
        numPyramid();
    }

    /*
        1   2   4   8
    1   2   4   8  16
    */
    public static void numPyramid() {
        for (int i = 0; i < 8; i++) {
            for (int k = 1; k <= (8 - i - 1); k++) {
                System.out.print("\t");
            }
            for (int j = 1; j <= Math.pow(2, i); j *= 2) {
                System.out.print(j + "\t");
            }
            for (int j = (int) (Math.pow(2, i - 1)); j > 0; j /= 2) {
                System.out.print(j + "\t");
            }
            System.out.println();
        }
    }
}

结果：

java编写一个类demol 编写一个demo.java程序_java_06

Demo44. (打印2到1000之间的素数）修改程序清单5-15，打印2到1000之间、包括2和1000的所有素数，每行显示8个素数。数字之间用一个空格字符隔开。

package Exer;

public class Demo44 {
    /*
    (打印2到1000之间的素数）修改程序清单5-15，
    打印2到1000之间、包括2和1000的所有素数，每行显示8个素数。
    数字之间用一个空格字符隔开。
    */
    public static void main(String[] args) {
        primeNumber();
    }

    private static void primeNumber() {
        int count = 0;
        for (int i = 2; i <= 1000; i++) {
            boolean isFlag = true;
            for (int j = 2; j <= i / 2; j++) {
                if (i % j == 0) {
                    isFlag = false;
                }
            }
            if (isFlag) {
                System.out.print(i + "\t");
                count ++;
                if (count % 8 == 0) {
                    System.out.println();
                }
            }
        }
    }
}

结果：

java编写一个类demol 编写一个demo.java程序_完全数_07

Demo45. (数列求和)编写程序，计算下面数列的和：1/3 + 3/5 + 5/7 + 7/9 + 9/11 + 11/13 + ... + 95/97 + 97/99

package Exer;

public class Demo45 {
    /*
    (数列求和)编写程序，计算下面数列的和：1/3 + 3/5 + 5/7 + 7/9 + 9/11 + 11/13 + ... + 95/97 + 97/99
    2n-1/2n+1
     */
    public static void main(String[] args) {
        System.out.println(sumSequence());
        System.out.println(sumSequence1(49));
    }

    // 循环
    private static double sumSequence() {
        // int n = 0;
        double sum = 0;
        for (int i = 1; i < 50; i++) {
            sum += (double)(2 * i - 1) / (2 * i + 1);
        }
        return sum;
    }

    // 递归
    private static double sumSequence1(int i) {
        // int n = 0;
        if (i == 1) {
            return (double)(2 * i - 1) / (2 * i + 1);
        }
        return (double)(2 * i - 1) / (2 * i + 1) + sumSequence1(i - 1);
    }
}

结果：

java编写一个类demol 编写一个demo.java程序_java_08

Demo46. (计算π)使用下面的数列可以近似计算π:

$\pi = 4(1-\frac{1}{3} + \frac{1}{5} - \frac{1}{7} + \frac{1}{9} - \frac{1}{11} + \frac{(-1)^{i + 1}}{2i -1})$

public class Demo46 {
    /*
    (计算n)使用下面的数列可以近似计算π
     */
    public static void main(String[] args) {
        System.out.println(countPI());
        double result = countPI1(1000);
        double PI = result * 4;
        System.out.println(PI);
    }

    private static double countPI() {
        double sum = 0;
        for (int i = 1; i < 100000000; i++) {
            sum += (Math.pow(-1, i + 1) / (2 * i - 1));
        }
        sum *= 4;
        return sum;
    }

    // 递归， 如果传入的n过大，容易造成栈溢出异常
    private static double countPI1(int n) {
        if (n == 1) {
            return (Math.pow(-1, n + 1) / (2 * n - 1));
        }
        return (Math.pow(-1, n + 1) / (2 * n - 1)) + countPI1(n - 1);
    }
}

结果：

java编写一个类demol 编写一个demo.java程序_开发语言_10

Demo47. 使用下面的数列可以近似的计算e：

$e=1 + \frac{1}{1!} + \frac{1}{2!} + \frac{1}{3!} + \frac{1}{4!} + ... + \frac{1}{i!}$

编写程序，显示当i = 10000，20000，...，100000时e的值。

提示:由于i! = i × (i - 1) × … × 2 × 1，那么1/i! = 1/i(i-1)!。将e和通项item初始化为1，反复将新的item加到e上。新的item由前一个item除以i得到，其中i=2，3，4，…。

public class Demo47 {
    /*
    使用下面的数列可以近似的计算e：
     */
    public static void main(String[] args) {
        System.out.println(countE());
    }

    private static double countE() {
        double sum = 1;
        for (int i = 1; i < 14; i++) {
            int factorial = 1;
            for (int j = 1; j <= i; j++) {
                factorial *= j;
            }
            sum += 1.0 / factorial;
        }
        return sum;
    }
}

结果：

java编写一个类demol 编写一个demo.java程序_java编写一个类demol_12

Demo48. (完全数)编写程序，找出这四个完全数。

如果一个正整数等于除它本身之外其他所有除数之和，就称之为完全数。例如:6是第一个完全数，因为6=1+2+3。下一个完全数是28=14+7+4+2+1。10 000以下的完全数有四个。

public class Demo48 {
    /*
    (完全数)编写程序，找出这四个完全数
    如果一个正整数等于除它本身之外其他所有除数之和，就称之为完全数。
    例如:6是第一个完全数，因为6=1+2+3。下一个完全数是28=14+7+4+2+1。10000以下的完全数有四个。
     */
    public static void main(String[] args) {
        completeNum();
    }

    private static void completeNum() {
        for (int i = 6; i < 10000; i++) {
            int sum = 0;
            for (int j = 1; j <= i / 2; j++) {
                if (i % j == 0) {
                    sum += j;
                }
            }
            if (i == sum) {
                System.out.println(i);
            }
        }
    }
}

结果：

java编写一个类demol 编写一个demo.java程序_开发语言_13

Demo49. (游戏:石头、剪刀、布）编程练习题Demo24，给出玩石头-剪刀-布游戏的程序。修改这个程序,让用户可以连续地玩这个游戏，直到用户或者计算机赢对手两次以上为止。

package Exer;

import java.util.Scanner;

public class Demo49 {
    /*
    (游戏:石头、剪刀、布）编程练习题Demo24，给出玩石头-剪刀-布游戏的程序。
    修改这个程序,让用户可以连续地玩这个游戏，直到用户或者计算机赢对手两次以上为止。
    (剪刀可以剪布，石头可以砸剪刀，而布可以包石头。)
    程序随机产生一个数，这个数为0、1或者2，分别表示石头、剪刀和布。
    程序提示用户输人值0、1或者2，
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int countPlay1 = 0, countPlay2 = 0;
        while (true) {
            int play1 = (int) (Math.random() * 3); // 随机一个[0, 3)的整数；
            System.out.println("请输入0、1或者2，分别表示石头、剪刀和布：");
            int play2 = scan.nextInt();
            int result = guessHand(play1, play2);
            if (result == 1) {
                countPlay2++;
                System.out.println("你赢了 " + countPlay2 + " 局了");
            } else if (result == 2) {
                countPlay1++;
                System.out.println("电脑赢了" + countPlay1 + "局了");
            } else if (result == 3) {
                System.out.println("打成平手");
            } else {
                System.out.println("你出的有误！");
            }
            if (countPlay1 > 2) {
                System.out.println("游戏结束，很遗憾你输了！电脑赢了");
                break;
            }
            if (countPlay2 > 2) {
                System.out.println("游戏结束，恭喜你赢了！战胜了电脑");
                break;
            }
        }
    }

    private static int guessHand(int play1, int play2) {
        if (play2 < 0 || play2 > 2) {
            return 0;
        } else {
            // (剪刀可以剪布，石头可以砸剪刀，而布可以包石头。)
            // 0 石头，1 剪刀，2 布
            if (play1 == 0 && play2 == 1) {
                System.out.println("恭喜你赢了！战胜了电脑");
                return 1;
            } else if (play1 == 0 && play2 == 2) {
                System.out.println("很遗憾你输了！电脑赢了");
                return 2;
            } else if (play1 == 1 && play2 == 0) {
                System.out.println("很遗憾你输了！电脑赢了");
                return 2;
            } else if (play1 == 1 && play2 == 2) {
                System.out.println("恭喜你赢了！战胜了电脑");
                return 1;
            } else if (play1 == 2 && play2 == 0) {
                System.out.println("恭喜你赢了！战胜了电脑");
                return 1;
            } else if (play1 == 2 && play2 == 1) {
                System.out.println("很遗憾你输了！电脑赢了");
                return 2;
            } else { // play1 == play2
                return 3;
            }
        }
    }
}

结果：

java编写一个类demol 编写一个demo.java程序_java_14

Demo50. (十进制到二进制）编写程序，提示用户输人一个十进制整数，然后显示对应的二进制值。在这个程序中不要使用Java的Interger.toBinaryString(int)方法。

import java.util.Scanner;

public class Demo50 {
    /*
    (十进制到二进制）编写程序，提示用户输人一个十进制整数，然后显示对应的二进制值。
    在这个程序中不要使用Java的Interger.toBinaryString(int)方法。
     */
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int num = scan.nextInt();
        toBinary(num);
    }
    /*
    10
    5  0
    2  1
    1  0
    0  1 ==> 1010
     */
    private static void toBinary(int num) {
        String binary = "";
        while (num / 2 != 0) {
            binary = (num % 2) + binary;
            num /= 2;
        }
        binary = num + binary;
        System.out.println(binary);
    }
}

结果：

java编写一个类demol 编写一个demo.java程序_System_15