黑马程序员技术交流社区

标题: ====>送技术分啦!答题有奖活动,快快参加吧!====< [打印本页]
作者: 孙百鑫    时间: 2013-6-15 16:11
标题: ====>送技术分啦!答题有奖活动,快快参加吧!====<
本帖最后由 巩建 于 2013-6-18 20:51 编辑

活动结束
嘿嘿~福利来了,送技术分啦,只要你敢答出来,我就敢给技术分

  巩建友情提示您：真的很简单，不要被限时吓到。
               
回复前需要看的提示
1. 本次答题时间限时15分钟，请先弄好运行环境。
2. 超过30分钟的，酌情给分..
3. 本次题目，对初学者而言，只用到毕老师视频中前四天的知识。
4. 需要写出完整代码，不要用几句数学语言就解决了。
5. 如果您看完前四条.请先配置好运行环境.那么开始回复看题目吧!
6.一人只能占一个楼层。





要求:
1.题目要自己做出来不要借助百度等资料(因为也不太难);  
2.将程序写的清晰明了.注释到位.
3.回复的时候把代码贴出来.和运算后结果的图片
（不会弄图片的把答案写出来） 不然不给分操作量太大，谢谢了


4.看完题目之后要在1小时内答出来.
5.如果正向思维解决，酌情加分，不限时（在此感谢（傻瓜一点红））但是，请在结束前完成。
万恶的鑫鑫，一直是我在加分。。。{:soso_e135:}
提示:
1.代码放到代码块中,不要压缩包(压缩包会累死的);
2.根据刘凯版主的建议,根据时间来和上面的要求,来个给相应的技术分
看题的时间我会记录住.答题的时间最好附上自己第一次看题的时间(不可以从新编译!).

关于技术分:
1.如果你得到正确答案并在规定的时间内会奖励技术分+1;
2.如果你不使用循环( 可是使用递归哦~)
得到正确答案会得到+2的技术分奖励;
3.如果你满足前两条.并且思路明晰注释到位.那么技术分+3!
---------------------------------------------------------------------------------------------
别再犹豫了.赶快答题吧!截止日期 6月17晚11点!
最后祝大家加技术分多多!

如果回答了问题,但是没有加技术的话.可以联系我!--->283122529.
注意注意在注意:一定要把运行后的截图发上来!!!!



作者: 夜默    时间: 2013-6-15 16:11
本帖最后由 巩建 于 2013-6-15 16:13 编辑

public class Test {
        public static void main(String[] args) {
                int j=1;//桃子数量   
                for(int i=1;i<10;i++){
                        j=(j+1)*2;//逆向思维  从最后一天往前算
                }
                System.out.println("第一天摘了"+j+"个桃子！");
        }
}

QQ图片20130615161258.jpg (8.03 KB, 下载次数: 0)

QQ图片20130615161258.jpg
作者: 袁梦希    时间: 2013-6-15 16:21
本帖最后由 袁梦希 于 2013-6-15 17:12 编辑

沙发   鑫鑫出的题很好  继续努力

public static void main(String[] args) {
         System.out.println(taozi(1));
}
// 递归调用法
public static int taozi(int sum) {
        int p;
        if (sum == 10) {
                p = 1;
        } else {
                p = (taozi(sum + 1) + 1) << 1;
        }
       return p;
}

作者: 神之梦    时间: 2013-6-15 16:25
我只看题目
作者: 曹秀云    时间: 2013-6-15 16:25
有没搞错这还要隐藏啊!!!!
作者: 高贵杰    时间: 2013-6-15 16:25
看看题
作者: cnbajie    时间: 2013-6-15 16:25
看看什么灰机
作者: kimi    时间: 2013-6-15 16:25
给力啊啊啊
作者: 董立权    时间: 2013-6-15 16:29
这个怎么答题
作者: 金辉    时间: 2013-6-15 16:31
看看~~~~
作者: 张俊迪    时间: 2013-6-15 16:32
looklook   
作者: 蔡汉康    时间: 2013-6-15 16:32
来看看{:soso_e100:}
作者: 蚂蚁搬家    时间: 2013-6-15 16:34
先看一下再说
作者: 蚂蚁搬家    时间: 2013-6-15 16:35
先看一下再说
作者: 曹秀云    时间: 2013-6-15 16:38

