看看题。。

什么东西，这么神秘

好                                            

class Test
{
public static void main(String[] args)
{
  float g =100; //这是总高度
  float c = 100; //这是经过的长度
  for(int x=1;x<=10;x++) //10次循环反弹
  {
   System.out.println("第"+x+"次经过长度---------"+c);
   g= g/2; //总高度的一半
   c = c+g*2; // g*2 球落下的高度和反弹经过的高度
   System.out.println("第"+x+"次反弹高度"+g);
   
  }
}
}
第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

求围观......

1. public class demo {
   
2.         public static void main(String[] args)
   
3.         {
   
4.                
   
5.                 int h= 100,c = 100;
   
6.                 for (int i = 0; i <=10; i++)
   
7.                 {
   
8.                         h = h/2;
   
9.                         c = c+h*2;
   
10.                 }
    
11.                 System.out.println("第10次弹的高度"+h);
    
12.                 System.out.println("10次弹的高度"+c);
    
13.                
    
14.        
    
15. 
    
16.         }
    
17.         }

复制代码

1.     class JuLi
   
2. {
   
3.      
   
4.    JuLi(float index,int count)
   
5.     {   float sum=index;
   
6.          int x=count;               
   
7.                 count--;
   
8.                  while(count>0)
   
9.                  {
   
10.                    index=index/2;
    
11.                    sum=sum+index*2;
    
12.                    count--;
    
13.                  }
    
14.       System.out.println("共经过"+sum+"米");
    
15.           System.out.println("第"+x+"次反弹"+index/2+"米");
    
16.     }
    
17. }
    
18.    class Ball
    
19. {
    
20.              public static void main(String []args)
    
21.           {
    
22.             JuLi s = new JuLi(100,10);
    
23.             
    
24.           }
    
25.           
    
26. }

复制代码

    class JuLi
{

   JuLi(float index,int count)
    {   float sum=index;
         int x=count;               
                count--;
                 while(count>0)
                 {
                   index=index/2;
                   sum=sum+index*2;
                   count--;
                 }
      System.out.println("共经过"+sum+"米");
          System.out.println("第"+x+"次反弹"+index/2+"米");
    }
}
   class Ball
{
             public static void main(String []args)
          {
            JuLi s = new JuLi(100,10);
            
          }
          
}

    一般情况下，我们都是使用double类型来存储数据，我今天使用了一个分数类来计算这道题，想看看两者的区别。

1、使用double类型截图如下


2、今天我弄了一个分数类，截图如下



3、我终于明白了javaAPI里面为什么没有提供分数类型，因为使用double类型几乎可以满足我们的需求了，再者，还有
      BigInteger类型，损失的精读几乎为0，可能只是那些天文地理计算、银行计算会用到这些吧。

先mark一个看看

先贴结果：
落地后反弹的高度--总下落高度
50.0--150.0
25.0--225.0
12.5--262.5
6.25--281.25
3.125--290.625
1.5625--295.3125
0.78125--297.65625
0.390625--298.828125
0.1953125--299.4140625
0.09765625--299.70703125

第10次反弹时，共经过： 299.70703125 米，第十次反弹： 0.09765625 米。
再贴代码：

1. /*
   
2. * 一球从100米高度落下，每次落下后反弹回原来高度的一半；
   
3. * 再落下，求它在第10次落地时，共经过多少米？第十次反弹多高？
   
4. */
   
5. public class Test {
   
6. 
   
7.         public static void main(String[] args) {
   
8.                 /*
   
9.                  * 思路：首先定义变量落地次数n、落地后反弹到最高点的高度h、总下落高度totalH。
   
10.                  * 第十次经过的高度就是总高度totalH, 第十次反弹的高度就是反弹高度h。
    
11.                  * totalH的计算公式应为：totalH += h +h/2
    
12.                  * 当h为奇数时，除以2则会出现小数。所以所有高度的数据类型应为double或float类型。
    
13.                  *经测试发现，float不够double准！
    
14.                  */
    
15.                
    
16.                
    
17.                 int n = 1;         //落地次数
    
18.                 double h =100d;        //落地后反弹到最高点的高度
    
19.                 double totalH = 0d;        //总下落高度
    
20.                 System.out.println("落地后反弹的高度--总下落高度");
    
21.                 for(int i = n; i  <= 10; i ++) {
    
22.                         totalH += h +h/2;
    
23.                         h = h/2;
    
24.                         System.out.println(h + "--" + totalH);
    
25.                 }
    
26.                 System.out.println();
    
27.                 System.out.println("第10次反弹时，共经过： " + totalH + " 米，第十次反弹： " + h + " 米。");
    
28.         }
    
29. 
    
30. }
    

