public class MonkeyPeach {
    /*逆推法
     * n1=1-->n2=(1+1)*2-->n3=(n1+1)*2...
     */
        public static void main(String[] args) {
                int days=1;
                int peachs=1;
                while(days<10){
                        peachs=(peachs+1)*2;
                        days++;
                }
                System.out.println(peachs);//结果1534
        }
}

题目是什么？？？

想看看是什么样的题目呢

1. package test;
   
2. 
   
3. import com.f.io.F;
   
4. 
   
5. public class Test {
   
6. 
   
7.         private static int day = 10;
   
8.         private static int sum = 0;
   
9.         public static void main(String[] args){
   
10.                 getNum(1);//计算第十天剩下1个桃子，第一天摘了多少桃子
    
11.                 System.out.println(sum);
    
12.         }
    
13.        
    
14.         public static void getNum(int num){//假设第十天剩下了num个桃子
    
15.                 day--;
    
16.                 sum = (num+1)*2;//第九天剩下了sum个桃子
    
17.                 if(day>1)//一直计算到第一天
    
18.                         getNum(sum);
    
19.         }
    
20. }
    
21. 
    
22. 
    
23. //输出结果为 1534

复制代码

我来试试

走你 给力 给力

我要技术分~~~~~

1. package it.cast.strem;
   
2. /**  
   
3. * 题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个 第二天早上又将剩  
   
4. * 下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。  
   
5. * 程序分析：采取逆向思维的方法，从后往前推断。  
   
6. */   
   
7. public class Monkey_Demo {   
   
8. //定义一个main方法，jvm虚拟机保证程序的独立运行
   
9. public static void main(String[] args) {   
   
10. //定义一个一维数组
    
11. int[] arr = new int[10];   
    
12. //定义一个最大下标为1个桃子
    
13. arr[9] = 1;   
    
14. // 下面利用的是数组和循环将每天的桃子数量都求出来了   
    
15. for (int i =arr.length - 1; i > 0; i--) {   
    
16.         //按情况来说当天的都是次天的桃子的二倍还多二个
    
17. arr[i - 1] = 2 * (arr[i] + 1);   
    
18. }   
    
19. //遍历数组
    
20. for (int i = 0; i < arr.length; i++) {   
    
21. System.out.println(arr[i]);   
    
22. }   
    
23. System.out.println("第一天的桃子数："+getarr_Num(10, 1));   
    
24. }   
    
25.   
    
26. // 利用递归的方法来求第一天的桃子数，day是天数，num是当天的桃子数，原理与上述类似
    
27. public static int getarr_Num(int day, int arr_num) {   
    
28. if (day == 1)   
    
29. return arr_num;   
    
30. else if (day < 1 || arr_num < 0)   
    
31. return 0;   
    
32. else   
    
33. return getarr_Num(day - 1, (arr_num + 1) * 2);   
    
34. }   
    
35. 
    
36. }  
    
37. 
    

复制代码

运行结果：
1534
766
382
190
94
46
22
10
4
1
第一天的桃子数：1534