public class MonkeyDemo {
        
   
    public static void main(String[] args) {
            int day=9,x=1,y=0;
                while(day>0)
            {
                    y=(x+1)*2;//第一天的桃子是第二天的桃子的个数加1在乘以2
                    x=y;
                    day--;
            }
       System.out.println("第一天摘了"+y+"个桃子");
    }
}
作者: 董立权    时间: 2013-6-15 16:40
public class Demo
{
        public static void main(String[] args)
        {
                int num=1;//第十天剩余的桃子
                for (int x=9;x>=1 ;x-- ) //用循环求出第一天的桃子书
                {
                        num=(num+1)*2;//上一天的桃子数
                }
                System.out.println("一共有桃子"+num);
        }
       
}

作者: 孙百鑫    时间: 2013-6-15 16:40
疯子——小菜 发表于 2013-6-15 16:38
public class MonkeyDemo {
        
   

把运行后的截图发上来:)谢谢您的配合
作者: 孙百鑫    时间: 2013-6-15 16:41
董立权 发表于 2013-6-15 16:40
public class Demo
{
        public static void main(String[] args)

把运行后的截图发上来:)谢谢您的配合
作者: 傻瓜一点红    时间: 2013-6-15 16:41
look一下
作者: cnbajie    时间: 2013-6-15 16:47
  1. public class FuckTao {

  3.         /**
  4.          * @param bajie
  5.          */
  6.         public static void main(String[] args) {
  7.                
  8.                 //最后一个
  9.                 int num=1;
  10.                
  11.                 //10天吃的
  12.         for(int i=1;i<10;i++){
  13.             num=(num+1)*2;
  14.         }
  15.         System.out.println("个数::"+num);
  16.         }

  18. }
复制代码

WNSJ$8C5FC46)2)U~DVR3`W.jpg (2.28 KB, 下载次数: 0)

WNSJ$8C5FC46)2)U~DVR3`W.jpg
作者: 张俊迪    时间: 2013-6-15 16:47
  1. public class Test8 {

  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
作者: 金辉    时间: 2013-6-15 16:49
  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.        

  16. }
复制代码

QQ截图20130615164826.png (10.35 KB, 下载次数: 0)

QQ截图20130615164826.png
作者: 蔡汉康    时间: 2013-6-15 16:51
  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. }
复制代码

QQ截图20130615165320.png (5.27 KB, 下载次数: 0)

QQ截图20130615165320.png
作者: 小羽天空    时间: 2013-6-15 16:53
刚睡醒就来了
作者: xiaohu1218    时间: 2013-6-15 16:56
可以答题了^-^
作者: 刘利民    时间: 2013-6-15 16:57
好激动啊，先看看。。
作者: 刘晓    时间: 2013-6-15 17:01
look,look.......
作者: 刘晓    时间: 2013-6-15 17:13
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 17:14
金辉 发表于 2013-6-15 16:49

