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

任雷彬 · 任雷彬

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

王怀亮 · 王怀亮

农夫10年后有28头牛

package com.itheima;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* 问题：一个农夫养了一头牛，三年后，这头牛每年会生出一头牛，生出来的牛三年后又可以内年生出一头牛....问农夫10年后有多少头牛，n年呢？
*
* @author liang
*/
public class Cow {// 定义牛类
private int age = 0;// 定义牛的初始年龄
// 记录牛的年龄，每过一年，牛的年龄加1
public void addAge() {
age++;
}
// 判断是否到了生育年龄
public boolean isCreatCow() {
return (age >= 3) ? true : false;
}
public static void main(String[] args) {
List<Cow> cowList = new ArrayList<Cow>();
// 农夫原有的第一头牛
cowList.add(new Cow());
int yearCount;// 年份
// 提示用户输入年份
Scanner scanner = new Scanner(System.in);
System.out.print("请您输入牛生长了多少年,输入后按回车可看到牛的数量奥：\n");
yearCount = scanner.nextInt();// 输入年份
for (int i = 1; i <= yearCount; i++) {// 根据输入的年份对牛进行循环计算，每过一年，牛的年龄都增加一岁
int cowNum = cowList.size();// list中有多少行数据，就有几头牛，定义变量，取得list中的行数，即牛的数量
for (int j = 0; j < cowNum; j++) {
Cow o = cowList.get(j);// 取出要进行生育的牛
// 每重复取到一头牛时，都意味着根据年份进行了一次新的循环，也就是又过了一年，所以每次新取出一头牛进行生育判断时，都要将这头牛的年龄加1
o.addAge();
// 对牛进行生育判断
if (o.isCreatCow()) {
// 如果这头牛到了生育年龄，就让牛生小牛
cowList.add(new Cow());
}
}
}
System.out.println(yearCount + "年后将有<--" + cowList.size() + "-->头牛。");
}
}

复制代码

王怀亮 · 王怀亮

答：农夫十年后将有28头牛

package com.itheima;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* 问题：一个农夫养了一头牛，三年后，这头牛每年会生出一头牛，生出来的牛三年后又可以内年生出一头牛....问农夫10年后有多少头牛，n年呢？
*
* @author liang
*/
public class Cow {// 定义牛类
private int age = 0;// 定义牛的初始年龄
// 记录牛的年龄，每过一年，牛的年龄加1
public void addAge() {
age++;
}
// 判断是否到了生育年龄
public boolean isCreatCow() {
return (age >= 3) ? true : false;
}
public static void main(String[] args) {
List<Cow> cowList = new ArrayList<Cow>();
// 农夫原有的第一头牛
cowList.add(new Cow());
int yearCount;// 年份
// 提示用户输入年份
Scanner scanner = new Scanner(System.in);
System.out.print("请您输入牛生长了多少年,输入后按回车可看到牛的数量奥：\n");
yearCount = scanner.nextInt();// 输入年份
for (int i = 1; i <= yearCount; i++) {// 根据输入的年份对牛进行循环计算，每过一年，牛的年龄都增加一岁
int cowNum = cowList.size();// list中有多少行数据，就有几头牛，定义变量，取得list中的行数，即牛的数量
for (int j = 0; j < cowNum; j++) {
Cow o = cowList.get(j);// 取出要进行生育的牛
// 每重复取到一头牛时，都意味着根据年份进行了一次新的循环，也就是又过了一年，所以每次新取出一头牛进行生育判断时，都要将这头牛的年龄加1
o.addAge();
// 对牛进行生育判断
if (o.isCreatCow()) {
// 如果这头牛到了生育年龄，就让牛生小牛
cowList.add(new Cow());
}
}
}
System.out.println(yearCount + "年后将有<--" + cowList.size() + "-->头牛。");
}
}

复制代码

董延京 · 董延京

本帖最后由董延京于 2013-4-10 15:37 编辑

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

复制代码

将臣 · 将臣

本帖最后由将臣于 2013-4-10 14:29 编辑

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

复制代码

郭利超 · 郭利超

package demo;
import java.util.ArrayList;
import java.util.List;
/**
* @author 郭利超
*
*/
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()+"】头牛。");
}
}

复制代码

10年后28头 N年后int yearCount = 10; 10改成N

HM刘俊 · HM刘俊

// 程序分析：牛的头数规律为1,1,2,3,5,8,13,21......
public class niu{
public static void main(String args[]){
int n=0;
math mymath = new math();//创建一个math实例对象
System.out.println(mymath.f(n)); // 输出n年后的牛的头数，当n输入10.时，计算结果为55.
}
}
class math
{
public int f(int x)
{
if(x==1 || x==2) //如果这头牛是出生的第一或第二年，
return 1; //那么就返回牛数为1
else
return f(x-1)+f(x-2); 否则返回三年或以上的牛的头数
}
}

