黑马程序员技术交流社区

标题: （奖励3分题目--24小时后关闭此贴------算法题） [打印本页]
作者: 滔哥    时间: 2012-7-21 00:16
标题: （奖励3分题目--24小时后关闭此贴------算法题）
直接贴图，避免一些学员直接复制百度

（3分题目隐藏回复可见）



警告：
需要过程和结果
直接贴代码无效


作者: 向向    时间: 2012-7-21 00:18
额，，，，
作者: 王龙彪    时间: 2012-7-21 00:18
先看看什么题...               
作者: 王冰    时间: 2012-7-21 00:19
先看看是什么
作者: 毛标    时间: 2012-7-21 00:19
1vvvvvvvvvvvvvvv
作者: 黑马黄宏强    时间: 2012-7-21 00:19
本帖最后由 轻尘一笑 于 2012-7-21 18:44 编辑

老衲来啦

下课回来发现无图无真相，果断上图

代码如下：
public class Tesl1 {
public static void main (String [] args){
  double tall=100; //原始高度
  int times =10; //下落次数
  System.out.println("球从"+tall+"米下落"+times+"次共经过了"+sum(tall,times)+"米");
  System.out.println("球从"+tall+"米下落"+times+"次后弹起高度为"+height(tall,times)+"米");
}

/*需求：定义一个方法，求一个球落地N次会共经历了多少米（反弹规则，每次落地反弹原高度的一半）
思路：
明确一： 有结果吗？ 有，返回共经过多少米double
明确二： 有未知内容吗？有初始高度double，下落次数int
使用for循环计算出每次下落弹起的高度，然后定义一个变量接收每次高度的累加，循环结束 返回总高度
*/
  public static double sum(double height,int times ){
   double  result =height;//因为第一次下落的高度等于原始高度，从第二次起高度等于原始高度加上本次高度
   for(int x=2;x<=times;x++){
    height=height/2;
    result+=height;
   }
   return result;
  }
  /*需求：定义一个方法，求一个求落地第N次后弹起的高度（反弹规则，每次落地反弹原高度的一半）
  明确一：有结果吗？ 有，返回第N第下落后弹起的高度 double
  明确二：有未知内容吗？ 有，初始高度double，下落次数int
  思路：使用for循环计算出每次弹起的高度，循环结束返回该高度
  */
  public static double height(double height,int times){
   double result =height; //未下落时高度为原始高度，每次下落弹起的高度为原来的一半
   for(int x=1;x<=times;x++){
    height=height/2;
    result=height;
   }
   return result;
  }
}



运行结果为：
球从100.0米下落10次共经过了199.8046875米
球从100.0米下落10次后弹起高度为0.09765625米
作者: 王明明    时间: 2012-7-21 00:21
本帖最后由 王明明 于 2012-7-21 01:11 编辑

/*
定义高度 gaodu 100M
定义 计算总经过路程 changdu
for循环计算
*/
class ceshi4
{
public static void main(String[] args)
{
  float gaodu =100;
  float changdu = 100;
  for(int num=1;num<=10;num++)
  {
   System.out.println("第"+num+"次着地经过长度---------"+changdu);
   gaodu= gaodu/2;
   changdu = changdu+gaodu*2;
   System.out.println("第"+num+"次反弹高度"+gaodu);
   
  }
}
}
第1经过长度---------100.0
第1反弹高度50.0
第2经过长度---------200.0
第2反弹高度25.0
第3经过长度---------250.0
第3反弹高度12.5
第4经过长度---------275.0
第4反弹高度6.25
第5经过长度---------287.5
第5反弹高度3.125
第6经过长度---------293.75
第6反弹高度1.5625
第7经过长度---------296.875
第7反弹高度0.78125
第8经过长度---------298.4375
第8反弹高度0.390625
第9经过长度---------299.21875
第9反弹高度0.1953125
第10经过长度---------299.60938
第10反弹高度0.09765625
不知道结果对不对...
作者: 张洁    时间: 2012-7-21 00:21
先看看题目…
作者: 李思静    时间: 2012-7-21 00:22
先刮开看看
作者: 周恺    时间: 2012-7-21 00:23
最近算法题目分热门啊
作者: rslheima    时间: 2012-7-21 00:23
有吸引力！！
作者: 李伟    时间: 2012-7-21 00:24
看看什么题目
作者: 芦曦    时间: 2012-7-21 00:25
本帖最后由 芦曦 于 2012-7-21 02:54 编辑
  1. /*
  2. 需求：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它第十次落地时，共经过多少米？
  3.    第十次反跳的高度？
  4. 步骤:
  5. 1.定义第一次落下经过的长度
  6. 2.定义原始的高度
  7. 3.用一个for循环，每次落下反跳的长度累加，每次反跳后的高度。
  8. */
  9. class Demo
  10. {
  11. public static void main(String[] args)
  12. {
  13.   double sum=100;//定义了第一次落下经过的长度
  14.   double x=100;//定义了原始的高度
  15.   for (int a=1;a<11 ;a++ )//球反弹10次
  16.   {
  17.    
  18.    x=x/2;//球每次落下，再反弹是原高度的二分之一。
  19.    sum=sum+x*2;//x*2是因为球有落下经过的高度和反弹经过的高度。
  20.    System.out.println("第"+a+"次反弹的高度"+x);//打印每次反弹的高度
  21.    System.out.println("第"+a+"次经过的长度----"+sum);//打印每次经过的长度、
  22.   }
  23. }
  24. }

复制代码

12345.png (11.66 KB, 下载次数: 200)

结果

结果
作者: 应文    时间: 2012-7-21 00:26
先看看题目
作者: 王薇熔    时间: 2012-7-21 00:27
看看到底是神马
作者: 陈欢    时间: 2012-7-21 00:30
快来抢分呀
作者: 林康春    时间: 2012-7-21 00:32
看看题目先
来了
作者: 丁二跃    时间: 2012-7-21 00:33
什么？
作者: 许瑞航老师    时间: 2012-7-21 00:33
我必须得看。。
作者: 黑马罗坚    时间: 2012-7-21 00:33
看下题目
作者: 贾飞雨    时间: 2012-7-21 00:34
涛哥给力
作者: 黑马罗坚    时间: 2012-7-21 00:35
这题以前好像在哪里见过。。
作者: 包晗    时间: 2012-7-21 00:36
占楼 先   代码慢慢写
作者: 张世威    时间: 2012-7-21 00:37
dddddddddddddddddd
作者: 吴立杰    时间: 2012-7-21 00:37
3分题目啊，快抢啊，到10分就可以走流程咯
作者: 王桂丽    时间: 2012-7-21 00:38
怎么看不到题目呢？
作者: 王龙彪    时间: 2012-7-21 00:38
提示: 该帖被管理员或版主屏蔽
作者: 余银桂    时间: 2012-7-21 00:38
据说回复可见！
作者: 朱东方    时间: 2012-7-21 00:40
看题再说。
作者: 王龙彪    时间: 2012-7-21 00:41
我真的是自己写的.!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
作者: 林康春    时间: 2012-7-21 00:41
提示: 该帖被管理员或版主屏蔽
作者: 陈欢    时间: 2012-7-21 00:48
本帖最后由 陈欢 于 2012-7-21 02:11 编辑

