黑马程序员技术交流社区

标题: 【答题贴】01期----答题有奖 [打印本页]
作者: 田磊阳    时间: 2013-4-9 23:41
标题: 【答题贴】01期----答题有奖
本帖最后由 田磊阳 于 2013-4-14 21:36 编辑

[fly]此贴为答题贴，原题地址如下[/fly]



【让技术飞】01期----答题有奖
http://bbs.itheima.com/thread-44933-1-1.html
作者: luguoyuanf    时间: 2013-4-9 23:50
沙发沙发,顶起!
作者: 丘凤光    时间: 2013-4-10 00:05
本帖最后由 丘凤光 于 2013-4-10 00:20 编辑

答案要写在这啊，嘿嘿，练过类似的题，有优势{:soso_e144:}
  1. /*
  2. 需求：一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?

  4. 思路：

  6. */
  7. public class Cow
  8. {
  9.         public static void main(String[] args)
  10.         {
  11.                 sop("第1年牛的头数:1");
  12.                 sop("第2年牛的头数:1");
  13.                 sop("第10年牛的头数:"+cowToCow(10));
  14.                
  15.         }

  17.         //n年后牛的头数
  18.         public static int cowToCow(int year)
  19.         {
  20.                 int f1 = 1;        //第一年牛的头数
  21.                 int f2 = 1;        //第二年牛的头数
  22.                 int f; //随时间变化的牛的头数
  23.                 for(int i=3; i<=year; i++)
  24.                 {
  25.                         //三年之后每年的牛都是去年和前年的牛的和
  26.                         f = f2;
  27.                         f2 = f1 + f2;
  28.                         f1 = f;
  29.                 }
  30.                 return f2;
  31.         }

  33.         //打印
  34.         public static void sop(Object obj)
  35.         {
  36.                 System.out.println(obj);
  37.         }
  38. }
复制代码
作者: zjm10zj    时间: 2013-4-10 00:17
本帖最后由 zjm10zj 于 2013-4-10 00:42 编辑

package demo1;

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-10 00:24
头疼..不知道对不对..试试吧..
  1. public static void main(String[] args)
  2.         {
  3.                 int num=bullCount(10);
  4.                 System.out.println(num);
  5.         }
  6.         public static int bullCount(int year)
  7.         {
  8.                 int bull=1;//初始一头牛
  9.                 for (int x=year-3;x>=0;x--)//这头牛三年后增加一头,之后每年增一头
  10.                 {
  11.                         bull+=bullCount(x);//递归调用
  12.                 }
  13.                 return bull;
  14.         }
复制代码
作者: shenshuangxi    时间: 2013-4-10 00:25
package cn.mathMethod;
/*
* 牛的规律为数列1,1,2,3,5,8,13,21....  
*
*/
public class fabonach {
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                int n = 8;
                int sum = add(n);
                System.out.println(sum);
        }
        private static int add(int n) {
                if(n<=0) return 0;
               
                //小于三年就只有一头牛
                if(n<3 & 0<n)
                        return 1;
               
                int sums = 0;
                //新增的牛为以前的牛每个月所产牛
                sums+= add(n-1)+add(n-2);
                return sums;
        }
       
       

}
作者: lyg2013    时间: 2013-4-10 00:26
本帖最后由 lyg2013 于 2013-4-10 00:28 编辑
  1. package test;
  2. public class cow {
  3.         public static void main(String[] args) {
  4.                 new cow(0);
  5.                 System.out.println("农夫10年后有"+count+"头牛");
  6.         }
  7.   public static int count = 0;
  8.   public cow( int year){
  9.      count++;
  10.         for(int i=3+year;i<=10;i++){ //由于3岁以上的牛才可以产子，所以i的初始值是3+year
  11.            new cow(i);
  12.         }
  13.          
  14.         }

  16. }
复制代码
n年后把i<=10,改成i<=n.农夫养的第一头牛是在构造方法中的count++语句产生的,每次循环都用到一个递归调用。
作者: shenshuangxi    时间: 2013-4-10 00:27
这是我以前写的关于兔子的同类题
作者: shenshuangxi    时间: 2013-4-10 00:27
shenshuangxi 发表于 2013-4-10 00:25
package cn.mathMethod;
/*
* 牛的规律为数列1,1,2,3,5,8,13,21....  

这是我以前写的关于兔子的同类题
作者: 柳 德 彬    时间: 2013-4-10 00:28
  1. import java.util.ArrayList;
  2. import java.util.List;

  4. /**
  5. * 一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后， 又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?
  6. */
  7. public class CreatCow {
  8.         private int age;// 年数
  9.         // 生成小牛
  10.         public boolean isCreatCow() {
  11.                 return (age >= 3) ? true : false;
  12.         }
  13.         // age加1
  14.         public void addYear() {
  15.                 age++;
  16.         }
  17.         public static void main(String[] args) {
  18.                 List<CreatCow> cowList = new ArrayList<CreatCow>();
  19.                 // first cow
  20.                 cowList.add(new CreatCow());
  21.                 int year = 10;// year = n;
  22.                 for (int i = 0; i < year; i++) {
  23.                         for (int j = 0; j < cowList.size(); j++) {
  24.                                 CreatCow cc = cowList.get(j);
  25.                                 cc.addYear();
  26.                                 // 3 年到了,是否可以生成小牛
  27.                                 if (cc.isCreatCow()) {
  28.                                         cowList.add(new CreatCow());
  29.                                 }
  30.                         }
  31.                 }
  32.                 System.out.println(year + "年之后将有" + cowList.size() + "头牛");// 10 年之后28头
  33.         }
  34. }
复制代码
作者: 余善航    时间: 2013-4-10 00:32
顶顶顶顶顶
作者: 葛迅    时间: 2013-4-10 00:33
本帖最后由 葛迅 于 2013-4-10 00:44 编辑
  1.        
  2. public class Cow
  3. {
  4.         static int count = 1;
  5.         private static void feedCow(int year,int age)
  6.         {
  7.                 year++;
  8.                 age++;
  9.                 if(year<=10)
  10.                 {
  11.                         if(age>=3)
  12.                         {
  13.                                 count++;
  14.                                 feedCow(year,0);
  15.                         }
  16.                         feedCow(year,age);
  17.                 }
  18.         }

  20.         public static void main(String[] args)
  21.         {
  22.                 new ClassFive().feedCow(0, 0);
  23.                 System.out.println(count);
  24.         }
  25. }
  26.        
复制代码
n年后，将year<= 10 改成 year <= n.即可。
作者: HM许涛    时间: 2013-4-10 00:36
本帖最后由 HM许涛 于 2013-4-10 00:37 编辑

/*题目：一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……
问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
解题理论依据：X(n)=X(n-1)+X(n-2),从第三项开始，后一项为前两项的数值和。斐波那契数列公式(括号内为年数，n>=3)*/
public class  Sum
{
        public static void main(String[] args)
        {
                System.out.println("第1年牛的数量：1");//第一年数量不变。
                System.out.println("第2年牛的数量：1");//第二年数量不变。
                int x1=1,x2=1,x,n=10;//给n赋值10，求第十年牛的数量。
                for(int y=3;y<=n;y++)//循环累加求出n年时牛的数量。从数量变化的年份开始。
                {
                        x=x2;
                        x2=x1+x2;//累加循环体，相加后赋值的x2为所求的值。
                        x1=x;
                        System.out.println("第"+y+"年牛的数量"+x2);
                }
        }
}
作者: 王海龙2013    时间: 2013-4-10 00:45
本帖最后由 王海龙2013 于 2013-4-10 00:49 编辑

Demo.zip (839 Bytes, 下载次数: 3)
作者: 鲜磊    时间: 2013-4-10 01:01
import java.util.Scanner;

public class Cattle {

        public static void main(String[] args) {
                // TODO Auto-generated method stub
        int n = new Scanner(System.in).nextInt(); //输入要计算多少年后牛的个数；
        if(n<0)
                System.out.print("输入不正确，请重新输入！");
        else if(n<3)
                System.out.print(n+"年后牛的数量："+1);
        else
            System.out.print(n+"年后牛的数量："+(2<<(n/3-1)));//输出n年后牛的个数；
        }

}
作者: 何红卫    时间: 2013-4-10 01:04
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;

  6. namespace 神牛
  7. {
  8.     class Program
  9.     {
  10.         //用来统计过year年后，牛的数量
  11.         public static int CowNmuber(int year)
  12.         {
  13.             int sum = 0;           
  14.             //1到6年时，牛的数目统计比较简单，则简单处理
  15.             if (year < 7)
  16.             {
  17.                 switch (year)
  18.                 {
  19.                     case 0:
  20.                     case 1:
  21.                     case 2:
  22.                     case 3:
  23.                         sum = 1;
  24.                         break;
  25.                     case 4:
  26.                         sum = 2;
  27.                         break;
  28.                     case 5:
  29.                         sum = 3;
  30.                         break;
  31.                     case 6:
  32.                         sum = 4;
  33.                         break;
  34.                     default:
  35.                         break;
  36.                 }
  37.             }
  38.             else
  39.             {
  40.                 //第7年开始，牛的数目呈现有规律的增长，则使用循环累加
  41.                 //具体规律为第7增加1头，第8年增加两头，第9年增加3头，如此类推……
  42.                 sum = 4;//第6年的时候已经有4头牛了
  43.                 for (int i = 7; i <= year; i++)
  44.                 {
  45.                     sum = sum + (i - 6);
  46.                 }
  47.             }                     
  48.             return sum;
  49.         }
  50.         static void Main(string[] args)
  51.         {
  52.             int n;
  53.             Console.Write("输入n：");
  54.             n =int.Parse(Console.ReadLine());
  55.             Console.WriteLine("{0}年后，农夫家有{1}头牛", n, CowNmuber(n));
  56.             Console.ReadKey();
  57.         }
  58.     }
  59. }
复制代码
作者: Lobster    时间: 2013-4-10 01:05
{:soso_e199:}

New2.zip

469 Bytes, 下载次数: 186
作者: 鲜磊    时间: 2013-4-10 01:12
import java.util.Scanner;

public class Cattle {

        public static void main(String[] args) {
                // TODO Auto-generated method stub
        int n = new Scanner(System.in).nextInt(); //输入要计算多少年后牛的个数；
        if(n<0)
                System.out.print("输入不正确，请重新输入！");
        //else if(n<3)
                //System.out.print(n+"年后牛的数量："+1);//
        else
            System.out.print(n+"年后牛的数量："+(1<<(n/3)));//输出n年后牛的个数；
        }

}
作者: Asan    时间: 2013-4-10 01:15
  1. package cn.learn.test;

  3. public class Test {

  5.         public static int count = 0;  // 初始化牛开始为0头
  6.         public static int n = 10;     // 初始化一共多少年，可以写的深一点可以写成用户输入年数

  8.         // 构造方法
  9.         public Test(int year) {
  10.                 // 每调用一次构造方法，牛的数量 +1;
  11.                 count++;
  12.                 // 每四年调用一次Test()方法
  13.                 for (int i = 3 + year; i <= n; i++) {
  14.                         new Test(i);
  15.                 }
  16.         }

  18.         public static void main(String[] args) {
  19.                 // 调用构造方法并初始化从0开始
  20.                 new Test(0);
  21.                 // 打印 n+" 年之后一共有  "+count+" 头牛"
  22.                 System.out.println(n + " 年之后一共有  " + count + " 头牛");
  23.         }
  24. }
