Java經典五十道題41-50

【程序41】 
題目：海灘上有一堆桃子，五隻猴子來分。第一隻猴子把這堆桃子憑據分爲五份，多了一個，這隻猴子把多的一 
個扔入海中，拿走了一份。第二隻猴子把剩下的桃子又平均分成五份，又多了一個，它同樣把多的一個扔入海中 
，拿走了一份，第三、第四、第五隻猴子都是這樣做的，問海灘上原來最少有多少個桃子？




【程序42】
題目：809*??=800*??+9*??+1 
其中??代表的兩位數,8*??的結果爲兩位數，9*??的結果爲3位數。求??代表的兩位數，及809*??後的結果。




【程序43】  
題目：求0—7所能組成的奇數個數。




【程序44】 
題目：一個偶數總能表示爲兩個素數之和。這個就不寫了，前面有




【程序45】//這個就是判斷素數的，不寫了
題目：判斷一個素數能被幾個9整除




【程序46】  
題目：兩個字符串連接程序，不寫了很簡單




【程序47】 
題目：讀取7個數（1—50）的整數值，每讀取一個值，程序打印出該值個數的＊。不寫了，很簡單




【程序48】 
題目：某個公司採用公用電話傳遞數據，數據是四位的整數，在傳遞過程中是加密的，加密規則如下：每位數字 
都加上5,然後用和除以10的餘數代替該數字，再將第一位和第四位交換，第二位和第三位交換。




【程序49】 
題目：計算字符串中子串出現的次數




【程序50】
題目：有五個學生，每個學生有3門課的成績，從鍵盤輸入以上數據（包括學生號，姓名，三門課成績），計算 

出平均成績，況原有的數據和計算出的平均分數存放在磁盤文件"stud"中。

package javaimprove041;
/*
 * 【程序41】 MonkeyPeach.java 
題目：海灘上有一堆桃子，五隻猴子來分。第一隻猴子把這堆桃子憑據分爲五份，多了一個，這隻猴子把多的一 
個扔入海中，拿走了一份。第二隻猴子把剩下的桃子又平均分成五份，又多了一個，它同樣把多的一個扔入海中 
，拿走了一份，第三、第四、第五隻猴子都是這樣做的，問海灘上原來最少有多少個桃子？
問題分析：又來一個遞歸，問的是最少的情況，最少的情況下就是當最後一隻猴子把剩下的分成五份，多了一個丟掉是最少的情況，
在桃子完整的默認前提下，剩下的peach5=(peach4-1)*(4/5),因此peach4=1.25peach5+1,peach4要是整數，

且滿足分五分多一，則：
peach5=5*i+1；
i=1,peach5=6 peach4 no
i=2,peach5=11 peach4 no
i=3,peach5=16 peach4 yes.
因此在第五隻猴子的時候，剩下的peach最少是16個
 */
public class MonkeyAndPeach {
	public int peach(int n)
	{
		if(n==5)
			return 16;
		return (int)(1.25*peach(n+1)+1);
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MonkeyAndPeach monkeypeach=new MonkeyAndPeach();
		System.out.printf("最少有%d個桃子。\n",monkeypeach.peach(1));
		System.out.printf("最少有%d個桃子。\n",monkeypeach.peach(2));
		System.out.printf("最少有%d個桃子。\n",monkeypeach.peach(3));
		System.out.printf("最少有%d個桃子。\n",monkeypeach.peach(4));
		System.out.printf("最少有%d個桃子。\n",monkeypeach.peach(5));
	}

}

package javaimprove042;
/*
 * 【程序42】  
題目：809*??=800*??+9*??+1 
其中??代表的兩位數,8*??的結果爲兩位數，9*??的結果爲3位數。求??代表的兩位數，及809*??後的結果。
 */
public class Equals {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(int x=10;x<100;x++)
		{
			if(8*x>9&&8*x<100)
			{
				if(9*x>99&&9*x<1000)
				{
					System.out.println(809*x);
				}
			}
		}
	}

}

package javaimprove043;
/*
 * 【程序43】 Test5.java 
題目：求0—7所能組成的奇數個數。
 */
public class OddNumber {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int counter=0;
		int num=10;
		for(int i=1;i<8;i++)//最高位不能是零
		{
			for(int j=1;j<8;j+=2)//最低位必須是1、3、5、7這四種，中間的位數不確定。
			{
				for(int k=0;k<num;k++)//一億內
				{
					for(int m=0;m<8;m++)//num位，每一位有8種可能
						counter++;
				}
			}
		}
		System.out.printf("在%d位內的奇數的個數爲：%d",num,counter);
	}

}

package javaimprove048;

import java.util.Scanner;

/*
 * 

【程序48】 TestCode.java 
題目：某個公司採用公用電話傳遞數據，數據是四位的整數，在傳遞過程中是加密的，加密規則如下：每位數字 
都加上5,然後用和除以10的餘數代替該數字，再將第一位和第四位交換，第二位和第三位交換。

 */
public class Encrypt {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("請輸入您要傳輸的四位整數：");
		Scanner in=new Scanner(System.in);
		int number;
		number=in.nextInt();
		
		while(number<1000||number>10000)
		{
			System.out.println("請重新輸入您要傳輸的四位整數：");
			number=in.nextInt();
		}
		int n4=(number/1000+5)/10;
		int n3=(number%1000/100+5)/10;
		int n2=(number%100/10+5)/10;
		int n1=(number%10+5)/10;
		System.out.printf("加密後的數據爲：%d",n1*1000+n3*100+n2*10+n4);

	}

}