研究研究
作者: 王龙彪    时间: 2012-7-21 00:48
本帖最后由 王龙彪 于 2012-7-21 02:37 编辑

感觉一个方法就搞定了,所以没有定义一个类来创建对象后再调用.
分别定义了当前高度的变量hight, 记录总长度的变量sum,记录最后一次落下后弹起高度的变量shoot
用一个for循环模拟球落下的过程
这里是输出的结果:






这里是代码:
  1. //需求:100米落下的球,落地后跌回一半,求第10次落下时候,经过了多少米,反弹多高?

  3. public class BallTest
  4. {
  5.       public static void main(String[] args)
  6.       {
  7.               getBall();
  8.       }
  9.       
  10.       public static void getBall()
  11.       {
  12.               double hight = 100;//定义球的当前高度
  13.               double step = 2;//球跌落后的高度每次减半
  14.               double sum = 0;//记录总高度的变量
  15.               double shoot = 0;//记录最后一次跌落后弹起的高度
  16.               
  17.               for(int x = 1; x <= 10; x++)//使用一个循环模拟球跌落的过程,并记录数据
  18.               {
  19.                        if(x== 1)
  20.                            sum = hight;//第一次落地时
  21.                        else
  22.                        {
  23.                            hight /= step;//下一次跌落前的最高高度
  24.                            sum += hight * 2;
  25.                        }
  26.                      
  27.                       sop("这是第" + x + "次落地,落地时当前总高度为:" + sum);
  28.               }
  29.               shoot = hight;//最后一次跌落后弹起的高度
  30.               
  31.               sop("当第10次落下的时候,一共经过了:" + sum+ "米.");
  32.               sop("第10次落下后,反弹了:" + shoot + "米.");
  33.       }

  35.       public static void sop(Object object)//一个方便打印的函数
  36.       {
  37.               System.out.println(object);
  38.       }
  39. }

复制代码
作者: 王冰    时间: 2012-7-21 00:49
本帖最后由 王冰 于 2012-7-21 20:40 编辑

class  Ball
{
        public static void main(String[] args)
        {
                get(10);
        }

        public static void get(int n)
        {
                double  s = 100.0,hn = s/2;

                for(int i = 2 ;i<=n;i++)
                {
                        s = s + 2*hn;//第n次落地时一共经过的米数
                        hn = hn/2;//第n次反弹的高度
                }
               
                System.out.println("第"+n+"次落地时，共经过"+s+"米");
                System.out.println("第"+n+"次反弹的高度为"+hn+"米");
        }
}

运行结果如下：
第10次落地时，共经过299.609375米
第10次反弹的高度为0.09765625米
作者: 廖超超    时间: 2012-7-21 00:49
占位置。。。。。。。
作者: 温少邦    时间: 2012-7-21 00:52
看看题先
...
作者: 许瑞航老师    时间: 2012-7-21 00:59
很简单哇。。。 只要知道算法就行了   刚开始 数老是不对 后来 才想到 第十次只是弹起 没落地 这点很重要
package Exam8;
public class ball {

static double height = 100;
static double distance = 9;

public static void main(String[] args) {
   for(int i=1; i<10; i++) {
    distance = distance + height;
    height = height / 2;
   }
  
   System.out.println("路程：" + distance);
   System.out.println("高度：" + height / 2);
}

}
作者: 许瑞航老师    时间: 2012-7-21 01:00
许瑞航 发表于 2012-7-21 00:59
很简单哇。。。 只要知道算法就行了   刚开始 数老是不对 后来 才想到 第十次只是弹起 没落地 这点很重要
p ...



结果：路程：209.21875
高度：0.1953125
作者: 刘福双    时间: 2012-7-21 01:01
看看滔哥写的是什么
作者: 王宝康    时间: 2012-7-21 01:01
不知道还在不在24小时内！
作者: 刘福双    时间: 2012-7-21 01:02
本帖最后由 刘福双 于 2012-7-21 01:17 编辑

pupublic class Ex10 { public static void main(String[] args)
{
         double s=0;
         double t=100;
         for(int i=1;i<=10;i++)
         {
         s+=t;
         t=t/2;
         }
         System.out.println(s);
         System.out.println(t);
         
}
}
作者: 丁二跃    时间: 2012-7-21 01:04
本帖最后由 丁二跃 于 2012-7-21 19:21 编辑
  1. public class Test {

  3.         public static void main(String[] args) {
  4.                
  5.         double h = 100;
  6.         int n =10;
  7.     System.out.println(getHeight(h, n));
  8.    System.out.println("----"+getLength(h, n));
  9. }

  11.         
  12.         static  double getHeight(double h , int n){ //初始高度  n次  返回小球高度
  13.                
  14.                 for(int i =1  ;i<=n;i++ ){
  15.                         h=h/2;
  16.                 }
  17.                
  18.                 return h;
  19.         }

  21.         static double getLength(Double h ,int n){ //初始高度  n次  返回第n 次 小球落地时 所走过的路程
  22.                  double nh = getHeight(h, n); //第 n 次 落地后小球弹起高度
  23.                  double ss =h; //初始高度
  24.                  for(;h/2 >nh;){  // 题目要求 第10次落地时 走过路程  那么从地面到 第 10次弹起的高度 这段距离不算  ， 除去第一次，到第n-1 次 小球 上去    下来 是 每次走过路程是 弹起高度的2倍 (也就是上一次小球的高度)
  25.                         h = h/2;
  26.                         ss+=h*2;
  27.                  }
  28.                 return ss;
  29.         }
  30.         
  31. }
复制代码
好吧---结果：

上面 那个 就是 第10 次 弹起的 距离……… 不过昨天写程序时候 急着发 没加上 一些 输出语句

哈哈……分数终于够了
作者: 温少邦    时间: 2012-7-21 01:04

  2. public class Fall {
  3.         public static void show(int count){
  4.                 double sum=100;
  5.                 double h=sum/2;
  6.                 while(--count>0){
  7.                         sum+=h*2;                        //上升+落下
  8.                         h/=2;                                
  9.                 }
  10.                 System.out.println(sum+"\r\n"+h);
  11.         }
  12.         public static void main(String[] args){
  13.                 show(10);
  14.         }
  15. }
复制代码
结果:

总路程:299.609375
第10次弹起高度:0.09765625

作者: 陈欢    时间: 2012-7-21 01:09
本帖最后由 陈欢 于 2012-7-21 02:16 编辑

这个题比较给力哦，童靴们抢分哦{:soso_e100:}
作者: 张世威    时间: 2012-7-21 01:09

作者: 陈欢    时间: 2012-7-21 01:11
本帖最后由 陈欢 于 2012-7-21 02:14 编辑