复制代码
作者: 杨成    时间: 2013-4-10 01:35
  1. import java.util.Scanner;//引入扫描类
  2. class  Cow
  3. {
  4.         public static int count=0;//全局共享计数变量

  6.         public Cow(int year,int m)//year:当前年数 m:要计算的截止年数
  7.         {
  8.                 count++;//+1头
  9.                
  10.                 for(int i=3+year;i<=m;i++)
  11.                 {
  12.                         new Cow(i,m);//递归创建牛对象
  13.                 }
  14.         }
  15.         public static void main(String[] args)
  16.         {
  17.                 System.out.println("一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，"+
  18.                         "生出来的牛三年后，又可以每年生出一头牛……"+"\n要计算n年后有多少头，");

  20.                 int temp=0;

  22.                 while(temp>=0)//循环输入，当输入-1时跳出输入循环
  23.                 {
  24.                         System.out.println("请输入数字按（enter结束输入），当输入-1的时候退出程序：");

  26.                         temp=new Scanner(System.in).nextInt();/*用输入对象System.in初始化创建扫描类对象，并调用
  27.                                                                                                         该对象读取方法读取扫描流的一个数据存入截止年份变量temp中
  28.                                                                                                         */

  30.                         if(temp==-1)//当输入-1的时候跳出输入循环的判断
  31.                                 break;

  33.                         new Cow(0,temp);//创建一头牛对象，初始年份为0，计算截止年份为temp
  34.                         System.out.println(temp+"年后共有"+count+"头牛");

  36.                         count=0;//计数清0
  37.                 }
  38.                 System.out.println("谢谢使用，再见！");
  39.         }
  40. }
复制代码

QQ截图20130410013524.png (8.91 KB, 下载次数: 48)

QQ截图20130410013524.png
作者: 余善航    时间: 2013-4-10 01:50
public class Test_niu {

        /**
         * @param args
         */
       
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                aaa(10);
        }
        public static void aaa(int n)
        {
                int[] Count={1,0,0};  //Count[0] 1年的牛    Count[1] 2年的牛    Count[2] 3年的牛
                int temp=0;
                for(int i=1;i<=n;i++)//因为该代码中没有0年的牛，所以从1年开始值
                {
                        temp=Count[2];   //该年中新出生的牛
                        Count[2]=Count[2]+Count[1];   //该年中成为3年的牛
                        Count[1]=Count[0];  //该年中成为2年的牛
                        Count[0]=temp;   //该年中成为1年的牛
                        System.out.println("第"+i+"年"+(Count[0]+Count[1]+Count[2])+"头牛");
                }
        }
}
       
作者: 曹宇    时间: 2013-4-10 01:56
  1. /*
  2. 一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
  3. */

  5. import java.util.*;
  6. class Run
  7. {
  8.        
  9.         public static int year=0;                                        //定义静态数据,年,被所有人共享.            
  10.         public static void main(String[] args)
  11.         {
  12.                 final int N=10;                         // 设定N年后计算牛数量.
  13.                
  14.                 ArrayList<Niu> al = new ArrayList<Niu>();//用ArrayList容器存放出生的牛,泛型数据为Niu类.
  15.                 al.add(new Niu(year,al));                                //第一头牛存入ArrayList.
  16.                 for(;year<=N;)                                                        //创建循环.
  17.                 {                                                                                               
  18.                         int x;                                                                //创建一个计数器.
  19.                         for(x=0;x<al.size();x++)                //遍历容器.
  20.                         {
  21.                                 Niu niu = al.get(x);                //创建一个牛类引用接受遍历对象.
  22.                                 niu.shengNiu();                                        //遍历调用牛类中 生牛方法.
  23.                         }
  24.                         year++;                                                                //本年结束,下一年开始.

  26.                         /*先计算当前年下,遍历所有牛,有资格生牛的(年龄大于等于3岁),就会生牛,全部遍历完
  27.                         成后再开始新一年.
  28.                         */
  29.                 }

  31.                 System.out.println(N+"年后有牛"+al.size()+"只");


  34.         }

  36.        
  37. }


  40. class Niu
  41. {
  42.         private int age;                //新生小牛年龄.
  43.         private int date;                //新生小牛出生的年.
  44.         private ArrayList al;        //创建ArrayList 类型引用型变量.
  45.         Niu(int year,ArrayList al)//构造函数.
  46.         {
  47.                 date=year;                        //当前年赋给出生年.
  48.                 this.al=al;                       
  49.         }
  50.        
  51.         public void shengNiu()        //生娃方法.
  52.         {
  53.                 age=Run.year-date;  //计算牛的年龄.当前年减去出生年.
  54.                 if (age>=3)
  55.                 {
  56.                        
  57.                         al.add(new Niu(Run.year,al));
  58.                         /*
  59.                         哈哈3岁了可以生娃了.创建一个新的Niu类对象生娃存入容器中.
  60.                         */
  61.                 }
  62.         }

  64. }
复制代码
作者: 黄小贝    时间: 2013-4-10 02:21
斑竹威武，这个处理的办法的确很强大，防止了灌水以及抄袭的现象，而且为了不让大家能在网上找到答案，还修改了题目，虽然改的有点吊炸天，一头牛三年后怎么生的，他自交了？
  1. import java.util.ArrayList;
  2. import java.util.List;


  5. public class Cattle {

  7. private int age = 0;

  9. /**
  10. * 一年之后发生的事情,首先牛的age肯定是要加 1 ，如果牛满 3岁，需要往牛棚里面再加一头新牛
  11. * @param cattles 牛棚，存放所有牛的List
  12. * @return 变化后的牛棚
  13. */
  14. public List<Cattle> oneYearLater(List<Cattle> cattles){

  16. this.age++;

  18. if(age >= 3){
  19. cattles.add(new Cattle());
  20. }

  22. return cattles;
  23. }

  25. public static void main(String[] args) {


  28. List<Cattle> cattles = new ArrayList<Cattle>();//牛棚在此
  29. cattles.add(new Cattle());// 最开始牛棚里面的一头寂寞的牛，由于某种莫名的原因，三年后他靠自己生崽了！自交？

  31. for (int i = 0; i < 10; i++) {//前10年

  33. for (int j = 0; j < cattles.size(); j++) {
  34. cattles = cattles.get(j).oneYearLater(cattles);
  35. }

  37. System.out.println("第一年牛棚里面有 " + cattles.size() + " 头牛");
  38. }


  41. }
  42. }
复制代码


作者: 续圆凯    时间: 2013-4-10 02:24
  1. import java.util.*;
  2. public class Cow
  3. {
  4.         private int age;  //定义牛的年龄
  5.         public Cow()
  6.         {
  7.                 age = 0;        //初始化的时候，牛为0岁
  8.         }
  9.         public Cow birth()
  10.         {
  11.                 age ++;
  12.                 return age > 3 ? new Cow():null;//判断：牛的年龄是否>3，如果>3则具备生牛的条件，不具备则不生牛。
  13.         }

  15.         public static void main(String[] args)
  16.         {
  17.                 ArrayList<Cow> list = new ArrayList<Cow>();//创建一个数组，将该数组视为牛圈。
  18.                 list.add(new Cow());//往牛圈中放入一头牛
  19.                 for(int i = 0; i <= 10;i++)//i为年份 初始i=0为第一年，i=1的时候为1年后。
  20.                         {
  21.                         for(int j =0;j<list.size();j++)//j为每年圈中牛的数量
  22.                                 {
  23.                                         Cow cow = list.get(j).birth();
  24.                                         if(cow != null)
  25.                                         list.add(cow);
  26.                                 }
  27.                         }
  28.                 System.out.println("10年后，共有：" + list.size()+"头牛。");
  29.         }
  30. }
复制代码
打印结果：10年后，共有28头牛。

如果求n年  把for(int i = 0; i <= 10;i++)中的10改成n即可。
作者: 李罡    时间: 2013-4-10 03:00
本帖最后由 李罡 于 2013-4-10 03:22 编辑

第一种方法为：
  1. package cn.itcast.testcow;

  3. /*
  4. * 看到这个题时，第一反应就是用数学来做。
  5. * 第1到10年的牛的数量分别为：1，1，2，3，4，6，9，13，19.。。
  6. * 归纳可以看出，从第4年开始，每年的牛的数量等于上一年的牛的数量加上前3年的牛的数量，即：3=2+1，4=3+1，6=4+2...
  7. * 即cowArr[i]=cowArr[i-1]+cowArr[i-3](i>=3)
  8. * */
  9. class Cow{   

  11.         public static void main(String[] args)  
  12.         {      
  13.                 long startTime = System.currentTimeMillis();
  14.                 //定义一个年数，要得到n年后，则把year设为n即可
  15.                 int year = 10;
  16.                 //定义一个数组来存放不同年牛的数量
  17.                 int[] cowArr = new int[year];
  18.                 //设置前3年的牛的数量,因为i>=3.
  19.                 cowArr[0]=cowArr[1]=1;
  20.                 cowArr[2]=2;
  21.                 for(int i=3;i<year ;i++){
  22.                         //每年的牛的数量等于上一年的牛的数量加上前3年的牛的数量
  23.                         cowArr[i] = cowArr[i-1]+cowArr[i-3];
  24.                 }
  25.                 long endTime = System.currentTimeMillis();
  26.                 //可以取到第1年到第n年任意年的牛的数量，cowArr[x],x<year-1
  27.                 System.out.println(year+"年后将会有"+cowArr[year-1]+"头牛");
  28.                 System.out.println("数组方式耗时"+(endTime - startTime)+"毫秒");

  30.         }
  31. }
  32. /*
  33. 输出为：
  34. 10年后将会有28头牛
  35. 数组方式耗时0毫秒
  36. */
复制代码
第二种方法为：
  1. <p>package cn.itcast.testcow;</p><p>import java.util.ArrayList;
  2. import java.util.List;
  3. /*
  4. * 用面向对象
  5. * */
  6. public class Cow1 {
  7. //牛刚生下来年龄为0~~
  8. private int age=0;
  9. //生个宝宝
  10. public Cow1 creatCow(){
  11.   //一年加一岁
  12.   age++;
  13.   //到3岁了，可以生了
  14.   return (age>=3)?new Cow1():null;
  15. }
  16. public static void main(String[] args) {
  17.   // TODO Auto-generated method stub
  18.   long startTime = System.currentTimeMillis();
  19.   //若为n年后则设置为n
  20.   int year = 10;
  21.   //定义一个集合来存放牛，因为长度是可变的。
  22.   List<Cow1> cowList = new ArrayList<Cow1>();
  23.   //刚开始有一头牛
  24.   cowList.add(new Cow1());
  25.   //每年判断一次
  26.   for(int i = 1 ;i<=year ;i++){
  27.    int number = cowList.size();
  28.    if(number!=0){
  29.    //把每头牛都取出来看看，若它到3岁了则往集合里增加一头牛
  30.    for(int j = 0; j<number ;j++){
  31.     Cow1 cow = cowList.get(j);
  32.     if(cow.creatCow()!=null)
  33.      //增加一头牛
  34.      cowList.add(new Cow1());
  35.    }
  36.    }
  37.   }
  38.   long endTime = System.currentTimeMillis();
  39.   System.out.println(year+"年将会有"+cowList.size()+"头牛");
  40.   System.out.println("集合方式耗时"+(endTime - startTime)+"毫秒");
  41. }</p><p>}
  42. /*
  43. 输出为：
  44. 10年将会有28头牛
  45. 集合方式耗时0毫秒
  46. */</p>
复制代码
算一算运行时间
设置year为40.
第一种方法：

第二种方法：

所以用数组效率更高！
当把year设置为50时，用第一种方法计算出的将会有122106097头牛，消耗的时间仍然为0.
而用第二种方式时，会出现异常：java.lang.OutOfMemoryError: Java heap space
这是因为对象太多了集合里装不了，会报出堆内存溢出异常！
而用数组则只是产生一个长度为50的数组并为里面的元素赋值，所以毫无压力！
当year为100时：100年后将会有24382819596721629头牛
数组方式耗时0毫秒（要把数组类型改为long）
所以用第一种方式更优。

QQ截图20130410025342.png (1.65 KB, 下载次数: 33)

第一种方式

第一种方式

QQ截图20130410025446.png (2.85 KB, 下载次数: 41)

第二种方式