编辑不了自己的是怎么回事啊？
作者: 刘晓    时间: 2013-6-15 17:14
打印结果：
一共有1534桃子
作者: 刘晓    时间: 2013-6-15 17:16
瞎了，忘记使用递归了。。。哎。这么简单。
作者: 傻瓜一点红    时间: 2013-6-15 17:17
  1. /*
  2. 题目：猜一猜猴子摘了多少桃子呢?
  3. 猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
  4. 剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候就发现剩下
  5. 一个桃子了.求第一天一共摘下了多少桃子呢?

  7. 思路：1、此题是一个数学推理题，可以采用逆向思维进行推理，先定义一个方法用表达式表示出第九天的结果；
  8.           2、利用递归原理调用计算方法，这样即可得到计算结果。

  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. }
复制代码
计算结果

QQ截图20130615171445.jpg (22.07 KB, 下载次数: 0)

QQ截图20130615171445.jpg
作者: 杨政    时间: 2013-6-15 17:18
先看看再说
作者: 小羽天空    时间: 2013-6-15 17:20
public static void main(String[] args)
{
        int x = 1;
        for(int i =2;i<=10;i++)
        {
                x=(x+1)*2;
        }
        System.out.println(x);
}
作者: tpsu88    时间: 2013-6-15 17:22
我来试试
作者: Heart    时间: 2013-6-15 17:24
又有福利喽
作者: 小羽天空    时间: 2013-6-15 17:26
结果忘给了，不好意思哈。1534
作者: 张俊迪    时间: 2013-6-15 17:27
张俊迪 发表于 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. }
复制代码
不写注释了，都一个原理
作者: 傻瓜一点红    时间: 2013-6-15 17:27
这个题出得不严谨啊，如果总数出现时奇数的时候，这个题就不是那么简单的了，还得推算几分之几，这就有点麻烦了，这个奇数的一半就出现小数了.........{:soso_e127:}
作者: 蚂蚁搬家    时间: 2013-6-15 17:27
  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个桃子！

作者: 刘晓    时间: 2013-6-15 17:33
不用送分，刚已经给过分了，但没有用递归写。这次用递归写的，就是检验自己的算法水平。
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桃子
作者: Heart    时间: 2013-6-15 17:34
  1. /**
  2. * 第一次看题时间：2013-06-15   17:28:35
  3. * @author Chu
  4. */
  5. public class MonkeyAndPeach {
  6.         //存储每天的桃子数
  7.         private static int count=1;

  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
复制代码
作者: 张俊迪    时间: 2013-6-15 17:34
张俊迪 发表于 2013-6-15 17:27
刚才仔细看题意现在用递归写一个你看看吧，不知还有分不不写注释了，都一个原理 ...

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

你可以试一下，从第一天开始算的算法，如果可行，技术分多多的  从第十天开始算的话，不会出现你说的这种情况..
作者: 刘利民    时间: 2013-6-15 17:35
  1. /*
  2. 看题时间：2013年6月15日 17:01:46
  3. 结束时间：2013年6月15日 17:31:34
  4. 题目：猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
  5. 剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候就发现剩下
  6. 一个桃子了.求第一天一共摘下了多少桃子呢?

  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次


  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. }
复制代码

Z`Y~3I9AV)1H7OO0M9EB`(B.jpg (40.2 KB, 下载次数: 0)

运行结果

运行结果
作者: To    时间: 2013-6-15 17:37
我看看小鑫鑫搞了什么好东东！
作者: 袁梦希    时间: 2013-6-15 17:39
qiudengqiang 发表于 2013-6-15 17:37
我看看小鑫鑫搞了什么好东东！

你又来看了  ;P
作者: To    时间: 2013-6-15 17:39
还你妹妹限时。来迟！
作者: 蚂蚁搬家    时间: 2013-6-15 17:40
蚂蚁搬家 发表于 2013-6-15 17:27
做出来了，第一天小猴总共摘了1534个桃子！

谢谢鼓励，我会继续努力滴！:lol
作者: 傻瓜一点红    时间: 2013-6-15 17:47
你回复的东东无法看到啊，被隐藏了；这个题之所以用超时了是因为这个题本身有点问题，逆向思维推理，很容易就推理出来，但得到结果后再正向推理，就出现问题了，如第一天是1023，那么一半就会出现几分之几的麻烦，但想了下既然你们说这个题简单，应该考虑的就是先减1再一半了，所以说这个题不严谨........
作者: xiaohu1218    时间: 2013-6-15 17:52
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);
        }

}


作者: 杨政    时间: 2013-6-15 17:54
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;
        }
}
作者: 王鑫    时间: 2013-6-15 17:55
看题了~~~
作者: xiaohu1218    时间: 2013-6-15 18:01
刚才忘了截图了
C:\Users\hxh\Desktop
作者: yin1031468524    时间: 2013-6-15 18:02
来看看、、
作者: chenwenbin    时间: 2013-6-15 18:03
哈哈哈  是什么东东，我来也
作者: toShareBeauty    时间: 2013-6-15 18:03
黑马酝酿了良好的学习氛围:)
作者: xiaohu1218    时间: 2013-6-15 18:05
xiaohu1218 发表于 2013-6-15 17:52
class GetSum {

        /**

请教下，我之前没贴过图片，不太会用图片功能，汗一个。。
作者: yasyas001    时间: 2013-6-15 18:16
看哈
做题才能提高啊,才能理解很多问题,
作者: yin1031468524    时间: 2013-6-15 18:16
yin1031468524 发表于 2013-6-15 18:02
来看看、、
  1. package com.itheima;

  3. public class Peach
  4. {
  5.         /**
  6.          * @param args
  7.          */
  8.         public static void main(String[] args)
  9.         {
  10.                 int count = 0;  // 记录每天吃的桃子数
  11.                 int next = 1; //定义最后一天桃子的个数
  12.                 for(int i =9;i>=1;i--){
  13.                         count = (next+1)*2;
  14.                         next = count;
  15.                 }
  16.                 System.out.println("total peach="+count);

  18.         }

  20. }