{:soso_e112:}
作者: 朱东方    时间: 2012-7-21 01:11
本帖最后由 朱东方 于 2012-7-21 20:48 编辑
  1. //需求：100米落下的球,落地后跌回一半,求第10次落下时候,经过了多少米,反弹多高?
  2. 思路：1，跌回减半，跌回后高度为一个变量。
  3.               同样，球走过的路程为一变量。共两个变量。
  4.           2，求路程需要用到累加，次数在变。控制循环

  6. class Test1
  7. {
  8.         public static void main(String[] args)
  9.         {
  10.                 Qiu(100,10);
  11.         }

  13.         public static void Qiu(double q,int i)
  14.         {
  15.                 double mid = 0,sum = q;
  16.                 while(i>0)
  17.                 {
  18.                         q= q/2;  //反弹减半
  19.                         sum += 2*q; //计算距离
  20.                         i--;
  21.                 }

  23.                 System.out.println("第10次反弹"+q+"米");
  24.                 System.out.println("第10次落地时，共经过"+sum+"米");
  25.         }
  26. }

  28. 结果：第10次反弹0.09765625米
  29. 第10次落地时，共经过299.8046875米
复制代码
作者: 周恺    时间: 2012-7-21 01:12

  2. <P> class CodeTest {</P>
  3. <P>  public static void main(String[] args)
  4.    {
  5.   
  6.                 float hight=100;//高度100米
  7.                 int times=10;//反弹次数
  8.                 float bounceHight = 0;//反弹高度
  9.                 float path=0;//总路径长度
  10.                 for (int i=0;i<times;i++)
  11.                {
  12.                        bounceHight=hight/2;//每一次反弹都是落下距离的二分之一
  13.    
  14.                        path=path+hight+bounceHight;//每一次反弹到最高点经过的路径都是当次落下距离加上反弹距离
  15.    
  16.                        hight=bounceHight;//当结束一次反弹后,反弹到最高点时的距离就变成了下一次落下距离.
  17.                }
  18.    System.out.println("第十次落地时共经过::"+(path-bounceHight)+"米");// 因为第十次反弹的高度不算.所以要减掉
  19.    
  20.    System.out.println("第十次反弹高度为:"+bounceHight+"米");
  21.   
  22.    
  23.   }</P>
  24. <P>}</P>
复制代码
结果:
第十次落地时共经过::299.60938米
第十次反弹高度为:0.09765625米


作者: 许瑞航老师    时间: 2012-7-21 01:14
package Exam8;
public class ball {

static double height = 100;
static double distance = 100;

public static void main(String[] args) {
   for(int i=1; i<10; i++) {
    distance = distance + height;
    height = height / 2;
   }
  
   System.out.println("路程：" + distance);
   System.out.println("高度：" + height / 2);
}

}
路程：299.609375
高度：0.09765625
作者: 贾飞雨    时间: 2012-7-21 01:15
本帖最后由 yufeiant 于 2012-7-21 01:51 编辑

刚开始想的有点着急了，哎，改进后的版本在下面
作者: 贾飞雨    时间: 2012-7-21 01:16
本帖最后由 yufeiant 于 2012-7-21 02:01 编辑

/*
题目：一球从100米高度自由落下，每次罗茨后反跳回原高度的一半；在落下，求它在第十次落地式，共经过多少米？第十次反弹多高？
思路：100，100,50,50，25,25,12.5,12.5,。。。。发现每一次弹跳走过的长度都是想到用数组，把每次落又返回中走过的长度记录到数组中，这个数组的类型是
double，每一次的弹跳走过的长度，都是它的高度的二倍，所以想到直接把它所有的高度都求出来然后相加在乘以2，然后再加上开始的时候的一百，就是跳到x次后走过的长度

*/
class TestDemo
{
        public static void main(String [] args)
                {
                        getNumber(100,10);

                }
                public static void getNumber(double num,int x)
                {
                     
                        double  sum = 0;
                        double [] arr = new double[x];
                        for ( x =0;x<10 ;x++ )
                        {

                             
                                num /=2;//发现这里如果先加上那100，的话，后面就没有办法在进行乘2，了所以把乘2和加100都放到输出里边
                                arr[x] =  num;
                               //System.out.println(arr[x]);便利一下，看看是不是对

                        }
                        double height = 0;
                        for (int z = 0;z<x ;z++ )
                        {
                                height += arr[z];
                                if (z==(x-1))
                                {
                                        System.out.println(arr[z]);
                                }
                        }
                        System.out.println(height*2+num);
                }
}
刚才发现错了，惭愧啊，没有想到会犯这样的错误
把所有的便利了一下，
50.0
25.0
12.5
6.25
3.125
1.5625
0.78125
0.390625
0.1953125
0.09765625
0.09765625
299.8046875
请按任意键继续. . .



未命名.jpg (15.94 KB, 下载次数: 35)

未命名.jpg
作者: 黑马黄宏强    时间: 2012-7-21 01:24
        public static void main (String [] args){
                double tall=100;
                int times =10;
                System.out.println("球从"+tall+"米下落"+times+"次共经过了"+sum(tall,times)+"米");
                System.out.println("球从"+tall+"米下落"+times+"次后弹起高度为"+height(tall,times)+"米");
        }
        //需求：定义一个方法，求一个球落地N次会共经历了多少米（反弹规则，每次落地反弹原高度的一半）
        //明确一： 有结果吗？ 有，返回共经过多少米double
        //明确二： 有未知内容吗？有初始高度double，下落次数int
                public static double sum(double height,int times ){
                        double  result =height;//因为第一次下落的高度等于原始高度，从第二次起高度等于原始高度加上本次高度
                        for(int x=2;x<=times;x++){
                                height=height/2;
                                result+=height;
                        }
                        return result;
                }
                //需求：定义一个方法，求一个求落地第N次后弹起的高度（反弹规则，每次落地反弹原高度的一半）
                //明确一：有结果吗？ 有，返回第N第下落后弹起的高度 double
                //明确二：有未知内容吗？ 有，初始高度double，下落次数int
                public static double height(double height,int times){
                        double result =height; //未下落时高度为原始高度，每次下落弹起的高度为原来的一半
                        for(int x=1;x<=times;x++){
                                height=height/2;
                                result=height;
                        }
                        return result;
                }
}
作者: 陈欢    时间: 2012-7-21 01:29
本帖最后由 陈欢 于 2012-7-21 02:22 编辑

做出来了 ，不知道给力不。

public class abc{
        public static void main(String[] args) {
                double num1= 100;//总高度100米
                double num2 = num1 / 2; //第一次反弹弹高度
                int i = 0;
                for (i = 2;i<=10;i ++){//设置循环
                num1 = num1 + num2 * 2; //第i次落地经过多少米
                num2 = num2 / 2;//第i次反弹的高度
                }

                System.out.println("第10次落地经过" + num1 +"米");
                System.out.println("第10次反弹" + num2 + "米");
                }

                }

b.jpg (33.65 KB, 下载次数: 80)

b.jpg

a.jpg (11.28 KB, 下载次数: 82)