复制代码

王薪婷 · 王薪婷

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

吴林飞 · 吴林飞

/*
一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，
又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
*/
public class Cow
{
static int count = 1;
static int n = 10;
private static void getCow(int year,int age)
{
year++;
age++;
if(year<=n)
{
if(age>=3)
{
//当牛的年龄达到3岁，则计数一次，代表一个小牛诞生。
count++;
//一个小牛诞生后，还会按照老牛的规律，三年后每年诞生一个新崽，所以还需要调用原来的方法
getCow(year,0);
}
getCow(year,age);
}
}
public static void main(String[] args)
{
new Cow().getCow(0, 0);
System.out.println(count);
}
}

复制代码

曹春贵 · 曹春贵

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
class Cattle {
private int year;// 年龄
private String name;// 姓名
private Cattle parentsCattle;// 生它的牛,牛对象Cattle
private List<Cattle> childCattle = new ArrayList<Cattle>();// 它生的牛,牛集合List<Cattle>
private int totalChildNumber;// 一共有多少个子女，子女数加上所有子女的子女数
private int birthYear;// 出生年龄
public Cattle() {
this.year = 1;// 初始化时牛年龄为1
this.birthYear = 1;
}
private void getChild(Cattle cattle) {
if (cattle.getYear() > 3) {// 年龄大于3则生牛
int year = cattle.getBirthYear() + 3;
for (int i = cattle.getYear() - 3; i > 0; i--) {// 年龄大于3每年生一个牛，i设置递减形式，最大值i则是生的第一个牛的年龄，以此类推。
Cattle c = new Cattle();// 实例化第一个子牛
c.parentsCattle = cattle;// 设置生它的牛对象
c.setName(cattle.getName() + "~"
+ (cattle.childCattle.size() + 1));// 设置子牛的名字：父母牛的名字+第几个子女
c.setBirthYear(year++);// 设置第几年出生
c.setYear(i);// 设置子牛的年龄，按照年龄让它生牛，这里核心思想就是递归调用
c.setTotalChildNumber();// 设置子牛的子女数目
cattle.childCattle.add(c);// 将子牛添加到集合
}
}
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
getChild(this);// 执行生牛的方法
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Cattle getParentsCattle() {
return parentsCattle;
}
public void setParentsCattle(Cattle parentsCattle) {
this.parentsCattle = parentsCattle;
}
public List<Cattle> getChildCattle() {
return childCattle;
}
public void setChildCattle(List<Cattle> childCattle) {
this.childCattle = childCattle;
}
public void setTotalChildNumber() {
for (Cattle c : childCattle) {// 遍历它子女集合，将它每个子女的子女数相加
this.totalChildNumber += c.getTotalChildNumber();
}
this.totalChildNumber += childCattle.size();// 累加上它的子女数，totalChildNumber此时代表子女数加上所有子女的子女数
}
public int getTotalChildNumber() {
return totalChildNumber;
}
public int getBirthYear() {
return birthYear;
}
public void setBirthYear(int birthYear) {
this.birthYear = birthYear;
}
}
public class CattleTest {
public static void main(String[] args) {
System.out.println("请输入年数：");
Scanner sc = new Scanner(System.in);
int year = sc.nextInt();
int number = getTotalNumber(year);// 根据年数获得总牛数
System.out.println(year + "年后，一共有" + number + "头牛");
}
public static int getTotalNumber(int year) {// 根据传递的参数year，返回总牛数
Cattle cattle = new Cattle();
cattle.setName("牛牛");
cattle.setYear(year);// 设置年龄的时候执行了生牛方法
cattle.setTotalChildNumber();
printTotalNumber(cattle, 0);// 递归调用输出关系图
return cattle.getTotalChildNumber() + 1;
}
public static void printTotalNumber(Cattle cattle, int livel) {// livel为目录级数
StringBuilder sb = new StringBuilder("");
for (int i = 0; i < livel; i++) {// 目录级数的前缀
sb.append("| ");
}
System.out.println(sb.toString() + "|-" + cattle.getName() + "(第"
+ cattle.getBirthYear() + "年出生)");
for (Cattle c : cattle.getChildCattle()) {
printTotalNumber(c, livel + 1);
}
}
}

复制代码

陈培茹 · 陈培茹

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()+"】头牛。");
}
}

肖明凯 · 肖明凯

