java猴子吃桃子问题
猴子吃桃子问题 大数据结构课程设计
标准文档目录1、需求分析 (1)2、概要设计 (1)2.1.用数组数据结构实现上述求解 (1)2.2.用链数据结构实现上述求解 (1)2.3 用栈数据结构实现求解 (1)2.4 用递归实现上述求解 (2)3、运行环境 (2)3.1 硬件环境 (2)3.2软件环境 (2)4、详细设计 (2)4.1系统流程图 (2)4.2用数组数据结构实现上述求解 (3)4.3用链数据结构实现上述求解 (4)4.4用栈数据结构实现求解 (5)4.5用递归实现上述求解 (6)5、调试分析 (7)6、运行结果 (7)课程设计总结 (8)参考文献 (9)附录： (9)1、需求分析1、猴子吃桃子问题有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
要求：1) 采用数组数据结构实现上述求解2) 采用链数据结构实现上述求解3) 采用栈实现上述求解4) 采用递归实现上述求解2、概要设计2.1.用数组数据结构实现上述求解在taozi函数中定义一个一维数组，分别存储每天的桃子个数，根据题目的内容找出各个数之间的关系，用数组元素表示出来，根据用户输入要计算哪一天的桃子，用for循环控制结束。
在main函数中让用户输入要计算的哪一天，调用taozi 函数，以便用户可查出任意一天的桃子个数，用switch语句判断用户要执行的功能，然后用while循环控制，直到用户输入0为止。
2.2.用链数据结构实现上述求解先写出预定义常量和类型，写出结点的类型定义，创建结点，初始化链表，定义变量并初始化，找出结点与其后继结点之间的联系，然后在主函数中控制。
2.3 用栈数据结构实现求解本部分包括预定义常量和类型，顺序栈的定义，InitStack函数，Push函数，和main函数，在InitStack函数构造一个空栈，在Push函数中调用该函数，并在其中编写控制栈顶指针和栈底指针移动的语句，找出指针所指向的数据之间的关系，在main函数中编写控制循环结束的语句，最后再用main函数去调用Push函数。
猴子吃桃子问题大数据结构课程设计
标准文档目录1、 .................................................. 需求分析12、 .................................................. 概要设计12.1. 用数组数据结构实现上述求解 (1)2.2. 用链数据结构实现上述求解 (1)2.3用栈数据结构实现求解 (1)2.4用递归实现上述求解 (2)3、运行环境 (2)3.1硬件环境 (2)3.2软件环境 (2)4、详细设计 (2)4.1系统流程图 (2)4.2用数组数据结构实现上述求解 (3)4.3用链数据结构实现上述求解 (4)4.4用栈数据结构实现求解 (5)4.5用递归实现上述求解 (6)5、调试分析 (7)6、 .................................................. 运行结果7课程设计总结 (8)参考文献 (9)附录： (9)1、需求分析1、猴子吃桃子问题有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10 天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
要求：1) 采用数组数据结构实现上述求解2) 采用链数据结构实现上述求解3) 采用栈实现上述求解4) 采用递归实现上述求解2、概要设计2.1. 用数组数据结构实现上述求解在taozi 函数中定义一个一维数组，分别存储每天的桃子个数，根据题目的内容找出各个数之间的关系，用数组元素表示出来，根据用户输入要计算哪一天的桃子，用for 循环控制结束。
在main 函数中让用户输入要计算的哪一天，调用taozi 函数，以便用户可查出任意一天的桃子个数，用switch 语句判断用户要执行的功能，然后用while 循环控制，直到用户输入0 为止。
2.2. 用链数据结构实现上述求解先写出预定义常量和类型，写出结点的类型定义，创建结点，初始化链表，定义变量并初始化，找出结点与其后继结点之间的联系，然后在主函数中控制。
50道JAVA基础编程练习题
50道JAVA基础编程练习题Java学习笔记2010-03-19 17:45:01 阅读1117 评论6 字号：大中小订阅【程序1】题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21....【程序2】题目：判断101-200之间有多少个素数，并输出所有素数。
1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
做了【程序3】题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
1.程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。
【程序4】题目：将一个正整数分解质因数。
例如：输入90,打印出90=2*3*3*5。
程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
(2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你n,重复执行第一步。
(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。
【程序5】题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
1.程序分析：(a>b)?a:b这是条件运算符的基本例子。
【程序6】题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
1.程序分析：利用辗除法。
【程序7】题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
JS之递归（例题：猴子吃桃）
JS之递归（例题：猴⼦吃桃）
例题1：公园⾥有200个桃⼦，猴⼦每天吃掉⼀半以后扔掉⼀个，问6天以后还剩余多少桃⼦？
var sum = 200;
for(var i= 0;i<6;i++)
{
sum = parseInt(sum/2)-1
}
alert(sum);
例题2：公园⾥有⼀些桃⼦，猴⼦每天吃掉⼀半以后扔掉⼀个，第6天的时候发现还剩下1个桃⼦，问开始有⼏个桃⼦？var sum = 1;
for(var i = 0;i<6;i++)
{
sum = (sum+1)*2;
}
alert(sum);
使⽤函数解决例题2
function ShuLiang(n)//⽤来返回第n天的数量
{
if(n == 6)//已知第6天
{
return 1;//桃⼦数量为1
}
var sl = (ShuLiang(n+1)+1)*2;//第n天的桃⼦数量=（下⼀天的桃⼦数量+1）*2
return sl;//return第n天的数量
}
alert(ShuLiang(0));
函数功能：给⼀个天数，返回该天数的桃⼦的数量。
最主要的是下⼀天的桃⼦数量怎么求，函数实现过程是想要求第1天的桃⼦数量就需要2天桃⼦数量；
想要求第2天的桃⼦数量就需要3天桃⼦数量；
想要求第3天的桃⼦数量就需要4天桃⼦数量；
想要求第4天的桃⼦数量就需要5天桃⼦数量；
想要求第5天的桃⼦数量就需要6天桃⼦数量；
⽽第6天的桃⼦的数量已经知道了，是1。
进⽽5-4-3-2-1-0的数量的桃⼦就能⽤公⽰算出来了。
Python经典算法-猴子吃桃-思路分析
print u"现在是第 %d 天，桃子的数目是：%d " % (11 - i, s) s = (s + 1) * 2
分析: 这是一套非常经典的算法题，这个题目体现了算法思想中的递推思想，递归有两种形式，顺推和逆推，针对递推，只要 我们找到递推公式，问题就迎刃而解了。
令S10=1，容易看出 S9=2(S10+1)， 简化一下 S9=2S10+2 S8=2S9+2 ..... Sn=2Sn+1+2
python代码
这是一套非常经典的算法题这个题目体现了算法思想中的递推思想递归有两种形式顺推和逆推针对递推只要我们找到递推公式问题就迎刃而解了
Python经典算法 -猴子吃桃 -思路分析
问题：ቤተ መጻሕፍቲ ባይዱ
猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾就多吃了一个。第二天早上又将剩下的桃子吃了一半，还是不过瘾又多吃了一个。以后每天都吃前一天剩下的一半再加一个。到第10天刚好剩一个。问猴子第一天摘了多少个桃子？
Java算法猴子分桃
Java算法猴子分桃题目：海滩上有一堆桃子，五只猴子来分。
第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。
第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？public class Dg {static int ts=0;//桃子总数int fs=1;//记录分的次数static int hs=5;//猴子数...int tsscope=5000;//桃子数的取值范围.太大容易溢出.public int fT(int t){if(t==tsscope){//当桃子数到了最大的取值范围时取消递归System.out.println("结束");return 0;}else{if((t-1)%hs==0 && fs <=hs){if(fs==hs){System.out.println("桃子数 = "+ts +" 时满足分桃条件");}fs+=1;return fT((t-1)/5*4);// 返回猴子拿走一份后的剩下的总数}else{//没满足条件fs=1;//分的次数重置为1return fT(ts+=1);//桃子数加+1}}}public static void main(String[] args) {new Dg().fT(0);}}奇数和public class Oddsum {public static void main(String args[]){int x=0;for(int i=1;i<=99;i+=2){x +=i;}System.out.println("result="+x);}}搬砖public class Brick {public static void main(String[] arg){int x,y,z;for(x=0;x<=9;x++){for(y=0;y<=12;y++){for(z=0;z<=36;z++){if(z%2==0){if(x*4+y*3+z/2==36&&x+y+z==36){System.out.println("x="+x+"y="+y+"z="+z);}}}}}}}米和英尺的转换public class change{public static void main(String args[]){double a=1.0;System.out.println("英尺\t米");for(int i=0;i<9;i++){System.out.println(a+"\t"+convertToMeter(a)); a++;}double b=20.0;System.out.println("米\t英尺");for(int i=0;i<9;i++){System.out.println(b+"\t"+convertToFoot(b)); b=b+5.0;}}public static double convertToMeter(double foot){double n=foot*0.32809;n=Math.round(n*1000)/1000.0;return n;}public static double convertToFoot(double meter){double n=meter/0.32809;n=Math.round(n*1000)/1000.0;return n;}}。
python猴子吃桃问题,数学解法
python猴子吃桃问题,数学解法猴子吃桃问题是数学中的一个经典问题，它的原型是：一只猴子在一个月圆之夜爬上一棵桃子树，树上共有n个桃子。
猴子每天吃掉一个桃子并往上爬1节树枝。
猴子第yi天只能爬上1节树枝，第二天可以爬上2节树枝，依此类推。
但是，猴子在每个月圆之夜都要回到地面开始吃桃子。
请问猴子多久才能吃到第n 个桃子？这个问题的数学解法可以用递归或动态规划的方法来解决。
下面我们将使用递归的方法来解决这个问题。
首先，我们需要定义一个函数来表示猴子的爬树过程。
这个函数接受两个参数：当前桃子数量n和当前夜晚数k。
函数返回猴子在第k个夜晚吃到第n个桃子的概率。
```pythondef monkey_probability(n, k):# 基本情况：当桃子数量为1时，猴子在第yi个夜晚就能吃到桃子if n == 1:return 1# 基本情况：当夜晚数为0时，猴子还无法吃到桃子if k == 0:return 0# 当桃子数量大于1时，猴子需要在夜晚k-1吃桃子，第k天回到地面吃桃子，所以概率为(n-1)/(k-1)else:return (n - 1) / (k - 1)```接下来，我们需要定义一个函数来计算猴子吃到第n个桃子的最有可能的晚上。
这个函数接受一个参数：桃子数量n。
```pythondef find_most_probable(n):# 初始化夜晚数和概率列表k = 1probabilities = [monkey_probability(n, i) for i in range(1, n)]# 使用动态规划计算概率列表的最大值和对应的夜晚数while k <= n:max_probability = max(probabilities)max_probability_index = probabilities.index(max_probability)probabilities[max_probability_index] = 0k += 1return k - 1```现在我们可以测试一下这个算法的准确性。
猴子吃桃问题
软件综合课程设计猴子吃桃问题学生搭配问题二〇一四年六月《猴子吃桃子课程设计》报告一、问题陈述猴子吃桃子问题：有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
二、需求分析要求：1．采用数组数据结构实现上述求解；2．采用链数据结构实现上述求解；3．采用递归实现上述求解。
三、概要设计四、详细设计猴子每天都吃当前桃子的一半多一个，假设今天还有n个桃子，则前一天就有（n+1）*2个桃子。
又已知第十天只剩下一个桃子，则可代入以上公式求出第九天的桃子数，以此类推求下去便可得到第一天的桃子数。
1．采用数组数据结构实现上述求解声明一个长度为10的整形数组arr[10],分别存放各天猴子吃前的桃子数。
下图所示arr[0] arr[1]arr[2]arr[3] arr[4]arr[5]arr[6]arr[7] arr[8]arr[9]先将arr[9]赋值为1，用一个循环语句for (int i=9; i>0; i--){ arr[i-1]=2*(arr[i]+1); }为其余各数组元素赋值，则数组元素arr[0]的值便是该问题的解。
2．采用链数据结构实现上述求解 建立单链表，声明一个类用来对链表的结点指针进行定义，在初始化函数中利用头插法创建具有10个元素的链表。
那么N 10便是要求问题的解。
3．采用递归实现上述求解利用一个递归函数来进行求值：依据返回值来记录每一天剩余桃子情况。
int UseRecursion(int n) {int m; if(n==1) m=1; elsem=(UseRecursion(n-1)+1)*2; return m; }五、程序代码1．头文件“MEP.h “ #ifndef MEP_H #define MEP_H#include<iostream> #include<malloc.h> using namespace std; typedef struct LNode {int data;struct LNode *next; }LNode,*LinkList; void UseLinkList();int UseRecursion(int n);int Swicth();void Diaoyong();void UseArray();void Fenxi();void LinkListAnalysis();void RecursionAnalysis();void ArrayAnalysis();static unsigned short arr[10]={0,0,0,0,0,0,0,0,0,1};#endif MEP_H;2.主函数void Diaoyong();void main(){Diaoyong();}3．Diaoyong：调用函数#include"MEP.h"void Diaoyong(){cout<<" --猴子吃桃子问题-- \n\n";cout<<"有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一\n";cout<<"半且再多吃一个，到了第10天就只余下一个桃子。
数据结构猴子吃桃
目录1 问题描述 (1)2 需求分析 (1)3 概要设计 (1)3．1抽象数据类型定义 (1)3．2模块划分 (2)4 详细设计 (3)4．1数据类型的定义 (3)4．2主要模块的算法描述 (3)5 测试分析 (6)6 课程设计总结 (7)参考文献 (8)附录（源程序清单） (9)1 问题描述有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子,求原来这群猴子共摘了多少个桃子。
一种采用数组数据结构实现；一种采用栈链数据结构实现；一种采用递归实现上述求解。
2 需求分析(1)由问题可知,题目中知道第十天所剩的桃子数,所以可以及往前算,算出前一天所剩余的桃子数,到第一天时即为总的桃子数,所以可用数组来存每天所剩的桃子数,容易实现求解。
(2)根据问题设第n天的桃子数为f(n),则前一天的桃子数为f(n+1)=f(n)-(f(n)/2+1)，化解可得f(n)=2f(n+1)+2,以此为依据实现递归。
(3)由栈与递归的实现可知调用函数各被调用函数之间的链接及信息交换是通过栈来实现的，因此可以用栈模拟函数递归。
即可通过用栈的链表储存结构模拟函数的递归调用过程来实现问题的求解。
3 概要设计3．1抽象数据类型定义栈的抽象数据类型定义AST Stack{数据对象：D={ai|ai∈ElemSet,i=1,2,...,n, n≥0}数据关系：R1={<ai-1,ai>|ai-1,ai∈D，i=2,...,n}约定an端为栈顶，a1端为栈底。
基本操作：InitStack(&S)操作结果：构造一个空栈S。
DestroyStack(&S)初始条件：栈S已存在。
操作结果：栈S被销毁。
ClearStack(&S)初始条件：栈S已存在。
操作结果：将栈S清为空栈。
StackEmpty(S)初始条件：栈S已存在。
操作结果：若栈S为空栈，则返回TRUE，否则FALSE。
Java基础编程题（含答案）_7
51道JAV A基础编程练习题1. 古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子对数为多少？2. 判断101-200之间有多少个素数，并输出所有素数。
3. 打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
4. 将一个正整数分解质因数。
例如：输入90,打印出90=2*3*3*5。
5. 利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
6. 输入两个正整数m和n，求其最大公约数和最小公倍数。
7. 输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
8. 求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。
例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。
9. 一个数如果恰好等于它的因子之和，这个数就称为"完数"。
例如6=1＋2＋3.编程找出1000以内的所有完数。
10. 一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？11. 有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？12. 企业发放的奖金根据利润提成。
利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？13. 一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？14. 输入某年某月某日，判断这一天是这一年的第几天？（变形：输入某一天，输出一千天后是那一天）15. 输入三个整数x,y,z，请把这三个数由小到大输出。
猴子吃桃问题
福建工程学院课程设计课程：数据结构课程设计题目：猴子吃桃问题专业：软件工程班级： 1002座号： 5号姓名：蔡梓楠年月日实验题目：猴子吃桃问题一、要解决的问题有一群猴子摘了一堆桃，他们每天都吃当前桃子的一半且在多吃一个，到了第十天就只剩下一个桃子。
用多种方法实现求出原来这群猴子一共摘了多少个桃子。
要求：1.采用数组数据结构实现上述求解2.采用链表数据结构实现上述求解3.采用递归算法实现上述求解4.（个人）采用堆栈数据结构实现上述求解（个人）本程序可实现10天以内第n天的桃子数。
二、算法基本思想描述：本次课程设计要采用回溯思想，因为题目中只告诉你第十天的桃子数量为1，则第九天的桃子数为（1+1）*2，之前几天的桃子树可用此公式m=(n+1)*2（m为前一天桃子数，n 为当天桃子数）公式解决。
若要求第一天到底有几个桃子，可将之前几天的桃子树一一存入各自结构中，然后求出第一天的桃子树；而如果用递归算法，则必须连续十次进行该函数。
三、设计1．数据结构的设计和说明本次试验四个要求中，除了“递归算法”要求不需要特殊存储结构意外，其他三个都要。
typedef int elemtype; /*定义新类型elemtype为int型*/ （1）数组存储结构typedef struct{elemtype data[n];int len;}Sequenlist;（2）链表存储结构typedef struct node{elemtype data;struct node *next;}linklist;（3）堆栈存储结构typedef struct{elemtype data[MAXSIZE];int top;}SeqStack;2．模块结构图及各模块的功能：void main() /*主函数*/ void Digui() /*递归算法*/ void duizhan() /*堆栈存储结构*/ void shuzu() /*数组结构存储*/ void lianbiao() /*链表存储结构*/ 3．关键算法的设计递归算法描述：int z;int digui(int j,int k){z自加1;当z等于输入天数时，返回j;j=(j+1)*2;digui(j,k);}四、源程序清单：#include"malloc.h"#define MAXSIZE 100#define n 100#define NULL 0int z=0;typedef int elemtype;/*定义新类型为elemtype*/typedef struct{elemtype data[MAXSIZE];int top;}SeqStack;/*定义栈类型*/typedef struct{elemtype data[n];int len;}Sequenlist;/*定义数组类型*/typedef struct node{elemtype data;struct node *next;}linklist;/*定义链表类型*/linklist *Initlinklist(linklist *L){L=(linklist *)malloc(sizeof(linklist));L->next=NULL;return(L);}/*初始化链表*/linklist *Creatlinklist(linklist *L){int i,j;linklist *r,*p;r=L;j=1;for(i=0;i<=9;i++){p=(linklist *)malloc(sizeof(linklist));p->data=j;p->next=NULL;r->next=p;r=r->next;j=(j+1)*2;}return(L);}/*链表创建*/Sequenlist *InitList(Sequenlist *L){L=(Sequenlist *)malloc(sizeof(Sequenlist));L->len=0;return(L);}/*初始化数组*/Sequenlist *CreatList(Sequenlist *L){int i,j,k;L->data[0]=1;k=1;for(j=0;j<9;j++){i=(L->data[j]+1)*2;L->data[j+1]=i;L->len++;k++;}L->len=k;return(L);}/*将算好每天的桃子数存入数组*/ SeqStack *InitStack(SeqStack *S){S=(SeqStack *)malloc(sizeof(SeqStack));S->top=-1;return(S);}/*初始化栈*/int Push(SeqStack *S,int item){if(S->top==MAXSIZE-1){printf("Stack overflow\n");return 0;}else{S->data[++S->top]=item;return 1;}}/*进栈*/elemtype Pop(SeqStack *S){if(S->top==-1){printf("Stack is empty.\n");return 0;}else{S->top--;return(S->data[S->top+1]);}}/*出战*/SeqStack *CreatStack(SeqStack *S){int i,j,k;Push(S,1);k=1;for(j=0;j<9;j++){i=(k+1)*2;k=i;Push(S,i);}}/*将算好每天的桃子数存入栈*/int digui(int j,int k){z++;if(z==k) return j;j=(j+1)*2;digui(j,k);}/*利用递归算法计算每天桃数*/void lianbiao()/*数据存储方式为链表*/{linklist *P,*u;int i,k;P=Initlinklist(P);Creatlinklist(P);u=P->next;printf("（链表算法）请输入天数（1-10）：");scanf("%d",&k);/*输入天数*/for(i=0;i<10-k;i++){u=u->next;/*寻找第k天桃子数*/}printf("第%d天桃子数为%d\n",k,u->data);printf("\n");}void shuzu()/*数据存储方式为数组*/{int k;Sequenlist *L;L=InitList(L);L=CreatList(L);printf("（数组算法）请输入天数（1-10）：");scanf("%d",&k);/*输入天数*/printf("第%d天桃子数为%d\n",k,L->data[10-k]);printf("\n");}void duizhan()/*数据存储方式为堆栈*/{int i,k;SeqStack *S;S=InitStack(S);CreatStack(S);printf("（堆栈算法）请输入天数（1-10）：");scanf("%d",&k);/*输入天数*/for(i=0;i<=k-2;i++) Pop(S);printf("第%d天桃子数为%d",k,Pop(S));printf("\n");printf("\n");}void Digui()/*递归算法*/{int k;z=0;printf("（递归算法）请输入天数（1-10）：");scanf("%d",&k);/*输入天数*/printf("第%d天桃子数为%d",k,digui(1,11-k));printf("\n");printf("\n");}void print()/*选择列表函数*/{printf("---------请输入你的选择---------\n");printf("-a:数组算法-\n");printf("-b:链表算法-\n");printf("-c:递归算法-\n");printf("-d:堆栈算法-\n");printf("-e:关闭程序-\n");printf("--------------------------------\n");}main(){char c;print();/*打印选择列表*/c=getchar();/*输入选择*/while(c!='e'){switch(c){case 'a': shuzu();break;/*选择用数组存储方式*/case 'b': lianbiao();break;/*选择用链表存储方式*/case 'c': Digui();break;/*计算过程选择用递归算法*/case 'd': duizhan();break;/*选择用堆栈存储方式*/case 'e': return;/*程序结束*/}print();/*打印选择列表*/getchar();c=getchar();}getch();getch();}五、测试数据及测试结果：测试过程：测试开始后，屏幕打印四种方法的选项：输入“a”；屏幕打印：提示输入天数：输入“1”；输出“1534”。
Java经典基础代码
Monkey_peach代码package com.sailor.game;/*** 题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩* 下的桃子吃掉一半，又多吃了一个。
以后每天早上都吃了前一天剩下的一半零一个。
到第10天早上想再吃时，见只剩下一个桃子了。
求第一天共摘了多少。
* 程序分析：采取逆向思维的方法，从后往前推断。
** @author Sailor**/public class Monkey_Peach {public static void main(String[] args) {int[] peach = new int[10];peach[9] = 1;// 下面利用的是数组和循环将每天的桃子数量都求出来了for (int i = peach.length - 1; i > 0; i--) {peach[i - 1] = 2 * (peach[i] + 1);}for (int i = 0; i < peach.length; i++) {System.out.println(peach[i]);}System.out.println("第一天的桃子数："+getPeach_Num(10, 1));}// 利用递归的方法来求第一天的桃子数,输入参数为天数和当天的桃子数，输出为第一天桃子数public static int getPeach_Num(int day, int peach_num) {if (day == 1)return peach_num;else if (day < 1 || peach_num < 0)return 0;elsereturn getPeach_Num(day - 1, (peach_num + 1) * 2);}}package com.sailor.game;/*** 题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩* 下的桃子吃掉一半，又多吃了一个。
猴子吃桃子问题
数据结构与算法B课程设计任务书学院名称：数学与计算机学院课程代码：__ 6013799______
专业：年级：
一、设计题目
猴子吃桃子问题
二、主要内容
有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
三、具体要求及应提交的材料
采用数组数据结构实现上述求解
采用链数据结构实现上述求解
采用递归实现上述求解
如果采用4种方法者,适当加分
用C/C++语言编程实现上述内容，对每个问题写出一个算法实现，并按数学与计算机学院对课程设计说明书规范化要求，写出课程设计说明书，并提交下列材料：
1)课程设计说明书打印稿一份
2)课程设计说明书电子稿一份；
3)源程序电子文档一份。
四、主要技术路线提示
根据不同的数据结构完成。
在此基础上用C/C++实现其操作。
五、进度安排
按教学计划规定，数据结构课程设计为2周，其进度及时间大致分配如下：
六、推荐参考资料
[1] 严蔚敏，吴伟民.数据结构.清华大学出版社出版。
[2] 严蔚敏，吴伟民. 数据结构题集(C语言版) .清华大学出版社.2003年5月。
[3] 唐策善，李龙澎.数据结构(作C语言描述) .高等教育出版社.2001年9月
[4] 朱战立.数据结构(C++语言描述)（第二版本）.高等出版社出版.2004年4月
[5] 胡学钢.数据结构(C语言版) .高等教育出版社.2004年8月
[6] 徐孝凯等著.数据结构（C语言描述）.清华大学出版社.2004
指导教师签名日期年月日
系主任审核日期年月日。
猴子吃桃问题数据结构课程设计
一、设计题目猴子吃桃子问题有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
二、运行环境（软、硬件环境）VC++6.0 PC电脑一台三、算法的需求分析1) 采用数组数据结构实现上述求解2) 采用链数据结构实现上述求解3) 采用递归实现上述求解4) 如果采用4种方法者,适当加分//用户界面int Desk(int n){printf("**************************************************\n");printf("| 欢迎进入猴子吃桃子系统|\n");printf("| 1-数组法2-链表法3-递归法4-二叉树法5-退出|\n");printf("***************************************************\n");printf("请输入要选择的方法: ");scanf("%d",&n);getchar();system("cls"); //刷新屏幕while(n<1 || n>5){printf("***输入错误! 请重新输入***\n");scanf("%d",&n);}return n;}四、算法概要设计//采用链数据结构 (栈) 实现上述求解typedef struct{int *top;int *base;}stack;//初始化一个栈stack Init(stack *s){s->base=(int *)malloc(STACK_SIZE*sizeof(int));if(s->base == NULL){printf("Init failed !\n");exit(-1);}s->top = s->base;return *s;}//二叉树创建一个大小为DAYS(由用给出)的二叉树,二叉树的左孩子节点存放当天的桃子数，右节点存放数字1，即为多吃的一个桃子。
猴子吃桃问题-数据结构与算法课程设计报告
合肥学院计算机科学与技术系课程设计报告2009～2010学年第二学期课程数据结构与算法课程设计名称猴子吃桃问题学生姓名王康可学号**********专业班级计算机科学与技术08级（2）班指导教师王昆仑张贯虹2010 年6月题目：（猴子吃桃问题）有一群猴子摘了一堆桃子，他们每天都吃当前桃子的一半且再多吃一个，到了第10天就只余下一个桃子。
用多种方法实现求出原来这群猴子共摘了多少个桃子。
一、问题分析和任务定义本题目中，猴子每天都吃当前桃子的一半且再多吃一个，假设第一天开始时，即摘的桃子总数有a0只桃子，第一天吃过之后剩下a1只桃子，第二天吃过之后剩下a2只，. . .，第9天吃过之后剩下a9只，第10天吃过之后剩下a10只，在a0，a1，a2，. . .，a1 0中，只有a10= 1是知道的，现要求a0，而我们可以看出，a0，a1，a2，. . .，a10之间存在一个简单的关系：a9= 2 * ( a1 0+ 1 )a8= 2 * ( a9+ 1 )┇a1= 2 * ( a2+ 1 )a0= 2 * ( a1+ 1 )也就是：ai= 2 * ( ai + 1)，其中i=10,9，8，7，6，...，1，0 。
这就是此题的数学模型。
通过阅读题目、分析题意，要求利用不同方法实现这群猴子摘桃子总数，为了实现题目要求，可采用递归、链式、数组等方法，而不管是采用哪种方法、哪种数据结构，其基本语句都是ai= 2 * ( ai + 1+1)，其中i=10,9，8，7，6，...，1，0。
二、数据结构的选择和概要设计按照题目要求，采用数组数据结构、链式数据结构。
分别利用递归算法、链式存储、数组来实现函数功能。
将所有模块放在一起，利用主函数中的菜单来调用不同子函数以实现题目要求。
三、详细设计和编码1、采用递归算法子函数中，关键语句为N=2*recursion(N+1)+2，采用判断语句 if…else…，“if(N==10) return 1；”，给出第十天吃过桃子后剩下桃子数为1，其他天数return N=2*recursion(N+1)+2，即通过递归调用计算，通过已知的后一天剩下的桃子总数来求出前一天剩下的桃子总数。
JAVA编程题目(含解答)
【程序1】题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21....import java.util.Scanner;public class RabbitsQuit {/*** 【程序1】题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一* 对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21....*/public static void main(String[] args) {// TODO Auto-generated method stubScanner sc = new Scanner(System.in);RabbitsQuit rq = new RabbitsQuit();System.out.println("请输入一个整数：");int n = sc.nextInt();for (int i = 0; i < n; i++) {System.out.println("第"+ (i + 1) + "个月："+ rq.calc(i + 1));}}private int calc(int x) {if (x == 1 || x == 2)return 1;elsereturn calc(x - 2) + calc(x - 1);}}【程序2】题目：判断101-200之间有多少个素数，并输出所有素数。
1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
import java.util.Scanner;public class RabbitsQuit {/*** 【程序1】题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一* 对兔子，假如兔子都不死，问每个月的兔子总数为多少？ 1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21....*/public static void main(String[] args) {// TODO Auto-generated method stubScanner sc = new Scanner(System.in);RabbitsQuit rq = new RabbitsQuit();System.out.println("请输入一个整数：");int n = sc.nextInt();for (int i = 0; i < n; i++) {System.out.println("第"+ (i + 1) + "个月："+ rq.calc(i + 1));}}private int calc(int x) {if (x == 1 || x == 2)return 1;elsereturn calc(x - 2) + calc(x - 1);}}法二：import java.util.Vector;public class PrimeNumber2 {/*** 【程序2】题目：判断101-200之间有多少个素数，并输出所有素数。
猴子吃桃子问题完美解决版
。
。
如果只吃n天应该一共要吃1 + 3 + 6 + 12 +24+42+。。。。。。。
也就是除了第一天外其余每天吃桃子的个数都是前天的2倍（大家可以从3,6,12,24,48中看出）
因此程序解决办法为
public class Demo03_对象A {
publicstatic void main(String[]args) {
猴子吃桃子问题想必就不用说了：
现在提出解决问题方法：首先说的是谭老的《C语言程序设计》解决办法有问题至于问题在哪里不说。大家可以用软件仿真一下和你算得结果是否相同
分析：
如果只吃一天应该一共只有1个桃子吃1个
如果只吃2天应该是一共3+1 = 4个桃子吃3个
如果只吃3天应该是一共6 + 1+ 3 = 10个桃子吃6个
intday = 10 ;
intsum = 0 ;//sum表示吃到第几天时的桃子总数
inttmp= 3;//tmp每天吃桃子的个数
while(day > 0 ) {
iout.println("第10天还有一个");
} elseif(day == 9) {
sum=tmp+ sum;
} else {
tmp=tmp*2;
sum= sum +tmp;
System.out.println("第"+day+"天还有桃子"+tmp+"个");
}
day--;
}
System.out.println("因此一共有桃子"+sum + "个");
Java50道经典习题-程序17猴子吃桃问题
Java50道经典习题-程序17猴⼦吃桃问题
题⽬：猴⼦吃桃问题：猴⼦第⼀天摘下若⼲个桃⼦，当即吃了⼀半，还不瘾，⼜多吃了⼀个第⼆天早上⼜将剩下的桃⼦吃掉⼀半，⼜多吃了⼀个。
以后每天早上都吃了前⼀天剩下的⼀半零⼀个。
到第10天早上想再吃时，见只剩下⼀个桃⼦了。
求第⼀天共摘了多少。
分析：采取逆向思维的⽅法，从后往前推断。
假设：第九天还有x个桃，第⼗天就还有(x/2)-1个桃；若设第⼗天还有m个桃，则满⾜等式(x/2)-1=m反推第九天还有(m+1)*2个桃
1public class Prog17 {
2public static void main(String[] args) {
3int m=1;//第⼗天还剩1个桃
4for(int i=9;i>0;i--) {//不包括第⼗次，所以只需要循环9次
5 m=(m+1)*2;
6 }
7 System.out.println("⼩猴⼦共摘了"+m+"桃⼦");
8 }
9 }
10/*运⾏结果
11⼩猴⼦共摘了1534桃⼦
12*/。
猴子吃桃问题。猴子第1天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。第2天早上又。。。
猴⼦吃桃问题。
猴⼦第1天摘下若⼲个桃⼦，当即吃了⼀半，还不过瘾，⼜多吃了⼀个。
第2天早上⼜。
猴⼦吃桃问题。
猴⼦第1天摘下若⼲个桃⼦，当即吃了⼀半，还不过瘾，⼜多吃了⼀个。
第2天早上⼜将剩下的桃⼦吃掉⼀半，⼜多吃了⼀个。
以后每天早上都吃了前⼀天剩下的⼀半零⼀个。
到第10天早上想再吃时，就只剩⼀个桃⼦了。
求第1天共摘多少个桃⼦。
从题⾯上来看，可以推出，后⼀天的桃⼦数量 = 前⼀天桃⼦数量 / 2 - 1。
所以，该公式也可以写成前⼀天的桃⼦数量 = (后⼀天桃⼦数量+1) * 2。
所以我们知道了第10天剩余桃⼦的数量，则可以依次推算出桃⼦的前⼀天桃⼦的总数。
需要注意的点，猴⼦只是吃了9天，所以，我们只需要遍历9次就可以了。
#include <stdio.h>
int main()
{
int day = 9;
int prev_day_count;
int cur_day_count = 1;
while (day > 0)
{
prev_day_count = (cur_day_count + 1) * 2;
cur_day_count = prev_day_count;
day--;
}
printf("total count : %d\n", cur_day_count);
return 0;
}。