蓝兔子编程
判断error的情况有问题。其实这题列出公式就可以解答了：
设x只鸽子，已知兔子，则：
x+y=n;
2x+4y=m;
解得：x=2n-m/2,y=m/2-n。
因为x,y都是非负整数，所以 m/2 必须是一个整数，也就是m必须是偶数。同时：
x=2n-m/2>=0，解得4n>=m;
y=m/2-n>=0,解得m>=2n;
因此 2n<=m<=4n,且m是偶数。这就是判断是否“Error”的条件。
#include <stdio.h>
int main(int argc, char *argv[])
{
unsigned int n,m;
while(scanf("%d%d",&n,&m)&&!(m==0&&n==0))
{
if(m%2!=0 || m<2*n || m>4*n)
printf("Error\n");
else
printf("%d %d\n",(2*n-m/2),(m/2-n));
}
return 0;
}
B. 兔子繁殖问题 C语言编程
根据题意，得出以下结果：
年份：0 0.5 1 1.5 2 2.5 3 3.5 4 ...
兔子：1 1 2 3 5 8 13 21 34...
序号: 0 1 2 3 4 5 6 7 8...
所以发现规律：除前两个外，后面的则是等于前两个的种即：A0=1,A2=1,An=A(n-1)+A(n-2)
这样程序就可以开始编制了
#include "stdio.h"
main()
{
int year,total,i,a1,a2;
printf("\n请输入多少年后：");
scanf("%d",&year);
a1=1;
a2=1;
for(i=2;i<2*year;i++)
{
if(i%2==1)
{
a1=a1+a2;
total=a1;
}else{
a2=a1+a2;
total=a2;
}
}
printf("\n第%d年末总共会有%d对兔子",year,total);
}
C. C语言编程：兔子繁殖问题
如图，此题难度较大，要用到队列(我优化为循环队列)
#include<stdio.h>
#defineLIFETIME13 //兔子寿命，单位半年（年龄小于此！）
#defineINITNUM1 //初始兔子有多少对
main()
{
inthY=0; //兔子历(就是时刻表)：单位:半年
intnum[LIFETIME]={INITNUM,0}; //存储不同年龄兔子的对数（初始为0岁1对）
//babyI下标代表0岁，往前年龄增大，越过数组下界跳到上界，所以babyI+1反而是最老兔子
intbabyI=0; //0岁兔子对应下标，年龄单位为半年
intloveNum=0; //可生育兔子数量
inttotalNum=INITNUM; //总计兔子数量
intage1I=LIFETIME-2; //1岁兔子对应下标（开始能生育）
intage5_5I=LIFETIME-11; //1岁、5.5岁兔子对应下标（刚好能生育、刚好不能生育年龄）
intn=30; //输入n半年后！
while(hY<=n){
inti,j; //遍历临时变量。①展示兔子数量。
printf("第%.1f年 总计：%d对 可生育：%d对
",(float)hY/2,totalNum,loveNum);
/*
for(i=0;i<LIFETIME;i++){
printf("%.1f岁 ",(float)i/2); //打印表头
//printf("%d,%.1f岁 ",i,(float)(++i)/2); //打印表头
}printf("单位：对
"); //换行*/
i=babyI; //显示各年龄对应数量
j=0;
do{
//printf("%d ",num[i]);
if(hY<21){ //仅用于加 显示
if((++j)%2==0)printf(" ");}
printf("%d",num[i]);
if(i>0)i--; //下标循环往左移动
elsei=LIFETIME-1;
}while(i!=babyI);
printf("
"); //换行
//②半年后
hY++; //时间过去半年
age1I=(age1I+1)%LIFETIME; //1岁数量(对)对应下标
age5_5I=(age5_5I+1)%LIFETIME;//5.5岁数量(对)对应下标
//printf("%d,%d
",age1I,age5_5I);
loveNum+=num[age1I]-num[age5_5I]; //可生育兔子数量(对)
babyI=(babyI+1)%LIFETIME; //新babyI设为原最老兔子的下标，
totalNum+=loveNum-num[babyI]; //每对大兔子可以生一对小兔子-死亡的老兔
num[babyI]=loveNum; //老兔的位置换成新兔
}
}
D. 求unit4 兔子繁殖 编程c++
#include<iostream>
using namespace std;
int main(){
int n;
long long sum = 0;
long long age[12] = {0};
age[0] = 1;//age[0]为刚出生，age[i]为i个月大的兔子
cout << "Enter n:" << endl;
cin >> n;
for (int i = 2; i <= n; i++)
{//当前为第i个月初，目前数组中的数据为第i-1个月初，现在进行处理
long long birth = 0;
for (int j = 1; j < 12; j++)//上月1~11个月大的兔子，在这个月变为2~12个月大，都会生小兔子
birth += age[j];
for (int j = 11; j >= 1; j--)//上月j-1个月大的这个月长为j个月大，上月 11月大小的这个月生完小兔子就死亡
age[j] = age[j-1];
age[0] = birth;
}
for (int i = 0; i < 12; i++)
sum += age[i];
cout << "total: " << sum%100000007 << endl;
}
看到你之前还有个问题，刚刚学编程？可以相互学习交流
E. c语言编程，求兔子问题。
因为只有6年，定义一个数组存储第n年各岁兔子的数量
#include<stdio.h>
int sum(int n)
{
int i,j,a[6];
a[0]=1; //初始化，第一年只有1对，都是1岁
for(i=1; i < 6; i++)
a[i] = 0; //初始化，第一年只有1对，其余为0
for(i=1; i < n; i++)
{//第n年x岁的兔子数是第n-1年x-1岁兔子的数量
// a[x] a[x-1]
for(j=5;j>0;j--)
a[j] = a[j-1];//7岁的就会死掉，直接丢弃
//到3岁就可以生一对，所以从3（数组从0开始，故这里是2）加到6
a[0] = a[2] + a[3] + a[4] + a[5];
}
return (a[0] + a[1] + a[2] + a[3] + a[4] + a[5]);
}
void main()
{
int i=1;
for(i=1; i < 25; i++)
{
printf("%-3d", i);
printf(":%5d\n", sum(i));
}
}
F. Java代码编程 经典的兔子问题
这是斐波那契数列的问题
可以用递归，也可以用循环
递归：
public class Demo3 {
// 使用递归方法
private static int getFibo(int i) {
if (i == 1 || i == 2)
return 1;
else
return getFibo(i - 1) + getFibo(i - 2);
}
public static void main(String[] args) {
System.out.println("斐波那契数列的前20项为：");
for (int j = 1; j <= 20; j++) {
System.out.print(getFibo(j) + "\t");
if (j % 5 == 0)
System.out.println();
}
}
}
循环：
public class Demo2 {
// 定义数组方法
public static void main(String[] args) {
int arr[] = new int[20];
arr[0] = arr[1] = 1;
for (int i = 2; i < arr.length; i++) {
arr[i] = arr[i - 1] + arr[i - 2];
}
System.out.println("斐波那契数列的前20项如下所示：");
for (int i = 0; i < arr.length; i++) {
if (i % 5 == 0)
System.out.println();
System.out.print(arr[i] + "\t");
}
}
}
G. c语言编程:求兔子问题。
不知道我理解错没 兔子夫妻 在第六年 先生下一对 然后双双死亡
#include<stdio.h>
int fun(int n)
{
int sum;
for(int i=0;i<=n;i++)
{
if(i==7)sum=sum-1;
//到了第七年 开始的一对死掉了 不能再生了
if(i>=9)sum=sum-(fun(i-6)-fun(i-7));
//到了第九年 又开始死了
if(i<3)sum=1;
//前二年只有一对
if(i>=3)sum*=2;
//二年后每年兔子都会翻倍
}
return sum;
}
void main()
{
int n;
for(;;){
printf("请输入年数:");
scanf("%d",&n);
printf("有兔子:%d对\n",fun(n));
}
}
H. 紧急！电脑编程高手请进！C#编程：兔子繁殖问题
楼主 晚上睡不着 于是给你用三种方法解答 嘿嘿 不要浪费哦
public class Program
{
static void Main(string[] args)
{
Console.Write("请输入月数:");
string buffer = Console.ReadLine();
int Months = Convert.ToInt32(buffer); //结束月数
CalculateByObjectOriented(Months);
CalculateByRecursion(Months);
CalculateByMathematics(Months);
}
public static void CalculateByObjectOriented(int MonthCount) //面向对象方法实现
{
Console.Write("使用面向对象方法实现,总兔子数:{0}\n" , new RearRing(MonthCount).GetRabbitTotal());
}
public static void CalculateByMathematics(int MonthCount)
{
//能力有限,抽象不出表达式，偷懒一下
//画一个节点图，你就能清楚地看出为什么了
int Period = 3; //出生后第几个月能生小兔
int val1 = 0;
int val2 = 0;
int val3 = 1;
int RubbitsCount = 2;
if (MonthCount > 3)
{
RubbitsCount += val3 * 2;
for (int i = Period + 1; i < MonthCount + 1; i++)
{
val1 = val2;
val2 = val3;
val3 = val2 + val1;
RubbitsCount += val3 * 2;
}
}
Console.Write("使用数学方法实现,总兔子数:{0}\n", RubbitsCount);
}
public static void CalculateByRecursion(int MonthCount) //递归实现
{
Console.Write("使用递归实现,总兔子数:{0}\n" , GetFinalNum(0,MonthCount,0));
}
private static int GetFinalNum(int StartMonth, int MonthCount,int Level) //递归调用
{
int FinalNum=2;
int Period = 3; //出生后第几个月能生小兔
for (int i = StartMonth; i < MonthCount; i++)
{
if (i - StartMonth >= Period-1)
{
FinalNum += GetFinalNum(i, MonthCount, Level + 1);
}
}
//For Debug
//Console.Write("当前级数:{0},共有兔子:{1}\n", Level, FinalNum);
return FinalNum;
}
}
public class RearRing
{
public IList<Rabbits> rabbitsList = new List<Rabbits>();
public RearRing(int MonthCount)
{
rabbitsList.Add(new Rabbits(this));
for (int i = 1; i < MonthCount; i++)
{
int count = rabbitsList.Count; //获取当前兔子数
for(int j=0;j<count;j++)
rabbitsList[j].Grow();
}
}
public int GetRabbitTotal()
{
return Rabbits.RabbitNum;
}
public void Add()
{
Rabbits newRabbits = new Rabbits(this);
rabbitsList.Add(newRabbits);
}
}
public class Rabbits
{
public static int RabbitNum = 0; //兔子总数
private const int BornRabbitNum = 2; //每次出生多少只
private const int Period = 3; //出生后第几个月能生小兔
private int Birthdate = 1; //题目不大明确，刚出生算几个月大？在此假定刚出生1个月大,也就是说，"第三个月开始"表示两轮后
RearRing _rearRing;
public Rabbits(RearRing RearRing)
{
this._rearRing = RearRing;
RabbitNum += BornRabbitNum;
}
public void Grow()
{
Birthdate+=1;
if (Birthdate >= Period)
Bear();
}
private void Bear()
{
_rearRing.Add();
}
}
I. 生兔子的经典编程算法
一般而言，兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对小兔子来。如果所有兔都不死，那么一年以后可以繁殖多少对兔子？
1 1月
1 2月
2 3月
3 4月
5 5月
8 6月
13 7月
21 8月
34 9月
55 10月
89 11月
144 12月
233 13月
第1种：
Private Sub Command1_Click()
i = 0
x = 1
y = 1
b = x & "," & y
For n = 3 To 13 Step 1
i = x + y
x = y
y = i
b = b & "," & i
Next
Print b
End Sub
这个算法是最经典的。其实a月的数量也就是老兔子加上新生兔子。老兔子这么算的：因为当月的生产数量为上个月的兔子总数，而这个生产数量就是由老兔子生的。所以老兔子的数量就是a-1月的数量也就是上一个月的数量。新兔子这么算的：因为新兔子就是上一个月的繁殖数量，即a-1月的繁殖数量，而这个繁殖数量就是由a-2月的总数决定的，所以新兔子就是a-2月了。所以根据这个原理，第一种方法成立。
第2种：
Private Sub Command1_Click()
i = 0
x = 1
y = 1
z = 2
b = x & "," & y & "," & z
For n = 4 To 13 Step 1
i = y * 2 + x
x = y
y = z
z = i
b = b & "," & i
Next
Print b
End Sub
第2种算法的逻辑是：
（a月-2的月总数）* 2 + （a月-3月总数）
因为当月的生产数量为上个月的兔子总数，而当月的新兔子（即上个月新生的兔子，这个月还未能生产）数量为上上个月的总数。
第3种：
Private Sub Command1_Click()
i = 0
x = 1
y = 1
z = 2
b = x & "," & y & "," & z
For n = 4 To 13 Step 1
i = z * 2 - x
x = y
y = z
z = i
b = b & "," & i
Next
Print b
End Sub
（a月总数*2） - （a-2月总数）
这第2种算法和第3种算法是基于第一种算法的原理的。只不过实在太复杂了，我自己脑子里只能粗略整理它的逻辑关系（其实也不是很懂），所以写出来大家一定看不懂。。。
后记：这个经典的兔子数列其实还可以继续玩下去。有非常复杂的递推关系（自己说的，虽然没学过什么叫真正的递推不过应该差不多吧）。每个参数影响非常复杂。我本来想继续这个混乱的递推逻辑，但想到再复杂的算法的时候我差不多都要疯掉了。。啊啊啊，暂时就这样吧~~~大脑休息下。熄火。