50 道 JAVA 基础编程

                               50 道 JAVA 基础编程练习题解答
【程序 1】
题目：古典问题：有一对兔子，从出生后第 3 个月起每个月都生一对兔子，小兔子长到第
三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？
.程序分析： 兔子的规律为数列 1,1,2,3,5,8,13,21.... 
解答：
（方法一）
利用数学分析可得知：这个月的兔子数量为前两个月的兔子数量之和，推导过程如下：
X1，X2，X3 Y1，Y2，Y3 Z1，Z2，Z3
X1：表示一个月大的兔子；X2表示两个月大的兔子；X3表示三个月及三月以上的兔子。
有以下数学表达式：
Y1=X2+X3 ，Y2=X1 ，Y3=X2+X3
Z1=Y2+Y3 ，Z2=Y1 ，Z3=Y2+Y3
Z1+Z2+Z3= Y2+Y3+Y1+(Y2+Y3)=(Y2+Y3+Y1)+(X2+X3+X1)
因此上面每个月的兔子的数量满足斐波那契数列。编程实现较为简单，此处省略。
（方法二）
方法二利用编程实现，具有一般性（开始兔子个数和产仔周期可自行输入），程序设计如下：

import java.util.*;
import java.io.*;
class TuZi
{
int nianling=1;
}
public class Text1 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
int shuliang=1;
int zhouqi=4;
int yuefen=0;
Vector<TuZi> rongqi=new Vector<TuZi>();
System.out.print("输入兔子开始数量：");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
shuliang=(new Integer(stdin.readLine()));
System.out.print("输入兔子生产周期：");
zhouqi=(new Integer(stdin.readLine()));
System.out.print("输入查询月份：");
yuefen=(new Integer(stdin.readLine()));
for(int i=1;i<=shuliang;i++)
{
rongqi.addElement(new TuZi());
}
for(int i=2;i<=yuefen;i++)
{
for(int j=0;j<rongqi.size();j++)
{
TuZi a=(TuZi)rongqi.elementAt(j);
a.nianling++;}
for(int j=0;j<rongqi.size();j++)
{
if(rongqi.elementAt(j).nianling>=zhouqi)
{
rongqi.addElement(new TuZi());
}
}
}
System.out.print("兔子数量为："+rongqi.size());
}
}
【程序 2】
题目：判断 101-200 之间有多少个素数，并输出所有素数。
1.程序分析：判断素数的方法：用一个数分别去除 2 到 sqrt(这个数)，如果能被整除，
则表明此数不是素数，反之是素数。
解答：
程序如下：
public class Text2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int sum=0;
System.out.print("101到200的素数是： ");
for(int i=101;i<=200;i++)
{
int flag=0;
for(int j=2;j<=Math.sqrt(i);j++)
{
float k=(float)i;
if(k%j==0)
{
flag=1;
break;
}
}
if(flag==0)
{
System.out.print(i+" ");
sum++;
}
}
System.out.println("");
System.out.print("素数个数为： ");
System.out.print(sum);
}
}
【程序 3】
题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于
该数本身。例如：153 是一个"水仙花数"，因为 153=1 的三次方＋5 的三次方＋3 的三次方。
1.程序分析：利用 for 循环控制 100-999 个数，每个数分解出个位，十位，百位。
解答：
程序如下：
public class Text3 {
public static void main(String[] args)
{
int a=0;int b=0;int c=0;
System.out.println("100到999的水仙花数为：");
for(int i=100;i<=999;i++)
{
a=i/100;
b=i/10-a*10;
c=i-b*10-a*100;
if(i==a*a*a+b*b*b+c*c*c)
{
System.out.println(i);
}
}
}
}
【程序 4】
题目：将一个正整数分解质因数。例如：输入 90,打印出 90=2*3*3*5。
解答：
分析：对 n 进行分解质因数，应先找到一个最小的质数 k，然后按下述步骤完成：
(1)如果这个质数恰等于 n，则说明分解质因数的过程已经结束，打印出即可。
(2)如果 n>k，但 n 能被 k 整除，则应打印出 k 的值，并用 n 除以 k 的商,作为新的正整数你
n,重复执行第一步。
(3)如果 n 不能被 k 整除，则用 k+1 作为 k 的值,重复执行第一步。
这个题目很明显是要用递归算法来实现的，打印“*”有些技巧，但也很容易解决，程序如
下：
import java.io.*;
public class Text4 {
public static void chuLi(int n)
{
for(int i=2;i<=n;i++)
{
if(n==i)
{ 
System.out.print(i);
return;
}
if(n>i&&(n%i==0))
{
n=n/i;
System.out.print(i+"*");
chuLi(n);
break;//这句很重要
}
}
}
public static void main(String[] args) throws IOException
{int shu=0;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入正整数：");
shu=(new Integer(stdin.readLine()));
chuLi(shu);
}
}
【程序 5】
题目：利用条件运算符的嵌套来完成此题：学习成绩>=90 分的同学用 A 表示，60-89 分之
间的用 B 表示，60 分以下的用 C 表示。
解答：
此题较为简单，程序如下
import java.io.*;
public class Text5 {
public static void main(String[] agrs) throws IOException
{
System.out.print("请输入成绩：");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
int chengji=new Integer(stdin.readLine());
char dengji=chengji<60?'C':(chengji>=90?'A':'B');
System.out.print(dengji);
} 
}
【程序 6】
题目：输入两个正整数 m 和 n，求其最大公约数和最小公倍数。
<求最大公约数>
算法（1）设计：
E0.[确保 m n] 若 m n，则 m n。
E1.[求余数] 以 n 除 m 并令 r 为所得余数。（我们将有 0 r n。）
E2.[余数为 0?] 若 r 为 0，算法结束，n 即为所求答案。
E3.[减少] 置 m n，n r，并返回步骤 E1。
数学证明：
(1) 若 m%n=0，则 n 为所求最大公因子
(2) 若 m%n 0，则只需证明下面命题成立
如果某数是 n 与 m%n 的最大公因子，则这个数也是 m 和 n 的最大公因子。(上面算
法可化为这句话)
证明：
假设 a 是 n 和 m%n 的最大公因子，则有：
因有(m%n)%a=0，故可设 m%n=k*a，k 为正整数。又 n%a=0，故可设 n=p*a，p 也为正
整数。
可得数学表达式：m=t*n+m%n，其中 t 为不小于 0 的整数。
因此有：m=t*p*a+k*a=(t*p+k)*a，因此可得 m%a=0
因此有如下两个表达式：
a 为 m 和 n 的公因子已经证毕。
如何确定 a 为 m 和 n 的最大公因子？（可用反证法证明）
证明：假设 m 和 n 存在公因子 b，且有 b>a。
则有:
可以仿照上面的推导过程得出：
则 b 也是 n 和 m%n 的公因子，又 b>a，与 a 是 n 和 m%n 的最大公因子矛盾。
综上，如果某数是 n 与 m%n 的最大公因子，则这个数也是 m 和 n 的最大公因子。
(3) 证毕。
对步骤 E0 的分析：
若 m<n，则 m%n=m。当进行 E0 后，m 为较大者，m%n n。
算法（2）设计：
F1.[余数 m/n] 以 n 除 m，并令 m 为余数。
F2.[它是 0?] 如果 m=0，则此算法以 n 为答案而终止。
F3.[余数 n/m] 以 m 除 n，并令 n 是余数。
F4.[它是 0?] 如果 n=0，则算法以答案 m 而终止，否则返回步骤 F1。
算法（2）可仿照算法（1）进行证明
<求最大公倍数>
算法设计：
F1：求出 m 和 n 的较大者，令较大者为 m，较小者为 n。
F2：判断 m 能否被 n 整除，若能则 m 为两者最小公倍数。
F2：将 n 分解因式。
F3：将 m 依次乘以 n 的因子，判断乘积能否被 n 整除，若能则乘积为两者最小公倍数。
根据上面的算法，程序如下：
import java.io.*;
import java.util.*;
public class Text6 {
public static void fenJie(Vector<Integer> m,int n)
{
for(int i=2;i<=n;i++)
{
if(n==i)
{ 
m.addElement(i);
return;
}
if(n>i&&(n%i==0))
{
n=n/i;
m.addElement(i);
fenJie(m,n);
break;
}
}
}
public static int gongBeiShu(Vector<Integer> m,int a,int b)
{
int chengji=1;
if(a%b==0)
return a;for(int i=0;i<m.size();i++)
{
chengji=chengji*m.elementAt(i);
if((a*chengji)%b==0)
{
return a*chengji;
}
}
return a*b;
}
public static int bigYinZi(int a,int b)
{
int r=a%b;
int m=0;
if(r==0)
return b;
else
{
a=b;
b=r;
m=bigYinZi(a,b);
return m;
}
}
public static void main(String[] args) throws IOException
{
Integer shu1=0;Integer shu2=0;int t=0;
Vector<Integer> pool=new Vector<Integer>();
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入第一个正整数：");
shu1=(new Integer(stdin.readLine()));
System.out.print("请输入第二个正整数：");
shu2=(new Integer(stdin.readLine()));
if(shu1<shu2)
{
t=shu2;
shu2=shu1;
shu1=t;
}
fenJie(pool,shu2);
t=bigYinZi(shu1,shu2);
System.out.println("最大公约数是："+t);
t=gongBeiShu(pool,shu1,shu2);
System.out.print("最小公倍数："+t);
}
}
【程序 7】
题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
解答：
这题需要对汉字的内码进行一定的了解，汉字占两个字节，每个字节的开始位为 1。程序如
下：
import java.io.*;public class Text7 {
public static void main(String[] agrs) throws IOException
{
String zifuchuan=new String("");
int hanzishu=0;int zimu=0;int kongge=0;int shuzi=0;int qita=0;
System.out.print("请输入一行字符：");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
zifuchuan=stdin.readLine();
byte[] bytes=zifuchuan.getBytes();
for(int i=0;i<bytes.length;i++)
{
if((bytes[i]>=65&&bytes[i]<=90)||(bytes[i]>=97&&bytes[i]<=122))
zimu++;
else if(bytes[i]==32)
kongge++;
else if(bytes[i]>=48&&bytes[i]<=57)
shuzi++;
else if(bytes[i]<0)
hanzishu++;
else
qita++;
}
System.out.println("字符串所占字节个数为："+bytes.length);
System.out.println("汉字个数为："+hanzishu/2);
System.out.println("英文字母个数为："+zimu);
System.out.println("空格个数为："+kongge);
System.out.println("数字个数为："+shuzi);
System.out.println("其他字符个数为："+qita);
}
}
【程序 8】
题 目 ： 求 s=a+aa+aaa+aaaa+aa...a 的 值 ， 其 中 a 是 一 个 数 字 。 例 如
2+22+222+2222+22222(此时共有 5 个数相加)，几个数相加有键盘控制。
解答：
在此题中，利用进行字符串运算的“+”运算符，然后将字符串转为数字，实现了程序过程，
程序设计如下：
import java.io.*;
public class Text8 {
public static void main(String[] args) throws IOException
{
int s=0;int a=0;int sum=0;String p="";
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入数字a：");
a=new Integer(stdin.readLine());
System.out.print("请输入数字个数s：");
s=new Integer(stdin.readLine());
for(int i=1;i<=s;i++)
{
Character c=(char)(a+'0');
p=c.toString();
for(int j=1;j<i;j++)
{p=p+a;
}
int d=Integer.parseInt(p);
sum=sum+d;
}
System.out.println("结果为："+sum);
}
}
【程序 9】
题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如 6=1＋2＋3.编程 找
出 1000 以内的所有完数。
解答：
根据题目意思，设计程序如下：
import java.io.*;
import java.util.*;
public class Text9 {
public static void fenJie(Vector<Integer> m,int n)
{
for(int i=1;i<=n/2;i++)
if(n%i==0) 
m.addElement(i);
}
public static boolean panBie(Vector<Integer> m,int n)
{
int sum=0;
for(int i=0;i<m.size();i++)
sum=sum+m.elementAt(i);
if(sum==n)
return true;
else
return false;
}
public static void main(String[] args) throws IOException
{
boolean zhenjia=false;
System.out.println("1000以内的完数为：");
for(int i=2;i<1000;i++)
{
Vector<Integer> pool=new Vector<Integer>();
fenJie(pool,i);
zhenjia=panBie(pool,i);
if(zhenjia)
System.out.println(i);
}
}
}
【程序 10】
题目：一球从 100 米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在 第
10 次落地时，共经过多少米？第 10 次反弹多高？
解答：
此题较为简单，程序设计如下：
import java.io.*;public class Text10 {
public static void main(String[] args) throws IOException {
float heigh=100;int cishu=10;float sum=0;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("输入初始下落高度：");
heigh=(new Float(stdin.readLine()));
sum=heigh;
System.out.print("输入落地碰撞次数：");
cishu=(new Integer(stdin.readLine()));
for(int i=1;i<cishu;i++)
{
heigh=heigh/2;
sum=sum+heigh*2;
}
System.out.println("第"+cishu+"次反弹高度为："+heigh);
System.out.println("第"+cishu+"次落地总经过长度为："+sum);
}
}
【程序 11】
题目：有 1、2、3、4 个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
解答：
理解好排列组合，可设计程序如下：
public class Text11 {
public static void main(String[] args) {
int[] a={1,2,3,4};
System.out.println("满足条件的三位数是：");
for(int i=0;i<a.length;i++)
{
for(int j=0;j<a.length;j++)
{
if(j==i)
continue;
for(int k=0;k<a.length;k++)
{
if(k==i||k==j)
continue;
for(int h=0;h<a.length;h++)
{
if(h==i||h==j||h==k)
continue;
System.out.println(a[j]*100+a[k]*10+a[h]);
}
}
}
}
}
}
//output
满足条件的三位数是：
234
243
324
342423
432
134
143
314
341
413
431
124
142
214
241
412
421
123
132
213
231
312
321
【程序 12】
题目：企业发放的奖金根据利润提成。利润(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，求应发
放奖金总数？
解答：
此题较为简单，注意定义时需把奖金定义成长整型。程序设计如下：
import java.io.*;
public class Text12 {
public static void main(String[] args) throws IOException {
float lirun=0;double jiangjin=0;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("输入当月利润（万）：");
lirun=(new Float(stdin.readLine()));
if(lirun<=10)
jiangjin=lirun*0.1;
else if(lirun<=20)
jiangjin=(lirun-10)*0.075+10*0.1;
else if(lirun<=40)
jiangjin=(lirun-20)*0.05+10*0.075+10*0.1;
else if(lirun<=60)
jiangjin=(lirun-40)*0.03+20*0.05+10*0.075+10*0.1;
else if(lirun<=100)
jiangjin=(lirun-60)*0.015+20*0.3+20*0.05+10*0.075+10*0.1;
else
jiangjin=(lirun-100)*0.01+40*0.015+20*0.3+20*0.05+10*0.075+10*0.1;
System.out.print("当月奖金为（万）："+jiangjin);}
}
【程序 13】
题目：一个整数，它加上 100 后是一个完全平方数，再加上 168 又是一个完全平方数，请
问该数是多少？
解答：
可先对问题进行适当分析，分析情况如下：
假设整数为 X，第一个完全平方数为 M，第二个完全平方数为 N，则有下面的关系式。
X+100=M2
X+168=N2
将两个式子相减，再进行适当的数学变形可得：(N-M)(N+M)=68
得出可被 68 整除的数（前面已经编程实现），令 N-M=Y，N+M=Z。
则有 N=(Y+Z)/2（N 需为正整数），则有 X=N*N-168。则可得出答案。
程序设计如下：（一般性程序，两个数可以自己输入）
import java.io.*;
import java.util.*;
public class Text13 {
public static void fenJie(Vector<Integer> m,int n)
{
for(int i=1;i<=Math.sqrt(n);i++)
if(n%i==0) 
m.addElement(i);
}
public static void main(String[] args) throws IOException
{
Vector<Integer> pool=new Vector<Integer>();
int m=100;int n=168;int t=0;int flag=0;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("输入第一个正整数：");
m=new Integer(stdin.readLine());
System.out.print("输入第二个正整数：");
n=new Integer(stdin.readLine());
if(m>n)
{
t=m;
m=n;
n=t;
}
fenJie(pool,n-m);
int a=0;int b=0;int N=0;int x=0;
for(int i=0;i<pool.size();i++)
{
x=0;
a=pool.elementAt(i);
b=(n-m)/a;
if((a+b)%2==0)
{
N=(a+b)/2;
x=N*N-n;
}
if(x>0)
{
flag=1;System.out.println(x);
}
}
if(flag==0)
System.out.println("不存在这样的数字！");
}
}
【程序 14】
题目：输入某年某月某日，判断这一天是这一年的第几天？
解答：
闰年的判断，可根据以下三点进行判断。
1、普通年能被 4 整除且不能被 100 整除的为闰年。（如 2004 年就是闰年,1900 年不是
闰年）
2、世纪年能被 400 整除的是闰年。(如 2000 年是闰年，1900 年不是闰年)
3、对于数值很大的年份,这年如果能整除 3200,并且能整除 172800 则是闰年。如
172800 年是闰年，86400 年不是闰年(因为虽然能整除 3200，但不能整除 172800)
分析： 利用 Scanner 类中 nextInt()进行数据的读取，由于是连续输入而且输入中有汉字，
故这种方法不行。程序设计需要改进，现利用 Character.isDigit 方法进行程序设计，达到了
较为理想的结果，程序如下所示。（此程序中有一段代码是对字符串中的数字进行提取，如
211 年 8 月 8 日提取三个数字分别为：211、8、8）
import java.io.*;
import java.util.*;
public class Text14xin {
public static void main(String[] args) throws IOException
{
long year=0;long month=0;long day=0;
String m=new String("");
String n=new String("");
Vector<String> s=new Vector<String>();
long tianshu=0;
int[] monthday={31,28,31,30,31,30,31,31,30,31,30,31};
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("输入日期：");
m=stdin.readLine();
char[] mass = m.toCharArray();
for(int i=0;i<mass.length;i++) //for循环是对字符串中的数字进行提取
{
if(Character.isDigit(mass [i]))
n=n+mass[i];
else
{
if(!n.isEmpty())
{
s.addElement(n);
n=new String("");
}
}
if(j==mass.length-1&&!n.isEmpty())
vector.addElement(n);
}
year=Long.parseLong(s.elementAt(0));
month=Long.parseLong(s.elementAt(1));day=Long.parseLong(s.elementAt(2));
if(year>=172800)
{
if(year%3200==0&&year%172800==0)
monthday[1]=29;
}
else
{
if(year%4==0&&year%100!=0)
monthday[1]=29;
if(year%400==0)
monthday[1]=29;
}
for(int j=0;j<month-1;j++)
tianshu=tianshu+monthday[j];
tianshu=tianshu+day;
System.out.print(m+"是这一年的第"+tianshu+"天。");
}
}
//output
输入日期：211年3月1日
211年3月1日是这一年的第60天。
输入日期：444nian3yue5ri
444nian3yue5ri 是这一年的第 65 天。
【程序 15】
题目：输入三个整数 x,y,z，请把这三个数由小到大输出。
解答：
利用 Scanner 类中 nextInt()进行数据的读取，Arrays.sort(a)进行排序，程序设计如下：
import java.io.*;
import java.util.*;
public class Text15xin {
public static void main(String[] args) throws IOException {
String m=new String("");
int[] a={0,0,0};
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("输入三个数（以一个空格隔开）：");
m=stdin.readLine();
Scanner scan=new Scanner(m);
for(int i=0;i<3;i++)
{
a[i]=scan.nextInt();
}
Arrays.sort(a);
System.out.print("三个数的升序排列为：");
for(int i=0;i<3;i++)
{
System.out.print(a[i]+" ");
}
}
}
【程序 16】
题目：输出 9*9 口诀。
1.程序分析：分行与列考虑，共 9 行 9 列，i 控制行，j 控制列。解答：
此题较为简单，程序设计如下：
public class Text16 {
public static void main(String[] args)
{
for(int i=1;i<=9;i++)
{
for(int j=1;j<=i;j++)
{
System.out.print(j+"*"+i+"="+i*j+" ");
}
System.out.println("");
}
}
}
【程序 17】
题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个
第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下 的
一半零一个。到第 10 天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
解答：
分析：采取逆向思维的方法，从后往前推断。
public class Text17 {
public static void main(String[] args) {
int a=1;//第十个月的桃子个数
int b=10;//用b-1来表示所经过的月数
for(int i=b-1;i>=1;i--)
{
a=(a+1)*2;
}
System.out.print(a);
}
}
【程序 18】
题目：两个乒乓球队进行比赛，各出三人。甲队为 a,b,c 三人，乙队为 x,y,z 三人。已抽签
决定比赛名单。有人向队员打听比赛的名单。a 说他不和 x 比，c 说他不和 x,z 比，请编程
序找出三队赛手的名单。
解答：
分析：
其实问题可转化为排列组合问题，a 可以选 x,y,z 中的一个，b 可以选剩下两个中的一个，
而 c 只能选最后剩下的一个，总共有 6 中可能。关于排列的实现可以参照程序 11，具体程
序如下：
public class Text18 {
public static void main(String[] args) {
Character[] b={'x','y','z'};
for(int j=0;j<3;j++)
{
for(int k=0;k<3;k++)
{
if(j==k)
continue;
for(int h=0;h<3;h++)
{
if(h==j||h==k)continue;
if(b[j]!='x'&&b[h]!='x'&&b[h]!='z')
{
String s1=b[j].toString();
String s2=b[k].toString();
String s3=b[h].toString();
System.out.println(" a"+"(vs)"+s1+" b"+"(vs)"+s2+" 
c"+"(vs)"+s3);
}
}
}
}
}
}
//output:
 a(vs)z b(vs)x c(vs)y
【程序 19】
题目：打印出如下图案（菱形）
* 
*** 
****** 
******** 
****** 
*** 
* 
解答：
1.先把图形分成两部分来看待，前四行一个规律，后三行一个规律，利用双重 for 循环，第
一层控制行，第二层控制列。问题比较简单，就不进行编程了。
2 为了使问题具有一般性，现在我们输入菱形的行数，编程实现菱形的绘制。
分析：
1、输入的列数必须为行数
2、假设输入的数字为 n，则第（n+1）/2 为中间一行，进行一些简单的数学推导，便能推
出具体某一行的打印情况，程序设计如下：
import java.io.*;
public class Text19 {
public static void main(String[] args) throws Exception{
int n=0;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入菱形行数：");
n=(new Integer(stdin.readLine()));
if(n%2!=0)
{
for(int i=1;i<=(n+1)/2;i++)
{
for(int j=1;j<=(n-1)/2+i;j++)
{
if(j<=(n+1)/2-i)
{
System.out.print(" ");
}
else
System.out.print("*");
}System.out.println("");
}
for(int i=(n+3)/2;i<=n;i++)
{
for(int j=1;j<=(3*n+1)/2-i;j++)
{
if(j<=i-(n+1)/2)
{
System.out.print(" ");
}
else
System.out.print("*");
}
System.out.println("");
}
}
else
System.out.print("请确保行数为奇数！");
}
}
//output:
请输入菱形行数：7
 *
 ***
*****
*******
*****
 ***
 *
【程序20】
题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
解答：
分析：请抓住分子与分母的变化规律。 分子分母都是斐波那契数列，递推公式的得出较为
简单，程序设计如下：
public class Text20 {
public static void main(String[] args) {
float fenmu=1;float fenzi=2;
float sum=fenzi/fenmu;
float t=0;
for(int i=1;i<20;i++)
{
t=fenmu+fenzi;
fenmu=fenzi;
fenzi=t;
sum=sum+fenzi/fenmu;
}
System.out.print(sum);
}
}
//output:
32.660263
【程序21】
题目：求1+2!+3!+...+20!的和
解答：注意：由于数据较大，应该将数据类型设为double，当所得数据超过double的最大值时，显
示为Infinity。而当数据类型设为int或者其他不是double类型的时候，超过该类型的
最大值时，溢出，先往符号位进一位，显示为负数，当再进位时，则进行窄化处理，显示这
个类型所占字节的大小。
public class Text21 {
public static void main(String[] args)
{
double sum=0;double jiecheng=1;
for(int i=1;i<=20;i++)
{
jiecheng=i*jiecheng;
sum=sum+jiecheng;
}
System.out.println(sum);
System.out.print(Double.MAX_VALUE);
}
}
//output:
2.5613274941118203E18
1.7976931348623157E308
【程序22】
题目：利用递归方法求5!。
解答：
此题较为简单，不进行编程，现将题目改为求200！。
分析：
200！大于Double类的最大值，所以如果用普通数据类型将200！进行存储，明显难以达到
要求。现构建一个容器，容器里面的存放变量，当该层的数为n且大于等于十时，往前一层
进(n-n%10)/10，自身保留n%10。这种程序设计下最大可求出292！（理论上能计算所有正
整数的阶乘，此处出现问题，但尚未分析出来，希望有人能指出来），而按照程序21中的
方法则只能计算到170！。
程序设计如下：
import java.util.*;
class ShuJu
{
double h;//设置成double将能进行更大数据的运算，至少比text21中的计算能力要大
ShuJu(double i)
{
h=i;
}
}
public class Text22 {
public static void jiecheng(Vector<ShuJu> m,int a)
{
ShuJu n=new ShuJu(1);
m.addElement(n);
for(int i=1;i<=a;i++)
{
int g=m.size();
for(int j=0;j<g;j++)
{
m.elementAt(j).h=m.elementAt(j).h*i;
}
for(int j=0;j<g;j++){
double k=m.elementAt(j).h;
if(k>=10)
{
m.elementAt(j).h=k%10;
if(j+1>=g)
m.addElement(new ShuJu((k-m.elementAt(j).h)/10));
//注意要减去余数，数据类型是double的，不进行这项操作将会存储为小数。
else
m.elementAt(j+1).h=m.elementAt(j+1).h+(k-m.elementAt(j).h)/10;
}
else
m.elementAt(j).h=k;
}
}
int flag=m.size()-1;
while(m.elementAt(flag).h>=10)//这个while循环是使得最高位的值向前转化，存入容
器。
//不进行这个循环将会导致容器的最高位为一个很大的数
{
double ch=m.elementAt(flag).h;
m.elementAt(flag).h=ch%10;
m.addElement(new ShuJu(((ch-m.elementAt(flag).h)/10)));
flag=flag+1;
}
}
public static void main(String[] args)
{
Vector<ShuJu> pool=new Vector<ShuJu>();
int x=200;int zeros=0;int flag=0;
jiecheng(pool,x);
for(int i=0;pool.elementAt(i).h==0;i++)
{
zeros++;//确保后面连续的零不进行输出
}
System.out.print((int)pool.elementAt(pool.size()-1).h+".");
//需将数据转化为int型的，不进行转化将会导致输出为double型的，将会引进无用的小
数点
for(int i=pool.size()-2;i>=zeros;i--)
{
System.out.print((int)pool.elementAt(i).h);
flag++;
if(flag>=10)//小数点后保留多少位小数
break;
}
System.out.print("*E"+(pool.size()-1));//输出指数标志
}
}
//output:
7.8865786736*E374
【程序23】
题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。
最后问第一个人，他说是10岁。请问第五个人多大？
解答：
此题较为简单，此处省略。
【程序24】
题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
解答：
1、 可先得到输入的字符串s，然后利用new Integer(s)将字符串转为数字，再进行除法运算，
则可得出相应答案，但这样做有些复杂。
2、 可先得到输入的字符串s，利用s.getBytes()可得到相应的Byte数组，再将数组处理一下，
逆序输出即可。程序设计如下：
//此程序对于任意位的正整数都行
import java.io.*;
public class Text24 {
public static void main(String[] args) throws Exception{
String s=new String("");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入一个正整数：");
s=stdin.readLine();
byte[]bytes=s.getBytes();
System.out.println("它是"+bytes.length+"位数");
for(int i=bytes.length-1;i>=0;i--)
{
System.out.print(bytes[i]-'0');
}
}
}
//output:
请输入一个正整数：123456
它是6位数
654321
【程序25】
题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千
位相同。
解答：
可按照程序24的思路对此题进行解答，程序设计如下：
//该程序不限制在5位数
import java.io.*;
public class Text25 {
public static void main(String[] args) throws Exception{
String s=new String("");
int flag=0;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入一个正整数：");
s=stdin.readLine();
byte[]bytes=s.getBytes();
System.out.println("它是"+bytes.length+"位数");
for(int i=0;i<bytes.length;i++)
{
if(bytes[i]!=bytes[bytes.length-1-i])
{
flag=1;break;
}
}
if(flag==0)
System.out.print("该数是回文数。");
else
System.out.print("该数不是回文数。");
}
}
//output:
请输入一个正整数：1234321
它是7位数
该数是回文数。
【程序26】
题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续 判
断第二个字母。
解答：程序设计如下：
import java.io.*;
public class Text26 {
public static void main(String[] args) throws Exception{
String s=new String("");char c=' ';char d=' ';
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入英文字母：");
s=stdin.readLine();
byte[]bytes=s.getBytes();
c=(char)bytes[0];
if(bytes.length>=2)
d=(char)bytes[1];
switch(c)
{
case 'M':
System.out.print("星期一");
break;
case 'm':
System.out.print("星期一");
break;
case 'T':
if(d=='u'||d=='U')
System.out.print("星期二");
if(d=='h'||d=='H')
System.out.print("星期四");
break;
case 't':
if(d=='u'||d=='U')
System.out.print("星期二");
if(d=='h'||d=='H')
System.out.print("星期四");
break;
case 'W':
System.out.print("星期三");
break;
case 'w':
System.out.print("星期三");break;
case 'F':
System.out.print("星期五");
break;
case 'f':
System.out.print("星期五");
break;
case 'S':
if(d=='a'||d=='A')
System.out.print("星期六");
if(d=='u'||d=='U')
System.out.print("星期天");
break;
case 's':
if(d=='a'||d=='A')
System.out.print("星期六");
if(d=='u'||d=='U')
System.out.print("星期天");
break;
}
}
}
【程序27】
题目：求100之内的素数
解答：和程序2一样
public class Text27 {
public static void main(String[] args) {
int sum=0;
System.out.print("100以内的素数是： ");
System.out.print(2+" ");
for(int i=3;i<100;i++)
{
int flag=0;
for(int j=2;j<=Math.sqrt(i);j++)
{
float k=(float)i;
if(k%j==0)
{
flag=1;
break;
}
}
if(flag==0)
{
System.out.print(i+" ");
sum++;
}
}
System.out.println("");
System.out.print("素数个数为： ");
System.out.print(sum+1);
}}
//output
100以内的素数是： 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 
71 73 79 83 89 97 
素数个数为： 25
【程序28】
题目：对10个数进行排序
1、利用Array.sort()方法进行排序，可参见程序15，程序设计较为简单，此处省略。
2、现将冒泡排序和选择的程序写出来。
冒泡排序
public class MaoPao {
public static void main(String[] args) {
int[] a={3,6,4,2,9,5,8,1,7,0};
int temp=0;int flag=0;
for(int i=0;i<a.length-1;i++)
{
for(int j=0;j<a.length-i-1;j++)
{
if(a[j]<a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
flag=1;
}
}
if(flag==0)
break;
}
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
}
}
选择排序
public class XuanZe {
public static void main(String[] args) {
int[] a={3,6,4,2,9,5,8,1,7,0};
int temp=0;int flag=0;
for(int i=0;i<a.length-1;i++)
{
flag=i;
for(int j=i+1;j<a.length;j++)
{
if(a[flag]<a[j])
{
flag=j;
}
}
if(flag!=i)
{
temp=a[flag];
a[flag]=a[i];a[i]=temp;
}
}
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
}
}
当然还有其他的排序方式，如希尔排序，基数排序等，可百度它们的排序规则，再按照这些
规则编程即可，此处不对这些排序进行编程。各种排序的性能如下图所示：
【程序29】
题目：求一个3*3矩阵对角线元素之和
1.程序分析：利用双重for循环控制输入二维数组，再将a[i][i]累加后输出。
解答：
为具有一般性，现设计自主输入n*n的矩阵，并求出对角线元素之和。
import java.io.*;
import java.util.*;
public class Text29
{
public static void main(String args[]) throws IOException
{
int n=0;
System.out.print("请输入矩阵的维数：");
Scanner reader = new Scanner(System.in);
n=reader.nextInt();
String[] s=new String[n];
Scanner[] scan=new Scanner[n];
long[][] a=new long[n][n];
long sum=0;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
for(int i=0;i<n;i++)
{
s[i]=stdin.readLine(); //连续输入多行
}
System.out.println("output:");
for(int i=0;i<n;i++){
scan[i]=new Scanner(s[i]);
}for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
a[i][j]=scan[i].nextLong();
}
}
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
System.out.print(a[i][j]+" ");
if(i==j)
{
sum=sum+a[i][j];
}
}
System.out.println("");
}
System.out.println("对角线数值和为："+sum);
}
}
//input
请输入矩阵的维数：5
1 2 3 4 5
6 7 8 9 0
0 9 8 7 6
5 4 3 2 1
3 4 5 6 7
output:
1 2 3 4 5 
6 7 8 9 0 
0 9 8 7 6 
5 4 3 2 1 
3 4 5 6 7 
对角线数值和为：25
【程序30】
题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
解答：
利用已经有的类和方法进行编程是java的核心思想。List类可以使用Collections.sort(List a)进
行排序，可以利用add(int x,long m)进行插入，相当简便，实现多个数据的插入可以仿照下面
的程序写出。具体程序如下：（关于类和方法不懂的可以查看JDK工具）
import java.io.*;
import java.util.*;
public class Text31xin {
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
System.out.print("请输入需要排列的数字（以空格键隔开）：");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
Scanner scan=new Scanner(stdin.readLine());
List<Long> p=new ArrayList<Long>();for(int i=0;scan.hasNext();i++)
{
p.add(scan.nextLong());
}
Collections.sort(p); //建议在JDK多看看这个方法
System.out.print("排列后的顺序为：");
for(int i=0;i<p.size();i++)
System.out.print(p.get(i)+" ");
System.out.println("");
System.out.print("请输入需要插入的数值：");
long m=new Long(stdin.readLine());
for(int i=0;i<p.size();i++)
{
if(m>=p.get(i)) //等号是必要的，可以减少一个数据的后移
continue;
p.add(i,m);
break;
}
System.out.print("插入后的顺序为：");
for(int i=0;i<p.size();i++)
System.out.print(p.get(i)+" ");
}
}
//output
请输入需要排列的数字（以空格键隔开）：9 8 7 6 4 3 2 1
排列后的顺序为：1 2 3 4 6 7 8 9 
请输入需要插入的数值：5
插入后的顺序为：1 2 3 4 5 6 7 8 9
【程序31】
题目：将一个数以二进制形式输出。
1、可利用Integer.toBinaryString(i)进行输出。
2、可利用与运算以及位移运算进行程序设计，设计的程序如下：
import java.io.*;
public class Text31{
public static void toBinary(int x)
{
int flag=0x80000000; //int型占四个字节，注意利用16进制进行赋值，更为简便
int flag1=0;
for(int i=1;i<=32;i++)
{
if((x&flag)==0)
{
if(flag1==1)
System.out.print(0);
}
else
{
System.out.print(1);
flag1=1; //flag标志可使得前面的0不进行输出
}
flag=flag>>>1;}
System.out.println("");
}
public static void main(String[] args) throws Exception {
int x=0;
String s=new String("");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入正整数：");
s=stdin.readLine();
x=new Integer(s);
toBinary(x);
}
}
//output
请输入正整数：12
1100
请输入正整数：2047
11111111111
【程序32】
题目：取一个整数a从右端开始的5～8位。
解答：
(1)先使a右移4位。
(2)设置一个低4位全为1,其余全为0的数。可用~(~0<<4) 
(3)将上面二者进行&运算。
import java.io.*;
public class Text32 {
public static void main(String[] args) throws Exception{
int n=5;int m=8;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入一个正整数：");
int a=new Integer(stdin.readLine());
int b=~(~0<<(m-n+1));
int c=a>>>(m-n+1);
int d=c&b;
System.out.print("正整数的二进制形式为：");
System.out.println(Integer.toBinaryString(a));
System.out.print("正整数的从右端开始的5～8位为：");
int k=Integer.toBinaryString(d).length();
if(k<m-n+1)
for(int i=k;i<m-n+1;i++)
System.out.print("0");//对前面的0进行输出
System.out.print(Integer.toBinaryString(d));
}
}
//output
请输入一个正整数：289
正整数的二进制形式为：100100001
正整数的从右端开始的5～8位为：0010
【程序33】
题目：打印出杨辉三角形（要求打印出10行如下图）
解答：
分析：
1 1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
杨辉三角的数学关系，可自己查阅，程序设计如下：
import java.io.*;
import java.util.*;
public class Text33 {
public static void main(String[] args) throws Exception{
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入需要打印的行数：");
int n=new Integer(stdin.readLine());
Vector<Integer> vector1=new Vector<Integer>();;
for(int i=1;i<=n;i++)
{
Vector<Integer> vector=new Vector<Integer>();
for(int j=1;j<=n-i;j++)
{
System.out.print(" ");//打印前面的空白
}
vector.addElement(1);
if(i>=3)
{
for(int k=2;k<=i-1;k++)
{
int m=vector1.elementAt(k-2)+vector1.elementAt(k-1);
vector.addElement(m);
}
}
if(i>=2)
vector.addElement(1);
vector1=vector;
for(int h=0;h<vector.size();h++)
{
System.out.print(vector.elementAt(h)+" ");
}
System.out.println("");
}
}
}
//output
请输入需要打印的行数：10
 1 
 1 1 
 1 2 1 
 1 3 3 1 
 1 4 6 4 1 
 1 5 10 10 5 1 
 1 6 15 20 15 6 1 
 1 7 21 35 35 21 7 1 