/* 一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……
* 问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
*
* 思路：构建牛类，通过容器装载牛实例，遍历容器，判断是否可生育，添加牛实例，容器size即为牛的总数。
*/
import java.util.ArrayList;
//牛类
class Cow
{
//牛的年龄
private int age;
public Cow(int age)
{
this.age = age;
}
//判断是否可生育，如果年龄不小于三，则为可生育的。
public boolean isFertile()
{
if (age>=3)
return true;
else
return false;
}
//年龄增长
public void grow()
{
age++;
}
}
public class Test
{
public static void main(String[] args)
{
//要计算n年后的牛总数，将10替换即可
getCows(10);
}
public static void getCows(int years)
{
//创建容器，存放Cow实例
ArrayList<Cow> al = new ArrayList<Cow>();
//存入第一只牛
al.add(new Cow(0));
for (int i=1; i<=years ; i++ )
{
//可生育牛的个数
int fertileSum = 0;
//遍历容器
for(int j=0; j<al.size(); j++)
{
Cow c = (Cow)al.get(j);
//牛年龄增加，后替换容器里的实例
c.grow();
al.set(j, c);
//判断是否可生育，记录可生育牛的总数
if (c.isFertile())
{
fertileSum++;
}
}
//new牛，并加到容器中，牛的初始年龄为0
for (int k=1; k<=fertileSum ; k++ )
{
al.add(new Cow(0));
}
//打印
System.out.println("第"+i+"年牛的总数为："+al.size());
}
}
}
/*
输出：
第1年牛的总数为：1
第2年牛的总数为：1
第3年牛的总数为：2
第4年牛的总数为：3
第5年牛的总数为：4
第6年牛的总数为：6
第7年牛的总数为：9
第8年牛的总数为：13
第9年牛的总数为：19
第10年牛的总数为：28
*/

复制代码

罗海云 · 罗海云

呵呵呵

谢达 · 谢达

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

飞天小猪猪 · 飞天小猪猪

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

}

刘国强 · 刘国强

答案为28具体计算代码带啊如下

package com.zknu.test;
public class Cow {
public static void main(String[] args) {
//创建一个牛对象，初始年龄为0
new Cow(0);
//输出打印出10年后的总牛数
System.out.println(count);
}
//创建一个int类型的变量，用于存放牛的总数，初始值为0
public static int count = 0;
//对出生的牛进行处理
public Cow(int year){
count++;
//如果牛的年龄大于等于3,则每年年都产生一头新的牛
for(int i=3+year;i<=10;i++){
new Cow(i);
}
}
}

复制代码

石琪 · 石琪

/*
一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，
又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢?
分析：
列出牛在每年的头数：1，1，2，3，5，8，13，21。。。发现从第三年开始当年牛数是前两年之和。
*/
import java.lang.*;
import java.io.*;
public class shuniu {
public static void main(String[] args)throws IOException
{
long t=1;//当年牛数
int y=1;//当年时间，起始为第一年
long f=1;//第一年牛数
long s=1;//第二年牛数
int ty=7;//总年份
sop("请输入总年份");
InputStream in=System.in;
StringBuilder sb=new StringBuilder();
while(true)
{
int ch=in.read();
if(ch=='\r')
continue;
if(ch=='\n')
break;
sb.append((char)ch);
}
ty=Integer.parseInt(sb.toString());
while(y<=ty-2)
{
if(ty==1||ty==2)//如果是第一年或第二年直接返回一头牛
{
s=1;
break;
}
t=f+s;//当年牛数=第一年+第二年
f=s;
s=t;
y++;
}
sop(t);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

复制代码

xyh19 · xyh19

本帖最后由徐彦淏于 2013-4-11 11:55 编辑

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

栗俊植 · 栗俊植

/*
需求:求牛在某个月的数目!
分析: 月数目
1 1
2 1
3 2
4 3
5 5
6 8
7 13
... ...
由上可以看出x月的数目是(x-1)月加上(x-2)月牛的数目
.......
*/
import java.util.*; //导入包
class CattleDemo {
public static void main(String[] args) {
Scanner cn=new Scanner(System.in); //创建Scanner的对象 cn
System.out.print("请输入要计算的月数:");
int m =cn.nextInt(); // 定义一个变量 m 调用nexInt()方法实现可以在Dos窗口中键盘输入我们要查询的月份
int i=1; //定义一个变量 i 表示表示第几个月
int[] arr=new int [m+1]; //创建一个数组因为我们要查询的是m月所以用m+1个数组元素就可以装下m个月的数
for(i=1;i<m+1;i++) {
if(i==1|i==2)
arr[1]=arr[2]=1;
else
arr[i]=arr[i-2]+arr[i-1];
}
System.out.println("第" + m +"月的牛数目为:" + arr[m]);
}
}

复制代码

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

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

评分

评分

点评

点评

评分

点评

评分

评分

评分

评分

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

评分

评分

评分

评分

点评

评分

评分

点评

评分

评分

点评

评分

点评

评分

评分

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

点评

评分

黑马骑士勋章