【程序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门课的成绩,从键盘输入以上数据(包括学生号,姓名,三门课成绩),计算
题目:海滩上有一堆桃子,五只猴子来分。第一只猴子把这堆桃子凭据分为五份,多了一个,这只猴子把多的一
个扔入海中,拿走了一份。第二只猴子把剩下的桃子又平均分成五份,又多了一个,它同样把多的一个扔入海中
,拿走了一份,第三、第四、第五只猴子都是这样做的,问海滩上原来最少有多少个桃子?
【程序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();
}
}
}