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

Asan · Asan

package cn.learn.test;
public class Test {
public static int count = 0; // 初始化牛开始为0头
public static int n = 10; // 初始化一共多少年，可以写的深一点可以写成用户输入年数
// 构造方法
public Test(int year) {
// 每调用一次构造方法，牛的数量 +1;
count++;
// 每四年调用一次Test()方法
for (int i = 3 + year; i <= n; i++) {
new Test(i);
}
}
public static void main(String[] args) {
// 调用构造方法并初始化从0开始
new Test(0);
// 打印 n+" 年之后一共有 "+count+" 头牛"
System.out.println(n + " 年之后一共有 " + count + " 头牛");
}
}

复制代码

杨成 · 杨成

import java.util.Scanner;//引入扫描类
class Cow
{
public static int count=0;//全局共享计数变量
public Cow(int year,int m)//year:当前年数 m:要计算的截止年数
{
count++;//+1头
for(int i=3+year;i<=m;i++)
{
new Cow(i,m);//递归创建牛对象
}
}
public static void main(String[] args)
{
System.out.println("一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，"+
"生出来的牛三年后，又可以每年生出一头牛……"+"\n要计算n年后有多少头，");
int temp=0;
while(temp>=0)//循环输入，当输入-1时跳出输入循环
{
System.out.println("请输入数字按（enter结束输入），当输入-1的时候退出程序：");
temp=new Scanner(System.in).nextInt();/*用输入对象System.in初始化创建扫描类对象，并调用
该对象读取方法读取扫描流的一个数据存入截止年份变量temp中
*/
if(temp==-1)//当输入-1的时候跳出输入循环的判断
break;
new Cow(0,temp);//创建一头牛对象，初始年份为0，计算截止年份为temp
System.out.println(temp+"年后共有"+count+"头牛");
count=0;//计数清0
}
System.out.println("谢谢使用，再见！");
}
}

复制代码

余善航 · 余善航

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])+"头牛");
}
}
}

曹宇 · 曹宇

/*
一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
*/
import java.util.*;
class Run
{
public static int year=0; //定义静态数据,年,被所有人共享.
public static void main(String[] args)
{
final int N=10; // 设定N年后计算牛数量.
ArrayList<Niu> al = new ArrayList<Niu>();//用ArrayList容器存放出生的牛,泛型数据为Niu类.
al.add(new Niu(year,al)); //第一头牛存入ArrayList.
for(;year<=N;) //创建循环.
{
int x; //创建一个计数器.
for(x=0;x<al.size();x++) //遍历容器.
{
Niu niu = al.get(x); //创建一个牛类引用接受遍历对象.
niu.shengNiu(); //遍历调用牛类中生牛方法.
}
year++; //本年结束,下一年开始.
/*先计算当前年下,遍历所有牛,有资格生牛的(年龄大于等于3岁),就会生牛,全部遍历完
成后再开始新一年.
*/
}
System.out.println(N+"年后有牛"+al.size()+"只");
}
}
class Niu
{
private int age; //新生小牛年龄.
private int date; //新生小牛出生的年.
private ArrayList al; //创建ArrayList 类型引用型变量.
Niu(int year,ArrayList al)//构造函数.
{
date=year; //当前年赋给出生年.
this.al=al;
}
public void shengNiu() //生娃方法.
{
age=Run.year-date; //计算牛的年龄.当前年减去出生年.
if (age>=3)
{
al.add(new Niu(Run.year,al));
/*
哈哈3岁了可以生娃了.创建一个新的Niu类对象生娃存入容器中.
*/
}
}
}

复制代码

黄小贝 · 黄小贝

斑竹威武，这个处理的办法的确很强大，防止了灌水以及抄袭的现象，而且为了不让大家能在网上找到答案，还修改了题目，虽然改的有点吊炸天，一头牛三年后怎么生的，他自交了？

import java.util.ArrayList;
import java.util.List;
public class Cattle {
private int age = 0;
/**
* 一年之后发生的事情,首先牛的age肯定是要加 1 ，如果牛满 3岁，需要往牛棚里面再加一头新牛
* @param cattles 牛棚，存放所有牛的List
* @return 变化后的牛棚
*/
public List<Cattle> oneYearLater(List<Cattle> cattles){
this.age++;
if(age >= 3){
cattles.add(new Cattle());
}
return cattles;
}
public static void main(String[] args) {
List<Cattle> cattles = new ArrayList<Cattle>();//牛棚在此
cattles.add(new Cattle());// 最开始牛棚里面的一头寂寞的牛，由于某种莫名的原因，三年后他靠自己生崽了！自交？
for (int i = 0; i < 10; i++) {//前10年
for (int j = 0; j < cattles.size(); j++) {
cattles = cattles.get(j).oneYearLater(cattles);
}
System.out.println("第一年牛棚里面有 " + cattles.size() + " 头牛");
}
}
}