a.jpg
作者: 黑马罗坚    时间: 2012-7-21 01:29
  1. package ball;

  3. import java.math.BigDecimal;

  5. /**
  6. * 一球从100米高自由落下，每次落地后调回原高度的一半，球它在地19次落地时，共进过多少米 反弹多高
  7. */
  8. public class Ball {
  9.         private BigDecimal height;
  10.         private BigDecimal location;
  11.         private BigDecimal total;
  12.        
  13.         public BigDecimal getHeight() {
  14.                 return height;
  15.         }
  16.         public BigDecimal getLocation() {
  17.                 return location;
  18.         }
  19.         public void setLocation(BigDecimal location) {
  20.                 this.location = location;
  21.         }
  22.         public BigDecimal getTotal() {
  23.                 return total;
  24.         }
  25.         public void setTotal(BigDecimal total) {
  26.                 this.total = total;
  27.         }
  28.         public void setHeight(BigDecimal height) {
  29.                 this.height = height;
  30.         }
  31.        
  32.         public Ball(int num){
  33.                 BigDecimal bd=new BigDecimal(String.valueOf(num));
  34.                 this.setLocation(bd);
  35.                 this.setHeight(bd);
  36.                 this.setTotal(new BigDecimal("0"));
  37.         }
  38.        
  39.         public void floor(){
  40.                 this.setLocation(new BigDecimal("0"));
  41.                 this.setTotal(this.getTotal().add(this.getHeight().add(this.getLocation().negate())));
  42.                 rebound();
  43.         }
  44.         public void rebound(){
  45.                 this.setHeight(this.getHeight().divide(new BigDecimal("2")));
  46.                 this.setTotal(this.getTotal().add(this.getHeight().add(this.getLocation().negate())));
  47.                 this.setLocation(this.getHeight());
  48.         }

  50.        
  51.         public static void main(String[] args) {
  52.                 Ball ball=new Ball(100);
  53.                 for(int index=0;index<19;index++){
  54.                         ball.floor();
  55.                 }
  56.                 System.out.println("共进"+ball.getTotal()+"米"+"反弹"+ball.getLocation()+"米");
  57.         }

  59. }
复制代码
作者: 高鑫    时间: 2012-7-21 01:30
kankan  会不会
作者: 何旭栋    时间: 2012-7-21 01:33
看看题目再说
作者: 王宝康    时间: 2012-7-21 01:36
  1. package exercise;

  3. public class SeekHeight {

  5.         /**
  6.          * @author Wangbaokang
  7.          * @param args height 球每次弹起的高度；time，第几次弹起，sum，球弹起过程中一共走过的路程
  8.          */
  9.         public static void main(String[] args) {
  10.                 // TODO Auto-generated method stub
  11.                 SeekHeight(10);
  12.                
  13.         }       
  14.         public static void SeekHeight(int time){
  15.                 double sum = 0,height =100;
  16.                 for ( int i =1; i <= time ; i++) {
  17.                         height = height * 0.5;
  18.                         sum += height;
  19.                         sop("第"+i+"次跳起"+height+"米  "+"到目前为止，共跳起"+sum+"米");                               
  20.                 }
  21.         }       
  22.         public static void sop(Object obj){
  23.                 System.out.println(obj);
  24.         }

  26. }
复制代码

1.JPG (41.32 KB, 下载次数: 44)

运行截图

运行截图
作者: 京鱼龙    时间: 2012-7-21 01:41
在来一瓶
作者: 金_鑫    时间: 2012-7-21 01:46
滔哥就是给力
作者: 廖超超    时间: 2012-7-21 01:46
class Demo ｛
     public static void main(String[] args) {
        double h = 100,s = 100;//当一次落下的时候落下是(100M)反弹+(50M)，在落下(+50M)在反弹+(25)，在落下(+25)…………一直这样循环到第10次
                                                  //每次落下和反弹的值是前一次的值
        for(int i=1; i<=10; i++) {
            s = s + h;//每次反弹高度相加
           h = h / 2;//每次反弹高度是原来的一半
           }
        System.out.println("经过路程：" + s);
        System.out.println("反弹高度：" + h);
     }
}
作者: 包晗    时间: 2012-7-21 01:53
本帖最后由 包晗 于 2012-7-21 01:58 编辑

  2. <P>/*
  3. 100米落下的球,落地后跌回一半,求第10次落下时候,经过了多少米,反弹多高?</P>
  4. <P>
  5. 思路：x=100除以2.再赋予x  
  6. x/2 是第一次反弹  10次就是第10次落下后的反弹</P>
  7. <P>因为初始化 是 球 在100的高空处  只要落下来 就是第一次   循环10次</P>
  8. <P>落下经过多少米，设置一个SUM来记录 x的值。将
  9. 落下来1次 经过了100米   落下来两次经过了100+50+50  第三次是100+50+50+25+25  以此类推  x是第十落地后弹起来的值  
  10. 要将其去除掉。
  11. 求经过多少米。理论上就是 落下的米数+弹起来的米数。。。。。
  12. 通过FOR循环求出来的sum  要减去 第十落地后弹起来的值  再乘以2   外加第一次落下的100米</P>
  13. <P> </P>
  14. <P>*/</P>
  15. <P>
  16. class Boll
  17. {
  18. double x=100,sum;
  19. public void show()
  20. {
  21.   for (int i=1;i<=10 ;i++ )
  22.   {
  23.    
  24.    x=x/2.0;
  25.    sum+=x;
  26.   }
  27.   sum=(sum-x)*2+100;//x是 第十次弹起来的米数
  28.   System.out.println("第十次反弹为"+x+"米");
  29.   System.out.println("第十次反弹经过了"+sum+"米");
  30. }
  31. }
  32. class  BollDemo
  33. {
  34. public static void main(String[] args)
  35. {
  36.   Boll o =new Boll();
  37.   o.show();
  38.   
  39. }
  40. }
  41. </P>
复制代码
对了吗？

三分啊，眼睛都绿了。结果 思路 程序 都写着。。
黑马 我想来

答案.jpg (8.36 KB, 下载次数: 49)

答案.jpg
作者: rslheima    时间: 2012-7-21 01:54
本帖最后由 rslheima 于 2012-7-21 02:06 编辑