第二种方式
作者: 邵彩华    时间: 2013-4-10 08:31
此题，我暂只能提供两种计算方法，大同小异，方法一用的是循环，方法二用的是Math类的数学方法。能力有限，如阳哥有纯面向对象的方法或优化方法，请贴在回复上，以便于我学习。谢谢阳哥！{:soso_e163:}
方法一：
class Cow {//定义牛类
        int num ;//农夫养牛的数量
        int year;//农夫养牛的时间
       
        Cow (int start) {//构造函数，指定初始牛数量
                num = start;
        }
       
        public int count (int year) {//该方法计算year年后，牛的数量
                this.year = year;
                for(int i=1;i<=year;i++) {//方法一：用循环方法
                        if(i%3==0)//每三年，让num值增一倍
                        num *= 2;
                }
                return num;
        }
}

class CountCow {//单独计算一个牛数量的类
        public static void main(String[] args) {
                Cow c = new Cow(1);//构造函数对牛数量进行初始化
                c.count(10);//调用count方法计算10年后牛的数量，
                System.out.println(c.year + "年后，牛的总数为：" + c.num);//打印输出结果，输出内容比较人性化哦。
        }
}

方法二：

class Cow {//定义牛类
        int num ;//农夫养牛的数量
        int year;//农夫养牛的时间
       
        Cow (int start) {//构造函数，指定初始牛数量
                num = start;
        }
       
        public double count (int year) {//该方法计算year年后，牛的数量
                this.year = year;
                num = num *(int) Math.pow(2,year/3);//用了java.lang包里的Math类的求幂方法。
                return num;
        }
}

class CountCow {//单独计算一个牛数量的类
        public static void main(String[] args) {
                Cow c = new Cow(1);//构造函数对牛数量进行初始化
                c.count(10);//调用count方法计算10年后牛的数量，
                System.out.println(c.year + "年后，牛的总数为：" + c.num);//打印输出结果，输出内容比较人性化哦。
        }
}
作者: 谢达    时间: 2013-4-10 08:44
看看.....
作者: 胡滨    时间: 2013-4-10 09:42
  1. /*
  2. 这道题的原型是斐波那契数列。
  3. 斐波那契数列又因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入，故又称为“兔子数列”。

  5. 分析：
  6. 牛在出生两年后，就有繁殖能力，一头牛每年能生出一头小牛来。如果所有牛都不死，那么一年以后可以繁殖多少头牛？
  7. 我们不妨拿新出生的一头小牛分析一下：
  8. 第一年小牛没有繁殖能力，所以还是一头
  9. 两年后，生下一头小牛总数共有两头
  10. 三年以后，老牛又生下一头，因为小牛还没有繁殖能力，所以一共是三头
  11. 。。。

  13. */


  16. public class Fibonacci {                                                //开始构造斐波那契数列
  17.         public static void main(String[] args) {
  18.                 int x = 1, y = 1;                                                //这是初始状态
  19.                 System.out.println(x);
  20.                 for (int i = 1; i <= 10; i++) {                        //这里的10就是十年，想知道n年改数字就行
  21.                         System.out.println(y);                             //输出的是第i年的头数
  22.                         y = x + y;
  23.                         x = y - x;
  24.                 }
  25.         }
  26. }
复制代码
作者: 我手心里的宝    时间: 2013-4-10 10:04
  1. package com.qdzks.day1;

  3. public class Test1 {
  4.         /*
  5.          * 题目：一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……
  6.          * 问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
  7.          * */
  8. }
  9. //1.运用递归的方法做
  10. class Cow1 {
  11.         static int count = 1;
  12.         private static void feedCow(int year,int age){
  13.                 year++;
  14.                 age++;
  15.                 //(结果为28，如果要算n年后的结果，只需将10改为n)：
  16.                 if(year<=10){
  17.                         if(age>=3){
  18.                                 count++;
  19.                                 feedCow(year,0);
  20.                         }
  21.                         feedCow(year,age);
  22.                 }
  23.         }

  25.         public static void main(String[] args) {
  26.                 new Cow1().feedCow(0, 0);
  27.                 System.out.println(count);
  28.         }
  29. }
  30. //方法2：面向对象的思路
  31. //结果是28，要求n年后，只需将i<10改为i< p>
  32. class Cow2 {
  33.         public static int count = 0;
  34.         public Cow2(int year){
  35.                 count++;
  36.                 for(int i=3+year;i<=10;i++){
  37.                         new Cow2(i);
  38.                 }
  39.         }

  41.         public static void main(String[] args) {
  42.                 new Cow2(0);
  43.                 System.out.println(count);
  44.         }
  45. }
复制代码
作者: 王军行    时间: 2013-4-10 10:12
  1. class ShuNiu
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.                 cowNum(10);
  6.         }
  7.         public static void cowNum(int N)//传入年数，打印该年有多少头牛
  8.         {
  9.                 if (N==1)
  10.                 {
  11.                         System.out.println("第1年的牛数:  1");
  12.                         return;
  13.                 }
  14.                 if (N==2)
  15.                 {
  16.                         System.out.println("第2年的牛数:  1");
  17.                         return;
  18.                 }
  19.                 int f1 = 1, f2 = 1, f;
  20.                 for(int i=3; i<=N; i++)
  21.                         {
  22.                            f = f2;
  23.                            f2 = f1 + f2;
  24.                            f1 = f;
  25.                         //这是数学规律的代码实现，用循环来算出第几年的牛数量
  26.                         //每循环一次，其实就是年数就+1；
  27.                         }
  28.                 System.out.println("第" + N +"年的牛数: "+f2);
  29.         }
  30. }
复制代码
作者: 刘胜寒    时间: 2013-4-10 10:47
本帖最后由 刘胜寒 于 2013-4-10 11:26 编辑

class Main {

        public static void main(String[] args) {
            Scanner cin = new Scanner(System.in);
                long[] ans = new long[40];//这个东西跑到五十年的时候就差不多内存溢出了 RunTime异常了 所以定义了40
            ans[1] = ans[2] = 1;
            for(int i=3;i<40;i++)
                    ans = ans[i-1] + ans[i-2];
            while(cin.hasNext())
            {

            int Year = cin.nextInt();// 年份
            if(Year>=40) {System.out.println("哥们  年数 大于40了");
            continue;
            }
            System.out.println(ans[Year]); //那一年有多少头年
            }

        }
/*
       年份         1        2        3        4        5        6        7        8        9
3年的老牛        0        0        1        1        2        3        5        8        13
2年的牛          0        1        0        1        1        2        3        5        5
1年的新牛       1        0        1        1        2        3        5        5        13
        斐波拉契数列 我是来混分的   


个人建议不要使用递归  耗时 很大 。
用for比较爽很快。
如果非要用递归建议使用记忆化递归， 节省时间

  */   
}

作者: 张旺达    时间: 2013-4-10 11:10
  1. //fibonacci数列问题
  2. //递归较耗时，但是本人新手目前只会用递归。。
  3. import java.util.Scanner;
  4. public class Main
  5. {
  6.         public static void main(String[] args)
  7.         {
  8.                 Scanner sc = new Scanner(System.in);
  9.                 while(sc.hasNext())
  10.                 {
  11.                         int n = sc.nextInt();
  12.                         System.out.println(fibonacci(n));
  13.                 }
  14.         }
  15.         public static long fibonacci(int n)
  16.         {
  17.                 if(n<=2)
  18.                         return 1;
  19.                 else
  20.                         return fibonacci(n-1)+fibonacci(n-2);
  21.         }
  22. }
复制代码
作者: 李永康    时间: 2013-4-10 11:38
具体思路  见思路
CODE ：

  2. public class test {
  3.         static int count = 1;// 初始牛数
  4.         private void Sum(int year, int age) {
  5.                 year++;//第N年
  6.                 age++;//年龄
  7.                 if (year <= 10) {
  8.                         if (age >= 3) {
  9.                                 count++;
  10.                                 Sum(year, 0);
  11.                         }
  12.                         Sum(year, age);
  13.                 }
  14.         }
  15.         public static void main(String[] args) {
  16.                 new test().Sum(0, 0);
  17.                 System.out.println(count);
  18.         }
  19. }
复制代码
作者: 黑马王双    时间: 2013-4-10 11:47
本帖最后由 黑马王双 于 2013-4-13 12:05 编辑

//以第一头牛为主，每年增加一岁，第三年开始每年生一头小牛//每三年重复一次第一头的牛的动作
public class Cow
{
         static int count= 1;
        private staticvoid feedCow(int year,int age)
        {
                year++;
                age++;
                if(year<=10)
                {
                        if(age>=3)
                        {
                                count++;
                                //当age=3的时候，第二头牛的年龄为1，重新调用第一头牛的动作，以此类推            
                                feedCow(year,0);
                        }
                        feedCow(year,age);
                }
        }
        public staticvoid main(String[] args)
        {
                new Cow().feedCow(0, 0);
                System.out.println(count);
        }
}
第n年的时候，将10替换为n即可。

作者: 黄欢    时间: 2013-4-10 11:59

import java.util.Scanner;

public class Cow {
        static int count = 1;
        static int year;

        // 设置年数
        public void setYear(int year) {
                Cow.year = year;
                CowCount(0, 0);
        }

        // 递归方法
        private static void CowCount(int i, int j) {
                i++;//年数
                j++;//牛的年龄
                if (i <= Cow.year) {
                        if (j >= 3) {
                                count++;
                                CowCount(i, 0);
                        }
                        CowCount(i, j);
                }
        }

        public static void main(String[] args) {
                Scanner s = new Scanner(System.in);
                System.out.print("请输入需要查询的年数： ");
                int year = s.nextInt();
                new Cow().setYear(year);
                System.out.println(year + "年后牛的数量为: " + count);
        }
}


作者: 彭波    时间: 2013-4-10 12:11
我的答案
作者: 彭波    时间: 2013-4-10 12:21
本帖最后由 彭波 于 2013-4-10 12:25 编辑

Cow.rar (626 Bytes, 下载次数: 2)

我的答案（权限是仅版主可见）
怎么设置“仅作者可见啊”？？？？


作者: 陈宇鹏    时间: 2013-4-10 12:35
本帖最后由 陈宇鹏 于 2013-4-10 12:41 编辑

首先，我象声明一下。以下代码是我从百度上找的
我确确实实不会这题，甚至不知道应该怎么去思考
但是还是来发帖的原因是  请求楼主给我一个这道题的思路。
请不要加分，但是麻烦也不要扣分，拜托
希望楼主可以给我指点一下。下面这段代码为什么这么写。每一句的思路是啥。
拜托了
第一个 百度上说是递归的
  1.    public class Cow {
  2.         static int count = 1;
  3.         private static void feedCow(int year,int age){
  4.             year++;
  5.             age++;
  6.             if(year<=30){
  7.                 if(age>=3){
  8.                     count++;
  9.                     feedCow(year,0);
  10.                 }
  11.                 feedCow(year,age);
  12.             }
  13.         }
  14.      
  15.         public static void main(String[] args) {
  16.             new Cow().feedCow(0, 0);
  17.             System.out.println(count);
  18.         }
  19.     }
复制代码
第二个是面向对象的
  1. public class Cow {
  2.         public static int count = 0;
  3.         public Cow(int year){
  4.             count++;
  5.             for(int i=3+year;i<=10;i++){
  6.                 new Cow(i);
  7.             }
  8.         }
  9.      
  10.         public static void main(String[] args) {
  11.             new Cow(0);
  12.             System.out.println(count);
  13.         }
  14.     }
复制代码
拜托拜托，希望楼主能给我讲讲~~~~

最后。。。。请不要加分，拜托也不要扣分
作者: 任雷彬    时间: 2013-4-10 12:41
class Oxen
{
        private int n;
        private int[] a;
         Oxen(int n){
                this.n = n;
                init();
                getNumber(n);
        }
                public void init(){
                a = new int[n];
                a[0] =1;
                a[1] =1;
                a[2] =2;
                }
                public void getNumber(int t){       
                for(int i=3;i<t;i++){
                        a[i]=a[i-1]+a[i-3];
                }
                for(int i=0; i<t; i++){               
                        System.out.println("第"+(i+1)+"年是"+a[i]+"头牛");
                }
                }
}
class OxenNumber
{
        public static void main(String[] args)
        {
        new Oxen(10);
        new Oxen(20);
        new Oxen(30);
        }
}
作者: 王怀亮    时间: 2013-4-10 12:43