复制代码

看题。。。。。。。。。。。。。。

还要先回复、、、、、、

占个楼，等会接着写

看看，没准会做。

等下有情况

******************************************************
在第 10 次落地时总路程 为： 299.609375该次反弹的路程为： 0.09765625
******************************************************
一个球从100米高度自由落下，每次落地后反跳回原高度的一半，再落下，求它在第10次落地时，共经过多少米？第10次反弹多高

******************************************************
                        An        Sn
1下    100                     100        100
1上    100/2                    50        150
2下    100/2                    50        200
2上    (100/2)/2                25        225
3下    (100/2)/2                25        250
3上    ((100/2)/2)/2                12.5        262.5
4下    ((100/2)/2)/2                12.5        275
4上    (((100/2)/2)/2)/2            6.25        283.25
....
10下    (((100/2)/2)....)/2 除以9次2
10上    (((100/2)/2)....)/2 除以10次2

n次下   100/(2^(n-1))
n次上    100/(2^n)



******************************************************
将下抽取出来
                An        Sn
1下    100             100        100
2下    100/2            50        150
3下    (100/2)/2        25        175
4下    ((100/2)/2)/2        12.5        187.5
..
10下    (((100/2)/2)....)/2 除以9次2

发现其为一个等比数列
其中首项：a1 = 100    公比：q = 1/2 = 0.5
通项公式：An = a1 * q ^ (n - 1)
求和公式：
当q != 1时， Sn = a1 * (1 - q^n) / (1 - q)
当q = 1时，Sn = n * a1

******************************************************
将上抽取出来：

1上    100/2   
2上    (100/2)/2
3上    ((100/2)/2)/2
4上    (((100/2)/2)/2)/2
...

发现其为一个等比数列
其中首项：b1 = a1 * q    公比：q = 1/2 = 0.5
通项公式：Bn = b1 * q ^ (n - 1)

******************************************************


经观察，Sn下 = S(n-1)上，即Sn = B(n-1)
所以，它在第10次落地时，共经过多少米,应为 S10下+S9上
所以，Sn总= 2 Sn下 - 100,即Sn_sum = 2 * Sn - a1

因此，本题中，求从100米落下，每次落地后反跳回原高度的一半，求它在第10次落地时，共经过多少米？
把 a1 = 100, q = 0.5带入以下公式即可
Sn = a1 * (1 - q^n) / (1 - q)
Sn_sum = 2 * Sn - a1;

因此，本题中，求第10次反弹的高度

把 a1 = 100, q = 0.5带入以下公式即可
Bn = b1 * q ^ (n - 1)

******************************************************

1. package Heima001_DumpAndDown100;
   
2. 
   
3. import java.io.BufferedReader;
   
4. import java.io.BufferedWriter;
   
5. import java.io.IOException;
   
6. import java.io.InputStreamReader;
   
7. import java.io.OutputStreamWriter;
   
8. 
   