复制代码

续圆凯 · 续圆凯

import java.util.*;
public class Cow
{
private int age; //定义牛的年龄
public Cow()
{
age = 0; //初始化的时候，牛为0岁
}
public Cow birth()
{
age ++;
return age > 3 ? new Cow():null;//判断：牛的年龄是否>3，如果>3则具备生牛的条件，不具备则不生牛。
}
public static void main(String[] args)
{
ArrayList<Cow> list = new ArrayList<Cow>();//创建一个数组，将该数组视为牛圈。
list.add(new Cow());//往牛圈中放入一头牛
for(int i = 0; i <= 10;i++)//i为年份初始i=0为第一年，i=1的时候为1年后。
{
for(int j =0;j<list.size();j++)//j为每年圈中牛的数量
{
Cow cow = list.get(j).birth();
if(cow != null)
list.add(cow);
}
}
System.out.println("10年后，共有：" + list.size()+"头牛。");
}
}

复制代码

打印结果：10年后，共有28头牛。

如果求n年把for(int i = 0; i <= 10;i++)中的10改成n即可。

李罡 · 李罡

本帖最后由李罡于 2013-4-10 03:22 编辑

第一种方法为：

package cn.itcast.testcow;
/*
* 看到这个题时，第一反应就是用数学来做。
* 第1到10年的牛的数量分别为：1，1，2，3，4，6，9，13，19.。。
* 归纳可以看出，从第4年开始，每年的牛的数量等于上一年的牛的数量加上前3年的牛的数量，即：3=2+1，4=3+1，6=4+2...
* 即cowArr[i]=cowArr[i-1]+cowArr[i-3](i>=3)
* */
class Cow{
public static void main(String[] args)
{
long startTime = System.currentTimeMillis();
//定义一个年数，要得到n年后，则把year设为n即可
int year = 10;
//定义一个数组来存放不同年牛的数量
int[] cowArr = new int[year];
//设置前3年的牛的数量,因为i>=3.
cowArr[0]=cowArr[1]=1;
cowArr[2]=2;
for(int i=3;i<year ;i++){
//每年的牛的数量等于上一年的牛的数量加上前3年的牛的数量
cowArr[i] = cowArr[i-1]+cowArr[i-3];
}
long endTime = System.currentTimeMillis();
//可以取到第1年到第n年任意年的牛的数量，cowArr[x],x<year-1
System.out.println(year+"年后将会有"+cowArr[year-1]+"头牛");
System.out.println("数组方式耗时"+(endTime - startTime)+"毫秒");
}
}
/*
输出为：
10年后将会有28头牛
数组方式耗时0毫秒
*/

复制代码

第二种方法为：

package cn.itcast.testcow;import java.util.ArrayList;
import java.util.List;
/*
* 用面向对象
* */
public class Cow1 {
//牛刚生下来年龄为0~~
private int age=0;
//生个宝宝
public Cow1 creatCow(){
//一年加一岁
age++;
//到3岁了，可以生了
return (age>=3)?new Cow1():null;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
long startTime = System.currentTimeMillis();
//若为n年后则设置为n
int year = 10;
//定义一个集合来存放牛，因为长度是可变的。
List<Cow1> cowList = new ArrayList<Cow1>();
//刚开始有一头牛
cowList.add(new Cow1());
//每年判断一次
for(int i = 1 ;i<=year ;i++){
int number = cowList.size();
if(number!=0){
//把每头牛都取出来看看，若它到3岁了则往集合里增加一头牛
for(int j = 0; j<number ;j++){
Cow1 cow = cowList.get(j);
if(cow.creatCow()!=null)
//增加一头牛
cowList.add(new Cow1());
}
}
}
long endTime = System.currentTimeMillis();
System.out.println(year+"年将会有"+cowList.size()+"头牛");
System.out.println("集合方式耗时"+(endTime - startTime)+"毫秒");
}}
/*
输出为：
10年将会有28头牛
集合方式耗时0毫秒
*/

复制代码

算一算运行时间
设置year为40.
第一种方法：

第二种方法：

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

邵彩华 · 邵彩华

此题，我暂只能提供两种计算方法，大同小异，方法一用的是循环，方法二用的是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);//打印输出结果，输出内容比较人性化哦。
}
}

谢达 · 谢达

看看.....

胡滨 · 胡滨