农夫10年后有28头牛
  1. package com.itheima;

  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.Scanner;

  7. /**
  8. * 问题：一个农夫养了一头牛，三年后，这头牛每年会生出一头牛，生出来的牛三年后又可以内年生出一头牛....问农夫10年后有多少头牛，n年呢？
  9. *
  10. * @author liang
  11. */
  12. public class Cow {// 定义牛类
  13.         private int age = 0;// 定义牛的初始年龄

  15.         // 记录牛的年龄，每过一年，牛的年龄加1
  16.         public void addAge() {
  17.                 age++;
  18.         }

  20.         // 判断是否到了生育年龄
  21.         public boolean isCreatCow() {
  22.                 return (age >= 3) ? true : false;
  23.         }

  25.         public static void main(String[] args) {
  26.                 List<Cow> cowList = new ArrayList<Cow>();
  27.                 // 农夫原有的第一头牛
  28.                 cowList.add(new Cow());
  29.                 int yearCount;// 年份
  30.                 // 提示用户输入年份
  31.                 Scanner scanner = new Scanner(System.in);
  32.                 System.out.print("请您输入牛生长了多少年,输入后按回车可看到牛的数量奥：\n");
  33.                 yearCount = scanner.nextInt();// 输入年份
  34.                 for (int i = 1; i <= yearCount; i++) {// 根据输入的年份对牛进行循环计算，每过一年，牛的年龄都增加一岁
  35.                         int cowNum = cowList.size();// list中有多少行数据，就有几头牛，定义变量，取得list中的行数，即牛的数量
  36.                         for (int j = 0; j < cowNum; j++) {
  37.                                 Cow o = cowList.get(j);// 取出要进行生育的牛
  38.                                 // 每重复取到一头牛时，都意味着根据年份进行了一次新的循环，也就是又过了一年，所以每次新取出一头牛进行生育判断时，都要将这头牛的年龄加1
  39.                                 o.addAge();
  40.                                 // 对牛进行生育判断
  41.                                 if (o.isCreatCow()) {
  42.                                         // 如果这头牛到了生育年龄，就让牛生小牛
  43.                                         cowList.add(new Cow());
  44.                                 }
  45.                         }
  46.                 }
  47.                 System.out.println(yearCount + "年后将有<--" + cowList.size() + "-->头牛。");
  48.         }
  49. }
复制代码
作者: 王怀亮    时间: 2013-4-10 12:46
答：农夫十年后将有28头牛
  1. package com.itheima;

  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.Scanner;

  7. /**
  8. * 问题：一个农夫养了一头牛，三年后，这头牛每年会生出一头牛，生出来的牛三年后又可以内年生出一头牛....问农夫10年后有多少头牛，n年呢？
  9. *
  10. * @author liang
  11. */
  12. public class Cow {// 定义牛类
  13.         private int age = 0;// 定义牛的初始年龄

  15.         // 记录牛的年龄，每过一年，牛的年龄加1
  16.         public void addAge() {
  17.                 age++;
  18.         }

  20.         // 判断是否到了生育年龄
  21.         public boolean isCreatCow() {
  22.                 return (age >= 3) ? true : false;
  23.         }

  25.         public static void main(String[] args) {
  26.                 List<Cow> cowList = new ArrayList<Cow>();
  27.                 // 农夫原有的第一头牛
  28.                 cowList.add(new Cow());
  29.                 int yearCount;// 年份
  30.                 // 提示用户输入年份
  31.                 Scanner scanner = new Scanner(System.in);
  32.                 System.out.print("请您输入牛生长了多少年,输入后按回车可看到牛的数量奥：\n");
  33.                 yearCount = scanner.nextInt();// 输入年份
  34.                 for (int i = 1; i <= yearCount; i++) {// 根据输入的年份对牛进行循环计算，每过一年，牛的年龄都增加一岁
  35.                         int cowNum = cowList.size();// list中有多少行数据，就有几头牛，定义变量，取得list中的行数，即牛的数量
  36.                         for (int j = 0; j < cowNum; j++) {
  37.                                 Cow o = cowList.get(j);// 取出要进行生育的牛
  38.                                 // 每重复取到一头牛时，都意味着根据年份进行了一次新的循环，也就是又过了一年，所以每次新取出一头牛进行生育判断时，都要将这头牛的年龄加1
  39.                                 o.addAge();
  40.                                 // 对牛进行生育判断
  41.                                 if (o.isCreatCow()) {
  42.                                         // 如果这头牛到了生育年龄，就让牛生小牛
  43.                                         cowList.add(new Cow());
  44.                                 }
  45.                         }
  46.                 }
  47.                 System.out.println(yearCount + "年后将有<--" + cowList.size() + "-->头牛。");
  48.         }
  49. }
复制代码
作者: 董延京    时间: 2013-4-10 12:56
本帖最后由 董延京 于 2013-4-10 15:37 编辑
  1. public class Play07 {

  3.   /**
  4.    * @Author black horse
  5.    * 这个问题是斐波那契序列，我最初遇到的是一对小兔子三个月后又出生一对。
  6.    * 问题的关键在于：
  7.    * 当年分大于3后，当前年份的小牛数量：
  8.    * 是上一年的牛数量    加上    三年前的成牛的数量（它们在今年新生了小牛）。
  9.    * 当年分小于等于3，则只有这一头牛。
  10.    * 即 a(n)=a(n-1)+a(n-3);（n>3）
  11.    */
  12.   public static void main(String[] args) {
  13.     System.out.println(getNum(10));//执行结果为19。
  14.   }

  16.   public static int getNum(int n) {
  17.     //年份小于等于三年，返回1.
  18.     if (n <= 3) {
  19.       return 1;
  20.     }
  21.     //年份大于三年，返回a(n-1)+a(n-3)
  22.     else {
  23.       return getNum(n - 1) + getNum(n - 3);
  24.     }
  25.   }
  26. }
复制代码
作者: 将臣    时间: 2013-4-10 13:50
本帖最后由 将臣 于 2013-4-10 14:29 编辑
  1. import java.util.ArrayList;
  2. import java.util.List;


  5. public class Cattle {

  7.         //小牛的年龄
  8.         int age=0;
  9.         //是否能生小牛
  10.         public boolean isproduce(){
  11.                 if(age>=3){
  12.                         return true;
  13.                 }else{
  14.                         return false;
  15.                 }
  16.         }
  17.         //生出来的小牛三年后才能再生产，那么age每次加++
  18.         public void addYear(){
  19.                 age++;
  20.         }
  21.         public static void main(String[] args){
  22.                 //一共几年
  23.                 int year=10;
  24.                   List catList = new ArrayList();
  25.                    //农夫的第一头母牛
  26.                   catList.add(new Cattle());
  27.                    //开始计算
  28.                    for(int i=1;i<=year;i++){
  29.                     int calf = catList.size();
  30.                     for(int j = 0; j<calf; j++){
  31.                             Cattle cattle = (Cattle) catList.get(j);
  32.                      //计算年龄 ++一次
  33.                             cattle.addYear();
  34.                      //判断一下是否到了三年能下崽了
  35.                      if(cattle.isproduce()){
  36.                       catList.add(new Cattle());
  37.                      }
  38.                     }
  39.                    }
  40.                    System.out.println("农夫"+year+"年后将有"+catList.size()+"头牛。");
  41.                 }
  42.         }
复制代码
作者: 郭利超    时间: 2013-4-10 13:55
  1. package demo;

  3. import java.util.ArrayList;
  4. import java.util.List;
  5. /**
  6. * @author 郭利超
  7. *
  8. */
  9. public class Cow
  10. {

  12.         private int age = 0;
  13. /**
  14. * 是否可以生产小牛
  15. * @return True | False
  16. */
  17.         public boolean isCreatSmallCow()
  18.         {
  19.                 return (age >= 3)?true:false;
  20.         }

  22. /**
  23. * 过年了，年龄又大了一岁
  24. */
  25.         public void addYear()
  26.         {
  27.                 age++;
  28.         }
  29. /**
  30. * @param args
  31. */
  32.         public static void main(String[] args)
  33.         {
  34.            List<Cow> cowList = new ArrayList<Cow>();
  35.            //第一头小牛
  36.            cowList.add(new Cow());
  37.            int yearCount = 10;
  38.            //就这样一年年过
  39.            for(int i=1;i<=yearCount;i++)
  40.            {
  41.                         int rowNum = cowList.size();
  42.                         for(int j = 0; j<rowNum; j++)
  43.                         {
  44.                                 Cow o = cowList.get(j);
  45.                                 //过年了
  46.                                 o.addYear();
  47.                                 //能生小牛吗？
  48.                                 if(o.isCreatSmallCow())
  49.                                 {
  50.                                         cowList.add(new Cow());
  51.                                 }
  52.                         }
  53.                  }
  54.            System.out.println(yearCount+"年后将有【"+cowList.size()+"】头牛。");
  55.         }
  56. }
复制代码
10年后28头   N年后int yearCount = 10; 10改成N
作者: HM刘俊    时间: 2013-4-10 14:46
  1. // 程序分析：牛的头数规律为1,1,2,3,5,8,13,21......
  2. public class niu{
  3. public static void main(String args[]){
  4. int n=0;
  5. math mymath = new math();//创建一个math实例对象

  7. System.out.println(mymath.f(n)); // 输出n年后的牛的头数，当n输入10.时，计算结果为55.
  8. }

  10. }
  11. class math
  12. {
  13. public int f(int x)
  14. {
  15. if(x==1 || x==2) //如果这头牛是出生的第一或第二年，
  16. return 1; //那么就返回牛数为1
  17. else
  18. return f(x-1)+f(x-2); 否则返回三年或以上的牛的头数
  19. }
  20. }
复制代码
作者: 王薪婷    时间: 2013-4-10 15:37
package test;
import java.util.*;
class  Test
{
        public static void main(String[] args)
        {
                //System.out.println("Hello World!");
                //获取用户输入的年数
                Scanner sc=new Scanner(System.in);
                int n=sc.nextInt();
                Niu(n);
        }
        public static void Niu(int n)
        {
                int f1=1,f2=1;
                if(n<3&&n>0)
                        System.out.println("第"+n+"年的牛的只数"+f2);
                else
                {
                        for(int x=3;x<=n;x++)
                        {
                                //定义一个临时变量
                                int f=f2;
                                f2=f1+f2;
                                f1=f;
                               
                                       
                               
                        }

                        System.out.println("第"+n+"年的牛的只数"+f2);
                }
        }
}
作者: 吴林飞    时间: 2013-4-10 16:34
标题: RE: 【答题贴】01期----答题有奖
  1. /*
  2. 一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，
  3. 又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
  4. */
  5. public class Cow
  6. {
  7.         static int count = 1;
  8.         static int n = 10;
  9.         private static void getCow(int year,int age)
  10.         {
  11.                 year++;
  12.                 age++;
  13.                 if(year<=n)
  14.                 {
  15.                         if(age>=3)
  16.                         {
  17.                                 //当牛的年龄达到3岁，则计数一次，代表一个小牛诞生。
  18.                                 count++;
  19.                                 //一个小牛诞生后，还会按照老牛的规律，三年后每年诞生一个新崽，所以还需要调用原来的方法
  20.                                 getCow(year,0);                       
  21.                         }
  22.                         getCow(year,age);
  23.                 }
  24.         }
  25.         public static void main(String[] args)
  26.         {
  27.                 new Cow().getCow(0, 0);
  28.                 System.out.println(count);
  29.         }
  30. }