9. public class Test001_DumpAndDown100 {
   
10.     public static void main(String[] args) throws IOException {
    
11. 
    
12.         System.out.println("一个球从100米高度自由落下，每次落地后反跳回原高度的一半，" + "再落下，求它在第10次落地时，共经过多少米？第10次反弹多高");
    
13. 
    
14.         System.out.println("请输入该球在第几次落地，程序将返回共经过多少米，以及返回该次反弹了多少米");
    
15. 
    
16.         System.out.println("即输入一个数字回车，本次结束，输入end回车，则程序结束");
    
17. 
    
18.         // 字符输入流
    
19.         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    
20.         // 字符输出流
    
21.         BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
    
22. 
    
23.         String line = null;
    
24.         String end = "end";
    
25.         // 等比数列公式参数定义：
    
26.         // 定义项数n
    
27.         int n = 0;
    
28.         // 定义公比q
    
29.         double q = 0.5;
    
30.         // 下落时的等比数列，定义首项a1
    
31.         double a1 = 100;
    
32.         //下落时的等比数列， 通项公式：An = A1×q^（n－1）
    
33.          double An = 0;
    
34.         // 下落时的等比数列，求和公式Sn,q≠1时：Sn=a1(1-q^n)/(1-q)；q=1时： Sn=n×a1（q=1）
    
35.          double Sn_down = 0;
    
36.         // 上升时的等比数列，定义首项b1: b1 = a1 * q;
    
37.          double b1 = 0;
    
38.          //上升时的等比数列，通项公式：Bn = b1 * q ^ (n - 1)
    
39.          double Bn = 0;
    
40.          //上升和下降的总路程，Sn_sum = 2 Sn_down - a1;
    
41.          double Sn_sum = 0;
    
42.          
    
43.         // 输入任意整数
    
44.         String regex = "\\d+";
    
45.         while ((line = bufr.readLine()) != null) {
    
46.             if (line.equals(end)) {
    
47.                 break;
    
48.             } else if (!line.matches(regex)) {
    
49.                 System.out.println("输入格式错误，请重新输入，如：23 或 end,回车");
    
50.                 continue;
    
51.             } else {
    
52.                 // n为输入的次数
    
53.                 n = Integer.parseInt(line);
    
54.                 // Sn下,Sn=a1(1-q^n)/(1-q)
    
55.                 Sn_down = a1 * (1 - Math.pow(q, n)) / (1 - q);
    
56.                 // Sn总= 2 Sn下 - 100
    
57.                 Sn_sum = 2 * Sn_down - a1;
    
58.                 //第1次上，b1 = a1 * q;
    
59.                 b1 = a1 * q;
    
60.                 // 第n次上：Bn = b1 * q ^ (n - 1)
    
61.                 Bn = b1 * Math.pow(q, n - 1);
    
62. 
    
63.                 System.out.println("你输入的n为：");
    
64.                 bufw.write(line);
    
65.                 bufw.newLine();
    
66.                 bufw.flush();
    
67.                 System.out.println("在第 " + n + " 次落地时" + "总路程为： " + Sn_sum + "  该次反弹的路程为： " + Bn);
    
68.                 System.out.println("可继续输入，结束输入end");
    
69.             }
    
70.         }
    
71.         bufw.close();
    
72.         bufr.close();
    
73.     }
    
74. }
    

复制代码

public class Test1 {
        public static void main(String[] args) {
               
                double sum = 0;
                metre(100, 10, sum);
               
        }
       
        public static double metre(double num, int count, double sum){
               
               
                if(count-- > 0){
                       
                        num /= 2;
                        sum +=        2*num;
                       
                        System.out.println("第"+(10-count)+"反弹了"+num+"米。");
                        System.out.println("到第"+(10-count)+"次反弹结束经过的路程："+(sum+100)+"米。");//因为计算的是从第一次到地上反弹开始到落下的距离，所以要加上从100米处落下的距离。
                       
                        metre(num, count, sum);
                }
               
               
                return num;
        }

}

结果：
第1反弹了50.0米。
到第1次反弹结束经过的路程：200.0米。
第2反弹了25.0米。
到第2次反弹结束经过的路程：250.0米。
第3反弹了12.5米。
到第3次反弹结束经过的路程：275.0米。
第4反弹了6.25米。
到第4次反弹结束经过的路程：287.5米。
第5反弹了3.125米。
到第5次反弹结束经过的路程：293.75米。
第6反弹了1.5625米。
到第6次反弹结束经过的路程：296.875米。
第7反弹了0.78125米。
到第7次反弹结束经过的路程：298.4375米。
第8反弹了0.390625米。
到第8次反弹结束经过的路程：299.21875米。
第9反弹了0.1953125米。
到第9次反弹结束经过的路程：299.609375米。
第10反弹了0.09765625米。
到第10次反弹结束经过的路程：299.8046875米。

:lol:shutup:

王超 发表于 2012-7-21 07:24

怎么能这样 ？ 只是没有忘了把结果贴上去 ! :'(