【答题贴】01期----答题有奖

余勇 · 余勇

/*
*/
package cn.yy.practice;
import java.util.*;
/**
* 既然母牛生小牛,就用Cow类代表牛,提及时间,用年龄age表示,刚出生age=0.
* 还应该提供一个bear()方法,返回一个新的Cow对象,表示生了一头牛.
* 使用List集合来存储所有的牛,每遍历一次,表示过了一年,增加一个变量currentYear表示当前年份
* 遍历过程中,判断每个Cow的age值,如果大于或等于3,生育一头小牛,并将这头小牛也存入集合
* 遍历后增加一个变量currentCount记录当前集合中总共有多少Cow对象
* 最后返回currentCount,表示指定年份n后总共有多少牛.
*/
public class CowProblem {
List<Cow> cows = new ArrayList<Cow>(); //每生一头牛,存入集合
public int count(int year){ //指定年份
int currentYear = 0; //当前年份
cows.add(new Cow()); //加入第一头母牛
int currentCount = cows.size(); //当前集合中元素个数.
while((currentYear++) < year ){
for (int i=0; i<currentCount; i++ )
{
Cow c = cows.get(i); //取出一个Cow对象,并将年龄加1
if(++c.age >= 3) //如果大于或等于3,则产生一个新Cow对象,并存入集合
cows.add(c.bear());
}
currentCount = cows.size(); //每次遍历后记录下当前集合内的元素个数,
//防止下一次遍历过程中,遍历到了新产生的牛
}
return currentCount;
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("input an integer(year) : ");
int year = 0;
int sum = 0;
try{
year = input.nextInt(); //指定年份
if(year >= 0)
sum = new CowProblem().count(year);
System.out.println("cow count = " + sum); //打印结果
}catch(InputMismatchException e){
System.out.println("not an integer, or is out of range");
}
}
}
class Cow { //定义一个Cow类,
int age;
public Cow(){ //初始化age
age = 0;
}
public Cow bear(){ //bear()方法,返回一个新的Cow对象,表示生了一头牛.
return new Cow();
}
}

复制代码

刘林虎 · 刘林虎

package choux;
import java.util.ArrayList;
import java.util.List;
public class Cow {
private int age = 0;
/**
* 是否可以生产小牛
*/
public boolean isCreatSmallCow(){
return (age >= 3)?true:false;
}
/**
* 过年了，年龄又大了一岁
*/
public void addYear(){
age++;
}
public static void main(String[] args) {
List<Cow> cowList = new ArrayList<Cow>();
//第一头小牛
cowList.add(new Cow());
int yearCount = 10;
//就这样一年年过
for(int i=1;i<=yearCount;i++){
int rowNum = cowList.size();
for(int j = 0; j<rowNum; j++){
Cow o = cowList.get(j);
//过年了
o.addYear();
//能生小牛吗？
if(o.isCreatSmallCow()){
cowList.add(new Cow());
}
}
}
System.out.println(yearCount+"年后将有【"+cowList.size()+"】头牛。");
}
}

复制代码

高新星 · 高新星

本帖最后由高新星于 2013-4-11 14:51 编辑

/*
* 需求：一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，
* 又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
*
* 思路：
* 1，定义一个计算牛的数量的功能函数getCattleNum();
* 2，确定函数的结果为牛的数量，所以该函数的返回结果为 int
* 3，确定函数的需要调用者传入的参数为几年，所以该函数的参数类型和个数确定为 int ,且个数为一
* 4，定义变量sum表示牛的数量
* 5，牛的总数等于前一年getCattleNum（year-1）的数量加上新出生的牛的数量
* 6，新出生牛的数量根据题意可以确定为三年前牛的数量gwtCattleNum（year-3），因为每头牛都是在三年后才会产牛
* 7，根据5,6可以确定该函数用的是递归的方法
*/
public class TeatCattle {
//定义变量牛的总数sum
static int sum;
/*
* 定义获取牛的数量的函数
*/
public static int getCattleNum(int year){
for(int x = 1;x <=year;x++){
//判断年数是否大于三，小于三直接返回牛的数量为1
if(year <= 3)
sum=1; //初始化时的牛的数量
else
sum = getCattleNum(year-3) +getCattleNum(year-1);
}
return sum; //返回牛的总数
}
public static void main(String[] args) {
//测试十年后的牛的数量
int year = 10;
int sum = getCattleNum(year);
System.out.println(sum);//数量为：19
}
}