复制代码
运行结果：
total peach=1534
作者: peerless2012    时间: 2013-6-15 18:18
来看看  试一下
作者: Heart    时间: 2013-6-15 18:20
Heart 发表于 2013-6-15 17:34
【运行结果】如下：

???
结果不对吗？怎么没技术分呢
作者: Heart    时间: 2013-6-15 18:21
???
结果不对吗？怎么没技术分呢
作者: 傻瓜一点红    时间: 2013-6-15 18:22
两位版主，不好意思，发现刚才我的那个计算结果是错的，思路没错，但结果错了，为了不误导大家 ，现将计算结果和代码重新修正如下，至于技术分都是其次的，因为我的早就25分了，主要是为了回顾一下

知识点
  1. /*
  2. 题目：猜一猜猴子摘了多少桃子呢?
  3. 猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
  4. 剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候就发现剩下
  5. 一个桃子了.求第一天一共摘下了多少桃子呢?

  7. 思路：1、此题是一个数学推理题，可以采用逆向思维进行推理，先定义一个方法用表达式表示出第九天的结果；
  8.           2、利用递归原理调用计算方法，这样即可得到计算结果。

  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.                 System.out.println("第"+i+"天有"+sum+"个桃子");
  20.                 sum=(sum+1)*2;
  21.                 i--;
  22.                 if(i>0)
  23.                         jiSuan(i,sum);//递归调用
  24.         }       
  25.         public static void main(String[] args)
  26.         {
  27.                 jiSuan(10,1);//调用计算方法
  28.         }
  29. }
复制代码
计算结果如下：




QQ截图20130615171445.jpg (22.51 KB, 下载次数: 0)

计算结果

计算结果
作者: Heart    时间: 2013-6-15 18:27
Heart 发表于 2013-6-15 17:34
【运行结果】如下：

思路走过了，以前这个问题做过，所以不难
作者: tpsu88    时间: 2013-6-15 18:29
这个结果对吗？
  1. /**
  2. *题目：猜一猜猴子摘了多少桃子呢?
  3. *猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
  4. *剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候就发现剩下
  5. *一个桃子了.求第一天一共摘下了多少桃子呢?
  6. *思路：1、猴子当天吃的和次天吃的桃子数是变量。
  7. *    2、第二天剩的桃子，是前一天的一半减一，已知最后一天剩一个，可以往前推算。
  8. *步骤1、定义最后一天剩1个i2=1，初始化倒数第二天i1=0。
  9.      2、前一天桃子的数量是第二天加一个再2倍的数量。
  10. * */
  11. public class Monkey {
  12.         public static void main(String[] args) {
  13.                 //定义i1为第一天吃的桃子数量，i2为次天吃的桃子数量，day为天数
  14.                 int i1 = 0;
  15.                 int i2 = 1;//最后一天只剩1个
  16.                 //定义day第10天
  17.                 for(int day=9; day>0; day--) {
  18.                         i1 = (i2+1) *2;//因为次天剩的是前一天的一半再减一个，即/2-1。
  19.                                                     //所以前一天是次天的加一个的2倍，即+1 *2。
  20.                         i2=i1;//前一天变次天，往前推进
  21.                 }
  22.                 System.out.println(i1);//最初桃子数量
  23.                
  24.         }
  25. }