大半夜的写这玩意，呵呵，滔哥，给分不？？？
  1. package 滔哥答题;
  2. class Ball{
  3.          double sum;
  4.          double temp;
  5.          double Height;
  6.          public static void main(String[] args){
  7.                 Ball ball=new Ball();
  8.                 ball.sum(100,10);//输入离地的高度100，经过几次反弹：10
  9.          }
  10.         public  void sum(double initHeight,int times ){
  11.                 int t=0;
  12.                 Height=initHeight;
  13.                 int n=times++;
  14.                 while(initHeight>0&&t<times){
  15.                         initHeight=bounce(initHeight,t);
  16.                         t++;
  17.                         if(t>1){
  18.                         System.out.println("第"+(t-1)+"次的反弹的高度是"+initHeight+"米");
  19.                         }
  20.                         if(t<=n)
  21.                         System.out.println("第"+t+"次落地时经过了"+sum+"米");
  22.                 }
  23.         }
  24.         public  double  bounce(double initHeight,int t){
  25.                 initHeight=Height/Math.pow(2,t);//此处用的是初始高度和反弹高度的关系定义的方法
  26.                 if(t==0){sum+=initHeight;}
  27.                 else{temp=initHeight*2;
  28.                          sum+=temp;//计算经历的路程
  29.                 }
  30.                 return initHeight;//返回反弹的高度
  31.         }
  32. }

  34. 结果：
  35. 第1次落地时经过了100.0米
  36. 第1次的反弹的高度是50.0米
  37. 第2次落地时经过了200.0米
  38. 第2次的反弹的高度是25.0米
  39. 第3次落地时经过了250.0米
  40. 第3次的反弹的高度是12.5米
  41. 第4次落地时经过了275.0米
  42. 第4次的反弹的高度是6.25米
  43. 第5次落地时经过了287.5米
  44. 第5次的反弹的高度是3.125米
  45. 第6次落地时经过了293.75米
  46. 第6次的反弹的高度是1.5625米
  47. 第7次落地时经过了296.875米
  48. 第7次的反弹的高度是0.78125米
  49. 第8次落地时经过了298.4375米
  50. 第8次的反弹的高度是0.390625米
  51. 第9次落地时经过了299.21875米
  52. 第9次的反弹的高度是0.1953125米
  53. 第10次落地时经过了299.609375米
  54. 第10次的反弹的高度是0.09765625米
复制代码
作者: 金_鑫    时间: 2012-7-21 02:06

public class Test {
public static void main(String[] args) {
double i= 100;//设置高度100米
double j = i / 2; //第一次反弹  
int w = 0;//初始化
for (w = 2;w<= 10;w ++){//循环
i = i+ j * 2; //第i次落地经过多少米
j = j / 2;//第i次反弹的高度
}

System.out.println(i+"米");
System.out.println(j"米");
}

}

运行结果如下：

作者: 王宝康    时间: 2012-7-21 02:10
  1. package exercise;

  3. public class SeekHeight {

  5.         /**
  6.          * @author Wangbaokang
  7.          * @param args height 球每次弹起的高度；time，第几次弹起，sum，球弹起过程中一共走过的路程
  8.          */
  9.         public static void main(String[] args) {
  10.                 // TODO Auto-generated method stub
  11.                 SeekHeight(10);
  12.                
  13.         }       
  14.         public static void SeekHeight(int time){
  15.                 double height =100,sum = height;
  16.                 for ( int i =1; i <= time ; i++) {
  17.                         sum += height;
  18.                         height = height * 0.5;                         
  19.                         sop("第"+i+"次跳起"+height+"米  "+"第"+i+"次反弹后落地，第"+(i+1)+"次弹起前共经过"+sum+"米");                               
  20.                 }
  21.         }       
  22.         public static void sop(Object obj){
  23.                 System.out.println(obj);
  24.         }

  26. }
复制代码
刚才只是计算的跳起的总高度，现在修改了下代码，

1.JPG (52.85 KB, 下载次数: 66)

运行结构截图

运行结构截图
作者: 应文    时间: 2012-7-21 02:43
本帖最后由 应文 于 2012-7-21 03:25 编辑

/**
    下 上   下    上  下   上      下      上        下        上        ---            上                                    球的轨迹：
100   50  50  25  25   12.5  12.5  6.25   6.25    3.125      ---     100/(x^x/2)
   |      50   |   25   |     12.5     |       6.25     |      3.125      ---     100/(x^x/2)
   |      2     |    4    |       8        |         16      |      32           ---        x^x/2
   |  >2次  |   >4   |     >6       |         >8      |     >10         ---     >20次
100        50         25           12.5               6.25                 ---   
   1           2          4                8                  16                   ---   
x=1次  >3        >5              >7                  >9                  ---        
*/
class Sum100
{
public static void main(String[] args)
{
//  double sum_jishu= 0; //初始基数经过的米数和sum
//  double sum_oushu= 0; //初始偶数经过的米数和sum
  double sum = 0;   //初始经过的米数总和sum
  double sum_ago = 0;  //初始前9次经过的米数和sum
  double sum_last = 0;  //初始第十次经过的米数和sum
  double height = 100;  //高度
  int order = 20;
  for(int x=1; x<=order; x++)
  {
   /**
   这个是第五次弹起时的情况
   if(x%2==0&& x!=10)
   {
    sum_oushu=sum_oushu+high/Math.pow(2,x/2);
   }
   if(x%2!=0&& x!=10)
   {
    sum_jishu=sum_jishu+height/Math.pow(2,x/2);
   }
   if(x==10)
   {
    sum_qian=height/Math.pow(2,x/2);
    sum=sum_jishu+sum_oushu;
   }
   */
   if(x == 20)  //第十次弹起即第20次上下运动
   {
    sum_last = height/Math.pow(2,x/2); //计算第十次反弹的高度
   }
   else
    sum_ago = sum_ago + height/Math.pow(2,x/2); //计算前19次共进过的米数和
  }
  sum = sum_ago ;  //落地时一共进过的米数=前19次共进过的米数和
  System.out.println("小球落地时共经过了："+sum+"米");
  System.out.println("第十次反弹了："+sum_last+"米");
}
}

新手学习中。。

1.jpg (9.7 KB, 下载次数: 60)

结果

结果
作者: 何旭栋    时间: 2012-7-21 03:14
本帖最后由 何旭栋 于 2012-7-21 03:27 编辑

复制代码

  2. class fallingDemo {
  3.         /**
  4.          * @param args
  5.          */
  6.         public static void main(String[] args) {
  7.                 // TODO Auto-generated method stub
  8.                 falling(100, 10);
  9.         }
  10.         
  11.         public static void falling(int height, int times) {
  12.                 // TODO Auto-generated constructor stub
  13.                 String h = ""+height;
  14.         /*
  15.          * 假设球无限弹，那么总共经过高度为：h = 100+(50+50)+(25+25)+(12.5+12.5)+....
  16.          * 如果times是无限，那么h就无限接近300，那么总高度为300减去最后一次弹起的高度乘以2
  17.          * 总高度循环相加可能造成精度损失，所以用300减去最后一次弹起的高度的两倍来计算更准确
  18.          */
  19.                 double sumHeight = 300d;
  20.                 String upspring = h;
  21.                
  22.                 for (int i=1; i<=times; i++){
  23.                         System.out.println("第"+i+"次落地时共经过："+
  24.                                         (sumHeight-Double.parseDouble(upspring)*2)+" 米");//总高度为300减去最后一次弹起的高度两倍
  25.                         upspring = half(upspring);
  26.                         System.out.println("第"+i+"次弹起的高度："+upspring);
  27.                 }
  28.         }
  29.         
  30. //        如果弹起次数过多直接double计算高度必然造成精度损失，所以转换字符串计算更加精确
  31.         public static String half(String height){
  32.                 int num = 0;
  33.                 int previous = 0;
  34.                 StringBuilder sb = new StringBuilder();
  35.                
  36.                 if (!height.contains(".")){
  37.                         num = Integer.parseInt(height);
  38.                         previous = num;
  39.                         num = num>>1;
  40.                         sb.append(num);
  41.                         if(previous%2 != 0){
  42.                                 sb.append('.');
  43.                                 sb.append(5);
  44.                         }        
  45.                 }
  46.                 else{
  47.                         int index = height.indexOf(".");
  48.                         num = Integer.parseInt(height.substring(0, index));
  49.                         char[] chs = height.substring(index+1).toCharArray();
  50.                         
  51.                         previous = num;
  52.                         num = num>>1;
  53.                         sb.append(num);
  54.                         sb.append('.');
  55.                         for (char ch : chs){
  56.                                 num = Integer.parseInt(""+ch);
  57.                                 if(previous%2 != 0)
  58.                                         num += 10;
  59.                                 previous = num;
  60.                                 num = num>>1;
  61.                                 sb.append(num);
  62.                         }
  63.                         if(previous%2 != 0)
  64.                                 sb.append(5);
  65.                 }
  66.                 return sb.toString();
  67.         }
  68. }