复制代码

刘渝灵 · 刘渝灵

public class Test01
{
static int sum = 0;
public static void main(String[] args)
{
method(10);
System.out.println("总数："+sum);
}
public static void method(int n){
if(n==0)
return;
sum+=n;
method(--n);
}
}

复制代码

HM邱刚权 · HM邱刚权

public class Cow
{
public static int count = 0;
public Cow(int year)
{
count++;
for(int i=3+year;i<=10;i++)
{
new Cow(i);
}
}

public static void main(String[] args)
{
new Cow(0);
System.out.println(count);
}
}
面向对象方法！

刘海东 · 刘海东

表示基础视频只学了一半，
我尽力了。

黄杨 · 黄杨

已做完，不知这样格式对不对，请过目。

王永贺 · 王永贺

本帖最后由王永贺于 2013-4-11 21:18 编辑

此题和兔子的那道题很类似都是用递归的方法解决这道题我刚发贴的时候我就回复过，我当时回复到发帖的里面了随后应该被删除了吧所以我现在重新回复下

public class cow {
static int cow_count = 1;
private static void fn(int year,int age,int n){ //year代表第几年， age代表牛的年龄，能代表最大年限
year++;
age++;
if(year<=n){ //如果没有达到上限年限则执行下面语句
if(age>=3){ //小牛的年龄大于三岁，每年生一头牛
cow_count++; //牛的总数加1
fn(year,0,n); //递归刚出生的小牛年龄设置为0
}
fn(year,age,n);
}
}
public static void main(String[] args) {
new cow().fn(0, 0,10);
System.out.println(cow_count);
}
}

复制代码

孙金鑫 · 孙金鑫

/*
一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，
又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)

year：1 2 3 4 5 6 7 8 9 10
1 1 1 1 1 1 1
1 1 1 1
1

思路：第一头牛三年后，从第四年开始生牛，十年时间一个生了7头；
第二头牛开始从第七年开始生牛，生了4头

......(以此类推)

所以，此方法得用递归！
*/

class Demo2
{
public static void main(String[] args)
{
System.out.println(method(10)+1); //method(10)+1; 加1是指最开始那头牛；
}

public static int method(int year)
{
int num=0; //num，用于存储牛的个数

year=year-3; //一头新牛过三年才开始生牛，每年一头；

num=num+year; //牛的个数加上三年后牛每一年生的牛个数；

if((year-3)>0) //这里是递归结束的条件。
num=num+method(year); //重新调用method()

return num; //返回值，牛的个数
}
}

李游 · 李游

import java.util.ArrayList;
import java.util.List;
/**
* n年的问题，只要将程序中的year改成n年即可
*
* @author LeeYou
*
*/
public class Cow {
private int age = 1; // 初始年龄为1岁
private static List<Cow> cowList = new ArrayList<Cow>();// 定义一个集合容器，用于装牛
/**
* 判断是否可以繁殖小牛
*
* @return
*/
public boolean canBreedCow() {
return (age > 3) ? true : false;
}
/**
* 岁数叫1
*/
public void addYear() {
age++;
}
/**
* 产牛工具函数
*
* @param year
*/
public static void BreedCow() {
cowList.add(new Cow());
}
public static void main(String[] args) {
cowList.add(new Cow());// 初始为1头牛
int year = 10;// 年数10年
// 外层循环控制年数
for (int i = 1; i <= year; i++) {
int cowCount = cowList.size();
// 内层循环获取每头牛的对象，并判断是否可以繁殖小牛
for (int j = 0; j < cowCount; j++) {
Cow cow = cowList.get(j);// 逐个获取每头牛的对象
cow.addYear();// 长大一岁
// 如果年龄大于三岁，则每年可以繁殖一头小牛
if (cow.canBreedCow()) {
BreedCow();
}
}
}
// 输出容器的容量即为牛的总头数
System.out.println(year + "年后总共有【" + cowList.size() + "】头牛");
}
}

