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】
題目：有一個已經排好序的數組?，F輸入一個數，要求按原來的規律將它插入數組中。
解答：
利用已經有的類和方法進行編程是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？又為什么下面的幾行沒有這個問題？思索良久得不出答案，
望高人指正。）