package javaimprove049;

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/*
 * 【程序49】 TestString2.java 
題目：計算字符串中子串出現的次數
 */
public class StringComp {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("請輸入字符串：");
		Scanner in=new Scanner(System.in);
		String str=in.nextLine();
		System.out.println("請輸入子串：");
		String str1=in.nextLine();
		int counter=0;
		//使用正則表達式進行處理，這個比在c語言中藥簡便得多。當然，去看看數據結構中的一些比較經典的 算法，比如KMp算法等，，也可以解決。
		Pattern pattern=Pattern.compile(str1, Pattern.CASE_INSENSITIVE);//用於匹配別的字符串的子串
		Matcher match=pattern.matcher(str);//被匹配的字符串
		while(match.find())
		{
			counter++;
		}
		System.out.printf("匹配得到%d個。",counter);
	}

}

package javaimprove050;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class MyObjectOutputStream extends ObjectOutputStream {
	public MyObjectOutputStream() throws IOException {  
	       super(); 
	}
	 public MyObjectOutputStream(OutputStream out) throws IOException {
	  super(out);
	 } 
	 @Override
	protected void writeStreamHeader() throws IOException { 
	   return;
	 }
}

package javaimprove050;

import java.io.BufferedWriter;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStreamWriter;
import java.io.Serializable;
import java.util.Scanner;

/*
 * 
【程序50】TestStu.java 
題目：有五個學生，每個學生有3門課的成績，從鍵盤輸入以上數據（包括學生號，姓名，三門課成績），計算 
出平均成績，將原有的數據和計算出的平均分數存放在磁盤文件"stud"中。
 * 
 * 
 */
public class Students implements Serializable{
	private int number;
	private String name;
	private int course1;
	private int course2;
	private int course3;
	private double average;
	Students()
	{
		this.number=0000;
		this.name="";
		this.course1=0;
		this.course2=0;
		this.course3=0;
		this.average=0;
	}
	Students(int number,String name,int course1,int course2,int course3)
	{
		this.number=number;
		this.name=name;
		this.course1=course1;
		this.course2=course2;
		this.course3=course3;
		this.average=(course1+course2+course3)/3;
	}
	public void setNumber(int number)
	{
		this.number=number;
	}
	public int getNumber()
	{
		return this.number;
	}
	public void setName(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return this.name;
	}
	public void setCourse1(int course1)
	{
		this.course1=course1;
	}
	public int getCourse1()
	{
		return this.course1;
	}
	public void setCourse2(int course2)
	{
		this.course2=course2;
	}
	public int getCourse2()
	{
		return this.course2;
	}
	public void setCourse3(int course3)
	{
		this.course3=course3;
	}
	public int getCourse3()
	{
		return this.course3;
	}
	public void setAverage()
	{
		this.average=(this.course1+this.course2+this.course3)/3;
	}
	public double getAverage()
	{
		return this.average;
	}
	/**
	 * @param args
	 * @throws IOException 
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		// TODO Auto-generated method stub
		File file=new File("D:\\stud.txt");
		ObjectOutputStream ObjectOut=null;
		Students[] students=new Students[5];//這個數組是可以不用的。在這裏是爲了能夠在存入文件前先行檢測輸入是否有誤。
		if(!file.exists())//如果文件不存在，則創建，後面則統一爲追加
		{
			try{				
				file.createNewFile();				
			}catch(IOException e1)
			{
				System.out.println("e1處出錯！");
				e1.printStackTrace();
			}
		}
		try{
			//這個if的意義是：當文件已經有內容了，那麼在再次寫入對象的時候，就不要再寫入頭部。
			//新建的這個myobjectoutputstream的意義就在於此，因此在實現這個抽象類裏面我們要將寫入頭部的方法體覆蓋起來
			if(file.length()<1)
			{
				ObjectOut=new ObjectOutputStream(new FileOutputStream(file,true));
			}else
			{
				ObjectOut=new MyObjectOutputStream(new FileOutputStream(file,true));
			}
		System.out.println("請輸入學生信息： \n學號 姓名 課程1成績 課程2成績 課程3成績");
		Scanner in=new Scanner(System.in);
		for(int i=0;i<5;i++)//控制輸入循環，五個學生。
		{			
			System.out.printf("學生%d:\n",i+1);
			int number=in.nextInt();
			String name=in.next();
			int course1=in.nextInt();
			int course2=in.nextInt();
			int course3=in.nextInt();
			Students student=new Students(number,name,course1,course2,course3);
			students[i]=student;		
		}
		for(int j=0;j<5;j++)//序列化寫入文件
		{
			ObjectOut.writeObject(students[j]);
			ObjectOut.flush();
		}
		}catch(IOException e2)
		{
		}finally
		{
			ObjectOut.close();
		}
		//----------------------------------------------------------------
		//再把它們讀出來，反序列化讀出來，使用ObjectOutputStreamm寫入，則應當用反序列讀出來比較方便。
		FileInputStream in=new FileInputStream(file);
		ObjectInputStream ObjectIn=new ObjectInputStream(in);
		try{
			while(true)
			{
				Students ins=(Students)ObjectIn.readObject();
				System.out.print(ins.number);
				System.out.print(ins.name);
				System.out.print(ins.course1);
				System.out.print(ins.course2);
				System.out.print(ins.course3);
				System.out.println(ins.average);
			}
		}catch(EOFException end)
		{//在這裏文件對象的數量不可知，我們爲了能夠得到文件的末尾，放置一個文件末尾的異常，檢測到異常那麼也就是讀到末尾
			
		}finally
		{
			ObjectIn.close();
		}

	}

}