计算并输出 -1 + 1/2 - 1/4 +1/8.....的和，直到最后一项的绝对值小于等于 1/10^6为止。

百度一下你就知道了

...........算了半天.....没能理解..
1/10^6...
老了...

包晗 发表于 2012-7-13 10:21
...........算了半天.....没能理解..
1/10^6...
老了...

哥们你这名字不错啊 ，包涵。呵呵 我就是还不会用java.math。这类东西呢

public static vooi main(String[] args)
{

double pi,t,n,s;
s=t=-1;
sum=0;
n=1;
while((fabs(t))>=1.0E-6)
{

n=n*2;
s=-s;
t=s/n;
}
sum=sum+t;
System.out.println("-1 + 1/2 - 1/4 +1/8.....的和是"+sum)}

求加分呀

public static vooi main(String[] args)
{

double pi,t,n,s;
s=t=-1;
sum=0;
n=1;
while((fabs(t))>=1.0E-6)
{

n=n*2;
s=-s;
t=s/n;
}
sum=sum+t;
System.out.println("-1 + 1/2 - 1/4 +1/8.....的和是"+sum)}

求加分呀

1. public class SumUp {
   
2.         public static void main(String[] args) {
   
3.                 int i = 0;                //i用于计数
   
4.                 double sum = 1, val, last = 1;                //sum为最后的和，val为 1/10^6，last为最后一项的值
   
5.                
   
6.                 val = 1/Math.pow(10, 6);
   
7.                
   
8.                 while(Math.abs(last) > val){
   
9.                         last = Math.pow(-1, i + 1) / Math.pow(2, i);
   
10.                         sum = sum + last;
    
11.                         i++;
    
12.                 }
    
13.                
    
14.                 System.out.println(sum);
    
15.         }
    
16. }

复制代码

1. public static double jisuan()
   
2.         {
   
3.                 int i;//计算2的 i 次幂
   
4.                 double sum = 0.0;
   
5.                 for(i=0;Math.pow(2,i)<=Math.pow(10,6)  ; i++)//直到最后一项的绝对值小于10的-6次方为止
   
6.                 {
   
7.                         double mu=Math.pow(2,i);
   
8.                         if(i%2 != 0)
   
9.                                 sum += (double)1/mu; //2的奇数次幂和为正
   
10.                         else
    
11.                                 sum -= (double)1/mu; //2的偶数次幂(含0)和为负
    
12.                 }
    
13.                 return sum;
    
14.         }

复制代码

class Sum{
        float i=-1;//用于描述正负
        float m=1;//用来表示当前的被加数
        float sum;//用来表示和
        float temp=1;//用来表示m的绝对值
       
       
        public void Cau(){
                while (temp>0.000001) {

               
                m=i*m;
                sum=sum+m;
                m=m/2;
                i=-i;
                //计算绝对值
                if(m<0){
                        temp=-m;
                }else{
                        temp=m;
                }
               
                System.out.println(sum);
               
                }
               
               

               
                //System.out.println(sum);
        }
        public static void main(String[] args) {
                new Sum().Cau();
        }
}

求加分啊 ，因为一个小错误调试我20分钟啊{:soso_e109:}

张天天 发表于 2012-7-13 10:43

哥们，你这样计算不好，因为你用的是2的幂次运算，每次都会重新运算一次，非常的耗时间。就是第九行代码，可以看出第二个数的绝对值是上一个数绝对值的1/2，只需要将上一个数的绝对值除以二就能得到这个数的绝对值。我表达的不是很好。这样就能只计算一次了

1. class Sum{
   
2.         float i=-1;//用于描述正负
   
3.         float m=1;//用来表示当前的被加数
   
4.         float sum;//用来表示和
   
5.         float temp=1;//用来表示m的绝对值
   
6.        
   
7.        
   
8.         public void Cau(){
   
9.                 while (temp>0.000001) {
   
10. 
    
11.                
    
12.                 m=i*m;
    
13.                 sum=sum+m;
    
14.                 m=m/2;
    
15.                 i=-i;
    
16.                 //计算绝对值
    
17.                 if(m<0){
    
18.                         temp=-m;
    
19.                 }else{
    
20.                         temp=m;
    
21.                 }
    
22.                
    
23.                 System.out.println(sum);
    
24.                
    
25.                 }
    
26.                
    
27.                
    
28. 
    
29.                
    
30.                 //System.out.println(sum);
    
31.         }
    
32.         public static void main(String[] args) {
    
33.                 new Sum().Cau();
    
34.         }
    
35. }

