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之间的整数，然后显示一个金字塔形状的图案，如下面的运行示例所示:
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("");
}
}
}结果：
Demo42. (使用循环语句打印4个图案)使用嵌套的循环语句，用四个独立的程序打印下面的图案：
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();
}
}
}
结果：
Demo43. (打印金字塔形的数字)编写一个嵌套的for循环，打印下面的输出
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();
}
}
}结果：
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();
}
}
}
}
}
结果：
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);
}
}
结果：
Demo46. (计算π)使用下面的数列可以近似计算π:
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);
}
}结果：
Demo47. 使用下面的数列可以近似的计算e：
编写程序，显示当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;
}
}结果：
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);
}
}
}
}结果：
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;
}
}
}
}
结果：
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);
}
}
结果：