复制代码
睡觉前看到，不能放过

截图.JPG (40.35 KB, 下载次数: 45)

截图.JPG
作者: rioy1    时间: 2012-7-21 03:34
看看题目
作者: rioy1    时间: 2012-7-21 04:10
        double height=10000;
        double sum=0;
        for(int i=1;i<11;i++)
        {
                sum+=height;
                height/=2;
                System.out.println(height);
        }
        System.out.println(sum);
作者: rioy1    时间: 2012-7-21 04:10
rioy1 发表于 2012-7-21 04:10
double height=10000;
        double sum=0;
        for(int i=1;i

这种题目提高自信啊
作者: 朱云坤    时间: 2012-7-21 04:14
看一下~
作者: 全海波    时间: 2012-7-21 04:50
路过，！！！！！！
作者: 朱云坤    时间: 2012-7-21 04:51
  1. class  Test
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.         double high=100.0;//定义初始高度
  6.         double sum=0;//定义一个sum用来记录总路程
  7.         for(int a=1;a<=3;a++)
  8.                 {
  9.            sum+=high+(high/2.0);//high+(high/2.0)每次小球从落地到弹起的路程
  10.            high=high/2.0;//小球下一次落地的初始高度
  11.         }
  12.         System.out.println("sum="+(sum-high));//小球第十次落地反弹后的总路程减去
  13.                                               //第十次弹起的路程 即为第十次落地时走过的总路程
  14.         System.out.println("high"+high);//小球第十次弹起的高度
  15.        
  16.         }
  17. }
复制代码
作者: 朱云坤    时间: 2012-7-21 05:00
  1. class  Test
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.         double high=100.0;//定义初始高度
  6.         double sum=0;//定义一个sum用来记录总路程
  7.         for(int a=1;a<=10;a++)
  8.                 {
  9.            sum+=high+(high/2.0);//high+(high/2.0)每次小球从落地到弹起的路程
  10.            high=high/2.0;//小球下一次落地的初始高度
  11.         }
  12.         System.out.println("sum="+(sum-high));//小球第十次落地反弹后的总路程减去
  13.                                               //第十次弹起的路程 即为第十次落地时走过的总路程
  14.         System.out.println("high"+high);//小球第十次弹起的高度
  15.        
  16.         }
  17. }


复制代码
上面的测试忘了改数值
加最终结果补上
C:\Documents and Settings\Administrator\桌面


作者: 朱云坤    时间: 2012-7-21 05:04
朱云坤 发表于 2012-7-21 05:00
上面的测试忘了改数值
加最终结果补上


作者: 张_涛    时间: 2012-7-21 06:24
看题目来了
作者: 王超    时间: 2012-7-21 06:28
{:soso_e145:}
作者: 张_涛    时间: 2012-7-21 07:22
本帖最后由 张_涛 于 2012-7-21 07:25 编辑
  1. /**
  2. * 题目：一球从100米高度自由落下，每次落地后反弹回原高度的一半；再落下，求它在第10次 落地时，共经过多少米？第10次反弹多高?
  3. */
  4. public class ReboundTest {
  5.         public static void main(String[] args) {
  6.                 // 定义初次落下的高度
  7.                 float height = 100;
  8.                 // 定义变量i记录一共反弹的次数
  9.                 int i = 10;
  10.                 // 定义变量count记录正在反弹的次数
  11.                 int count = 1;
  12.                 // 定义一个float数组记录每次反弹的高度(同时也是下次落下的高度)
  13.                 float[] reboundArr = new float[i];
  14.                
  15.                 rebound(reboundArr, height, i, count);
  16.                 float sum = countSum(reboundArr) + height - reboundArr[reboundArr.length - 1];
  17.                
  18.                 System.out.println("第10次（最后一次）落地时经过的总距离为：" + sum);
  19.                 System.out.println("第10次（最后一次）反弹的高度为：" + reboundArr[reboundArr.length - 1]);
  20.         }
  21.         
  22.         //将每次反弹的高度记录到arr数组当中
  23.         public static void rebound(float[] arr, float height, int i, int count) {
  24.                 arr[count - 1] = height / 2;
  25.                 count++;
  26.                 if (count <= i) {
  27.                         rebound(arr, arr[count - 2], i, count);
  28.                 }
  29.         }

  31.         //统计反弹的总高度
  32.         public static float countSum(float[] reboundArr) {
  33.                 float sum = 0;
  34.                 for (int i = 0; i < reboundArr.length; i++) {
  35.                         sum += 2 * reboundArr[i];
  36.                         System.out.println(reboundArr[i]);
  37.                 }
  38.                 return sum;
  39.         }
  40. }

  42. /*
  43. 算法思路：
  44. 1. 根据每次落下反弹，因为其都是反弹落下距离的一半，因此多次反弹具有相同的原理，由此想到使用递归算法。
  45.         在递归时，通过判断总弹起次数与当前弹起次数控制递归结束。
  46. 2. 使用rebound方法记录每次反弹的高度，即为落下高度的一半，存放到数组当中。
  47. 3. 而第10次落地时的距离包括第一次落下的距离，不包括第10次弹起的距离。而每次弹起，下次落下的距离是相等的，因此将其乘以2加入总距离当中。
  48. 4. 综上，即可得出所求。
  49. */

  51. 运行结果:
  52. 第1次弹起的高度为：50.0
  53. 第2次弹起的高度为：25.0
  54. 第3次弹起的高度为：12.5
  55. 第4次弹起的高度为：6.25
  56. 第5次弹起的高度为：3.125
  57. 第6次弹起的高度为：1.5625
  58. 第7次弹起的高度为：0.78125
  59. 第8次弹起的高度为：0.390625
  60. 第9次弹起的高度为：0.1953125
  61. 第10次弹起的高度为：0.09765625
  62. 第10次（最后一次）落地时经过的总距离为：299.70703
  63. 第10次（最后一次）反弹的高度为：0.09765625