复制代码
作者: peerless2012    时间: 2013-6-15 18:32
我做出来了
  1. class Demo2
  2. {
  3.         /*基本思路：
  4.          * 可以把顺倒过来，正序是每天吃一半多一个，第十天开始发现剩余一个，说明上面的过程重复了9遍
  5.          * 倒序的话本来一个，每一天加上一个再乘以2，循环9次
  6.          * for循环，循环9次，每次都是在上次基础上加1乘以2.第一次是1加上1乘以2
  7.          * */
  8.         public static void main(String[] args) {
  9.                 //第十天剩余1个桃子
  10.                 int num=1;
  11.                 for (int i = 0; i < 9; i++) {
  12.                         //每次加上1，再乘以2
  13.                         num=(num+1)*2;
  14.                 }
  15.                 //输出结果
  16.                 System.out.println(num);
  17.         }
  18. }
复制代码
结果：
作者: tpsu88    时间: 2013-6-15 18:32
这个是结果！

QQ图片20130615183041.jpg (13.83 KB, 下载次数: 0)

运行结果

运行结果
作者: peerless2012    时间: 2013-6-15 18:35
peerless2012 发表于 2013-6-15 18:32
我做出来了结果：

上传图片，结果附件没有确认插入，截图如下





作者: 董延京    时间: 2013-6-15 18:36
看看是什么题目
作者: 王靖远    时间: 2013-6-15 18:49
我来看看啊
作者: 王靖远    时间: 2013-6-15 19:01
class ZhuanFen
{
public static void main(String[] args)
{
  
  int count = 1;//最后一天剩下的桃子数，并用它来当计数器记录前一天的桃子数
  
  for (int x=0;x<8 ;x++ )//因为是第十天早上发现桃子只有一个 所以第九天早上吃完后就剩1个桃子了，所以要循环9次。
  {
   count = (count+1)*2;//计算前一天的桃子数，并用计数器记录
  }
  System.out.println(count);
  
}
}

作者: 董延京    时间: 2013-6-15 19:03
提交代码，查看题目大概在二十六分钟前(系统说的)。
  1. public class Test11 {
  2. /**
  3. * 猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
  4.         剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候就发现剩下
  5.         一个桃子了.求第一天一共摘下了多少桃子呢?
  6.         
  7. * 分析：如下，前一天吃掉的一半，在吃去一个，就是第二天的。可以有下的公式。      
  8. * a(n) = a(n-1)/2-1;
  9. * a(n-1) = 2[a(n)+1] 那么根据这个公司，可以根据后一天推算出前一天的，叠加出天数。就可以。
  10. */
  11.         public static void main(String[] args) {
  12.                 System.out.println(getNum(10));//1534
  13.         }
  14.         public static int getNum(int day){
  15.                 //第十天剩下的1个。
  16.                 int count = 1;
  17.                 //根据公式，前一天，等于后一天的数目的二倍加上两个。循环天数，最终可以算出第一天的。
  18.                 for(int i= 1;i<day;i++){
  19.                         count = 2*count +2;
  20.                 }
  21.                 //返回第一天的数目。
  22.                 return count;
  23.         }
  24. }