复制代码

重新贴一下代码，这样好看很多了

如果把这里的除以2用移位运算，应该可以获得更快的速度

题目不难，正好看见了，练练手，我也贴下自己的代码。
思路：观察求和公式可以发现规律，正项负项交替出现，且后一项是前一项的-1/2倍。所以便有如下的代码。

1. //计算并输出 -1 + 1/2 - 1/4 +1/8.....的和，
   
2. //直到最后一项的绝对值小于等于 1/10^6为止。
   
3. 
   
4. import java.lang.Math;
   
5. class Sum
   
6. {
   
7.         public static void main(String[] args)
   
8.         {
   
9.                 final double TEMP = 1/Math.pow(10,6);
   
10.                 double num = -1, sum = 0;
    
11. 
    
12.                 while(Math.abs(num)>=TEMP)
    
13.                 {
    
14.                         sum = num + sum;
    
15.                         num = -(num/2);
    
16.                 }
    
17.                 System.out.println("-1 + 1/2 - 1/4 +1/8.....的和sum = "+sum);
    
18.                 System.out.println("Hello World!");
    
19.         }
    
20. }

复制代码

帅李 发表于 2012-7-13 10:55
哥们，你这样计算不好，因为你用的是2的幂次运算，每次都会重新运算一次，非常的耗时间。就是第九行代码 ...

无所谓，可以每次last *= -1/2;嘛，呵呵

苑占丽 发表于 2012-7-13 10:30
public static vooi main(String[] args)
{

多谢你们的建议，我会多多注意的。

1. package demo;
   
2. 
   
3. public class Summ {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          * -1/2^0,1/2^1,-1/2^2,1/2^3.....分析知道每一项为（-2）^(1-n),此例中使用到了Math类的abs()和pow()方法
   
8.          * public BigDecimal abs()返回 BigDecimal，其值为此 BigDecimal 的绝对值
   
9.          * public BigDecimal pow(int n,
   
10.                       MathContext mc)
    
11.        n - 此 BigDecimal 的幂。mc - 要使用的上下文。
    
12.          */
    
13.         public static void main(String[] args) {
    
14.                 // TODO Auto-generated method stub
    
15.                 double sum =0.0;
    
16.                 for (int i = 0; Math.abs(Math.pow(-2, 1-i)) > Math.pow(10, -6); i++) {
    
17.                          sum  = sum + Math.pow(-2, 1-i);                         
    
18.                 }
    
19.                 System.out.print(sum);
    
20.         }
    
21. 
    
22. }

复制代码

编程就是勤加锻炼啊，咱也贴一段代码。

帅哥，为了看你这道题我之前一直按while(true)想先算每项的值，看看结果对不对，结果每一项都是 sun:Infinity   把我弄得，你叫我情何以堪啊  用了我好久时间  但是还是给弄出来了
你在不给我分   我哭长城去啊{:soso_e109:}。。。。。。

public class TestArgs
{
        public static void main(String[] args)
        {
  
        //计算并输出 -1 + 1/2 - 1/4 +1/8.....的和，直到最后一项的绝对值小于等于 1/10^6为止。        
        
                method();
               
        }
        
        public static void method()
        {

                 int  x = 1;           //分母
                    int  i = -1;         //记录正负号
                 double  temp = 1;   //记录每一项的值
                 double sun =0;     //记录和
                double  d = 1/Math.pow(10, 6);   //条件1/10^6
                while(Math.abs(temp)>=d)
                {
                         
                        if(x==1)   //第一项取值
                        {
                        temp = (double)i/x;
                        x++;
                        }
                        else   //后面的第N+1项的值
                        {  
                        i = -i;           //变换正负号
                        temp = (double)i/x;       
                        x = 2*x;              

                        }       
                       
                        sun = sun+temp;

                }
                System.out.println("sun:"+sun);               
               
        }
}

2的n次方等于1000000
1000000的约数肯定有5，所以n不是整数
2^19=524288
n=19.931568569324174087221916576936
所以让所以分母是2的小于20的次方这就好说了，分母就确定了，奉上代码和结果
结果是：-1.9073486328125E-6，其实想明白了很容易的，看看这个是不是想要的结果