复制代码

HelloWorld_2013 · HelloWorld_2013

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

public class Cow {

private int age = 0;

/**
* 是否可以生产小牛
* @return True | False
*/
public boolean isCreatSmallCow(){
return (age >= 3)?true:false;
}

/**
* 过年了，年龄又大了一岁
*/
public void addYear(){
age++;
}

/**
* @param args
*/
public static void main(String[] args) {
List<Cow> cowList = new ArrayList<Cow>();
//第一头小牛
cowList.add(new Cow());
int yearCount = 10;
//就这样一年年过
for(int i=1;i<=yearCount;i++){
int rowNum = cowList.size();
for(int j = 0; j<rowNum; j++){
   Cow o = cowList.get(j);
   //过年了
   o.addYear();
   //能生小牛吗？
   if(o.isCreatSmallCow()){
   cowList.add(new Cow());
   }
}
}
System.out.println(yearCount+"年后将有【"+cowList.size()+"】头牛。");
}
}

------十年有28头

艾萱 · 艾萱

本帖最后由艾萱于 2013-4-12 00:18 编辑

public class CountBulls {
public static void main(String[] args){
System.out.println(coutChildren(10) + 1);//孩子有了，加上孩子妈
}
/**
* 计算经过指定年数后的孩子总数
* @param num 指定年数
*/
public static int coutChildren(int num){
int count = 0;
//每过三年才会有新的小牛第一次生小牛，在计算小牛的孩子后，看看它的孩子有没有生小牛
//函数调用自己无限深入下一代去检查，直到下一代还没有到生小牛的年纪
if(num >= 3)
count = (num + 1 - 3) + coutChildren(num - 3);
return count;
}
}

复制代码

孙百鑫 · 孙百鑫

/*
题目描述：
一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，
又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
*/
/*
思路.
1.定义一个变量来存贮一共牛的数量 num
2.因为牛生牛,每次间隔都会有三年.所以在定义一个变量num1
3.遍历牛.年份减去3就是第一头牛所生的所以小牛.然后小牛生小牛,又是三年后的事.所以用第一批牛的总数减3来当第三批牛的"年"
*/
class Demo
{
public static void main(String[] args)
{
//定义一个cattle函数.往里面扔"年",返回多少牛
int n=cattle(9);
System.out.println(n);//打印牛
}
public static int cattle(int i)
{
/*
定义两个变量,一个为牛的总数.另一个为下批牛的变量
*/
int num1=0;
int num=1;
for(int x=0;x<=i-3;x++)
{
num++;
if(num==i-3)//当牛的总数加到年减三的时候.就赋值给下批牛的变量.
{
num1=num;
num=num+cattle(num1);//使用递归
}
}
return num;
}
}
/*
ps:版主出的题目也太绕人了吧....我足足研究了两个小时....主要是考数学啊!!!!
应该是对的了.....如果哪里不对还请帮忙给我通通哈...谢谢啦.
*/

复制代码

Sword · Sword

1递归(结果为28，如果要算n年后的结果，只需将10改为n)：
public class Cow {
static int count = 1;
private static void feedCow(int year,int age){
year++;
age++;
if(year<=30){
if(age>=3){
count++;
feedCow(year,0);
}
feedCow(year,age);
}
}
public static void main(String[] args) {
new Cow().feedCow(0, 0);
System.out.println(count);
}
}

复制代码

2.面向对象（很经典的思路，结果当然是28，要求n年后，只需将i<10改为i< p>

public class Cow {
public static int count = 0;
public Cow(int year){
count++;
for(int i=3+year;i<=10;i++){
new Cow(i);
}
}
public static void main(String[] args) {
new Cow(0);
System.out.println(count);
}
}

复制代码

30年后居然可以生出58425头牛…

ゞSunペ果果つ · ゞSunペ果果つ