复制代码
作者: 傻瓜一点红    时间: 2013-6-15 19:07
两位版主，请教一个问题一下，因为对递归调用这块不是怎么熟悉，就这道题而言，如果用递归的方法，怎么能正确返回最后的值啊，意思就是只打印第一天的值，其它天数的不打印出来，我试了几次都木有能正确返回来，请问你们有木有比较好的方法啊？
  1. /*
  2. 题目：猜一猜猴子摘了多少桃子呢?
  3. 猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
  4. 剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候就发现剩下
  5. 一个桃子了.求第一天一共摘下了多少桃子呢?

  7. 思路：1、此题是一个数学推理题，可以采用逆向思维进行推理，先定义一个方法用表达式表示出第九天的结果；
  8.           2、利用递归原理调用计算方法，这样即可得到计算结果。

  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.                 System.out.println("第"+i+"天有"+sum+"个桃子");[color=Red]//这里打印出来的是每天的数值，请问在递归中有什么方法能只打印第一天的数值啊[/color]
  20.                 sum=(sum+1)*2;
  21.                 i--;
  22.                 if(i>0)
  23.                         jiSuan(i,sum);//递归调用
  24.         }       
  25.         public static void main(String[] args)
  26.         {
  27.                 jiSuan(10,1);//调用计算方法
  28.         }
  29. }
复制代码
作者: yasyas001    时间: 2013-6-15 19:43
public class Demo {
    public static void main(String[] args) throws Exception {
         //第十天的桃子,做为基数
          int x = 1;

       //变化从九天开始,时间倒流计算
       //第十天是1个,那么在它的基础加多吃一个,再这个基础上还有一半,那么就乘2,就是当天最多的桃子数量
       for (int i = 9; i >0; i--) {
                x=(x+1)*2;   
        //System.out.println(x);
         }
    System.out.println("第一天一共摘了"+x+"个桃子");
    }
}

11.jpg (4.03 KB, 下载次数: 0)

11.jpg
作者: 张玉保    时间: 2013-6-15 19:50
孙柏鑫你什么时候成了版主了
作者: 王鑫    时间: 2013-6-15 19:51
class  ChiTaoTest2
{
        public static void main(String[] args)
        {
       
                System.out.println("猴子第一天摘的桃子数是："+taozi(10));//打印10天前桃子总数
        }
               
        public static int taozi(int days)//定义一个函数求days天前的桃子总数
        {
                int sum;          //定义一个sum接收桃子总数
               
                if(days==1)       //最后一天桃子数是1
                        sum=1;
                else
                        sum=2*(taozi(days-1)+1);  //前一天桃子数是当天桃子数加1后的2倍
                return sum;
        }
               
}

作者: 陈新    时间: 2013-6-15 19:57
看看题目。。。。
作者: toShareBeauty    时间: 2013-6-15 20:02
  1. /**
  2. 需求:猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上
  3. 又将剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候
  4. 就发现剩下一个桃子了.求第一天一共摘下了多少桃子呢?

  6. 思路:
  7. 从这个文字的描述看，这个系统中包含的对象可以有猴子、桃子、桃子集合，整个系统发生的事情就是猴子
  8. 摘桃子、吃桃子，最后需要知道猴子第一天摘了多少桃子。如果把这个系统用计算机描述出来，并模拟系统
  9. 的运行，是可以知道猴子第一条摘多少桃子的。因为开始不知道猴子摘了多少桃子，所以只能逆着模拟系统
  10. 的正常情况来模拟运行。


  13. 步骤:
  14. 1.系统要运行需要桃子仓库，用来保存桃子，桃子仓库用可以动态增删元素的集合来表示
  15. 2.还需要猴子，猴子要有吃桃子的行为，由于是逆着模拟系统，所以根据当天剩余的桃子数量可以计算出当
  16. 天猴子吃掉的桃子，然后把猴子吃掉的保存进桃子仓库，这样就得到了上一天的仓库的桃子剩余数量，一直
  17. 递归调用猴子吃桃，直到 10 天前
  18. 3.把猴子吃掉10天后桃子仓库的数量打印出来就是猴子摘的桃子的总量
  19. */
  20. import java.util.*;

  22. class MonkeyAndPeachMain
  23. {
  24.     public static void main(String[] args)
  25.     {
  26.         LinkedList<Peach> peachStorage = new LinkedList<Peach>();
  27.         Monkey monkey = new Monkey();

  29.         peachStorage.add(new Peach());  //因为最后一天还剩一个桃，所以先把仓库里面放一个桃子
  30.         monkey.eatPeach(peachStorage, 1);

  32.         System.out.println("猴子总共摘了 " + peachStorage.size() + " 个桃子");
  33.     }
  34. }

  36. class Monkey
  37. {
  38.     /**
  39.      * @param peachStorage  桃子仓库
  40.      * @param day           猴子吃桃的天数
  41.      */
  42.     public void eatPeach(LinkedList<Peach> peachStorage, int day)
  43.     {
  44.         if(day >= 10)
  45.         {
  46.             return;
  47.         }
  48.         else
  49.         {
  50.             int currentPeachAcount = 0;
  51.             int peachStorageSize = peachStorage.size();
  52.             while(currentPeachAcount < (2*(peachStorageSize+1)-peachStorageSize))
  53.             {
  54.                 peachStorage.add(new Peach());
  55.                 currentPeachAcount++;
  56.             }
  57.             eatPeach(peachStorage, day+1);
  58.         }
  59.     }
  60. }

  62. class Peach
  63. {
  64. }
