`
啸笑天
  • 浏览: 3465557 次
  • 性别: Icon_minigender_1
  • 来自: China
社区版块
存档分类
最新评论

母牛繁殖问题

招聘面试 
阅读更多

question：农场的母牛寿命是5年，母牛第二年和第四年会繁殖母牛一只，第五年死去。现假设农场第一年有一岁母牛一只，问第五年农场有几只牛。

answer：

用面向对象的角度解下。我这里理解的死去那年没有繁殖能力且对配置文件输入的输入没有验证。

母牛类：

 

 

package com.baixing.shanghai.interview;
/**
 * 母牛
 * @author zyj
 *
 */
public class Cow {

	private int age;// 年龄，从1开始
	private int lifespan;// 寿命
	private String fertilizeAges;// 繁殖年龄点，表示方式：",2,4,"
	private boolean fertilize;// 繁殖能力

	public Cow() {
		super();
	}

	public Cow(int lifespan, String fertilizeAges) {
		super();
		this.age = 1;
		this.lifespan = lifespan;
		this.fertilizeAges = fertilizeAges;
		judgeFertilize(age);
	}

	public Cow(int age, int lifespan, String fertilizeAges) {
		super();
		this.age = age;
		this.lifespan = lifespan;
		this.fertilizeAges = fertilizeAges;
		judgeFertilize(age);
	}

	/**
	 * 年龄加一
	 * 
	 * @return
	 */
	public int moveTONextyear() {
		age++;
		if (age == lifespan) {
			return lifespan;
		}
		judgeFertilize(age);
		return age;
	}

	/**
	 * 设置繁殖能力
	 * 
	 * @param age
	 */
	public void judgeFertilize(int age) {
		String strAge = "," + String.valueOf(age) + ",";
		if (fertilizeAges.indexOf(strAge) == -1) {
			fertilize = false;
		} else {
			fertilize = true;
		}
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
		judgeFertilize(age);
	}

	public String getFertilizeAges() {
		return fertilizeAges;
	}

	public void setFertilizeAges(String fertilizeAges) {
		this.fertilizeAges = fertilizeAges;
	}

	public boolean getFertilize() {
		return fertilize;
	}

	public void setFertilize(boolean fertilize) {
		this.fertilize = fertilize;
	}

	public int getLifespan() {
		return lifespan;
	}

	public void setLifespan(int lifespan) {
		this.lifespan = lifespan;
	}
}
 

 

工厂类：

 

package com.baixing.shanghai.interview;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
 * 母牛繁殖类
 * @author zyj
 *
 */
public class BreedFactury {
	private List<Cow> cows = new ArrayList<Cow>();// 所以母牛
	private BigInteger cowNUM = BigInteger.ZERO; // 母牛数量
	private int years ; // 时间：年限
	private int lifespan; // 寿命
	private String fertilizeAges;// 繁殖年龄点，表示方式：",2,4,"

	
	public BreedFactury() {
		super();
	}

	public BreedFactury(int years, int lifespan, String fertilizeAges) {
		super();
		this.years = years;
		this.lifespan = lifespan;
		this.fertilizeAges = fertilizeAges;
	}

	/**
	 * 规定的年限里繁殖母牛
	 * 
	 * @return
	 */
	public List<Cow> produce() {
		// 初始化第一年一头母牛
		cows.add(new Cow(5, ",2,4,"));
		cowNUM = cowNUM.add(BigInteger.valueOf(1));
		for (int i = 2; i <= years; ++i) {
//			System.out.print("第"+i+"年：");
			doyear(cows); // 今年要做的事情
		}
		return cows;
	}

	/**
	 * 今年要做的事情：年龄加一，删除到寿命的牛，繁殖母牛
	 * 
	 * @param cows
	 * @return
	 */
	public List<Cow> doyear(List<Cow> cows) {
		// 所有母牛年龄加一
		for (Cow cow : cows) {
			cow.moveTONextyear();
		}
		// 删除lifespan岁数的母牛
		Iterator<Cow> iterator = cows.iterator();
		while (iterator.hasNext()) {
			Cow cow = (Cow) iterator.next();
			if (cow.getAge() == 5) {
				iterator.remove();
				cowNUM = cowNUM.subtract(BigInteger.valueOf(1));
			}
			;
		}
		// 母牛繁殖
		int currentAmount = cows.size();
		for (int i = 0; i < currentAmount; ++i) {
			if (cows.get(i).getFertilize()) {// 判断有繁殖能力
				cows.add(new Cow(5, ",2,4,"));
				cowNUM = cowNUM.add(BigInteger.valueOf(1));
			}
		}
//      遍历看下每年怒牛数量和年龄
//      System.out.print("共"+cowNUM.toString()+"只母牛。");		
//		for (Cow cow : cows) {
//			System.out.print(cow.getAge()+",");
//		}
//		System.out.println();
		return cows;

	}

	public List<Cow> getCows() {
		return cows;
	}

	public void setCows(List<Cow> cows) {
		this.cows = cows;
	}

	public BigInteger getCowNUM() {
		return cowNUM;
	}

	public void setCowNUM(BigInteger cowNUM) {
		this.cowNUM = cowNUM;
	}

	public int getYears() {
		return years;
	}

	public void setYears(int years) {
		this.years = years;
	}

	public int getLifespan() {
		return lifespan;
	}

	public void setLifespan(int lifespan) {
		this.lifespan = lifespan;
	}

	public String getFertilizeAges() {
		return fertilizeAges;
	}

	public void setFertilizeAges(String fertilizeAges) {
		this.fertilizeAges = fertilizeAges;
	}

}
 

 

 Junit4类：

 

package com.baixing.shanghai.interview;

import java.io.InputStream;
import java.util.List;
import java.util.Properties;
import org.junit.Test;

public class ClassTest {

	@Test
	public void test() throws Exception {

		InputStream inputStream = ClassTest.class.getResourceAsStream("config.properties");
		Properties properties = new Properties();
		properties.load(inputStream);
		int years = Integer.parseInt(properties.getProperty("years")); // 时间：年限，第几年
		int lifespan = Integer.parseInt(properties.getProperty("lifespan")); // 寿命
		String fertilizeAges = properties.getProperty("fertilizeAges");// 繁殖年龄点，表示方式：",2,4,"

		BreedFactury breedFactury = new BreedFactury(years, lifespan,fertilizeAges);
		List<Cow> cows = breedFactury.produce();
		System.out.println(years+"年母牛总数:" + breedFactury.getCowNUM().toString());
	}

}
 

 

同一包下的config.properties配置文件

 

years=5
lifespan=5
fertilizeAges=,2,4,
 

输出结果：

 

第2年：共2只母牛。2,1,

第3年：共3只母牛。3,2,1,

第4年：共5只母牛。4,3,2,1,1,

第5年：共7只母牛。4,3,2,2,1,1,1,

5年母牛总数:7

 

 


 

 

 

 

 

 

 

 

 

分享到：
| 赏析2011年赶集网、58同城、百姓网分类信息 ...
评论
4 楼 啸笑天 2011-12-30  
sinly 写道

我考虑的是5年必死，生下算0岁：
随便写了个
package com.cow;

import java.util.ArrayList;
import java.util.List;

public class Cow {
	private int age;
	private boolean isDead;
	private List<Cow> children;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public boolean isDead() {
		return isDead;
	}
	public void setDead(boolean isDead) {
		this.isDead = isDead;
	}
	public List<Cow> getChildren() {
		return children;
	}
	public void setChildren(List<Cow> children) {
		this.children = children;
	}
	
	
	@Override
	public String toString() {
		return "Cow [age=" + age + ", isDead="
				+ isDead + "]";
	}
	public static void main(String[] args) {
		Cow cow = new Cow();
		cow.setAge(1);
		cow.setChildren(null);
		cow.setDead(false);
		List<Cow> cows = new ArrayList<Cow> ();
		cows.add(cow);
		CountCow cc = new CountCow();
		cc.afterManyYeas(10, cows);
		int count = cc.count(cows);
		System.out.println(count);
		cc.print(cows);
	}
	
}


class CountCow{
	public int count(List<Cow> cows) {
		int count = 0;
		if(cows != null && cows.size() > 0){
		 count = cows.size();
		for (Cow cow :cows) {
			if(cow.isDead()){
				count --;
			}
			if (cow.getChildren() != null && cow.getChildren().size() > 0){
				count += count(cow.getChildren());
			}
		}
		}
		return count;
	}

	public List<Cow> addYear(List<Cow> cows) {
		List<Cow> result = cows;
		for (Cow cow : result) {
			int age = cow.getAge();
			if (cow.isDead()) {
			} else if (age + 1 == 5) {
				cow.setAge(age + 1);
				cow.setDead(true);
			} else {
				cow.setAge(age + 1);
			}
			age = cow.getAge();
			// 如果年龄是2或者4,繁衍一头母牛
			if (age == 2 || age == 4) {
				Cow children = new Cow();
				children.setAge(0);
				children.setDead(false);
				if (cow.getChildren() != null && cow.getChildren().size() > 0) {
					addYear(cow.getChildren());
					
				} else if (cow.getChildren() == null) { 
					cow.setChildren(new ArrayList<Cow>());
				}
				// 添加为其后代
				cow.getChildren().add(children);
			} else {
				if (cow.getChildren() != null && cow.getChildren().size() > 0) {
					addYear(cow.getChildren());
				}
			}
			
		}
		return result;
	}

	public List<Cow> afterManyYeas(int year,List<Cow> cows) {
		for (int i =0 ; i < year; i++) {
			addYear(cows);
		}
		return cows;
	}
	public void print(List<Cow> cows) {
		for (Cow cow:cows) {
			System.out.println(cow);
			if (cow.getChildren() != null && cow.getChildren().size() > 0) {
				print(cow.getChildren());
			}
		}
	}
}

学习了。
public Cow(int lifespan, String fertilizeAges) {
super();
this.age = 0;
this.lifespan = lifespan;
this.fertilizeAges = fertilizeAges;
judgeFertilize(age);
}
public List<Cow> produce() {
// 初始化第一年一头母牛
    Cow cow=new Cow(5, ",2,4,");
cow.setAge(1);
cows.add(cow);
cowNUM = cowNUM.add(BigInteger.valueOf(1));
for (int i = 2; i <= years; ++i) {
System.out.print("第"+i+"年：");
doyear(cows); // 今年要做的事情
}
return cows;
}
这样一改就等效于你的，不过我是第x年，你是过了x-1年。
而且你的效率也提高了
3 楼 sinly 2011-12-30  

我考虑的是5年必死，生下算0岁：
随便写了个
package com.cow;

import java.util.ArrayList;
import java.util.List;

public class Cow {
	private int age;
	private boolean isDead;
	private List<Cow> children;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public boolean isDead() {
		return isDead;
	}
	public void setDead(boolean isDead) {
		this.isDead = isDead;
	}
	public List<Cow> getChildren() {
		return children;
	}
	public void setChildren(List<Cow> children) {
		this.children = children;
	}
	
	
	@Override
	public String toString() {
		return "Cow [age=" + age + ", isDead="
				+ isDead + "]";
	}
	public static void main(String[] args) {
		Cow cow = new Cow();
		cow.setAge(1);
		cow.setChildren(null);
		cow.setDead(false);
		List<Cow> cows = new ArrayList<Cow> ();
		cows.add(cow);
		CountCow cc = new CountCow();
		cc.afterManyYeas(10, cows);
		int count = cc.count(cows);
		System.out.println(count);
		cc.print(cows);
	}
	
}


class CountCow{
	public int count(List<Cow> cows) {
		int count = 0;
		if(cows != null && cows.size() > 0){
		 count = cows.size();
		for (Cow cow :cows) {
			if(cow.isDead()){
				count --;
			}
			if (cow.getChildren() != null && cow.getChildren().size() > 0){
				count += count(cow.getChildren());
			}
		}
		}
		return count;
	}

	public List<Cow> addYear(List<Cow> cows) {
		List<Cow> result = cows;
		for (Cow cow : result) {
			int age = cow.getAge();
			if (cow.isDead()) {
			} else if (age + 1 == 5) {
				cow.setAge(age + 1);
				cow.setDead(true);
			} else {
				cow.setAge(age + 1);
			}
			age = cow.getAge();
			// 如果年龄是2或者4,繁衍一头母牛
			if (age == 2 || age == 4) {
				Cow children = new Cow();
				children.setAge(0);
				children.setDead(false);
				if (cow.getChildren() != null && cow.getChildren().size() > 0) {
					addYear(cow.getChildren());
					
				} else if (cow.getChildren() == null) { 
					cow.setChildren(new ArrayList<Cow>());
				}
				// 添加为其后代
				cow.getChildren().add(children);
			} else {
				if (cow.getChildren() != null && cow.getChildren().size() > 0) {
					addYear(cow.getChildren());
				}
			}
			
		}
		return result;
	}

	public List<Cow> afterManyYeas(int year,List<Cow> cows) {
		for (int i =0 ; i < year; i++) {
			addYear(cows);
		}
		return cows;
	}
	public void print(List<Cow> cows) {
		for (Cow cow:cows) {
			System.out.println(cow);
			if (cow.getChildren() != null && cow.getChildren().size() > 0) {
				print(cow.getChildren());
			}
		}
	}
}
2 楼 啸笑天 2011-12-30  
sinly 写道
请问母牛生下来就算一岁么?

我是这么考虑的
1 楼 sinly 2011-12-30  
请问母牛生下来就算一岁么?
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    母牛问题关于C++

    关于母牛生小牛的客观问题，需要C++的一定素养，但是不得因为邮件而阅览

    C语言关于母牛问题的计算代码

    【问题描述】 x年出生的母牛从第x+m年开始到第x+n年止(含, 1 )每年生小母牛一头，并在第x+p(n )年被淘汰。设第0年有刚出生的小母牛一头，求第k(k &gt; 0)年存栏母牛多少头。 【输入形式】 从标准输入上顺序...

    c++:母牛生小母牛问题 （类方法）

    这个问题可以通过编程来解决，特别地，本例采用了 C++ 的面向对象编程方式，定义了一个 `cow` 类来模拟母牛的成长和繁殖过程。 #### 二、代码结构分析 整个程序由三个主要部分组成：`cow.h` 头文件、`cow.cpp` ...

    c++:母牛生小母牛问题（递归）

    本题通过一个简单的递归算法解决了母牛繁殖的问题。递归方法不仅简洁而且易于理解，但需要注意的是，对于较大的 `n` 值，这种方法可能会导致大量的重复计算，从而影响效率。在实际应用中，可以考虑使用动态规划等...

    c++中有关母牛问题的程序代码

    问题描述： 假设单性繁殖成立，一头母牛从出生第四年起每年生一头母牛，生出的小母牛在四岁时也将具有生殖能力。以此类推，第n年时有多少头母牛？

    算法设计与优化第六章递归法经典例题（如最大值，母牛繁殖，x的n次幂等共5个）

    本主题涵盖了5个使用C语言编写的递归法经典例题，包括找到数组中的最大值、模拟母牛繁殖、计算x的n次幂、求一个整数各数字的和以及输出整数的各位数字。下面将详细解释这些知识点： 1. **最大值**：在"最大值.c...

    母牛生小牛的C语言算法

    roblem 2 母牛生小牛问题 设有一头小母牛，从出生第四年起每年生一头小母牛，按此规律，第N年时有几头母牛？ Input 本题有多组数据。每组数据只有一个整数N，独占一行。(1≤N≤50) Output 对每组数据，输出一个...

    c++经典程序题库

    小母牛繁殖问题** - **题目描述**: 若一头小母牛从第四年开始每年生一头母牛，求第 n 年时有多少头母牛。 - **知识点**: - 递推算法的应用。 - 数学逻辑的实现。 **23. 正整数平均值计算** - **题目描述**: ...

    母牛难产预防和救助原则.doc

    在养牛业中，母牛难产是一个不容忽视的问题，它关系到母牛的健康与生存，同时对养牛业的经济效益也造成重大影响。尤其是在农户和小规模养牛场中，由于管理经验和专业技能的局限，难产问题更显突出。因此，建立一套...

    农场与母牛

    在“农场与母牛”的场景中，源码可能涉及到如何用编程语言（如Java、Python、C++等）表示农场和母牛的类结构，以及它们的行为（如喂养、繁殖、产奶等）。学习源码可以理解程序的设计思路，分析算法，以及优化代码。 ...

    C语言母球生小牛

    从给定的文件信息来看，这是一段C语言代码，旨在解决一个经典的数学问题：母牛繁殖模型。这个问题类似于斐波那契数列，但有其特定的规则和背景。让我们详细解析这段代码以及它背后的数学逻辑。 ### 母牛繁殖模型 ...

    php经典趣味算法实例代码

    2. **母牛繁殖问题**：这是一个涉及递归和动态规划的问题。描述了一头母牛从4岁开始每年能生一头小牛，直到15岁绝育，20岁死亡。函数`niu`利用静态变量来记录当前的牛群总数，并递归地计算n年后的母牛数量。这里的...

    肉牛繁殖的新技术.doc

    首先，理解肉牛母牛的发情周期是进行有效繁殖管理的基础。健康的肉牛母牛在性成熟之后，其发情周期一般为21天左右，周期内的生理变化可以细分为四个阶段：发情前期、发情旺期、发情后期和体情期。发情前期通常表现为...

    家畜繁殖学母畜的发情PPT课件.pptx

    持久黄体是异常情况，黄体未能按预期萎缩，可能导致繁殖问题。 总之，理解母畜的发情周期对于提高家畜繁殖效率、安排合适的配种时间以及解决繁殖障碍具有重要意义。通过科学的饲养管理和对周期的准确判断，可以有效...

    算法-母牛的故事（HDU-2018）（包含源程序）.rar

    母牛的故事可能是一个关于计算或优化问题的隐喻，例如，可能要求参赛者解决一个与牧场上的母牛相关的数学问题，比如如何安排饲料分配、繁殖计划，或者找出最高效的放牧路径等。这类问题往往需要参赛者通过编写程序来...

Magicbox
Global site tag (gtag.js) - Google Analytics