复制代码
作者: 曹春贵    时间: 2013-4-10 17:49
  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.Scanner;

  5. class Cattle {
  6.         private int year;// 年龄
  7.         private String name;// 姓名
  8.         private Cattle parentsCattle;// 生它的牛,牛对象Cattle
  9.         private List<Cattle> childCattle = new ArrayList<Cattle>();// 它生的牛,牛集合List<Cattle>
  10.         private int totalChildNumber;// 一共有多少个子女，子女数加上所有子女的子女数
  11.         private int birthYear;// 出生年龄

  13.         public Cattle() {
  14.                 this.year = 1;// 初始化时牛年龄为1
  15.                 this.birthYear = 1;
  16.         }

  18.         private void getChild(Cattle cattle) {
  19.                 if (cattle.getYear() > 3) {// 年龄大于3则生牛
  20.                         int year = cattle.getBirthYear() + 3;
  21.                         for (int i = cattle.getYear() - 3; i > 0; i--) {// 年龄大于3每年生一个牛，i设置递减形式，最大值i则是生的第一个牛的年龄，以此类推。
  22.                                 Cattle c = new Cattle();// 实例化第一个子牛
  23.                                 c.parentsCattle = cattle;// 设置生它的牛对象
  24.                                 c.setName(cattle.getName() + "~"
  25.                                                 + (cattle.childCattle.size() + 1));// 设置子牛的名字：父母牛的名字+第几个子女
  26.                                 c.setBirthYear(year++);// 设置第几年出生
  27.                                 c.setYear(i);// 设置子牛的年龄，按照年龄让它生牛，这里核心思想就是递归调用
  28.                                 c.setTotalChildNumber();// 设置子牛的子女数目
  29.                                 cattle.childCattle.add(c);// 将子牛添加到集合
  30.                         }
  31.                 }
  32.         }

  34.         public int getYear() {
  35.                 return year;
  36.         }

  38.         public void setYear(int year) {
  39.                 this.year = year;
  40.                 getChild(this);// 执行生牛的方法
  41.         }

  43.         public String getName() {
  44.                 return name;
  45.         }

  47.         public void setName(String name) {
  48.                 this.name = name;
  49.         }

  51.         public Cattle getParentsCattle() {
  52.                 return parentsCattle;
  53.         }

  55.         public void setParentsCattle(Cattle parentsCattle) {
  56.                 this.parentsCattle = parentsCattle;
  57.         }

  59.         public List<Cattle> getChildCattle() {
  60.                 return childCattle;
  61.         }

  63.         public void setChildCattle(List<Cattle> childCattle) {
  64.                 this.childCattle = childCattle;
  65.         }

  67.         public void setTotalChildNumber() {
  68.                 for (Cattle c : childCattle) {// 遍历它子女集合，将它每个子女的子女数相加
  69.                         this.totalChildNumber += c.getTotalChildNumber();
  70.                 }
  71.                 this.totalChildNumber += childCattle.size();// 累加上它的子女数，totalChildNumber此时代表子女数加上所有子女的子女数
  72.         }

  74.         public int getTotalChildNumber() {
  75.                 return totalChildNumber;
  76.         }

  78.         public int getBirthYear() {
  79.                 return birthYear;
  80.         }

  82.         public void setBirthYear(int birthYear) {
  83.                 this.birthYear = birthYear;
  84.         }

  86. }

  88. public class CattleTest {

  90.         public static void main(String[] args) {
  91.                 System.out.println("请输入年数：");
  92.                 Scanner sc = new Scanner(System.in);
  93.                 int year = sc.nextInt();
  94.                 int number = getTotalNumber(year);// 根据年数获得总牛数
  95.                 System.out.println(year + "年后，一共有" + number + "头牛");
  96.         }

  98.         public static int getTotalNumber(int year) {// 根据传递的参数year，返回总牛数
  99.                 Cattle cattle = new Cattle();
  100.                 cattle.setName("牛牛");
  101.                 cattle.setYear(year);// 设置年龄的时候执行了生牛方法
  102.                 cattle.setTotalChildNumber();
  103.                 printTotalNumber(cattle, 0);// 递归调用输出关系图
  104.                 return cattle.getTotalChildNumber() + 1;
  105.         }

  107.         public static void printTotalNumber(Cattle cattle, int livel) {// livel为目录级数
  108.                 StringBuilder sb = new StringBuilder("");
  109.                 for (int i = 0; i < livel; i++) {// 目录级数的前缀
  110.                         sb.append("|  ");
  111.                 }
  112.                 System.out.println(sb.toString() + "|-" + cattle.getName() + "(第"
  113.                                 + cattle.getBirthYear() + "年出生)");
  114.                 for (Cattle c : cattle.getChildCattle()) {
  115.                         printTotalNumber(c, livel + 1);
  116.                 }
  117.         }
  118. }
复制代码
作者: 陈培茹    时间: 2013-4-10 18:01
import java.util.ArrayList;
import java.util.List;
/**
* @author songwentao
* 2009-12-03
*/
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()+"】头牛。");
}
}
作者: 肖明凯    时间: 2013-4-10 18:13
  1. /*  一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……
  2. *         问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
  3. *
  4. *        思路：构建牛类，通过容器装载牛实例，遍历容器，判断是否可生育，添加牛实例，容器size即为牛的总数。
  5. */

  7. import java.util.ArrayList;

  9. //牛类
  10. class Cow
  11. {
  12.         //牛的年龄
  13.         private int age;
  14.         public Cow(int age)
  15.         {
  16.                 this.age = age;
  17.         }
  18.         //判断是否可生育，如果年龄不小于三，则为可生育的。
  19.         public boolean isFertile()
  20.         {
  21.                 if (age>=3)
  22.                         return true;
  23.                 else
  24.                         return false;
  25.         }
  26.         //年龄增长
  27.         public void grow()
  28.         {
  29.                 age++;
  30.         }
  31. }

  33. public class Test
  34. {
  35.         public static void main(String[] args)
  36.         {
  37.                 //要计算n年后的牛总数，将10替换即可
  38.                 getCows(10);
  39.                
  40.         }
  41.        
  42.         public static void getCows(int years)
  43.         {
  44.                
  45.                 //创建容器，存放Cow实例
  46.                 ArrayList<Cow> al = new ArrayList<Cow>();
  47.                 //存入第一只牛
  48.                 al.add(new Cow(0));
  49.                 for (int i=1; i<=years ; i++ )
  50.                 {
  51.                         //可生育牛的个数
  52.                         int fertileSum = 0;
  53.                         //遍历容器
  54.                         for(int j=0; j<al.size(); j++)
  55.                         {
  56.                                 Cow c = (Cow)al.get(j);
  57.                                 //牛年龄增加，后替换容器里的实例
  58.                                 c.grow();
  59.                                 al.set(j, c);
  60.                                 //判断是否可生育，记录可生育牛的总数
  61.                                 if (c.isFertile())
  62.                                 {
  63.                                         fertileSum++;
  64.                                 }
  65.                         }
  66.                         //new牛，并加到容器中，牛的初始年龄为0
  67.                         for (int k=1; k<=fertileSum ; k++ )
  68.                         {
  69.                                 al.add(new Cow(0));
  70.                         }
  71.                         //打印
  72.                         System.out.println("第"+i+"年牛的总数为："+al.size());
  73.                 }
  74.         }
  75. }


  78. /*
  79.         输出：
  80.                 第1年牛的总数为：1
  81.                 第2年牛的总数为：1
  82.                 第3年牛的总数为：2
  83.                 第4年牛的总数为：3
  84.                 第5年牛的总数为：4
  85.                 第6年牛的总数为：6
  86.                 第7年牛的总数为：9
  87.                 第8年牛的总数为：13
  88.                 第9年牛的总数为：19
  89.                 第10年牛的总数为：28
  90. */
复制代码
作者: 罗海云    时间: 2013-4-10 18:25
呵呵呵

罗海云.zip

693 Bytes, 阅读权限: 100, 下载次数: 1
作者: 谢达    时间: 2013-4-10 19:17
package com.ccsu.xie.test;

import java.util.ArrayList;

public class Farm {
        // 存储农场种牛的信息
        ArrayList<Cow> cows = new ArrayList<Cow>();

        public Farm() {
                cows.add(new Cow(1, 1));
        }

        // n年之后农场牛的数量
        public int addCow(int year) {
                //保存新生牛的信息
                ArrayList<Cow> newCows = null;
                int count=cows.size();
                for (int i = 1; i <=year; i++) {
                       
                        newCows = new ArrayList<Cow>();
                        for (Cow cow : cows) {
                                if (cow.getAge()>=3){
                                        count++;
                                        newCows.add(cow.add(count));
                                }
                                cow.ageAdd();
                        }
                        //将新生牛信息加入cows中
                        cows.addAll(newCows);
                        System.out.println(i+" 年  农  场  信  息  ");
                        //输出每年农场中牛的信息
                        show();
                }
               
               
                return cows.size();
        }
       
        //输出信息
        public void show(){
                for(Cow cow : cows){
                        System.out.println(cow);
                }
        }
       
       
        public static void main(String[] args) {
       
                Farm farm = new Farm();
                System.out.println("总数量" + farm.addCow(10));
        }

       
}

// 牛
class Cow {
        private int id ;  //编号
        private int age;  //年龄
        Cow(int id, int age) {
                this.id = id;
                this.age = age;

        }

        public int getId() {
                return this.id;
        }

        public int getAge() {
                return this.age;
        }

        public void ageAdd() {
                this.age++;
        }

        public Cow add(int id) {
                return new Cow(id, 1);
        }
       
        public String toString(){
                return "id--->"+id+" age--->"+age;
        }
}
作者: 飞天小猪猪    时间: 2013-4-10 22:47
public class BullSum {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                System.out.println(getSum(10));
                System.out.println(getSum_1(10));
        }
        //思路是：3年后每头牛会每年生一头牛，新的牛3年后也会每年生一头牛。从第四年开始
        //第一头牛开始生小牛，以后每一年都开始生小牛，小牛三年后开始生小牛，即斐波拉契数列
        //年是n，总数即为 f(n)=f(n-1)+f(n-3)今年的牛总数为去年的总数加上三年前的总数。
        //使用递归算法，前3年每年总数都是1，第四年开始去年总数加上三年前的总数之和。
        public static int getSum(int year)
        {                                                               
                int sum=1;
                if(year==1)
                        return sum;
                if(year==2)
                        return sum;
                if(year==3)
                        return sum;
                return getSum(year-1)+getSum(year-3);
        }
        //用定义一个长度为3的数组，将前三年的总数存进去，数组里代表1、2、3年的总数
        //然后从第四年的总数为数组0角标和2角标之和即去年和三年前总数之和。
        //然后将数组中的数字向前挪一位，将第四年总数放进2角标里。这时数组里即为
        //2,3,4年的总数。继续for循环，获得以后每一年的总数。
        public static int getSum_1(int year)
        {
                int sum=1;
                int[] num={1,1,1};//
                if(year<4)
                        return sum;
                for(int x=4;x<=year;x++)
                {
                        sum=num[2]+num[0];
                        num[0]=num[1];
                        num[1]=num[2];
                        num[2]=sum;
                }       
                return sum;
        }
}

作者: 蓝色骨头    时间: 2013-4-10 23:28
本帖最后由 蓝色骨头 于 2013-4-10 23:31 编辑

package heimatest;

