A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 田磊阳   /  2013-4-9 23:41  /  8673 人查看  /  90 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 杜鹏飞 于 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){

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

  8.                 int[] f = new int[]{1,1,1,0};
  9.                
  10.                 for(int n=4;n<=N+1;n++){
  11.                         f[3]=f[0]+f[2];
  12.                         f[0]=f[1];
  13.                         f[1]=f[2];
  14.                         f[2]=f[3];
  15.                 }
  16.                
  17.                 System.out.println(f[3]);//输出答案
  18.         }
  19. }
复制代码

点评

如果采用面向对象的方法会更好  发表于 2013-4-14 19:43

评分

参与人数 1技术分 +2 收起 理由
田磊阳 + 2

查看全部评分

回复 使用道具 举报
  1. import java.util.ArrayList;
  2. import java.util.List;


  3. public class Cattle {

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

评分

参与人数 1技术分 +3 收起 理由
田磊阳 + 3

查看全部评分

回复 使用道具 举报
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 19:41

评分

参与人数 1技术分 +3 收起 理由
田磊阳 + 3

查看全部评分

回复 使用道具 举报
本帖最后由 黑马-陈思源 于 2013-4-14 10:25 编辑

都以图片形式保存。

评分

参与人数 1技术分 +1 收起 理由
田磊阳 + 1 将代码写出最好

查看全部评分

回复 使用道具 举报
本帖最后由 通行天下 于 2013-4-14 22:37 编辑
  1. /*

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

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


  4. */


  5. import java.util.Scanner;

  6. class TestSum
  7. {

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

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


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

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

  13.                 int n = in.nextInt();


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

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

  16.         }


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

  18.         public static int getSum(int year)

  19.         {

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

  21.                 if(year<0)

  22.                 {

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

  24.                         return -1;

  25.                 }


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

  27.                 else if(year<3)

  28.                         return 1;

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

  30.                 else
  31.                 {

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

  33.                         int sum = 1;


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

  35.                         //也即数组的长度为year-2(因为数组角标是从0开始的)。

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

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

  38.                         {

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

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

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

  42.                                 if(i>=3)

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


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

  45.                                 else

  46.                                         arr[i]= 1;

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

  48.                                 sum += arr[i];


  49.                         }

  50.                
  51.                         //返回输入年数所对应的总牛数

  52.                         return sum;

  53.                 }

  54.         }

  55. }

  56. 楼主,麻烦看一下我的对吗?我这也是第10年为28头牛,先谢谢啦!!
复制代码

点评

正确,但是你这是在活动之后发布的答案,只能给你2分了····不要介意啊  发表于 2013-4-15 10:22

评分

参与人数 1技术分 +2 收起 理由
田磊阳 + 2

查看全部评分

回复 使用道具 举报
邵彩华 发表于 2013-4-10 08:31
此题,我暂只能提供两种计算方法,大同小异,方法一用的是循环,方法二用的是Math类的数学方法。能力有限, ...

谢谢阳哥! 汗~看错题意了 这两份纯属恩惠啊
回复 使用道具 举报
技术分终于够了,谢谢楼主!!
回复 使用道具 举报
董延京 发表于 2013-4-10 12:56

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

太谢谢你啦!问一下,啥时候才出题啦?
回复 使用道具 举报
题目在哪啊?
回复 使用道具 举报
呵呵!他们写的代码我能看懂了
回复 使用道具 举报
/**
*需求:一个农夫养了一头牛,三年后,这头牛每一年会生出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);
                        }
                }
        }

}
回复 使用道具 举报
强大的代码就需要严谨,各位大神好厉害
回复 使用道具 举报
12345
您需要登录后才可以回帖 登录 | 加入黑马