复制代码
实在调不好这个代码的缩进，我勒个去。


作者: mulua    时间: 2013-6-15 20:15
好活动    多多举办
作者: toShareBeauty    时间: 2013-6-15 20:23
不知道楼主说的正向思维是什么意思，难道要一个一个的数测试？
作者: 陈新    时间: 2013-6-15 20:24
class cx3
{

public static void main(String[] args) {
  int x=10;
  int sl=Sl(x);
     System.out.println("第一天总共摘了"+sl+"个桃子，真能摘！");
}
public  static int Sl(int n)
     {
      int x;// 第一天总共摘的。
      if(n==1)//最后一天
       x=1;
      else
       x=2*(Sl(n-1)+1);//前一天的桃子数目等于后一天数量加1乘2
      return x;
     }
}

QQ图片20130615202458.jpg (7.39 KB, 下载次数: 0)

QQ图片20130615202458.jpg
作者: x.love    时间: 2013-6-15 20:27
好的，让我来瞧瞧
作者: hm_李大强    时间: 2013-6-15 20:38
上次做粽子题上瘾了
作者: hm_李大强    时间: 2013-6-15 20:50
class Test
{
        public static void main(String[] args) {
                System.out.println(taozi(10));
        }
        public  static int taozi(int t)   //参数为天数
        {
                        int g =0;//个数
                        if(t==1) //最后一天
                         g=1;  
                        else
                         g=2*(taozi(t-1)+1);/*递归调用天数逐次减少*/
                        return g;  //返回桃子个数
        }
}
作者: 王靖远    时间: 2013-6-15 20:51
class ZhuanFen
{
public static void main(String[] args)
{
  
  int count = 1;//最后一天剩下的桃子数，并用它来当计数器记录前一天的桃子数
  
  for (int x=0;x<9 ;x++ )//因为是第十天早上发现桃子只有一个 所以第九天早上吃完后就剩1个桃子了，所以要循环9次。
  {
   count = (count+1)*2;//计算前一天的桃子数，并用计数器记录
  }
  System.out.println(count);
  
}
}

之前循环次数数错了，小于9才是循环9次，嘿嘿
作者: joker_chan    时间: 2013-6-15 20:54
来得分 亲爱的鑫鑫。哈
作者: ytblght55    时间: 2013-6-15 20:58
啥情况
！！！
作者: 吕祥艺    时间: 2013-6-15 21:03
新手试试看能做出来不
作者: joker_chan    时间: 2013-6-15 21:03
package learningtest;

/*
猴子吃桃的问题:猴子第一天摘下来N个桃子,当天就吃了一半,但是还不过瘾,又多吃了一个,第二天早上又将
剩下的桃子吃了一半,又多吃了一个,以后每天早上都吃了前一天剩下的一半零一个,到第十天早上的时候就发现剩下
一个桃子了.求第一天一共摘下了多少桃子呢?
*/
public class Joker {

        public static void main(String[] args) {
                System.out.println(Mokey.getPeach(1));
        }

}

class Mokey {
       