复制代码
作者: 张凯    时间: 2012-7-21 07:24
看看再说
作者: 王超    时间: 2012-7-21 07:24
本帖最后由 王超 于 2012-7-21 19:05 编辑
  1. /*
  2. 1,所用到得数字：小球当前高度，反跳高度，经过的距离
  3. 2，下一次反跳高度=当前高度/2
  4. 3,用循环，实现累加
  5. */
  6. class BallHeight
  7. {
  8.         public static void main(String[] args)
  9.         {
  10.                 float height = 100;//初始小球高度
  11.                 float distance = 100;//小球经过的长度
  12.                 for（int i=1;i<=10;i++）
  13.                 {
  14.                         System.out.println("第"+i+"次着地小球经过"+distance+"米");
  15.                         height = height/2;//下一次小球的反弹高度=当前高度/2
  16.                         distance = distance + height*2;//小球已经经历的距离
  17.                         System.out.println("第"+i+"次反弹"+height+"米");
  18.                 }
  19.                
  20.         }
  21. }


复制代码

result.jpg (52.57 KB, 下载次数: 50)

result.jpg
作者: 李思静    时间: 2012-7-21 07:43
本帖最后由 帅李 于 2012-7-21 07:47 编辑

  2. class Test{
  3. static double high=100;//定义并初始化高度
  4. static double sum=100;//定义并初始化总高度
  5. static int num=0;

  7. //用来计算每次下落的总路程
  8. static void   total(){
  9.   sum=sum+2*high;
  10. }
  11. //用来计算每次反弹的高度，并调用计算总路程的函数
  12. static void  nextHigh(){
  13.   //对下落的此数进行判断
  14.   if(num>=10)
  15.   {
  16.    System.out.println("总共下落了多少："+sum);
  17.    System.exit(0);
  18.   }
  19.   num++;
  20.   high=high/2;
  21.   System.out.println("第"+num+"次反弹："+high);
  22.   total();
  23.   nextHigh();
  24. }
  25. public static void main(String[] args) {
  26.   nextHigh();
  27. }
  28. }
复制代码


作者: 夏儒日    时间: 2012-7-21 07:48
什么题？
作者: 梁小波    时间: 2012-7-21 08:05
let me look look
作者: 孙飞    时间: 2012-7-21 08:21
看看什么题
作者: 周坤    时间: 2012-7-21 08:35
看看会不会做，浪费不浪费时间
作者: 黑马振鹏    时间: 2012-7-21 09:09
学习下
作者: 张凯    时间: 2012-7-21 09:19
本帖最后由 张凯 于 2012-7-21 09:26 编辑
  1. /*
  2. 1.设置double类型变量sum1,用来记录小球走过的路程，初始值是0，
  3. 2.设置一个double类型变量l，来记录小球每次落地后反弹的高度，初始值为100，以后每经过一次落地，反弹高度变为l=l/2.
  4. 3.经过一个for循环，可求得小球走过的距离sum1=sum1+2*l.
  5. 4.因为再算距离时对100算了两次，所以最后的结果需要sum=sum1-100进行调整。
  6. 5.不要掉入陷阱，小球走过的路程不仅仅是弹起的高度，还有落下的高度。
  7. */
  8. class Demo
  9. {
  10.         public static void main(String[] args)
  11.         {
  12.                 double sum=0;//设置一个求最后小球走过路程的变量。
  13.                 double sum1=0;//这是初步求的小球经过路程的变量，最后还要调整一次。
  14.                 double l=100.0;//设置小球第一的反弹高度值为100.
  15.                 for(int a=1;a<=10;a++)//通过for循环，进行10次循环，
  16.                         {
  17.                         sum1=sum1+2*l;//获取每次小球落地时经过的路程。
  18.                         l=l/2;//获取每次落地反弹后的高度。
  19.                         System.out.println("第"+a+"次小球反弹"+l+"米");//打印出小球每次落地后的反弹高度。
  20.                         
  21.                 }
  22.         sum=sum1-100;//对最后小球经历路程进行调整（原因前面有介绍）
  23.         System.out.println("第10次落地时，小球经过的距离是"+sum+"米");//最后打印出小球经过10次落地后，所经历的路程。
  24.         }
  25. }
复制代码
这是运行结果：

未命名.jpg (31.06 KB, 下载次数: 34)

未命名.jpg
作者: 夏儒日    时间: 2012-7-21 09:19
先回复再回答~~~
作者: 蒙武辉    时间: 2012-7-21 09:28
看看什么题目
作者: 夏儒日    时间: 2012-7-21 09:28
/*
思路：我的思路是这样的：
第一次：100米的高空，可以假设第一次落下时先弹起100米再落下100米，这样第一次落地时走过的距离就是200米；
第二次：上升50米再落下50米，故第二次走过的距离是100米；
第三次：上升25米再落下25米，故第三次走过的距离是50；
。
。
。
以此类推，每次落地时走过的距离都是前一次落地时走过距离的一半。这样只要把十次走过的距离相加求和就行。
但是需要注意的是最后一次时一定要减去第一次时假设上升的那100米。
第十次落地时弹起的高度就是前一次落地时走过距离的1/4。
这样，通过程序计算的落地十次时走过的距离为sum=299.609375；
第十次落地后弹起的高度为：endUp=0.048828125.
*/

class GetBallSum1
{
        public static void main(String[] args)
        {
                getSum(100,10);
        }
        public static void getSum(double dis,int n)
        {
                double s = dis*2;
                double endUp = 0;
                double sum = 0;
                for (int i = 1;i<=n ;i++ )
                {
                        sum =sum + s;
                        s = s/2;
                }
                sum = sum -dis;
                endUp = s/4;

                System.out.println("落地第"+n+"次时走过的距离："+sum);
                System.out.println("第"+n+"次落地后弹起来的高度："+endUp);
        }
}
作者: 孙飞    时间: 2012-7-21 09:30
本帖最后由 feigecal 于 2012-7-21 09:31 编辑

/**
需求：一球从100米高度自由落下，每次落地后反跳到原来 高度的一半再落下，求它在第10次落地时共经过多少米？第10反跳多高？
分析：第10次落地，说明共反跳了9次，把第一次也算上是反跳起来的，那总路程就是前9次高度的二倍再减去100，第10次反跳高度是第9次的一半
步骤：
1，定义double型变量用于记录和高
2，用循环语句计算每次的高，再相加
3，打印输出
*/
class JiSuan
{
        public static void main(String[] args)
       {
              double h=100;
              double sum=0;
              double d=0;
              for (int x=0;x<10 ;x++ )
            {
                        double temp1=Math.pow(2,x);
                        double temp=h/temp1;
                        sum+=temp;                                //求出把100当第一次的前9次的高度和
                       if (x==9)
                      {
                              d=temp/2;                             //第9次高度的一半是第10次的高度
                      }
          }
          sum=sum*2-100;
           System.out.println("共经过"+sum+"米,"+"第十次反跳"+d+"米。");
     }
}
作者: 曹恒业    时间: 2012-7-21 09:34
本帖最后由 曹恒业 于 2012-7-21 11:19 编辑