import java.math.BigInteger;
import java.util.Arrays;
/*
* 思路：
* 动态规划思想
* 用cowSub(years)表示一头牛years年后将生多少牛。
* 那么cowSub(years) = (years-3) + cowSub(years-3) + cowSub(years-4) +……+ cowSub(0)
* 其中(years-3)表示这头牛生的牛的数量，当years < 3时cowSub(years)为0
* cowSub(years-3) + cowSub(years-4) +……+ cowSub(0)表示这头牛生的牛 再繁衍的牛的数量
* 那么如果有一头years年后的牛总数为：cowSub(years)+1，其中1为原来的这头牛
*
* 因为递归时会产生重复计算,
* 比如在计算cowSub(10)是要计算cowSub(4)，在计算cowSub(7)时也要计算cowSub(4)
* 所以可以定义一个数组cowSub，cowSub表示一头牛i年后将生多少头牛。
* 如果没有计算过了就计算这个值，否则直接返回cowSub。
*
* 当years比较大时int类型不够,使用BigInteger
*/
public class CowTest {
        public static int cow(int years){
               
                int[] cowSub = new int[years];        //创建数组，用于保留计算结果，避免重复计算，dp思想                        
        
                Arrays.fill(cowSub, -1);                //初始化为-1表示没有计算过
               
                return cowSub(cowSub, years) + 1;
        }
        private static int cowSub(int[] cowSub,int years){
               
                if( years < 3 ){
                        return 0;
                }
               
                int count =0;
                for(int i = 3; i <= years; i++){
                        count++;
                        if(cowSub[years-i] == -1){
                                cowSub[years-i] = cowSub(cowSub, years-i);                        
                        }
                        count += cowSub[years-i];
                }
               
                return count;
        }
        
        /*
         * 发现int长度不够，直接使用BigInteger
         */
        private static BigInteger one = new BigInteger("1");
        private static BigInteger nagtiveOne = new BigInteger("-1");
        public static BigInteger cow2(int years){
                BigInteger[] cowSub = new BigInteger[years];        //创建数组，用于保留计算结果，避免重复计算，dp思想                        
        
                Arrays.fill(cowSub, nagtiveOne);                //初始化为-1表示没有计算过
               
                return cowSub2(cowSub, years).add(one);
        }
        private static BigInteger cowSub2(BigInteger[] cowSub,int years){
               
                if( years < 3 ){
                        return new BigInteger("0");
                }
               
                BigInteger count = new BigInteger("0");
                for(int i = 3; i <= years; i++){
                        count = count.add(one);
                        if(cowSub[years-i].compareTo(nagtiveOne) == 0){
                                cowSub[years-i] = cowSub2(cowSub, years-i);                        
                        }
                        count = count.add(cowSub[years-i]);
                }
               
                return count;
        }

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                for(int n =  0; n < 100; n++){
                        System.out.println(n+" year: "+cow(n)+" cows");
                }
               
                for(int n =  0; n < 100; n++){
                        System.out.println(n+" year: "+cow2(n)+" cows");
                }
        }

}
作者: 刘国强    时间: 2013-4-11 01:31
答案为28具体计算代码带啊如下
  1. package com.zknu.test;

  3. public class Cow {

  5.         public static void main(String[] args) {
  6.                
  7.                 //创建一个牛对象，初始年龄为0
  8.                 new Cow(0);
  9.                
  10.                 //输出打印出10年后的总牛数
  11.                 System.out.println(count);


  14.         }
  15.        
  16.         //创建一个int类型的变量，用于存放牛的总数，初始值为0
  17.         public static int count = 0;
  18.        
  19.         //对出生的牛进行处理
  20.         public Cow(int year){
  21.                
  22.                 count++;
  23.                
  24.                 //如果牛的年龄大于等于3,则每年年都产生一头新的牛
  25.                 for(int i=3+year;i<=10;i++){
  26.                         new Cow(i);
  27.                 }
  28.         }

  30. }
复制代码
作者: 石琪    时间: 2013-4-11 03:29
  1. /*
  2. 一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，
  3. 又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?

  5. 分析：
  6.         列出牛在每年的头数：1，1，2，3，5，8，13，21。。。发现从第三年开始当年牛数是前两年之和。
  7. */
  8. import java.lang.*;
  9. import java.io.*;
  10. public class shuniu {
  11.         public static void main(String[] args)throws IOException
  12.         {
  13.                 long t=1;//当年牛数
  14.                 int y=1;//当年时间，起始为第一年
  15.                 long f=1;//第一年牛数
  16.                 long s=1;//第二年牛数
  17.                 int ty=7;//总年份
  18.                 sop("请输入总年份");
  19.                 InputStream in=System.in;
  20.                 StringBuilder sb=new StringBuilder();  
  21.         while(true)  
  22.         {  
  23.             int ch=in.read();  
  24.             if(ch=='\r')  
  25.                 continue;  
  26.             if(ch=='\n')  
  27.             break;
  28.             sb.append((char)ch);  
  29.               
  30.         }
  31.                  ty=Integer.parseInt(sb.toString());
  32.                
  33.                
  34.                 while(y<=ty-2)
  35.                 {
  36.                         if(ty==1||ty==2)//如果是第一年或第二年直接返回一头牛
  37.                         {
  38.                                 s=1;
  39.                                 break;
  40.                         }
  41.                         t=f+s;//当年牛数=第一年+第二年
  42.                         f=s;
  43.                         s=t;
  44.                         y++;
  45.                 }
  46.                 sop(t);
  47.         }
  48.        
  49.         public static void sop(Object obj)
  50.         {
  51.                 System.out.println(obj);
  52.         }
  53.        

  55. }
复制代码
作者: xyh19    时间: 2013-4-11 11:48
本帖最后由 徐彦淏 于 2013-4-11 11:55 编辑

。。。。。。。。。。。。。。

Cow.zip

550 Bytes, 阅读权限: 100, 下载次数: 0
作者: 栗俊植    时间: 2013-4-11 12:06
标题: RE: 【答题贴】01期----答题有奖
  1. /*
  2. 需求:求牛在某个月的数目!
  3. 分析:    月     数目
  4.                  1        1
  5.                  2                  1
  6.                  3        2
  7.                  4        3
  8.                  5        5
  9.                  6        8
  10.                  7        13
  11.                  ...      ...
  12. 由上可以看出x月的数目 是(x-1)月加上(x-2)月牛的数目
  13. .......
  14. */
  15. import java.util.*;   //导入包
  16. class CattleDemo {
  17.         public static void main(String[] args) {
  18.                 Scanner cn=new Scanner(System.in); //创建Scanner的对象 cn
  19.                 System.out.print("请输入要计算的月数:");
  20.                 int m =cn.nextInt();  // 定义一个变量 m  调用nexInt()方法  实现可以在Dos窗口中键盘输入我们要查询的月份
  21.                 int i=1;      //定义一个变量 i 表示 表示第几个月
  22.                 int[] arr=new int [m+1];   //创建一个数组  因为我们要查询的是m月  所以用m+1个数组元素就可以装下m个月的数
  23.                 for(i=1;i<m+1;i++) {
  24.                         if(i==1|i==2)
  25.                                 arr[1]=arr[2]=1;
  26.                         else       
  27.                                 arr[i]=arr[i-2]+arr[i-1];
  28.                 }
  29.                 System.out.println("第" + m +"月的牛数目为:" + arr[m]);
  30.         }   
  31. }
复制代码
作者: 符立波    时间: 2013-4-11 12:50
看看,看看....
作者: 施家雄    时间: 2013-4-11 12:54
之前没有在这里答题，现在放到这里来。。
  1. import java.util.ArrayList;
  2. import java.util.Scanner;
  3. /*
  4. * 主要要定义一个可变数组来存储变化的牛的数量。要查看第几年有多少牛，从键盘中输入一个年数
  5. * 就能知道第几年有几头牛了。
  6. *
  7. * */
  8. public class CowTest {
  9. //定义年龄为0以后每年加1
  10. private int age = 0;
  11. //定义方法，判断过了3年就能生小牛
  12. public boolean isCreatSmallCow(){
  13.    return (age >= 3)?true:false;
  14. }
  15. //过一年age自增
  16. public void addYear(){
  17.    age++;
  18. }

  20. public static void main(String[] args) {
  21.         
  22.         //定义一个可变数组，对每年的出生的牛加以前的牛保存起来
  23.    ArrayList<CowTest> list = new ArrayList<CowTest>();
  24.    
  25.    //这是第一头牛
  26.    list.add(new CowTest());
  27.    
  28.    System.out.print("请输入这是第几年：");
  29.    //定义一个键盘
  30.    Scanner input=new Scanner(System.in);
  31.    
  32.    //从键盘中输入年数
  33.    int yearsCount=0;
  34.    try{
  35.    yearsCount = input.nextInt();
  36.    }catch(Exception e)
  37.    {
  38.      System.out.println("你输入的数字不合法！");
  39.    }
  40.    //因为不知道过了几年，所以定义循环语句
  41.    for(int i=1;i<=yearsCount;i++){
  42.            int rowNum = list.size();     //可变数组中的牛的数量
  43.            for(int j = 0; j<rowNum; j++){
  44.                    CowTest cow = list.get(j);
  45.                    cow.addYear();             //过一年就自增
  46.                    if(cow.isCreatSmallCow()){    //若是第三年就有小牛出生
  47.                            list.add(new CowTest());
  48.      }
  49.     }
  50.    }
  51.   
  52.    System.out.println(yearsCount+"年后总共有"+list.size()+"头牛。");
  53. }
  54. }
复制代码
作者: 余勇    时间: 2013-4-11 13:45
  1. /*

  3. */
  4. package cn.yy.practice;

  6. import java.util.*;

  8. /**
  9. * 既然母牛生小牛,就用Cow类代表牛,提及时间,用年龄age表示,刚出生age=0.
  10. * 还应该提供一个bear()方法,返回一个新的Cow对象,表示生了一头牛.
  11. * 使用List集合来存储所有的牛,每遍历一次,表示过了一年,增加一个变量currentYear表示当前年份
  12. * 遍历过程中,判断每个Cow的age值,如果大于或等于3,生育一头小牛,并将这头小牛也存入集合
  13. * 遍历后增加一个变量currentCount记录当前集合中总共有多少Cow对象
  14. * 最后返回currentCount,表示指定年份n后总共有多少牛.
  15. */
  16. public class CowProblem {
  17.        
  18.         List<Cow> cows = new ArrayList<Cow>();           //每生一头牛,存入集合

  20.         public int count(int year){                                        //指定年份

  22.                 int currentYear = 0;                                        //当前年份

  24.                 cows.add(new Cow());                                        //加入第一头母牛
  25.                
  26.                 int currentCount = cows.size();                        //当前集合中元素个数.
  27.                                                                                                

  29.                 while((currentYear++) < year ){                       

  31.                         for (int i=0; i<currentCount; i++ )
  32.                         {
  33.                                 Cow c = cows.get(i);                        //取出一个Cow对象,并将年龄加1
  34.                                
  35.                                 if(++c.age >= 3)                                //如果大于或等于3,则产生一个新Cow对象,并存入集合
  36.                                         cows.add(c.bear());                               
  37.                         }
  38.                         currentCount = cows.size();                        //每次遍历后记录下当前集合内的元素个数,
  39.                                                                                                 //防止下一次遍历过程中,遍历到了新产生的牛
  40.                 }
  41.        
  42.                 return currentCount;
  43.                
  44.         }               

  46.         public static void main(String[] args) {
  47.                 Scanner input = new Scanner(System.in);

  49.                 System.out.print("input an integer(year) : ");

  51.                 int year = 0;
  52.                 int sum = 0;
  53.                 try{
  54.                         year = input.nextInt();                       //指定年份               

  56.                         if(year >= 0)
  57.                                 sum = new CowProblem().count(year);

  59.                         System.out.println("cow count = " + sum);                //打印结果

  61.                 }catch(InputMismatchException e){
  62.                         System.out.println("not an integer, or is out of range");
  63.                 }                                                       
  64.                
  65.                
  66.         }
  67.        
  68. }

  70. class Cow {                                                        //定义一个Cow类,
  71.                
  72.                 int age;

  74.                 public Cow(){                                //初始化age
  75.                         age = 0;
  76.                 }       
  77.                 public Cow bear(){                        //bear()方法,返回一个新的Cow对象,表示生了一头牛.
  78.                         return new Cow();
  79.                 }
  80.         }
复制代码

CowProblem.zip