public class Test
{
private static int COUNT=1;
public static void main(String a[]){
calve(10);
outSum();
}
public static void calve(int n){
for(int i=1;i<=n;i++){
if(i>3){
COUNT++;
calve(n-i);
}
}
}
public static void outSum(){
System.out.println("牛的头数为："+COUNT);
}
}

复制代码

因为版主说3年后，我就从第四年开始算的。没有包括第三年。楼主辛苦了

艾萱 · 艾萱

发现不对，换了一种思路，再来一次

public class CountBulls {
public static void main(String[] args){
new CountBulls(0);//调用构造函数传入一个0
System.out.println("10年后一共有： " + count + "头牛");//输出最后牛的总数
}
public static int count = 0;//定义一头牛初始为0，static修饰为了主函数调用方便
public CountBulls(int year){
count++;//累加牛的数量
//每过三年才会有新的小牛第一次生小牛，一共10年
for(int i=3+year;i<=10;i++){
new CountBulls(i);//函数调用自己无限深入下一代去检查，直到下一代还没有到生小牛的年纪
}
}
}

复制代码

wlt · wlt

public class Demo98
{
static int count = 1; // 计数牛的个数
//定义两个变量
private static void feedCow(int year,int age)
{
year++;
age++;
if(year<=10)
{
if(age>=3)
{
count++;
feedCow(year,0);
}
feedCow(year,age);
}
}
public static void main(String[] args)
{
new Demo98().feedCow(0, 0);//调用方法
System.out.println(count);
}

燕国庆 · 燕国庆

本帖最后由燕国庆于 2013-4-13 14:23 编辑

public class CountCow {

      /**
      * @param args
      * 一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，
      * 又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)

      */
      public static void main(String[] args) {

            //自定义几年后
            int years=10;
            //调用求N年后有多少牛的quantity()的方法
            int cattlenum=quantity(years);
            //把N年后牛的总数打印来
            System.out.println(years+"年后牛的总数目为："+cattlenum);


      }
      public static int quantity(int year){
            //定义一个计数器，用来记录牛的总数
            int count=1;
            //根据题意给定循环的条件，进行循环。
            for(int i=4;i<=year;i+=3){
                     //每一次循环条件的满足都是在已有的数量的基础上进行
                     //当前数目的自加。
                     count+=count;

            }
            return count;

      }

}

杜鹏飞 · 杜鹏飞

本帖最后由杜鹏飞于 2013-4-13 18:38 编辑

推导了一个公式,目前尚未发现其他人用此方法.

import java.util.*;
public class first {
private static Scanner in;
public static void main(String[] args){
in = new Scanner(System.in);
int N = in.nextInt();//取年数
int[] f = new int[]{1,1,1,0};
for(int n=4;n<=N+1;n++){
f[3]=f[0]+f[2];
f[0]=f[1];
f[1]=f[2];
f[2]=f[3];
}
System.out.println(f[3]);//输出答案
}
}

复制代码

段旭东 · 段旭东

import java.util.ArrayList;
import java.util.List;
public class Cattle {
//小牛的年龄
int age=0;
//是否能生小牛
public boolean isproduce(){
if(age>=3){
return true;
}else{
return false;
}
}
//生出来的小牛三年后才能再生产，那么age每次加++
public void addYear(){
age++;
}
public static void main(String[] args){
//一共几年
int year=10;
List catList = new ArrayList();
//农夫的第一头母牛
catList.add(new Cattle());
//开始计算
for(int i=1;i<=year;i++){
int calf = catList.size();
for(int j = 0; j<calf; j++){
Cattle cattle = (Cattle) catList.get(j);
//计算年龄 ++一次
cattle.addYear();
//判断一下是否到了三年能下崽了
if(cattle.isproduce()){
catList.add(new Cattle());
}
}
}
System.out.println("农夫"+year+"年后将有"+catList.size()+"头牛。");
}
}

复制代码

帐号		自动登录	找回密码
密码			加入黑马

【答题贴】01期----答题有奖

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

点评

评分

评分

黑马骑士勋章