看一看！~~

/*
需求：一球从100米高度自由落下，每次落地后反跳到原来高度的一半再落下，
          求它在第10次落地时共经过多少米？第10反跳多高？
思路：估计大家都是循环做的，所以写个递归，思路见各函数说明。
*/
class BallDemo
{
        //经过num次，初始高度为height米，额外增加首次落体高度小球所经过多少米
        public static double getTotal(int num, double height)
        {
                if(num==0)
                        return 2*height;
                //以小球每上升和下一次下落为一组，则该组经过的距离是后一组的2倍，以此为递归条件。
                return 2*height+getTotal(num-1,height/2);
        }

        //经过num次，初始高度为height，小球共经过多少米
        public static double getLen(int num, double height)
        {
                //getTotal()中多算了一次初始下落高度，故要减去
                return getTotal(num, height)-height;
        }

        //经过num次，初始高度为height米，小球上升弹起的高度
        public static double getUpLen(int num, double height)
        {
                if(num==0)
                        return height;
                //小球每落地上升一次，弹起的高度减半
                return getUpLen(num-1,height/2);
        }

        public static void sop(Object obj)
        {
                System.out.println(obj);
        }

        public static void main(String[] args)
        {
                sop("第10次反跳的高度："+getUpLen(10,100));

                sop("在第10次落地时共经过"+getLen(10,100)+"米");
        }
}


作者: 曹印亮    时间: 2012-7-21 09:40
看看会不
作者: 陈冲    时间: 2012-7-21 09:42
本帖最后由 陈冲 于 2012-7-21 11:34 编辑
  1. /*
  2. 一球从100米高空自由落下，每次落地后反跳回原高度的一半，再落下。求它在第10次落地时，共经过了多少米？第10次反弹多高？
  3. */


  6. class FallingBall
  7. {
  8.     public static void main(String[] args)
  9.     {
  10.         rtHeight(100,10);
  11.     }

  13.     /*
  14.     定义一个求反弹高度的函数，需要将起始高度和反弹次数传入函数
  15.     在反弹过程中，高度计算可能出现小数，所以高度定义为double h；
  16.     反弹次数定义为int count；
  17.     */
  18.     public static void rtHeight(double height,int count)
  19.     {   
  20.         double h=height;
  21.         double sum=height;//首次落地时，高度为100米
  22.         while(count>0)
  23.         {
  24.             count--;
  25.             if((10-count)>1)
  26.             {
  27.                 sum+=2*h;//第n次落地的时候，球走过的距离是第n-1次反弹高度的两倍（反弹和落地高度相同）
  28.                                     //而n-1>0的情况，只在n>=2时存在，n<2的情况在下面的else中讨论
  29.                 h=0.5*h;
  30.                 System.out.println("第"+(10-count)+"次落地时，球共经过了："+sum+" 米");
  31.                 System.out.println("第"+(10-count)+"反弹的高度是："+h+" 米");
  32.             }
  33.             else
  34.             {
  35.                 h=0.5*h;
  36.                 System.out.println("第"+(10-count)+"次落地时，球共经过了："+height+" 米");
  37.                 System.out.println("第"+(10-count)+"反弹的高度是："+h+" 米");
  38.             }
  39.         }
  40.     }
  41. }
复制代码
运算结果如下：

未命名.jpg (60.79 KB, 下载次数: 36)

运算结果

运算结果
作者: 夏儒日    时间: 2012-7-21 09:44
之前回复的有一点错误，现在更改如下：
/*
思路：我的思路是这样的：
第一次：100米的高空，可以假设第一次落下时先弹起100米再落下100米，这样第一次落地时走过的距离就是200米；
第二次：上升50米再落下50米，故第二次走过的距离是100米；
第三次：上升25米再落下25米，故第三次走过的距离是50；
。
。
。
以此类推，每次落地时走过的距离都是前一次落地时走过距离的一半。这样只要把十次走过的距离相加求和就行。
但是需要注意的是最后一次时一定要减去第一次时假设上升的那100米。
第十次落地时弹起的高度就是前一次落地时走过距离的1/4。
这样，通过程序计算的落地十次时走过的距离为sum=299.609375；
第十次落地后弹起的高度为：endUp=0.048828125.
*/
class GetBallSum1
{
public static void main(String[] args)
{
  getSum(100,10);
}
public static void getSum(double dis,int n)
{
  double s = dis*2;
  double endUp = 0;
  double sum = 0;
  for (int i = 1;i<=n ;i++ )
  {
   sum =sum + s;
   endUp = s/4;
   s = s/2;
   
   System.out.println("落地第"+i+"次时走过的距离(包含那假设的100米)："+sum);
   System.out.println("第"+i+"次落地后弹起来的高度："+endUp);
  }
  sum = sum - dis;
  //endUp = s/4;
  System.out.println("最终结果如下----------------------");
  System.out.println("落地第"+n+"次时走过的距离："+sum);
  System.out.println("第"+n+"次落地后弹起来的高度："+endUp);
}
}

作者: 乐峰    时间: 2012-7-21 09:49
我要回复
作者: 徐帅    时间: 2012-7-21 10:10
看是啥题目
作者: 周坤    时间: 2012-7-21 10:23
  1. /*
  2. * 一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，
  3. * 求它在第10次落地时，共经过多少米？第10次反弹多高？
  4. * 分析：
  5. * 第一次落地100，第一次反弹高度50；
  6. * 第二次落地100+（50+50），第二次反弹高度为25；
  7. * 第三次反弹到最高点路程100+（50+50）+（25+25），第三次反弹高度为12.5；
  8. * 。。。
  9. * 可见每反弹一次，反弹高度就会减半，而每落地一次，就是上一次落地的总距离距离+上一次反弹高度的两倍。
  10. * 逆向向前推，第九次反弹高度*2+第八次反弹高度*2+。。。。+第一次反弹高度*2+100，就为一共的路程。
  11. */

  13. public class LuoTiDemo {
  14.         public static void main(String[]args){
  15.                 System.out.println(fantan(100,10));
  16.                 System.out.println(lucheng(100,10));
  17.                
  18.                
  19.         }
  20.         public static  double fantan(int height,int count)//反弹高度逐次减半
  21.         {
  22.          return height/(Math.pow(2, count));
  23.         }
  24.         public static double lucheng(int height,int count )
  25.         {

  27.                 double sum=0;//先求取从第一次落地反弹到第十次触地的距离。
  28.        
  29.                 while(count>1){
  30.                         sum+=2*fantan(height,count-1);
  31.                         count--;
  32.                 }
  33.                        
  34.                 return sum+height;
  35.         }

  37. }
复制代码
结果：
0.09765625
299.609375
作者: 吴扬    时间: 2012-7-21 10:28
看看什么题！
作者: 陈云帆    时间: 2012-7-21 10:42
看看题目
作者: 韦念欣    时间: 2012-7-21 10:58
大家加油哦！考验大家基础的时刻到了！



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