李征 发表于 2013-6-16 16:31
class ChiTaoDemo
{
        public static void main(String[] args)

我多判断了一天，应该是<10，我写成了<=10,所以错了，还是读题不深呐，唉，不求技术分，只为锻炼，所以我也没再回复了

1. package com.itheima.bbs.peach;
   
2. 
   
3. public class PeachTest {
   
4. 
   
5. /**
   
6. * 猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
   
7. * 剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,
   
8. * 到第十天早上的时候就发现剩下一个桃子了.求第一天一共摘下了多少桃子呢?
   
9. */
   
10. public static void main(String[] args) {
    
11. //i代表第几天，m代表吃完剩下的桃子数目
    
12. int i,m;
    
13. //n代表第一天一共摘的桃子数目
    
14. int n=1;
    
15. //布尔变量，控制跳出循环
    
16. boolean flag = false;
    
17. while(true){
    
18. n++;
    
19. m=eatPeach(n);
    
20. //由于第一天的桃子已经吃了(就是上一句),所以从第二天开始循环，直到第10天，如果桃子数目正好是1个，则当时的n就是正确结果
    
21. for(i=2;i<11;i++){
    
22. m=eatPeach(m);
    
23. if(m==1){
    
24. //如果吃后剩下的桃子数目是1个，还要判断是第几天
    
25. if(i==10){
    
26. flag = true;
    
27. }else{
    
28. //跳出for循环
    
29. break;
    
30. }
    
31. }
    
32. }
    
33. if(flag){
    
34. System.out.println("猴子第一天一共摘下了"+n+"桃子");
    
35. //跳出while循环
    
36. break;
    
37. }
    
38. }
    
39. 
    
40. }
    
41. //猴子每次吃后剩下m个
    
42. public static int eatPeach(int n){
    
43. int m;
    
44. m = n/2-1;
    
45. return m;
    
46. }
    
47. }
    
48. 
    

复制代码

运行结果：猴子第一天一共摘下了3070桃子
虽然晚了，但是还是发出来，请赐教。呵呵

/*
猜一猜猴子摘了多少桃子呢?


猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候就发现剩下
一个桃子了.求第一天一共摘下了多少桃子呢?
*/
class  TaoZi
{
        public static void main(String[] args)
        {
                int sum = 0;
                sum = sum(1);
                System.out.println("一共吃了"+sum+"个桃子");
        }
        public static int sum(int day)//递归算法
        {
                int count = 0;
                if(day == 10)
                count = 1;
                else
                        count = (sum(day+1)+1)*2;//今天的总量等于下一天的总量加上一个的和的2倍
                return count;
        }
}


答案是
Microsoft Windows [版本 6.1.7601]
版权所有 (c) 2009 Microsoft Corporation。保留所有权利。

C:\Users\Administrator>g:

G:\>cd javapractice

G:\javaPractice>javac TaoZi.java

G:\javaPractice>java TaoZi
一共吃了1534个桃子

不好意思 本本不能上网  只能酱紫了--1

错过了唉？以后要多多关注一下:L

我也想要，能看到题目么？

wangpan 发表于 2013-6-16 21:38
运行结果：猴子第一天一共摘下了3070桃子
虽然晚了，但是还是发出来，请赐教。呵呵

我知道是哪里出问题了，因为最后一天没有吃就剩下1个了。所以我那个for循环应该改成：for(i=2;i<10;i++)并且在只剩下1个桃子的时候，应该用9判断
谢谢指正哦~

1. 
   
2. <P>package com.itheima.bbs.peach;</P>
   
3. <P>public class PeachTest {</P>
   
4. <P> /**
   
5.   * 猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
   
6.   * 剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,
   
7.   * 到第十天早上的时候就发现剩下一个桃子了.求第一天一共摘下了多少桃子呢?
   
8.   */
   
9. public static void main(String[] args) {
   
10.   //i代表第几天，m代表吃完剩下的桃子数目
    
11.   int i,m;
    
12.   //n代表第一天一共摘的桃子数目
    
13.   int n=1;
    
14.   //布尔变量，控制跳出循环
    
15.   boolean flag = false;
    
16.   while(true){
    
17.    n++;
    
18.    m=eatPeach(n);
    
19.    //由于第一天的桃子已经吃了(就是上一句),所以从第二天开始循环，直到第9天吃完，如果剩下的桃子数目正好是1个，则当时的n就是正确结果
    
20.    for(i=2;i<10;i++){
    
21.     m=eatPeach(m);
    
22.     if(m==1){
    
23.      //如果吃后剩下的桃子数目是1个，还要判断是第几天
    
24.      if(i==9){
    
25.       flag = true;
    
26.      }else{
    
27.       //跳出for循环
    
28.       break;
    
29.      }
    
30.     }
    
31.    }
    
32.    if(flag){
    
33.     System.out.println("猴子第一天一共摘下了"+n+"桃子");
    
34.     //跳出while循环
    
35.     break;
    
36.    }
    
37.   }
    
38. /*  for(i=1;i<10;i++){
    
39.    n=(n+1)*2;
    
40.   }
    
41.   System.out.println(n);*/
    
42.   
    
43. }
    
44. //猴子每次吃后剩下m个
    
45. public static int eatPeach(int n){
    
46.    int m;
    
47.    m = n/2-1;
    
48.    return m;
    
49. }
    
50. }</P>
    
51. <P>
    
52. </P>

复制代码

结果为：猴子第一天一共摘下了1534桃子

我想看看噻

回复看下把！！！

1. 
   
2. public class Demo {
   
3. 
   
4.         /**
   
5.          * @param args
   
6.          */
   
7.         public static void main(String[] args) {
   
8.        System.out.println(tianShu(10));
   
9.         }
   
10.         public static int  tianShu(int day)
    
11.         {
    
12.                 int x;//记录桃子的数量
    
13.                 if(day==1)
    
14.                 {
    
15.                         x=1;
    
16.                 }else
    
17.                 {
    
18.                         //前一天的桃子数目等于后一天数量加1乘2
    
19.                         x =2*(tianShu(day-1)+1);
    
20.                 }
    
21.                
    
22.                 return x;
    
23.                
    
24.         }
    
25. }

复制代码

结果是：1534

知行 发表于 2013-6-16 23:25
我想看看噻

谢谢了  ，技术分相当的缺啊:)

希望我能会做

1. <div class="blockcode"><blockquote>class Demo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int x = 1;
   
6. 
   
7.                 for (int y = 10;y>=1 ;y-- )
   
8.                 {
   
9.                         x = (x+1)*2;
   
10. 
    
11.                         System.out.println("第"+y+"天"+"有"+x+"个桃子");
    
12.                 }
    
13.         }
    
14. }

复制代码