        public static int getPeach(int day) {
                int sum = 0;
                if(day == 10) {
                        sum = 1;
                } else if(day < 10) {
                        sum=2*(getPeach(day+1)+1);  
                }
                return sum;
        }
       
}
作者: likairoudou    时间: 2013-6-15 21:16
先下来看看到底是啥题
作者: x.love    时间: 2013-6-15 21:17
  1. package com.itheima.reflect;

  3. public class TestDemo {

  5.         public static void main(String[] args) {
  6.                 //分析题可知。
  7.                 int n = method(1);//第九天剩下的桃子
  8.                 for(int i=0;i<8;i++){
  9.                         n = method(n);//利用循环求出总数
  10.                 }
  11.                 System.out.println(n);
  12.         }
  13.         public static int method(int x){
  14.                 return (x+1)*2;
  15.         }
  16. }
复制代码
c:\Users\Win7\Desktop\捕获.PNG
作者: 风爽    时间: 2013-6-15 21:17
、、、、、、、、
作者: x.love    时间: 2013-6-15 21:18
x.love 发表于 2013-6-15 21:17

不能粘贴图片，结果是1534
作者: 梁海君    时间: 2013-6-15 21:20
看看哈，会不会呢
作者: Pan_King    时间: 2013-6-15 21:23
做上一做
作者: mulua    时间: 2013-6-15 21:24
  1. /**思路
  2. *  第十天早上剩余一个即第九天吃过后剩余一个
  3. *  用递归的话需要有出口，第九天吃过后剩余一个就是一个很好的出口
  4. *  所以定义一个函数f 返回第i天吃过后剩下的桃子树木
  5. *  递归出口就是 f(9)=1;
  6. *  对于一般情况第i天
  7. * f(i)=f(i-1)-f(i-1)-1;化简后的f(i)=2*f(i+1)+2;
  8. * 所以递归函数为
  9. *                 if (i==9)            
  10.                 {
  11.                         m=1;
  12.                 }
  13.                 else
  14.                 {
  15.                   m=2*f(i+1)+2;   
  16.                 }
  17. * 由此可以算出第一天剩下是的桃子为f(1);
  18. * 那么猴子第一天摘的桃子的个数为2*f(1)+2;
  19. */
  20. public class Monkey {
  21.         public static void main(String[] args) throws Exception{
  22.                 Monkey mon=new Monkey();
  23.                 int i=1;
  24.                 int t=mon.f(i);
  25.                 int zong =2*t+2;
  26.                 System.out.println("猴子第一天摘了"+zong+"桃子");
  27.         }
  28.         //函数f的功能是计算出第i天吃过后剩下的桃子
  29.         public int f(int i)
  30.         {
  31.                
  32.                 int m;                //当天吃过剩下的桃子
  33.                 if (i==9)             //递归的出口
  34.                 {
  35.                         m=1;
  36.                 }
  37.                 else
  38.                 {
  39.                   m=2*f(i+1)+2;       //递归体
  40.                 }
  41.                 return m;
  42.         }
  43.        

  45. }
复制代码

作者: 风爽    时间: 2013-6-15 21:28

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

  14. }
复制代码
作者: likairoudou    时间: 2013-6-15 21:29
  1. class Eat
  2. {
  3. int eatPeach(int time,int peach)
  4. {
  5. if(time==1)
  6. {return peach;}
  7. else
  8. {
  9. time--;
  10. peach=(peach+1)*2;
  11. return eatPeach(time,peach);
  12. }

  14. }
  15. }
  16. public class Houzi
  17. {
  18. public static void main(String args[])
  19. {
  20. Eat test=new Eat();
  21. int time=10,peach=1,count;
  22. count=test.eatPeach(time,peach);
  23. System.out.println("第一天摘了"+count+"个桃");
  24. }
  25. }
复制代码

0CDDKJA``E{]Z1M{$J0ZDJG.jpg (6.98 KB, 下载次数: 0)

0CDDKJA``E{]Z1M{$J0ZDJG.jpg
作者: 闵云波    时间: 2013-6-15 21:29
占楼答题咯..



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2