1. public class Test8 {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 int sum=1;//第十天的数量
   
5.                 for(int i=9;i>=1;i--)
   
6.                 {
   
7.                         sum=(sum+1)*2;//上一天的数量是今天的数量加1乘以2循环九次即为第一天的数量
   
8.                 }
   
9.                 System.out.println("总共桃子数为："+sum);               
   
10.         }
    
11. }

复制代码

答案为：
总共桃子数为：1534

1. public class Monkey {
   
2.         public static int total(int day){
   
3.                 if(day == 10){   //当第十天的时候剩一个桃子
   
4.                         return 1;
   
5.                         }
   
6.                 else{
   
7.                           return (total(day+1)+1)*2;//每天剩余的桃数是第二天桃数加1的两倍
   
8.                         }
   
9.                 }
   
10.         public static void main(String[] args)
    
11.         {
    
12.                 System.out.println(total(1));
    
13.         }
    
14.        
    
15. 
    
16. }

复制代码

1. public class Houzi {
   
2. public static void main(String[] args) {
   
3.   //定义最后一天的桃子数量sum=1
   
4.   int sum=1;
   
5.   //采用循环，利用递归求解
   
6.   for(int day=10;day>=1;day--){
   
7.    System.out.println("第"+day+"天的桃子总数："+sum);
   
8.    sum=get(sum);   
   
9.   }
   
10. }
    
11. //递归求解桃子总数
    
12. public static int get(int sum){
    
13.   return (sum+1)*2;
    
14. }
    
15. }

复制代码

刚睡醒就来了

可以答题了^-^

好激动啊，先看看。。

look,look.......

public class test1 {
        public static void main(String[] args)
        {
                int sum=1;
                for(int i=1;i<10;i++)//一共10天，控制循环次数
                {
                        sum=(sum+1)*2;//实现前一天的一半加一个
                }
                System.out.println("一共有"+sum+"桃子");//打印一共有多少桃子
        }

}

金辉 发表于 2013-6-15 16:49

编辑不了自己的是怎么回事啊？

打印结果：
一共有1534桃子

瞎了，忘记使用递归了。。。哎。这么简单。

1. /*
   
2. 题目：猜一猜猴子摘了多少桃子呢?
   
3. 猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
   
4. 剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候就发现剩下
   
5. 一个桃子了.求第一天一共摘下了多少桃子呢?
   
6. 
   
7. 思路：1、此题是一个数学推理题，可以采用逆向思维进行推理，先定义一个方法用表达式表示出第九天的结果；
   
8.           2、利用递归原理调用计算方法，这样即可得到计算结果。
   
9. 
   
10. 步骤：1、定义一个类，把主函数和计算方法定义在这个类中即可。
    
11.           2、定义计算方法及利用递归原理进行调用计算出结果。
    
12.           3、定义主函数，调用方法即可得到计算结果。
    
13. */
    
14. class Demo
    
15. {
    
16.         public static void jiSuan(int i,int j)//定义计算方法
    
17.         {
    
18.                 int sum=j;
    
19.                 sum=sum*2+1;
    
20.                 System.out.println("第"+i+"天有"+sum+"个桃子");
    
21.                 i--;
    
22.                 if(i>0)
    
23.                         jiSuan(i,sum);//递归调用
    
24.         }
    
25.                
    
26.         public static void main(String[] args)
    
27.         {
    
28.                 jiSuan(10,0);//调用计算方法
    
29.         }
    
30. }

复制代码

计算结果

先看看再说

public static void main(String[] args)
{
        int x = 1;
        for(int i =2;i<=10;i++)
        {
                x=(x+1)*2;
        }
        System.out.println(x);
}

我来试试

又有福利喽

结果忘给了，不好意思哈。1534

张俊迪 发表于 2013-6-15 16:47
答案为：
总共桃子数为：1534

刚才仔细看题意现在用递归写一个你看看吧，不知还有分不

1. public class Test8 {
   
2.         static int day=10;
   
3.         static int sum=1;//第十天的数量
   
4.         public static void main(String[] args) {
   
5.                 sum=run(sum);
   
6.                 System.out.println(sum);
   
7.         }
   
8.         public static  int  run(int sum){
   
9.                 sum=(sum+1)*2;
   
10.                 day--;
    
11.                 if(day==1)
    
12.                 {
    
13.                         return sum;
    
14.                 }
    
15.                 else{
    
16.                         sum=run(sum);
    
17.                         return sum;
    
18.                 }
    
19.         }
    
20. }

复制代码

不写注释了，都一个原理

这个题出得不严谨啊，如果总数出现时奇数的时候，这个题就不是那么简单的了，还得推算几分之几，这就有点麻烦了，这个奇数的一半就出现小数了.........{:soso_e127:}

1. public class MonkeyPeach
   
2. {               
   
3.         public int day = 1;                        //天数；
   
4.         public int peach = 1;                //桃子的数量；
   
5.        
   
6.         public void add()                        //通过逆向递归调用来获取第一天摘取桃子的总数；
   
7.         {       
   
8.                 if(day <= 9)
   
9.                 {
   
10.                         peach = (peach+1)*2;        //因为每天都先吃了一半，然后又吃了一个，逆向来说就是先加上一个，然后再乘以2；
    
11.                         day+=1;
    
12.                         add();       
    
13.                 }
    
14.                
    
15.         }
    
16.        
    
17.         public void show()                        //打印桃子的实际数量；
    
18.         {
    
19.                 System.out.println("第一天，猴子总共摘了"+peach+"个桃子！");       
    
20.         }
    
21.        
    
22.         public static void main(String [] args)
    
23.         {
    
24.                         MonkeyPeach mp = new MonkeyPeach();
    
25.                         mp.add();
    
26.                         mp.show();
    
27.         }
    
28. }

复制代码

做出来了，第一天小猴总共摘了1534个桃子！