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

	}

}