看看什么题！

1. 
   
2. /*
   
3. 需求：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它第十次落地时，共经过多少米？
   
4.    第十次反跳的高度？
   
5. 思路：1，先求出某一次弹起的高度。
   
6.         2，再求出弹起高度的总和。
   
7. 
   
8. */
   
9. package com.itheima;
   
10. 
    
11. public class Climb {
    
12. 
    
13.         public static void main(String[] args) {
    
14.                 int n = 10;
    
15.                 double sum = 100;
    
16.                 for(int i=1;i<=n;i++){
    
17.                         System.out.println("第"+i+"次弹起的高度："+binaryValue(i)*100);
    
18.                         sum += binaryValue(i)*100*2;//因为弹起和落下要有两次,所有要乘以2。
    
19.                 }
    
20.                 System.out.println("第"+n+"次弹起的高度总和："+sum);
    
21.         }
    
22.         public static double binaryValue(double n){//这里用到了递归的方法。取到第N次所需要乘的数据。
    
23.                 double inital = 1d/2d;
    
24.                 if(n == 1){
    
25.                         return inital;
    
26.                 }
    
27.                 return binaryValue(n-1)*inital;
    
28.         }
    
29. }
    

复制代码

结果图片没发上。再发过一次，接上楼。。。

看看题目

大家加油哦！考验大家基础的时刻到了！

看下题目吧

/*
  小球先落地，再弹起，即：至第十次落地的路程不包含第十次弹起的高度
*/
class Demo
{
public static void main(String[] args)
{
  double sum=0;//定义初始路程
  double high=100;//定义初始高度
  for (int x=1;x<=10 ;x++ )//遍历小球弹起次数
  {
     if (x==1)//因为至第一次落地小球行驶路程为单程，也就是初始高度high
     {
        sum=high;
     }
     else
        sum=sum+high*2;//求和，除第一次外其余小球弹起和下降走的都是上次弹起高度：high*2
     high=high/2.0;//求商，第x次弹起的高度为上次弹起高度的一半
     System.out.println("至第"+x+"次落地经过路程"+sum+"\t"+"第"+x+"次落地弹起高度"+high);
  }
}
}

/*思路：1用for循环
2每次路程是上次的一半
3求和，把以前的结果相加，用sum
4定义higgt，得到每次的高度*/
lass one
  {
   public static void main(String[]args)
   { hight(11);
   //float sum1= (return sum);
//System.out.println(sum1);
   }
  
  
  public static void hight(int num)
  {
   float H=100f;
  float sum=100f;
   for(int x=0;x<num;x++)
    {
   H=H/2;
   System.out.print("高度H("+x+")="+H+"\t");
   sum+=H; System.out.println("总路程"+sum);
   System.out.println();
  
  // return H;
   // return sum;
    }
   
   
  }
  }
修改了n次我认为是对的，注释的代码不知道怎么改进，还有我加了制表符
但是打印的还是很丑陋，求高手给我优化一下

package sss;

public class Heights {

        /**
         *需求： 一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共

       经过多少米？第10次反弹多高？
         */
        public static void main(String[] args) {
                       double height=100;//定义原始高度100米
                           double  fantan=100;//定义球落地时所反弹的高度
                           double  sum=height;//定义球落地时所经过的总长度
                           int num=10;//定义落地次数10次
                           for(int i=1;i<=num;i++){
                                   fantan=fantan/2;
                                   sum=sum+fantan*2;
                                   System.out.println("第"+i+"次落地时，共经过"+sum+"米");
                                   System.out.println("第"+i+"次落地时，反弹"+fantan+"米");
                          }
        }

}
执行结果是：
第1次落地时，共经过200.0米
第1次落地时，反弹50.0米
第2次落地时，共经过250.0米
第2次落地时，反弹25.0米
第3次落地时，共经过275.0米
第3次落地时，反弹12.5米
第4次落地时，共经过287.5米
第4次落地时，反弹6.25米
第5次落地时，共经过293.75米
第5次落地时，反弹3.125米
第6次落地时，共经过296.875米
第6次落地时，反弹1.5625米
第7次落地时，共经过298.4375米
第7次落地时，反弹0.78125米
第8次落地时，共经过299.21875米
第8次落地时，反弹0.390625米
第9次落地时，共经过299.609375米
第9次落地时，反弹0.1953125米
第10次落地时，共经过299.8046875米
第10次落地时，反弹0.09765625米

我好想做错了，从第一以后路程是双倍，我忘记了。郁闷。我再改改

1.思路及过程编码见calc.png
2.结果见result.png

在for循环里面改成 sum+=H*2；这下结果对了，{:soso_e142:}

必须看看。。

看下题目，顺便占楼
代码写好了

1. 
   