1.16 KB, 下载次数: 37
作者: 刘林虎    时间: 2013-4-11 14:43
  1. package choux;

  3. import java.util.ArrayList;
  4. import java.util.List;

  6. public class Cow {

  8. private int age = 0;

  10. /**
  11. * 是否可以生产小牛
  12. */
  13. public boolean isCreatSmallCow(){
  14.    return (age >= 3)?true:false;
  15. }

  17. /**
  18. * 过年了，年龄又大了一岁
  19. */
  20. public void addYear(){
  21.    age++;
  22. }
  23. public static void main(String[] args) {
  24.    List<Cow> cowList = new ArrayList<Cow>();
  25.    //第一头小牛
  26.    cowList.add(new Cow());
  27.    int yearCount = 10;
  28.    //就这样一年年过
  29.    for(int i=1;i<=yearCount;i++){
  30.     int rowNum = cowList.size();
  31.     for(int j = 0; j<rowNum; j++){
  32.      Cow o = cowList.get(j);
  33.      //过年了
  34.      o.addYear();
  35.      //能生小牛吗？
  36.      if(o.isCreatSmallCow()){
  37.       cowList.add(new Cow());
  38.      }
  39.     }
  40.    }
  41.    System.out.println(yearCount+"年后将有【"+cowList.size()+"】头牛。");
  42. }
  43. }

复制代码
作者: 高新星    时间: 2013-4-11 14:47
本帖最后由 高新星 于 2013-4-11 14:51 编辑
  1. /*
  2. * 需求：一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，
  3. *                         又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
  4. *
  5. * 思路：
  6. * 1，定义一个计算牛的数量的功能函数getCattleNum();
  7. * 2，确定函数的结果为牛的数量，所以该函数的返回结果为 int
  8. * 3，确定函数的需要调用者传入的参数为几年，所以该函数的参数类型和个数确定为 int ,且个数为一
  9. * 4，定义变量sum表示牛的数量
  10. * 5，牛的总数等于前一年getCattleNum（year-1）的数量加上新出生的牛的数量
  11. * 6，新出生牛的数量根据题意可以确定为三年前牛的数量gwtCattleNum（year-3），因为每头牛都是在三年后才会产牛
  12. * 7，根据5,6可以确定该函数用的是递归的方法
  13. */

  15. public class TeatCattle {
  16.         //定义变量牛的总数sum
  17.         static int sum;

  19.         /*
  20.          * 定义获取牛的数量的函数
  21.          */
  22.         public static int getCattleNum(int year){
  23.                
  24.                 for(int x = 1;x <=year;x++){
  25.                         //判断年数是否大于三，小于三直接返回牛的数量为1
  26.                         if(year <= 3)
  27.                                 sum=1;                                                                                        //初始化时的牛的数量
  28.                         else
  29.                                 sum = getCattleNum(year-3) +getCattleNum(year-1);
  30.                 }
  31.                
  32.                 return sum;                                                                                        //返回牛的总数
  33.         }
  34.         
  35.         
  36.         
  37.         public static void main(String[] args) {
  38.                 //测试十年后的牛的数量
  39.                 int year = 10;
  40.                 int sum = getCattleNum(year);
  41.                 System.out.println(sum);//数量为：19

  43.         }
  44. }
复制代码
作者: 刘渝灵    时间: 2013-4-11 16:06
  1. public class Test01
  2. {
  3.         static int sum = 0;
  4.         public static void main(String[] args)
  5.         {
  6.                 method(10);
  7.                 System.out.println("总数："+sum);
  8.         }

  10.         public static void method(int n){
  11.                 if(n==0)
  12.                         return;
  13.                 sum+=n;
  14.                 method(--n);               
  15.         }
  16. }
复制代码
作者: HM邱刚权    时间: 2013-4-11 16:22
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 19:15
表示基础视频只学了一半，
我尽力了。

Test.rar

1.85 KB, 阅读权限: 100, 下载次数: 2

答案
作者: 黄杨    时间: 2013-4-11 19:53
已做完，不知这样格式对不对，请过目。

黄杨.zip

904 Bytes, 阅读权限: 100, 下载次数: 1
作者: 王永贺    时间: 2013-4-11 21:15
本帖最后由 王永贺 于 2013-4-11 21:18 编辑

此题和兔子的那道题很类似都是用递归的方法解决   这道题我刚发贴的时候我就回复过，我当时回复到发帖的里面了 随后应该被删除了吧  所以我现在重新回复下
  1. public class cow {
  2.         static int cow_count = 1;
  3.         private static void fn(int year,int age,int n){        //year代表第几年， age代表牛的年龄，能代表最大年限
  4.                 year++;
  5.                 age++;
  6.                 if(year<=n){  //如果没有达到上限年限则执行下面语句
  7.                         if(age>=3){ //小牛的年龄大于三岁，每年生一头牛
  8.                                 cow_count++;  //牛的总数加1
  9.                                 fn(year,0,n);  //递归刚出生的小牛年龄设置为0
  10.                         }
  11.                         fn(year,age,n);
  12.                 }
  13.         }

  15.         public static void main(String[] args) {
  16.                 new cow().fn(0, 0,10);
  17.                 System.out.println(cow_count);
  18.         }
  19. }
复制代码
作者: 孙金鑫    时间: 2013-4-11 21:58
/*
一个农夫养了一头牛，三年后，这头牛每一年会生出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;                //返回值，牛的个数
        }
}
作者: 李游    时间: 2013-4-11 22:27
  1. import java.util.ArrayList;
  2. import java.util.List;

  4. /**
  5. * n年的问题，只要将程序中的year改成n年即可
  6. *
  7. * @author LeeYou
  8. *
  9. */
  10. public class Cow {
  11.         private int age = 1; // 初始年龄为1岁
  12.         private static List<Cow> cowList = new ArrayList<Cow>();// 定义一个 集合容器，用于装牛

  14.         /**
  15.          * 判断是否可以繁殖小牛
  16.          *
  17.          * @return
  18.          */
  19.         public boolean canBreedCow() {
  20.                 return (age > 3) ? true : false;
  21.         }

  23.         /**
  24.          * 岁数叫1
  25.          */
  26.         public void addYear() {
  27.                 age++;
  28.         }

  30.         /**
  31.          * 产牛工具函数
  32.          *
  33.          * @param year
  34.          */
  35.         public static void BreedCow() {
  36.                 cowList.add(new Cow());
  37.         }

  39.         public static void main(String[] args) {

  41.                 cowList.add(new Cow());// 初始为1头牛
  42.                 int year = 10;// 年数10年
  43.                 // 外层循环控制年数
  44.                 for (int i = 1; i <= year; i++) {
  45.                         int cowCount = cowList.size();
  46.                         // 内层循环获取每头牛的对象，并判断是否可以繁殖小牛
  47.                         for (int j = 0; j < cowCount; j++) {
  48.                                 Cow cow = cowList.get(j);// 逐个获取每头牛的对象
  49.                                 cow.addYear();// 长大一岁
  50.                                 // 如果年龄大于三岁，则每年可以繁殖一头小牛
  51.                                 if (cow.canBreedCow()) {
  52.                                         BreedCow();
  53.                                 }
  54.                         }
  55.                 }

  57.                 // 输出容器的容量即为牛的总头数
  58.                 System.out.println(year + "年后总共有【" + cowList.size() + "】头牛");
  59.         }

  61. }
复制代码
作者: HelloWorld_2013    时间: 2013-4-11 23:40
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:09
本帖最后由 艾萱 于 2013-4-12 00:18 编辑
  1. public class CountBulls {
  2.         public static void main(String[] args){
  3.                 System.out.println(coutChildren(10) + 1);//孩子有了，加上孩子妈
  4.         }
  5.         /**
  6.          * 计算经过 指定年数后 的孩子总数
  7.          * @param num 指定年数
  8.          */
  9.         public static int coutChildren(int num){
  10.                 int count = 0;
  11.                 //每过三年才会有新的小牛 第一次生小牛，在计算小牛的孩子后，看看它的孩子有没有生小牛
  12.                 //函数调用自己无限深入下一代去检查，直到下一代还没有到生小牛的年纪
  13.                 if(num >= 3)
  14.                         count = (num + 1 - 3) + coutChildren(num - 3);
  15.                 return count;
  16.         }
  17. }
复制代码
作者: 孙百鑫    时间: 2013-4-12 01:27
  1. /*
  2. 题目描述：
  3. 一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，
  4. 又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
  5. */
  6. /*
  7. 思路.
  8. 1.定义一个变量来存贮一共牛的数量 num
  9. 2.因为牛生牛,每次间隔都会有三年.所以在定义一个变量num1
  10. 3.遍历牛.年份减去3就是第一头牛所生的所以小牛.然后小牛生小牛,又是三年后的事.所以用第一批牛的总数减3来当第三批牛的"年"
  11. */

  13. class Demo
  14. {
  15.         public static void main(String[] args)
  16.         {
  17.                 //定义一个cattle函数.往里面扔"年",返回多少牛
  18.                 int n=cattle(9);
  19.                 System.out.println(n);//打印牛
  20.         }
  21.         public static int cattle(int i)
  22.         {       
  23.                 /*
  24.                 定义两个变量,一个为牛的总数.另一个为下批牛的变量
  25.                 */
  26.                 int num1=0;
  27.                 int num=1;
  28.                 for(int x=0;x<=i-3;x++)
  29.                 {
  30.                         num++;
  31.                         if(num==i-3)//当牛的总数加到年减三的时候.就赋值给下批牛的变量.
  32.                         {
  33.                                 num1=num;
  34.                                 num=num+cattle(num1);//使用递归
  35.                         }
  36.                 }               
  37.                 return num;
  38.         }
  39. }
  40. /*
  41. ps:版主出的题目也太绕人了吧....我足足研究了两个小时....主要是考数学啊!!!!
  42. 应该是对的了.....如果哪里不对还请帮忙给我通通哈...谢谢啦.
  43. */
复制代码

未命名.jpg (67.94 KB, 下载次数: 6)

未命名.jpg
作者: Sword    时间: 2013-4-12 16:21
  1. 1递归(结果为28，如果要算n年后的结果，只需将10改为n)：

  3. public class Cow {
  4.         static int count = 1;
  5.         private static void feedCow(int year,int age){
  6.                 year++;
  7.                 age++;
  8.                 if(year<=30){
  9.                         if(age>=3){
  10.                                 count++;
  11.                                 feedCow(year,0);
  12.                         }
  13.                         feedCow(year,age);
  14.                 }
  15.         }

  17.         public static void main(String[] args) {
  18.                 new Cow().feedCow(0, 0);
  19.                 System.out.println(count);
  20.         }
  21. }
复制代码
2.面向对象（很经典的思路，结果当然是28，要求n年后，只需将i<10改为i< p>
  1. public class Cow {
  2.         public static int count = 0;
  3.         public Cow(int year){
  4.                 count++;
  5.                 for(int i=3+year;i<=10;i++){
  6.                         new Cow(i);
  7.                 }
  8.         }

  10.         public static void main(String[] args) {
  11.                 new Cow(0);
  12.                 System.out.println(count);
  13.         }
  14. }
复制代码
30年后居然可以生出58425头牛…
作者: ゞSunペ果果つ    时间: 2013-4-12 19:14
  1. public class Test
  2. {       
  3.         private static  int COUNT=1;

  5.         public static void main(String a[]){
  6.         calve(10);
  7.         outSum();
  8.         }

  10.         public static void calve(int n){
  11.                 for(int i=1;i<=n;i++){
  12.                         if(i>3){
  13.                                 COUNT++;
  14.                                 calve(n-i);
  15.                         }
  16.                 }
  17.         }

  19.         public static void outSum(){
  20.                 System.out.println("牛的头数为："+COUNT);
  21.         }

  23. }