/*
这道题的原型是斐波那契数列。
斐波那契数列又因数学家列昂纳多·斐波那契以兔子繁殖为例子而引入，故又称为“兔子数列”。
分析：
牛在出生两年后，就有繁殖能力，一头牛每年能生出一头小牛来。如果所有牛都不死，那么一年以后可以繁殖多少头牛？
我们不妨拿新出生的一头小牛分析一下：
第一年小牛没有繁殖能力，所以还是一头
两年后，生下一头小牛总数共有两头
三年以后，老牛又生下一头，因为小牛还没有繁殖能力，所以一共是三头
。。。
*/
public class Fibonacci { //开始构造斐波那契数列
public static void main(String[] args) {
int x = 1, y = 1; //这是初始状态
System.out.println(x);
for (int i = 1; i <= 10; i++) { //这里的10就是十年，想知道n年改数字就行
System.out.println(y); //输出的是第i年的头数
y = x + y;
x = y - x;
}
}
}

复制代码

我手心里的宝 · 我手心里的宝

package com.qdzks.day1;
public class Test1 {
/*
* 题目：一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……
* 问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
* */
}
//1.运用递归的方法做
class Cow1 {
static int count = 1;
private static void feedCow(int year,int age){
year++;
age++;
//(结果为28，如果要算n年后的结果，只需将10改为n)：
if(year<=10){
if(age>=3){
count++;
feedCow(year,0);
}
feedCow(year,age);
}
}
public static void main(String[] args) {
new Cow1().feedCow(0, 0);
System.out.println(count);
}
}
//方法2：面向对象的思路
//结果是28，要求n年后，只需将i<10改为i
class Cow2 {
public static int count = 0;
public Cow2(int year){
count++;
for(int i=3+year;i<=10;i++){
new Cow2(i);
}
}
public static void main(String[] args) {
new Cow2(0);
System.out.println(count);
}
}

复制代码

王军行 · 王军行

class ShuNiu
{
public static void main(String[] args)
{
cowNum(10);
}
public static void cowNum(int N)//传入年数，打印该年有多少头牛
{
if (N==1)
{
System.out.println("第1年的牛数: 1");
return;
}
if (N==2)
{
System.out.println("第2年的牛数: 1");
return;
}
int f1 = 1, f2 = 1, f;
for(int i=3; i<=N; i++)
{
f = f2;
f2 = f1 + f2;
f1 = f;
//这是数学规律的代码实现，用循环来算出第几年的牛数量
//每循环一次，其实就是年数就+1；
}
System.out.println("第" + N +"年的牛数: "+f2);
}
}

复制代码

刘胜寒 · 刘胜寒

本帖最后由刘胜寒于 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比较爽很快。
如果非要用递归建议使用记忆化递归，节省时间

 */
}

张旺达 · 张旺达

//fibonacci数列问题
//递归较耗时，但是本人新手目前只会用递归。。
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
while(sc.hasNext())
{
int n = sc.nextInt();
System.out.println(fibonacci(n));
}
}
public static long fibonacci(int n)
{
if(n<=2)
return 1;
else
return fibonacci(n-1)+fibonacci(n-2);
}
}

复制代码

李永康 · 李永康

具体思路见思路
CODE ：

public class test {
static int count = 1;// 初始牛数
private void Sum(int year, int age) {
year++;//第N年
age++;//年龄
if (year <= 10) {
if (age >= 3) {
count++;
Sum(year, 0);
}
Sum(year, age);
}
}
public static void main(String[] args) {
new test().Sum(0, 0);
System.out.println(count);
}
}

复制代码

黑马王双 · 黑马王双

本帖最后由黑马王双于 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即可。

黄欢 · 黄欢

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:25 编辑

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

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

陈宇鹏 · 陈宇鹏

本帖最后由陈宇鹏于 2013-4-10 12:41 编辑

首先，我象声明一下。以下代码是我从百度上找的
我确确实实不会这题，甚至不知道应该怎么去思考
但是还是来发帖的原因是请求楼主给我一个这道题的思路。
请不要加分，但是麻烦也不要扣分，拜托
希望楼主可以给我指点一下。下面这段代码为什么这么写。每一句的思路是啥。
拜托了
第一个百度上说是递归的

public class Cow {
static int count = 1;
private static void feedCow(int year,int age){
year++;
age++;
if(year<=30){
if(age>=3){
count++;
feedCow(year,0);
}
feedCow(year,age);
}
}
public static void main(String[] args) {
new Cow().feedCow(0, 0);
System.out.println(count);
}
}

复制代码

第二个是面向对象的

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);
}
}

复制代码

拜托拜托，希望楼主能给我讲讲~~~~

最后。。。。请不要加分，拜托也不要扣分

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

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

点评

评分

点评

评分

评分

点评

评分

点评

评分

评分

点评

评分

点评

评分

评分

点评

评分

评分

评分

评分

评分

评分

评分

评分

评分

黑马骑士勋章