• Java编程练习题Demo41-Demo50

    目录

    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之间的整数，然后显示一个金字塔形状的图案，如下面的运行示例所示:

    1. import java.util.Scanner;
    2.  
    3. public class Demo41 {
    4.     /*
    5.     (显示金字塔）编写程序，提示用户输入一个在1到15之间的整数，
    6.     然后显示一个金字塔形状的图案，如下面的运行示例所示:
    7.                 1
    8.               2 1 2
    9.             3 2 1 2 3
    10.           4 3 2 1 2 3 4
    11.         5 4 3 2 1 2 3 4 5
    12.       6 5 4 3 2 1 2 3 4 5 6
    13.     7 6 5 4 3 2 1 2 3 4 5 6 7
    14.      */
    15. 	public static void main(String[] args) {
    16. 		Scanner scan = new Scanner(System.in);
    17. 		System.out.println("请输入一个整数(1-15)：");
    18. 		int num = scan.nextInt();
    19. 		pyramid(num);
    20. 	}
    21.  
    22. 	public static void pyramid(int num) {
    23. 		for (int i = 1; i <= num; i++) {
    24. 			for (int j = 0; j < 2 * (num - i); j++) {
    25. 				System.out.print(" ");
    26. 			}
    27. 			for (int k = 0; k < i; k++) {
    28. 				System.out.print(i-k + " ");
    29. 			}
    30. 			for (int k = 2; k <= i; k++) {
    31. 				System.out.print(k + " ");
    32. 			}
    33. 			System.out.println("");
    34. 		}
    35. 	}
    36. }

    结果：

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

    1. public class Demo42 {
    2. 	/*
    3. 	(使用循环语句打印4个图案)使用嵌套的循环语句，用四个独立的程序打印下面的图案
    4. 	*/
    5. 	public static void main(String[] args) {
    6. 		// 图案1
    7. 		printPattern1();
    8. 		System.out.println();
    9. 		// 图案2
    10. 		printPattern2();
    11. 		System.out.println();
    12. 		// 图案3
    13. 		printPattern3();
    14. 		System.out.println();
    15. 		// 图案4
    16. 		printPattern4();
    17. 	}
    18. 	
    19. 	/*
    20. 	1
    21. 	1 2
    22. 	1 2 3
    23. 	1 2 3 4
    24. 	1 2 3 4 5
    25. 	1 2 3 4 5 6
    26. 	*/
    27. 	public static void printPattern1() {
    28. 		for (int i = 1; i <= 6; i++) {
    29. 			for (int j = 1; j <= i; j++) {
    30. 				System.out.print(j + " ");
    31. 			}
    32. 			System.out.println();
    33. 		}
    34. 	}
    35. 	
    36. 	/*
    37. 	1 2 3 4 5 6
    38. 	1 2 3 4 5
    39. 	1 2 3 4
    40. 	1 2 3
    41. 	1 2
    42. 	1
    43. 	*/
    44. 	public static void printPattern2() {
    45. 		for (int i = 0; i < 6; i++) {
    46. 			for (int j = 1; j <= 6 - i; j++) {
    47. 				System.out.print(j + " ");
    48. 			}
    49. 			System.out.println();
    50. 		}
    51. 	}
    52. 	
    53. 	/*
    54. 	          1
    55. 			2 1
    56. 		  3 2 1
    57. 		4 3 2 1
    58. 	  5 4 3 2 1
    59. 	6 5 4 3 2 1
    60. 	*/
    61. 	public static void printPattern3() {
    62. 		for (int i = 1; i <= 6; i++) {
    63. 			for (int k = 0; k < 2 * (6 - i); k++) {
    64. 				System.out.print(" ");
    65. 			}
    66. 			for (int j = i; j > 0; j--) {
    67. 				System.out.print(j + " ");
    68. 			}
    69. 			System.out.println();
    70. 		}
    71. 	}
    72. 	
    73. 	/*
    74. 	1 2 3 4 5 6
    75. 	  1 2 3 4 5
    76. 		1 2 3 4
    77. 		  1 2 3
    78. 			1 2
    79. 			  1
    80. 	*/
    81. 	public static void printPattern4() {
    82. 		for (int i = 1; i <= 6; i++) {
    83. 			for (int k = 0; k < 2 * (i - 1); k++) {
    84. 				System.out.print(" ");
    85. 			}
    86. 			for (int j = 1; j <= 7 - i; j++) {
    87. 				System.out.print(j + " ");
    88. 			}
    89. 			System.out.println();
    90. 		}
    91. 	}
    92. }

    结果：

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

    1. public class Demo43 {
    2.  
    3.     /*
    4.     (打印金字塔形的数字)编写一个嵌套的for循环，打印下面的输出
    5.     */
    6.     public static void main(String[] args) {
    7.         numPyramid();
    8.     }
    9.  
    10.     /*
    11.         1   2   4   8
    12.     1   2   4   8  16
    13.     */
    14.     public static void numPyramid() {
    15.         for (int i = 0; i < 8; i++) {
    16.             for (int k = 1; k <= (8 - i - 1); k++) {
    17.                 System.out.print("\t");
    18.             }
    19.             for (int j = 1; j <= Math.pow(2, i); j *= 2) {
    20.                 System.out.print(j + "\t");
    21.             }
    22.             for (int j = (int) (Math.pow(2, i - 1)); j > 0; j /= 2) {
    23.                 System.out.print(j + "\t");
    24.             }
    25.             System.out.println();
    26.         }
    27.     }
    28. }

    结果：

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

    1. package Exer;
    2.  
    3. public class Demo44 {
    4.     /*
    5.     (打印2到1000之间的素数）修改程序清单5-15，
    6.     打印2到1000之间、包括2和1000的所有素数，每行显示8个素数。
    7.     数字之间用一个空格字符隔开。
    8.     */
    9.     public static void main(String[] args) {
    10.         primeNumber();
    11.     }
    12.  
    13.     private static void primeNumber() {
    14.         int count = 0;
    15.         for (int i = 2; i <= 1000; i++) {
    16.             boolean isFlag = true;
    17.             for (int j = 2; j <= i / 2; j++) {
    18.                 if (i % j == 0) {
    19.                     isFlag = false;
    20.                 }
    21.             }
    22.             if (isFlag) {
    23.                 System.out.print(i + "\t");
    24.                 count ++;
    25.                 if (count % 8 == 0) {
    26.                     System.out.println();
    27.                 }
    28.             }
    29.         }
    30.     }
    31. }

    结果：

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

    1. package Exer;
    2.  
    3. public class Demo45 {
    4.     /*
    5.     (数列求和)编写程序，计算下面数列的和：1/3 + 3/5 + 5/7 + 7/9 + 9/11 + 11/13 + ... + 95/97 + 97/99
    6.     2n-1/2n+1
    7.      */
    8.     public static void main(String[] args) {
    9.         System.out.println(sumSequence());
    10.         System.out.println(sumSequence1(49));
    11.     }
    12.  
    13.     // 循环
    14.     private static double sumSequence() {
    15.         // int n = 0;
    16.         double sum = 0;
    17.         for (int i = 1; i < 50; i++) {
    18.             sum += (double)(2 * i - 1) / (2 * i + 1);
    19.         }
    20.         return sum;
    21.     }
    22.  
    23.     // 递归
    24.     private static double sumSequence1(int i) {
    25.         // int n = 0;
    26.         if (i == 1) {
    27.             return (double)(2 * i - 1) / (2 * i + 1);
    28.         }
    29.         return (double)(2 * i - 1) / (2 * i + 1) + sumSequence1(i - 1);
    30.     }
    31. }

    结果：

    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})

    1. public class Demo46 {
    2.     /*
    3.     (计算n)使用下面的数列可以近似计算π
    4.      */
    5.     public static void main(String[] args) {
    6.         System.out.println(countPI());
    7.         double result = countPI1(1000);
    8.         double PI = result * 4;
    9.         System.out.println(PI);
    10.     }
    11.  
    12.     private static double countPI() {
    13.         double sum = 0;
    14.         for (int i = 1; i < 100000000; i++) {
    15.             sum += (Math.pow(-1, i + 1) / (2 * i - 1));
    16.         }
    17.         sum *= 4;
    18.         return sum;
    19.     }
    20.  
    21.     // 递归， 如果传入的n过大，容易造成栈溢出异常
    22.     private static double countPI1(int n) {
    23.         if (n == 1) {
    24.             return (Math.pow(-1, n + 1) / (2 * n - 1));
    25.         }
    26.         return (Math.pow(-1, n + 1) / (2 * n - 1)) + countPI1(n - 1);
    27.     }
    28. }

    结果：

    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，…。

    1. public class Demo47 {
    2.     /*
    3.     使用下面的数列可以近似的计算e：
    4.      */
    5.     public static void main(String[] args) {
    6.         System.out.println(countE());
    7.     }
    8.  
    9.     private static double countE() {
    10.         double sum = 1;
    11.         for (int i = 1; i < 14; i++) {
    12.             int factorial = 1;
    13.             for (int j = 1; j <= i; j++) {
    14.                 factorial *= j;
    15.             }
    16.             sum += 1.0 / factorial;
    17.         }
    18.         return sum;
    19.     }
    20. }

    结果：

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

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

    1. public class Demo48 {
    2.     /*
    3.     (完全数)编写程序，找出这四个完全数
    4.     如果一个正整数等于除它本身之外其他所有除数之和，就称之为完全数。
    5.     例如:6是第一个完全数，因为6=1+2+3。下一个完全数是28=14+7+4+2+1。10000以下的完全数有四个。
    6.      */
    7.     public static void main(String[] args) {
    8.         completeNum();
    9.     }
    10.  
    11.     private static void completeNum() {
    12.         for (int i = 6; i < 10000; i++) {
    13.             int sum = 0;
    14.             for (int j = 1; j <= i / 2; j++) {
    15.                 if (i % j == 0) {
    16.                     sum += j;
    17.                 }
    18.             }
    19.             if (i == sum) {
    20.                 System.out.println(i);
    21.             }
    22.         }
    23.     }
    24. }

    结果：

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

    1. package Exer;
    2.  
    3. import java.util.Scanner;
    4.  
    5. public class Demo49 {
    6.     /*
    7.     (游戏:石头、剪刀、布）编程练习题Demo24，给出玩石头-剪刀-布游戏的程序。
    8.     修改这个程序,让用户可以连续地玩这个游戏，直到用户或者计算机赢对手两次以上为止。
    9.     (剪刀可以剪布，石头可以砸剪刀，而布可以包石头。)
    10.     程序随机产生一个数，这个数为0、1或者2，分别表示石头、剪刀和布。
    11.     程序提示用户输人值0、1或者2，
    12.      */
    13.     public static void main(String[] args) {
    14.         Scanner scan = new Scanner(System.in);
    15.         int countPlay1 = 0, countPlay2 = 0;
    16.         while (true) {
    17.             int play1 = (int) (Math.random() * 3); // 随机一个[0, 3)的整数；
    18.             System.out.println("请输入0、1或者2，分别表示石头、剪刀和布：");
    19.             int play2 = scan.nextInt();
    20.             int result = guessHand(play1, play2);
    21.             if (result == 1) {
    22.                 countPlay2++;
    23.                 System.out.println("你赢了 " + countPlay2 + " 局了");
    24.             } else if (result == 2) {
    25.                 countPlay1++;
    26.                 System.out.println("电脑赢了" + countPlay1 + "局了");
    27.             } else if (result == 3) {
    28.                 System.out.println("打成平手");
    29.             } else {
    30.                 System.out.println("你出的有误！");
    31.             }
    32.             if (countPlay1 > 2) {
    33.                 System.out.println("游戏结束，很遗憾你输了！电脑赢了");
    34.                 break;
    35.             }
    36.             if (countPlay2 > 2) {
    37.                 System.out.println("游戏结束，恭喜你赢了！战胜了电脑");
    38.                 break;
    39.             }
    40.         }
    41.     }
    42.  
    43.     private static int guessHand(int play1, int play2) {
    44.         if (play2 < 0 || play2 > 2) {
    45.             return 0;
    46.         } else {
    47.             // (剪刀可以剪布，石头可以砸剪刀，而布可以包石头。)
    48.             // 0 石头，1 剪刀，2 布
    49.             if (play1 == 0 && play2 == 1) {
    50.                 System.out.println("恭喜你赢了！战胜了电脑");
    51.                 return 1;
    52.             } else if (play1 == 0 && play2 == 2) {
    53.                 System.out.println("很遗憾你输了！电脑赢了");
    54.                 return 2;
    55.             } else if (play1 == 1 && play2 == 0) {
    56.                 System.out.println("很遗憾你输了！电脑赢了");
    57.                 return 2;
    58.             } else if (play1 == 1 && play2 == 2) {
    59.                 System.out.println("恭喜你赢了！战胜了电脑");
    60.                 return 1;
    61.             } else if (play1 == 2 && play2 == 0) {
    62.                 System.out.println("恭喜你赢了！战胜了电脑");
    63.                 return 1;
    64.             } else if (play1 == 2 && play2 == 1) {
    65.                 System.out.println("很遗憾你输了！电脑赢了");
    66.                 return 2;
    67.             } else { // play1 == play2
    68.                 return 3;
    69.             }
    70.         }
    71.     }
    72. }

    结果：

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

    1. import java.util.Scanner;
    2.  
    3. public class Demo50 {
    4.     /*
    5.     (十进制到二进制）编写程序，提示用户输人一个十进制整数，然后显示对应的二进制值。
    6.     在这个程序中不要使用Java的Interger.toBinaryString(int)方法。
    7.      */
    8.     public static void main(String[] args) {
    9.         Scanner scan = new Scanner(System.in);
    10.         System.out.println("请输入一个整数：");
    11.         int num = scan.nextInt();
    12.         toBinary(num);
    13.     }
    14.     /*
    15.     10
    16.     5  0
    17.     2  1
    18.     1  0
    19.     0  1 ==> 1010
    20.      */
    21.     private static void toBinary(int num) {
    22.         String binary = "";
    23.         while (num / 2 != 0) {
    24.             binary = (num % 2) + binary;
    25.             num /= 2;
    26.         }
    27.         binary = num + binary;
    28.         System.out.println(binary);
    29.     }
    30. }

    结果：

  • 相关阅读:
    Java并发编程实战读书笔记三
    nexus5x 刷机root
    因为模型参数量小，仅考虑该模型是否成功被调用）（如果没有渠道打开Huggingface，可以用其镜像网站hf-mirror代替，如何解决？
    3、传统的Synchronized锁
    【Node.js项目】大事件项目：后台架构图（含具体技术栈）、典型代码
    Ubuntu离线安装g++、locales
    7.10飞书一面面经
    一个动力密集型产业的预算的数据分析建模过程
    Python编写Word文档
    在C语言中，堆和栈是两种不同的内存分配机制
  • 原文地址：https://blog.csdn.net/weixin_51612062/article/details/126003169