1. public static void main(String[] args) {
   
2.                
   
3.                 System.out.println(count(1,10));//第一参数代表第十天剩余的桃子，第二个参数表示第十天
   
4.                
   
5.         }
   
6.         public static int count(int n, int day){
   
7.                 if(n<0)
   
8.                         return -1;
   
9.                 if(day==1)
   
10.                         return n;
    
11.                
    
12.                 return count(2*(n+1),day-1);////逆向推算。最后一天是1个，每一天是后一天的个数加上1再乘以2
    
13.         }

复制代码

pys200603027 发表于 2013-6-16 10:33

嗯，其实挺简单
思路分析：
（1）第一天有N个桃子，吃掉N/2-1个，得到第二天的桃子数
设第二天的桃子数x2,则数学表达式为：x2=N-(N/2-1)；
N=2(x2+1);
....
最后依次类推到第十天剩余1，第九天的桃子数就是x9=2(x10+1);
（2）从第十天开始倒序计算回第一天就得到第一天桃子数
非递归算法如下

1. int x = 1;//第10天桃子的数量
   
2.                 for (int i = 9; i > 0; i--) {//循环9次
   
3.                 x = (x + 1) * 2;
   
4. 
   
5.                 }
   
6.                 System.out.println(x);

复制代码

我来也 15钟够了吗

1. 
   
2. <P> </P>

复制代码

萧萧北 发表于 2013-6-16 12:35

楼主抱歉，我粘贴出现失误，怎么看不到自己的内容了 敬请谅解

题目你快出来啊啊啊啊啊题目呢

pys200603027 发表于 2013-6-16 11:04
嗯，其实挺简单
思路分析：
（1）第一天有N个桃子，吃掉N/2-1个，得到第二天的桃子数

请帖完整代码.并且把结果发上来:)

萧萧北 发表于 2013-6-16 12:36
楼主抱歉，我粘贴出现失误，怎么看不到自己的内容了 敬请谅解

那就从新发表一下.吧.记得带上运行结果

看不到？

1. 
   
2. public class houtaozi {
   
3.         public static void main(String[] args){
   
4.                 int a=1;
   
5.                 for(int i=1;i<=10;i++){
   
6.                         a=(a+1)*2;
   
7.                 }
   
8.                 System.out.println(a);
   
9.         }
   
10. 
    
11. }
    

复制代码

。。。。。。。。。。。

public class Test3 {

        public static void main(String[] args) {
                 int num = 1 ;//第十天剩下一个
                 for(int i=2; i<=10; i++)
                //第一天的桃子数是第2天桃子数加1后的2倍,第二天的桃子数是第三天桃子数加1后的2倍 ，依次推理
                  num = (num+1)*2;
                 System.out.println("猴子第一天一共摘下了 " + num + " 个桃子");

        }

}

猴子第一天一共摘下了 1534 个桃子

public class Test3 {

        public static void main(String[] args) {
                 int num = 1 ;//第十天剩下一个
                 for(int i=2; i<=10; i++)
                //第一天的桃子数是第2天桃子数加1后的2倍,第二天的桃子数是第三天桃子数加1后的2倍 ，依次推理
                  num = (num+1)*2;
                 System.out.println("猴子第一天一共摘下了 " + num + " 个桃子");

        }

}

猴子第一天一共摘下了 1534 个桃子

看题目罗，看题目罗，

1. 
   
2. public class houtaozi {
   
3.         public static void main(String[] args){
   
4.                 int a=1;
   
5.                 for(int i=1;i<=10;i++){
   
6.                         a=(a+1)*2;
   
7.                 }
   
8.                 System.out.println(a);
   
9.         }
   
10. 
    
11. }
    

复制代码

万琪 发表于 2013-6-16 13:38
看题目罗，看题目罗，

1. package active;
   
2. 
   
3. /*
   
4. * 猜一猜猴子摘了多少桃子呢?
   
5. 
   
6. 
   
7. 猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
   
8. 剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候就发现剩下
   
9. 一个桃子了.求第一天一共摘下了多少桃子呢?
   
10. */
    
11. public class Test1 {
    
12.         public static void main(String[] args) {
    
13.                 Test1 test1 = new Test1();
    
14.                 test1.reEat();
    
15.         }
    
16. 
    
17.         // 桃子总数
    
18.         int tao;
    
19. 
    
20.         // 吃桃子
    
21.         void eat(int tao) {
    
22.                 if (tao != 1) {
    
23.                         tao = tao / 2 - 1;
    
24.                         eat(tao);
    
25.                 } else
    
26.                         System.out.println("吃完了，剩" + tao + "个");
    
27.         }
    
28. 
    
29.         // 逆向思维
    
30.         // 剩一个
    
31.         int taoed = 1;
    
32.         int day = 10;
    
33. 
    
34.         void reEat() {
    
35.                 if (day != 1) {
    
36.                         taoed = (taoed + 1) * 2;
    
37.                         day--;
    
38.                         reEat();
    
39.                 } else
    
40.                         System.out.println("原来有" + taoed + "个");
    
41.         }
    
42. }

复制代码

结果：
原来有1534个

dongpunk 发表于 2013-6-16 13:40

再仔细看看思路哦

我来看看，是神马题目啊

class ChiTaoDemo
{
        public static void main(String[] args)
        {
                int Day = 10;  //定义天数
                int Tao = ChiTao.Chi(Day); //传递天数，并将返回值赋给Tao
                System.out.println(Tao);//输出桃子总数
               
               
        }
}

class ChiTao
{
        private static int x = 1; //定义开始的天数，第一天
        private static int last = 1;//定义最后一天的桃子数量，并准备对此进行累加计算

        public static int Chi(int Day) //按倒叙排列计算
        {
                if(x<=Day)//如果最后一天递减至第一天之后，停止判断，否则继续递归调用
                {
                last = (last+1)*2;//这里是将算法倒叙，(总数/2)+1，反过来就是（剩下的+1）*2，最后把值累加赋给静态变量last
                Chi(--Day);//天数减去一天，递归
                }
               
                return last;//返回累计后的总数
        }
}

看看，尝试一下