刚才忘了截图了
C:\Users\hxh\Desktop

看题了~~~

public class Test1 {
        public static void main(String[] args) {
                System.out.println("第一天一共摘下了"+statistics(10)+"个桃子");
        }
        private static int statistics(int i) {
                //statistics(i)与第(10-i+1)天桃数对应
                if(i>1)//前桃子数量是后一天数量+1的两倍
                        return (statistics(i-1)+1)*2;
                else//第10天剩一个桃
                        return 1;
        }
}

class GetSum {

        /**
         * @param args
         * 猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,
     * 第二天早上又将剩下的桃子吃了一半,又多吃了一个,
     * 以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候就发现剩下一个桃子了.
         * 求第一天一共摘下了多少桃子呢?
         *
         *解题思路：递归思想：刚摘下来N个桃子
         *假设每一天没吃之前有num(n)个桃子
         *第一天有N个    N= num(1)
         *第二天有 num(2)=num(1)/2-1    num(1)=(num(2)+1)*2
         *第三天有 num(3)=num(2)/2-1    num(2)=(num(3)+1)*2
         *...
         *
         *反过来想
         *第十天只有1个桃子num(10)=1
         *那么第九天有num(9)=2*(num(10)+1);
         *第八天有 num(8)=2*(num(9)+1);
         *...
         *第1天  N=2*(num(2)+1)
         *
         *求出N共需要迭代9次
         */
       
       
        public static void main(String[] args) {
                // TODO Auto-generated method stub
               
  
        System.out.println("桃子的总数是："+getnum(1));
        }
        public static int getnum(int n)//迭代函数
        {
                if(n>10 || n<1)
                        System.out.println("输入数据不合法");
                if (n == 10)//第十天有1个桃子
                        return 1;
                else
                    return 2*(getnum(n+1)+1);
        }

}

你回复的东东无法看到啊，被隐藏了；这个题之所以用超时了是因为这个题本身有点问题，逆向思维推理，很容易就推理出来，但得到结果后再正向推理，就出现问题了，如第一天是1023，那么一半就会出现几分之几的麻烦，但想了下既然你们说这个题简单，应该考虑的就是先减1再一半了，所以说这个题不严谨........

蚂蚁搬家 发表于 2013-6-15 17:27
做出来了，第一天小猴总共摘了1534个桃子！

谢谢鼓励，我会继续努力滴！:lol

还你妹妹限时。来迟！

qiudengqiang 发表于 2013-6-15 17:37
我看看小鑫鑫搞了什么好东东！

你又来看了  ;P

我看看小鑫鑫搞了什么好东东！

1. /*
   
2. 看题时间：2013年6月15日 17:01:46
   
3. 结束时间：2013年6月15日 17:31:34
   
4. 题目：猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
   
5. 剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候就发现剩下
   
6. 一个桃子了.求第一天一共摘下了多少桃子呢?
   
7. 
   
8. 审题思路：
   
9. 1.猴子：monkey;桃子：peach。
   
10. 2.因为只有第十天的个数是明确的，故采用逆向思维法。
    
11. 3.第十天早上的时候发现剩下1个桃子，说明第九天吃完后剩下最后一个。
    
12. 4.用第九天吃下的最后一个加1再X2，则就是第八天吃完后剩下的个数。
    
13. 。。。。
    
14. 5.同理那么第二天吃下的最后一个加1再X2，就是第一天吃完后剩下的个数。
    
15. 6.再加1乘2就是第一天一共摘下的桃子的个数了。
    
16. 7.共循环了9次
    
17. 
    
18. 
    
19. */
    
20. class MonkeyEat
    
21. {
    
22.         public static void main(String[] args)
    
23.        {
    
24.               int N = 1;//第九天吃完后剩下最后一个
    
25.               for (int x=9; x>=1; x--)//利用for循环，每循环一次“审题思路”向前推一步。共9次。
    
26.              {
    
27.                    if(x<=9)
    
28.                   {
    
29.                         N = (N+1)*2 ;
    
30.                   }
    
31.             }
    
32.             System.out.println("第一天一共摘下了："+N+" 个桃子");
    
33.     }
    
34. }
    

复制代码

傻瓜一点红 发表于 2013-6-15 17:27
这个题出得不严谨啊，如果总数出现时奇数的时候，这个题就不是那么简单的了，还得推算几分之几，这就有点麻 ...

你可以试一下，从第一天开始算的算法，如果可行，技术分多多的  从第十天开始算的话，不会出现你说的这种情况..

张俊迪 发表于 2013-6-15 17:27
刚才仔细看题意现在用递归写一个你看看吧，不知还有分不不写注释了，都一个原理 ...

谢谢了！！

1. /**
   
2. * 第一次看题时间：2013-06-15   17:28:35
   
3. * @author Chu
   
4. */
   
5. public class MonkeyAndPeach {
   
6.         //存储每天的桃子数
   
7.         private static int count=1;
   
8. 
   
9.         public static int num(int time){
   
10.                 // 如果是第一天那么递归结束
    
11.                 if(time==1){
    
12.                         System.out.println("一共摘的桃子数为："+count);
    
13.                         return count;
    
14.                 }else{//如果不是第一天那么一直递归求前一天的桃子数
    
15.                         System.out.println("第"+time+"天有"+count+"个桃子");
    
16.                         count=count*2+1;
    
17.                         time=time-1;
    
18.                         num(time);
    
19.                 }
    
20.                 return count;
    
21.         }
    
22.        
    
23.         public static void main(String[] args) {
    
24.                 System.out.println(num(10));
    
25.         }
    
26. }
    

复制代码

【运行结果】如下：

1. 第10天有1个桃子
   
2. 第9天有3个桃子
   
3. 第8天有7个桃子
   
4. 第7天有15个桃子
   
5. 第6天有31个桃子
   
6. 第5天有63个桃子
   
7. 第4天有127个桃子
   
8. 第3天有255个桃子
   
9. 第2天有511个桃子
   
10. 一共摘的桃子数为：1023

复制代码

不用送分，刚已经给过分了，但没有用递归写。这次用递归写的，就是检验自己的算法水平。
public class test1 {
        public static void main(String[] args)
        {
                System.out.println("一共"+TaoZi(10)+"桃子");//打印一共有多少桃子
        }
        public static int TaoZi(int i)
        {
                if(i==1)           //判断，当第10天的时候，只剩一个桃子
                {
                        return 1;
                }       
           return (TaoZi(i-1)+1)*2;//递归算出有多少桃子
        }
}
打印结果：一共1534桃子

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个桃子！

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

张俊迪 发表于 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. }

复制代码

不写注释了，都一个原理

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

又有福利喽

我来试试