2. <P>/*
   
3. 需求：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它第十次落地时，共经过多少米？</P>
   
4. <P>   第十次反跳的高度？
   
5. 求共经过多少米的时候，因为球反复跳起，那么向上跳起的距离也应该计算在内</P>
   
6. <P>思想：1，因为每次落地反跳回原高度的一半，所以用到循环，for
   
7.    2，要求第十次落地时共经过多少米，累加思想
   
8. 步骤：1，定义高度，也就是第一次落下的高度
   
9.    2，用for循环，定下循环的次数，因为第一次直接落下，之前没有跳起，所以应该是循环9次
   
10.       3，累加每次落下反跳的长度
    
11. */</P>
    
12. <P>class  Test
    
13. {
    
14. public static void main(String[] args)
    
15. {
    
16.   float xg = 100,fg= xg/2;//xg下落高度，hg反跳高度
    
17.   
    
18.   for (int n=2;n<=10 ;n++ )
    
19.   {
    
20.    
    
21.     xg = xg+2*fg;//落地时共经过的米数，因为有跳起有下落，所以应该是跳起高度的2倍
    
22.     fg = fg/2;//第N次反跳的高度
    
23.    
    
24.    
    
25.   }
    
26.   
    
27.   System.out.println("第十次落地共经过"+xg+"米");
    
28.   System.out.println("第十反跳的告诉为"+fg+"米");
    
29. }
    
30. }
    
31. </P>

复制代码

结果如图

俺也来顶顶滔哥

1. 
   
2. <P> </P>

复制代码

1. class Demo1
   
2. {
   
3. public static void main(String[] args)
   
4. {
   
5. 
   
6. int y=10;//跳跃次数
   
7. double h=100;//高度
   
8. int m;
   
9. double sum=100;//跳跃后共经过的米数
   
10. 
    
11. for (m=1;m<=y ;m++ )
    
12. {
    
13. System.out.println("第"+m+"次落地时，共经过："+sum+"米");
    
14. 
    
15. h=h/2;//计算跳跃第m次的高度，
    
16. System.out.println("反弹"+m+"次的高度是："+h);
    
17. 
    
18. sum=sum+h*2;//计算跳跃m次的总高度。
    
19. 
    
20. 
    
21. }
    
22. }
    
23. }

复制代码

结果：

1. 第1次落地时，共经过：100.0米
   
2. 反弹1次的高度是：50.0
   
3. 第2次落地时，共经过：200.0米
   
4. 反弹2次的高度是：25.0
   
5. 第3次落地时，共经过：250.0米
   
6. 反弹3次的高度是：12.5
   
7. 第4次落地时，共经过：275.0米
   
8. 反弹4次的高度是：6.25
   
9. 第5次落地时，共经过：287.5米
   
10. 反弹5次的高度是：3.125
    
11. 第6次落地时，共经过：293.75米
    
12. 反弹6次的高度是：1.5625
    
13. 第7次落地时，共经过：296.875米
    
14. 反弹7次的高度是：0.78125
    
15. 第8次落地时，共经过：298.4375米
    
16. 反弹8次的高度是：0.390625
    
17. 第9次落地时，共经过：299.21875米
    
18. 反弹9次的高度是：0.1953125
    
19. 第10次落地时，共经过：299.609375米
    
20. 反弹10次的高度是：0.09765625

复制代码

分析：
这题也就是用到遍历，
先思考整个物理过程，最好画个图，这样就会很清楚了，
用上面的方法都能看懂，简单，
其实还有另外一种方法：第x次跳跃的高度=100除以（2的x次方），
其他的都一样。

见图：

不管拿到拿不到，先看看

还要先回复才能看

很明显，每次弹起的高度为50,25,12.5等等，即100的1/2,1/4,1/8,即第N次弹起的高度是100乘以2的N次方之1。接着分析每次弹起经过的路程，第一次：100+50，第二次：50+25，第三次：25+12.5，不难发现，每一次的路程等于前一次弹起的高度+前一次高度的一半，即前一次高度的3/2，或者是本次弹起高度的3倍，以此类推，第N次弹起的路程=第N次弹起高度*3=（100乘以2的N次方之1）*3，用代码表示如下：

1. package pack1;
   
2. 
   
3. public class ClassE {
   
4. 
   
5.         
   
6.         public static void main(String[] args) {
   
7.                
   
8.                 double h;  //第10次跳起的高度
   
9.                
   
10.                 double s=0.0;  //第10次弹起时，总共经过的路程
    
11.                
    
12.                 h = 100/Math.pow(2, 10); //表示2的10次方
    
13.                
    
14.                 for(int n=1;n<=10;n++){
    
15.                         
    
16.                         s+=100*3/(Math.pow(2, n));
    
17.                         
    
18.                 }
    
19.                
    
20.                 System.out.println("第10次弹起的高度为："+h);
    
21.                
    
22.                 System.out.println("第10次弹起时，所经过总路程为："+s);
    
23.                
    
24.         }
    
25. 
    
26. }
    

复制代码

张_涛 发表于 2012-7-21 07:22

呃，多算了一次