1 8 28 56 70 56 28 8 1 1 9 36 84 126 126 84 36 9 1 
【程序34】
题目：输入3个数a,b,c，按大小顺序输出。
解答：与程序15相同，此处不做解答。
【程序35】
题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
解答：
程序设计如下：
import java.io.*;
import java.util.*;
public class Text35 {
public static void main(String[] args) throws Exception{
System.out.print("请输入需要排列的数字（以空格键隔开）：");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
Scanner scan=new Scanner(stdin.readLine());
List<Long> p=new ArrayList<Long>();
for(int i=0;scan.hasNext();i++)
{
p.add(scan.nextLong());
}
int flag=0;
int flag1=p.size()-1;
long temp=0;
for(int i=1;i<p.size();i++)
{
if(p.get(flag)<p.get(i))
flag=i;
}
if(flag!=0)
{
temp=p.get(0);
p.set(0,p.get(flag));
p.set(flag,temp);
}
for(int i=p.size()-2;i>=0;i--)
{
if(p.get(flag1)>p.get(i))
flag1=i;
}
if(flag1!=p.size()-1)
{
temp=p.get(p.size()-1);
p.set(p.size()-1,p.get(flag1));
p.set(flag1,temp);
}
System.out.print("改变后的顺序为：");
for(int i=0;i<p.size();i++)
System.out.print(p.get(i)+" ");
}
}
//output请输入需要排列的数字（以空格键隔开）：6 7 8 9 5 4 1 2 3
改变后的顺序为：9 7 8 6 5 4 3 2 1
请输入需要排列的数字（以空格键隔开）：2 3 1 1 5 5 4
改变后的顺序为：5 3 1 4 2 5 1 (最大的取从左到右的第一个，最小的取从右到左的第
一个)
【程序36】
题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
import java.io.*;
import java.util.*;
public class Text36 {
public static void main(String[] args) throws Exception{
System.out.print("请输入需要排列的数字（以空格键隔开）：");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
Scanner scan=new Scanner(stdin.readLine());
List<Long> p=new ArrayList<Long>();
for(int i=0;scan.hasNext();i++)
{
p.add(scan.nextLong());
}
System.out.print("请输入需要向后移动的位数：");
long m=new Long(stdin.readLine());
if(m<=p.size())
{
int n=p.size();
for(int i=1;i<=m;i++)
p.add(0,p.get(n-1));//插入一位，全部后移移位，故要移走的总是最后一个
System.out.print("移动后的顺序为：");
for(int i=0;i<n;i++) //p的大小改变，应该打印原先的大小n
System.out.print(p.get(i)+" ");
}
else
System.out.print("error!");
}
}
//output
请输入需要排列的数字（以空格键隔开）：1 2 3 4 5 6 7 8 9
请输入需要向后移动的位数：4
移动后的顺序为：6 7 8 9 1 2 3 4 5
【程序37】
题目：有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人
退出圈子，问最后留下的是原来第几号的那位。
解答：
import java.io.*;
import java.util.*;
public class Text37 {
public static void main(String[] args) throws Exception{
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入总人数：");
int n=new Integer(stdin.readLine());
System.out.print("请输入循环人数：");
int m=new Integer(stdin.readLine());
List<Integer> p=new ArrayList<Integer>();int flag=1;
int flag1=0;
for(int i=0;i<n;i++)
{
p.add(i+1);
}
while(true)
{
flag1=0;
for(int j=0;j<p.size();j++)
{
if(p.get(j)!=0) //0表示这个人已经被移除
{
flag1++; //计算还存在的人数
if(flag==m) //判断是否移除
{
p.set(j,0); //移除该人
flag=1; //判断标志重置
}
else
flag++; //判断标志加1
}
}
if(flag1==1) //设置最后剩下的人是一个（不能设置为任意人数，否则不能跳
出）
break;
}
System.out.print("最后剩下的是");
for(int i=0;i<p.size();i++)
{
if(p.get(i)!=0) //0的表示已经移除，不打印出来
System.out.print("序号为"+p.get(i)+"的人");
}
}
}
//output
请输入总人数：600
请输入循环人数：7
最后剩下的是序号为48的人
【程序38】
题目：写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。
解答：
1、利用类中的方法可直接求出。
2、判断当前的值是否为“\n”，程序设计较为简单，不做解答。
【程序39】
题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n,当输入n为奇数时，调
用函数1/1+1/3+...+1/n(利用指针函数) 
解答：
程序设计较为简单，此处省略。（可参见程序20）。
【程序40】
题目：字符串比较。
解答：1、利用字符串中类的方法进行实现。public int compareToIgnoreCase(String str)
2、逐一比较，采用递归方法，程序设计如下：
import java.io.*;
public class Text40 {
public static int compare(String a,String b)
{
char[] x=a.toCharArray();
char[] y=b.toCharArray();
int k=x.length;
int g=y.length;
int kk=k;
if(k>g)
k=g; //取较短字符串的长度范围进行比较
for(int i=0;i<k;i++)
{
char u=Character.toLowerCase(x[i]); //都转换成小写
char t=Character.toLowerCase(y[i]);
if(u>t)
return 1; //大于则返回1
if(u<t)
return -1; //小于返回-1，等于的话则执行下一次循环
} //结束后则说明，在这段相同的范围内，它们是相等的，则需要比较长度
if(kk==g)
return 0;
if(kk>g)
return 1;
return -1;
}
public static void main(String[] args) throws Exception{
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入第一个字符串：");
String n=stdin.readLine();
System.out.print("请输入第二个字符串：");
String m=stdin.readLine();
int daxiao=compare(n,m);
if(daxiao==0)
System.out.print(n+"="+m);
if(daxiao==1)
System.out.print(n+">"+m);
if(daxiao==-1)
System.out.print(n+"<"+m);
}
}
//
请输入第一个字符串：aBcd
请输入第二个字符串：ABCD
aBcd=ABCD
请输入第一个字符串：abcd
请输入第二个字符串：accd
abcd<accd
请输入第一个字符串：abcde
请输入第二个字符串：abcd
abcde>abcd【程序41】
题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，
这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又
多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做
的，问海滩上原来最少有多少个桃子？
解答：
这题可以逆向思考得出答案，第五个猴子分的时候有m个桃子，根据分的逻辑关系可知第
四个猴子分的时候有m*5/4+1个桃子，根据此关系依次递推。假设第5个猴子得到了n个桃子，
则有m=5*n+1的数学关系。必须保证每次分的时候桃子的个数为整数，猴子得到的桃子数
也为整数。（要确保这一点，需要每次m都能被4整除）。
public class Text41 {
public static void main(String[] args) {
int n=1;
int m=0;
int flag=1;
int monkeyNum=5;
while(true)
{
flag=1;
m=monkeyNum*n+1;
for(int i=monkeyNum;i>=1;i--)
{
if(m%(monkeyNum-1)==0)
{
m=m/(monkeyNum-1)*monkeyNum+1;
flag++; //计算多少次的桃子数量被4整除
}
else
break;
}
if(flag==monkeyNum) //每次的桃子数量都能被4整除
break;
n++;
}
System.out.println("开始的桃子数至少是："+m);
System.out.print("此时第五个猴子得到的桃子数是："+n);
}
}
//output
开始的桃子数至少是：3121
此时第五个猴子得到的桃子数是：255
【程序42】
题目：809*??=800*??+9*??+1 其中??代表的两位数,8*??的结果为两位数，9*??的结果为
3位数。求??代表的两位数，及809*??后的结果。
解答：此题貌似有问题，不做解答。
【程序43】
题目：求0—7所能组成的奇数个数。
题目表述不清不做解答。
【程序44】
题目：一个偶数总能表示为两个素数之和。
不会，不明白这种证明要怎么去编程实现。
【程序45】题目：判断一个素数能被几个9整除
题目表述不清不做解答。
【程序46】
题目：两个字符串连接程序
解答：
1、直接使用“+”运算符即可。
2、 public String concat(String str) 方法，"cares".concat("s") returns "caress" ，
"to".concat("get").concat("her") returns "together"。
【程序47】
题目：读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的＊。
解答：
程序较为简单，此处不做解答。（可参见程序29的输入方法）
【程序48】
题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密
规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交
换，第二位和第三位交换。
解答：
程序设计如下：
import java.io.*;
public class Text48 {
public static void main(String[] args) throws Exception {
System.out.print("请输入需要加密的四位数整数：");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
String s=stdin.readLine();
char[] a=s.toCharArray();
int[] b=new int[a.length];
for(int i=0;i<a.length;i++)
{
b[i]=((a[i]-'0')+5)%10;
}
System.out.print("加密后的数字为：");
for(int i=b.length-1;i>=0;i--)
{
System.out.print(b[i]);
}
}
}
//output
请输入需要加密的四位数整数：1234
加密后的数字为：9876
请输入需要加密的四位数整数：4567
加密后的数字为：2109
【程序49】
题目：计算字符串中子串出现的次数
解答：
import java.io.*;
public class Text49 {
public static void main(String[] args) throws Exception {
System.out.print("请输入字符串：");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
String s=stdin.readLine();
System.out.print("请输入子字符串：");String s1=stdin.readLine();
char[] a=s.toCharArray();
char[] b=s1.toCharArray();
int num=0;
int flag=0;
for(int i=0;i<a.length;i++)
{
if(a[i]==b[flag])
{
flag++;
if(flag==b.length -1)
{
num++;
flag=0;
}
}
else
{
flag=0;
}
}
System.out.print("拥有的子字符串个数为："+num);
}
}
//output
请输入字符串：ab1ab1ab1ab1
请输入子字符串：ab1
拥有的子字符串个数为：4
【程序50】
题目：有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，
三门课成绩），计算出平均成绩，况原有的数据和计算出的平均分数存放在磁盘文件"stud"
中。
import java.io.*;
import java.util.*;
public class Text50 {
public static double meg(float i) //四舍五入保留一位小数
{
 int b = (int)Math.round(i * 10); 
 double c = (double)b/10.0;
 return c;
}
public static void main(String[] agrs) throws Exception
{
FileOutputStream out=new FileOutputStream("stdu.txt");
String n=new String("");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
for(int i=1;i<=5;i++)
{
String s=stdin.readLine();
Vector<String> vector=new Vector<String>();
byte[] a=s.getBytes();
char[] mass = s.toCharArray();
for(int j=0;j<mass.length;j++) //for 循环是对字符串中的数字进行提取{
if(Character.isDigit(mass [j])||mass [j]==46)
n=n+mass[j];
else
{
if(!n.isEmpty())
{
vector.addElement(n);
n=new String("");
}
}
if(j==mass.length-1&&!n.isEmpty())
{
vector.addElement(n);
n=new String("");
}
}
float[] shu=new float[vector.size()];
float sum=0;
for(int j=0;j<vector.size();j++)
{
shu[j]=Float.parseFloat(vector.elementAt(j));
sum=sum+shu[j];
}
float pinjun=sum/vector.size();
double pinjun1=meg(pinjun);
String sh=Double.toString(pinjun1);
byte[] b=sh.getBytes();
out.write(a);
byte a2='\t';
out.write(a2);
out.write(b);
byte[] a3={'\r','\n'}; //在 txt 中输出回车
out.write(a3);
}
}
}
//input（输入人名与数字之间用 tab 键隔开）
张三 78 79 81
李四 78 79 79.5
王二 66 86 86.6
赵五 98 95 93
孙六 78 78 79
//output（在 stdu.txt 中）
zs 张三 78 79 81 79.3
李四 78 79 79.5 78.8
王二 66 86 86.6 79.5
赵五 98 95 93 95.3
孙六 78 78 79 78.3
（观察输出结果可以看出，第一行多打印了 zs，我用搜狗输入张三时是输入 zs 的，为什么
会出现 zs？以及如何去掉 zs？又为什么下面的几行没有这个问题？思索良久得不出答案，
望高人指正。）