复制代码
因为版主说3年后，我就从第四年开始算的。没有包括第三年。楼主辛苦了
作者: 艾萱    时间: 2013-4-12 22:34
发现不对，换了一种思路，再来一次
  1. public class CountBulls {
  2.         public static void main(String[] args){               
  3.                 new CountBulls(0);//调用构造函数传入一个0
  4.                 System.out.println("10年后一共有： " + count + "头牛");//输出最后牛的总数
  5.         }
  6.                
  7.         public static int count = 0;//定义一头牛初始为0，static修饰为了主函数调用方便
  8.         public CountBulls(int year){
  9.                 count++;//累加牛的数量
  10.                 //每过三年才会有新的小牛 第一次生小牛，一共10年
  11.                 for(int i=3+year;i<=10;i++){
  12.                         new CountBulls(i);//函数调用自己无限深入下一代去检查，直到下一代还没有到生小牛的年纪
  13.                 }
  14.         }
  15. }
复制代码
作者: wlt    时间: 2013-4-12 22:47
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 08:50
本帖最后由 燕国庆 于 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:37
本帖最后由 杜鹏飞 于 2013-4-13 18:38 编辑

推导了一个公式,目前尚未发现其他人用此方法.
  1. import java.util.*;
  2.         
  3. public class first {
  4.         private static Scanner in;
  5.         public static void main(String[] args){

  7.                 in = new Scanner(System.in);
  8.                 int N = in.nextInt();//取年数

  10.                 int[] f = new int[]{1,1,1,0};
  11.                
  12.                 for(int n=4;n<=N+1;n++){
  13.                         f[3]=f[0]+f[2];
  14.                         f[0]=f[1];
  15.                         f[1]=f[2];
  16.                         f[2]=f[3];
  17.                 }
  18.                
  19.                 System.out.println(f[3]);//输出答案
  20.         }
  21. }
复制代码
作者: 段旭东    时间: 2013-4-14 01:08
  1. import java.util.ArrayList;
  2. import java.util.List;


  5. public class Cattle {

  7.         //小牛的年龄
  8.         int age=0;
  9.         //是否能生小牛
  10.         public boolean isproduce(){
  11.                 if(age>=3){
  12.                         return true;
  13.                 }else{
  14.                         return false;
  15.                 }
  16.         }
  17.         //生出来的小牛三年后才能再生产，那么age每次加++
  18.         public void addYear(){
  19.                 age++;
  20.         }
  21.         public static void main(String[] args){
  22.                 //一共几年
  23.                 int year=10;
  24.                   List catList = new ArrayList();
  25.                    //农夫的第一头母牛
  26.                   catList.add(new Cattle());
  27.                    //开始计算
  28.                    for(int i=1;i<=year;i++){
  29.                     int calf = catList.size();
  30.                     for(int j = 0; j<calf; j++){
  31.                             Cattle cattle = (Cattle) catList.get(j);
  32.                      //计算年龄 ++一次
  33.                             cattle.addYear();
  34.                      //判断一下是否到了三年能下崽了
  35.                      if(cattle.isproduce()){
  36.                       catList.add(new Cattle());
  37.                      }
  38.                     }
  39.                    }
  40.                    System.out.println("农夫"+year+"年后将有"+catList.size()+"头牛。");
  41.                 }
  42.         }
复制代码
作者: 沈浩    时间: 2013-4-14 05:24
import java.util.*;
/*
通过分析得到每头牛每年长一岁又要判断是否能生小牛
我们可以采取面相对象的思想把牛看成对象
那么就想到用集合来操作此对象
最后得到如下代码
*/
class Cow
{       
        int  age=0;
}
class CowDemo
{
        public static void main(String[] args)
        {
                //把牛看成一个对象那么首先建立一个容器存储对象
                ArrayList<Cow> list = new ArrayList<Cow>();
                //最开始有一头牛那么先存一个牛对象到容器
                list.add(new Cow());
                //每增加一年牛的年龄也长一岁那么就要遍历所有的牛对象给它增长年龄而且还要判断是否能生小牛所以在这里用到for循环嵌套
                for (int year=1;year<=10 ;year++ )
                {       
                        //当生一个小牛后就把它存进集合容器那么容器的元素数就是牛的个数
                        int cowNumber = list.size();
                        for (int x=0;x<cowNumber ;x++ )
                        {
                                //根据索引遍历集合
                                Cow c = list.get(x);
                                //过一年牛长一岁
                                c.age= c.age+1;
                                //判断哪些牛能生小牛生一个往容器内存一个
                                if(c.age>=3)
                                        list.add(new Cow());
                        }
                }
                System.out.println("十年后将有【"+list.size()+"】头牛");
        }
}
作者: 黑马-陈思源    时间: 2013-4-14 10:22
本帖最后由 黑马-陈思源 于 2013-4-14 10:25 编辑

都以图片形式保存。
作者: 通行天下    时间: 2013-4-14 22:28
本帖最后由 通行天下 于 2013-4-14 22:37 编辑
  1. /*

  3. 题目：一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?

  5. (不考虑其他因素，只考虑此数学问题)


  8. */


  11. import java.util.Scanner;

  13. class TestSum
  14. {

  16.         public static void main(String[] args)
  17.         {   

  19.                 Scanner in = new Scanner(System.in);


  22.                 //向系统中输入任意一个年数，并赋值给变量n

  24.                 System.out.println("请输入一个年数:");

  26.                 int n = in.nextInt();


  29.                 //打印输入的年数所对应的牛的总头数

  31.                 System.out.println("到第"+n+"年，总共有牛"+getSum(n)+"头");

  33.         }


  36.         //此方法用来计算所输入年数的总的牛头数

  38.         public static int getSum(int year)

  40.         {

  42.                 //当输入的年数小于零时，返回-1，表示输入有误。

  44.                 if(year<0)

  46.                 {

  48.                         System.out.println("输入的数据不符合要求！");

  50.                         return -1;

  52.                 }


  55.                 //当输入的年数小于或者等于2时，返回1.因为又题意可知，三年以后，才会有新的牛出生；因此，此时牛的总头数为1.

  57.                 else if(year<3)

  59.                         return 1;

  61.                 //下面是年数大于2的情况

  63.                 else
  64.                 {

  66.                         //最开始时，有一头牛，所以总数sum初始化为1

  68.                         int sum = 1;


  71.                         //定义一个数组来存放每一年新出生的牛，因为从第3年开始才有新牛出生，所以此数组中存储的第一个元素是从第3年开始的，

  73.                         //也即数组的长度为year-2（因为数组角标是从0开始的）。

  75.                         int[] arr = new int[year-2];

  77.                         for(int i=0;i<arr.length;i++)

  79.                         {

  81.                                 //因为是每一头牛都在三年后生产一头小牛，并且以后此牛会每一年生一头小牛；故从第3年起，

  83.                                 //每一年出生的小牛数都等于上一年出生的小牛数加上三年前的那一年出生的小牛数

  85.                                 //(如：第七年出生的小牛数=第六年出生的小牛数+第四年出生的小牛数).这一步很关键！！！

  87.                                 if(i>=3)

  89.                                         arr[i] = arr[i-1]+ arr[i-3];


  92.                                 //当年数为3、4、5时，每年只有一头牛出生

  94.                                 else

  96.                                         arr[i]= 1;

  98.                                 //将每一年的牛数叠加起来

  100.                                 sum += arr[i];


  103.                         }

  105.                
  106.                         //返回输入年数所对应的总牛数

  108.                         return sum;

  110.                 }

  112.         }

  114. }

  116. 楼主，麻烦看一下我的对吗？我这也是第10年为28头牛，先谢谢啦！！
复制代码
作者: 邵彩华    时间: 2013-4-15 09:05
邵彩华 发表于 2013-4-10 08:31
此题，我暂只能提供两种计算方法，大同小异，方法一用的是循环，方法二用的是Math类的数学方法。能力有限， ...

谢谢阳哥！ 汗~看错题意了 这两份纯属恩惠啊
作者: 李罡    时间: 2013-4-15 10:11
技术分终于够了，谢谢楼主！！
作者: 董延京    时间: 2013-4-15 10:12
董延京 发表于 2013-4-10 12:56

这个题大一第一次学编程的示例，先入为主的用了这个方法，没有考虑面向对象的设计。答案的错误是因为，我假设第一头是在第一年才有，第四年才能生小牛。所以，我的第十年，就比别人少了一年。将第一个判断改为（i<3）或者计算第十一年的牛数目，就是正确答案：28
作者: 通行天下    时间: 2013-4-15 10:33
通行天下 发表于 2013-4-14 22:28

太谢谢你啦！问一下，啥时候才出题啦？
作者: 张龙欢    时间: 2013-5-2 00:46
题目在哪啊？
作者: 孙清福    时间: 2013-5-7 22:00
呵呵！他们写的代码我能看懂了
作者: shenshuangxi    时间: 2015-1-17 15:21
/**
*需求:一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，
*又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
*
* 思路:由题可知分析，第一年，1 一头牛产子第二年1 一头牛产子 第3年为2，两头牛头牛产子
*     由此可知牛的数量是由两个方面决定牛的年龄，牛的原有数量，年数
*     所以可以用一个Map集合，键为牛的名字，值为牛的年龄，遍历判断牛的年龄，判断产子，判读总数
*     
* 步骤：1，建立map集合，新建一个函数用于添加牛的属性，判断产子与否，产子往map集合中添加
*
* */

public class Answer {

        public static void main(String[] args) {
                // TODO Auto-generated method stub
//                定义一集合用于装载所有牛
                Map<String,Integer> cowGate = new TreeMap();
//                放入一条种牛
                cowGate.put("cow1", 1);
               
                int totalYear = 6;
//                在一定年数后得到的牛的数量
                getCowsNumber(totalYear,cowGate);
//                判断牛的数量
                if(cowGate.size()<1){
                        System.out.println("no cow ,how to get cow,my gold?");
                        return;
                }
//                打印输出
                System.out.println(cowGate.size());
                Set<Map.Entry<String, Integer>> cowSet = cowGate.entrySet();
                Iterator<Entry<String, Integer>> it = cowSet.iterator();
                while(it.hasNext()){
                        Entry<String, Integer> entry = it.next();
                        System.out.println(entry.getKey()+" : "+entry.getValue());
                }
               
        }
       
       
        /**
         * descriptor:得到一年后牛的数量
         *
         * @param  
         *                   totalYear          years later to get the cows number
         *        cowGate                  a cow gate to capacity all cow
         *         
         *
         * */
        private static void getCowsNumber(int totalYear,
                        Map<String, Integer> cowGate) {
                // TODO Auto-generated method stub
//                判断牛的数量
                if(cowGate.size()<1){
                        System.out.println("no cow ,how to get cow,my gold?");
                        return;
                }
                int i = 1;
                while(i<=totalYear){
                        i++;
//                        一年后牛的数量
                        cowOfYear(cowGate);
                       
                }
        }

        /**
         * descriptor:得到一年后牛的数量
         *
         * @param  
         *        cowGate  a cow gate to capacity all cow
         *         
         *
         * */
        private static void cowOfYear(Map<String, Integer> cowGate) {
                // TODO Auto-generated method stub
//                用一个新的牛栏装原来的牛，不然迭代就会报异常
                Map<String,Integer> newCowGate =  new TreeMap(cowGate);
                Set<Map.Entry<String, Integer>> newCowSet = newCowGate.entrySet();
                Iterator<Entry<String, Integer>> itNewCowSet = newCowSet.iterator();
                while(itNewCowSet.hasNext()){
                        while(itNewCowSet.hasNext()){
                                Entry<String, Integer> entryNewCowSet = itNewCowSet.next();
//                                判断牛的年龄是否超过3岁，超过牛栏加一条新生牛
                                if(entryNewCowSet.getValue()>=3){
                                        int newCowNum = cowGate.size()+1;
                                        cowGate.put("cow"+newCowNum, 1);
                                }
//                                牛的年龄加一岁
                                cowGate.replace(entryNewCowSet.getKey(), entryNewCowSet.getValue()+1);
                        }
                }
        }

}
作者: 骷髅王子    时间: 2016-3-7 21:12
强大的代码就需要严谨，各位大神好厉害



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2