---------------答题活动：求π的值---------------

2013-11-18 17:06 上传

本帖最后由杨增坤于 2013-11-25 11:06 编辑

此活动结束了，大家有不懂的地方可以参考一下其他人的代码，现在大家可以查看了!有什么建议，大家可以提出来！

问题1：

根据公式求π的值，直到所加项小于1E-10位置。

解释：1E-10表示的是1.0*Math.pow(10,-10),10的-10次幂。

问题2：

根据第一题求出的π的值，求圆的面积，半径从键盘上录入。

要求：

1.要求写出自己观察的规律，写出你的答题思路。

2.要写出自己的详细注释，包括函数和类。

3.要对输入的半径进行判断。

4.结果贴出来，结果清晰：π，半径和面积

评分：

1.正确的求出π。1分

2.在(1)的基础上写出了详细的思路和想法。2分

3.利用正确的π正确的求出了圆的面积。1分

4.对出入的半径做了正确的判断和结果清晰。1分

满分为5分。根据大家做的情况会给出相应技术分。

技术分会在本活动结束或者结束前做出评分。

提示：

可以使用循环，也可以使用其他的方法。

如果公式不清楚，那么可以查看附件！

本活动截至时间为2013-11-24 中午12点

大家赶快行动起来吧，你们都是最棒的！！！

Linuxgg · Linuxgg

#在这里快速回复#谢谢楼主期望灌水，我是来拿技术分 Sun Feb 23 20:38:20 CST 2014

Linuxgg · Linuxgg

#在这里快速回复#谢谢楼主期望灌水，我是来拿技术分 Sun Feb 23 18:03:30 CST 2014

瓶中人 · 瓶中人

package com.ping.test;

import java.util.Scanner;

public class PI {

/**
   * 题目：根据公式求π值
   * 思路：
   * 1.π的值等于右边的值乘以6，所以就是要求右边的值即可
   * 2.由右边公式可知，其实“+”号间的数字段都是分为三个公式相乘而来，
   * 如（(1/2)*(3/4)*(5/6)）*(1/7)*(1/2)的七次方 ,可分为（(1/2)*(3/4)*(5/6)）、 (1/7) 与 (1/2)的七次方
   * 3.只需要观察每个公式的规律即可，其中一个段（1/2）可以想成1*1*(1/2)
   * 4.解第一个公式，提取提供资料的4段数字分别为：1 、1/2、(1/2)*(3/4)、((1/2)*(3/4)*(5/6))
   * ，由相乘数字递增就可知这就是一个循环递增的相乘所得，每段都可在前面加“1*”，由((1/2)*(3/4)*(5/6))
   * 可知其每项的分子比分母少一，而个分母都比前一个数的分母多2，当然除了第个公式除外，所以单独把它划出（if(j==1)num1=1;），
   * 原来是这个的（(2*j-1) /(2*j)）,不过如果第一项的特殊的关系，改为（（1-（2*(j-1))）j不等于1）
   * 5，解第二个公式，同样从4段式子中抽取数字分别为 1，（1/3），(1/5)，(1/7)可知，其分子均为1，而分母的关系是（（2*j） -1）
   * 6，解第三个公式同样从4段式子中抽取数字分别为 1/2,(1/2)³，（1/2）5次方，（1/2）七次方，很容易就可以想出（1/2）(2-1)次方
   * 7，就这样将其分别循环，再将一次循环所得相乘，再在外循环中相加，直到其满足条件后跳出外循环。
   * 8，其中需要注意因其主要是小数计算，所以是不能用int 类型定义变量，而且不能写（1/2）因其两者皆为int，相除结果只会为0
   * @param args
   */
public static void main(String[] args) {
// TODO Auto-generated method stub
//调用manager()
   manager();

}
public static void manager(){
//新建Scanner对象
Scanner input = new Scanner(System.in);
System.out.println("请输入圆的半径：");
//输入半径
double radius = 0;
//用捕获异常的方法是为了防止输入异常字符
try {
radius = input.nextDouble();
//判断其是否为正整数
if(radius <= 0){
System.out.println("请输入大于0的数字！");
}
//按要求输入半径，圆周率与面积
System.out.println("圆的半径为："+ getPI()+",半径为："+radius +",圆的面积为：" + getPI() * radius * radius);
} catch (Exception e) {
// TODO Auto-generated catch block
System.out.println("请输入数字！");
}

}
//计算π的方法
public static double getPI(){
//定义变量
//右边的数之和
double sum = 0;
//循环变量
double i = 1 ;
//设外循环为死循环，满足条件即跳出
while(true){
//每段数字的和的变量
double littleSum = 0;
//第一个公式的和
double num1 = 1;
//第二个公式的和
double num2 = 0;
//第三个公式的和
double num3 = 1;

//第一个公式的和的计算方法
   for(double j = 1 ; j <= (i * 2 -1) ; j ++){
   num1 *= 0.5 ;
   }
   //第二个公式的计算方法
   num2 = 1 /(2 * i -1);
   //第三个公式的计算方法
   for(double j = 1 ; j <= i ; j ++){
   if(j==1)
   //将情况为1的区别出来
   num3 = 1 ;
   else
   num3 *= 1 - 1 /((j -1) *2);
   }
   //第一段公式之和
   littleSum = num1 * num2 * num3;
   //所有段的公式相加
   sum += littleSum;
   i++;
   //若满足条件，即跳出循环
   if(littleSum < 1.0*Math.pow(10, -10)){
   break;
   }
}
//因π等于右边之和乘以 6
   return sum * 6;
}

}

ysunday · ysunday

本帖最后由 ysunday 于 2013-11-21 03:20 编辑

/*
* 思路：
* 1/2 + (1/2)*(1/3)*(1/2)^3 + (1/2*3/4)*(1/5)*(1/2)^5
* 对除了第一项，每项可分为3部分，第一部分的规律是(1/2*3/4*5/6...(2n-3)*(2n-2)
* 对于2和3部分可找规律为 1/(2n-1), (1/2)^(2n-1)
*
* 既然找出规律来，就先循环求出第n项，然后将n项累加，求出PI
*
* 对键盘录入，用户可能输入错误的格式，那就有可能异常，先捕捉异常，
* 同时还得判断用户是否输入负数，如果用户输入错了，得让用户可以重新
* 输入，故采用while
*/
import java.text.DecimalFormat;
import java.util.Scanner;
public class Test10 {
/**
* @param args
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); //建立对控制台的输入的关联
double PI = findPI(); //求出PI
while(true){ //循环，直到用户输入正确的格式
System.out.println("please input R:");//提示
String s = sc.nextLine(); //读取一行
Double r = null; //定义r
try{
r = Double.valueOf(s); //转型
if(r < 0 || r == null){//判断是否为空，或者小于0,个人认为半径为0可接受
//如果符合条件，进行下次循环，让用户输入
System.out.println("R can't be less than
zero,please input right format");
continue; //跳出本次循环
}
//如果符合，计算面积，这里对结果进行了格式化，保留四位小数
String area =
new DecimalFormat("#.0000").format(PI * r * r);
System.out.println("PI: " + PI);//输出PI和园的信息
System.out.println("R:" + r + " Area:" + area);
break; //结束循环
}catch(Exception e){ //因为用户有可能输入的字符ab之类抓异常
System.out.println("your input format is wrong, please a number");
continue; //结束本次输入，进行下次
}
}
sc.close(); //关闭资源
}
public static double nthNum(int n){//计算除第一个数之外的第n项值
double nthNum = 1; //记录结果用
double y = Math.pow(0.5, 2 * n - 1 + 0.0);//这是每项中间那部分的值
for(int x = 2; x <= n; x = x + 1){ //循环n - 1次，因为没有第1项
nthNum *= (2 * x - 3 + 0.0)/(2 * x - 2 + 0.0);//累乘
}
return nthNum * (1 / (2 * n - 1 + 0.0)) * y; //返回第n项的值
}
public static double findPI(){ //利用第n项，算最终的结果的函数
double sum = 0.5; //第一项 1/2
//各项累加,直到第n项小于等于给定值为止
for(int x = 2;nthNum(x) >= Math.pow(10.0, -10.0); x++){
sum += nthNum(x);
}
return sum * 6; //返回PI
}
}

复制代码

谢谢您的批阅！您辛苦了

joure · joure

本帖最后由 joure 于 2013-11-22 10:48 编辑

/*一,观察规律：
通过观察规律第n项的值可以拆分为三部分表示
第一部分为 1~(2*n-3)的奇数除以2~(2*n-2)的偶数
第二部分为 1除以（2*n-1）
第三部分为       1/2的（2*n-1）次幂
思路：
使用循环嵌套解决问题
外循环控制运算次数，内循环算出单项的值
运算结果：
π的值为3.1415926535153385
*/

class  PiDemo
{
      public static void main(String[] args)
      {
            double pi;
            double sum=0.5,sum_n=0.5;       //sum表示的是右边算式总和，sum_n表示第n项的值

            for (int n=2; sum_n>1.0*Math.pow(10,-10);n++ )//sum_n小于1E-10位置结束循环
            {
                     double  x=1.0;
                     for (int i=1; i<=(2*n-3); i=i+2)
                     {
                              x=x*i/(i+1);             //算式括号内的值用x表示
                     }
                     sum_n =x*Math.pow(0.5,2*n-1)/(2*n-1);       //求出单项值
                     sum=sum+sum_n;                      //求出右边算式总和
            }
            pi=6*sum;                               //π的值
            System.out.println("π的值为"+pi);
      }
}
/*

二，思路
利用π值求圆面积，使用scanner方法输入，利用公式求出圆面积并输出

输入数据判断是一个难点，也是我目前的一个盲点，所以第4个功能未能够实现
我会争取早日把这部分的内容学完,实现这个功能
运算结果：
                     请输入圆的半径：
                     5
                     圆的半径为：5
                     圆的面积为:78.53981633788347
*/
import java.util.*;
class Asd
{
      public static void main(String[] args)
      {
            double pi=3.1415926535153385;
            System.out.println("请输入圆的半径：");
            Scanner input=new Scanner(System.in);
            int r=input.nextInt();
            System.out.println("圆的半径为："+r+"\n"+"圆的面积为:"+pi*r*r);
}
}

总结：自己的基础太薄弱，做第一个问题的时候一连出了十几个错误，调试了大半天
      使我意识到盲目追求进度是不可取的，必须把基础学扎实，才能提高后续的学习效率

向阳泪无痕 · 向阳泪无痕

本帖最后由向阳泪无痕于 2013-11-20 10:58 编辑

/*
问题1：
根据公式求π的值，直到所加项小于1E-10位置。
解释：1E-10表示的是1.0*Math.pow(10,-10),10的-10次幂。
问题2：
根据第一题求出的π的值，求圆的面积，半径从键盘上录入。
要求：
1.要求写出自己观察的规律，写出你的答题思路。
2.要写出自己的详细注释，包括函数和类。
3.要对输入的半径进行判断。
4.结果贴出来，结果清晰：π，半径和面积
问题1：
思路：
1，根据公式可知，这是一个无限加下去的公式，而每次所加的值都和其前后有着有关系，根据公式可知
这个公式中可能出现了等比，等差数列的组合，所以从这个角度去分析这个公式，找出他们每一项的通式。
则可采用for循环来叠加，求出更精确的PI值。
2，分析公式找到了通式，把公式先设成 PI/6 = 1/2 + Sn
S由公式右边从第二项开始
公式Sn = (1/2)1/3(1/2)^3+（1/2*3/4)1/5(1/2)^5+(1/2*3/4*5/6)1/7(1/2)^7+.....
= a1+a2+a3+....an
S可看成由3部分组成 (n从1开始取)
T1 ：就是每项的第一个括号括住的每一项值分别是 1/2 1/2*3/4 1/2*3/4*5/6 1/2*3/4*5/6*... 通式 1/2*3/4*...*（2n-1）/2n
T2 : 中间那个分数每一项值是 1/3 1/5 1/7 1/9 ... 通式 1/(2n+1)
T3 : 最后那个括号括及幂方（1/2）^3 (1/2)^5 (1/2)^7 (1/2)^9 ... 通式 (1/2)^(2n+1)
an = T1*T2*T3
= [1/2*3/4*...*（2n-1）/2n] * 1/(2n+1) * (1/2)^(2n+1)
3，使用for循环叠加当S的第n项小于1E-10位置时，结束循环。
步骤：
1，用上面方法求出S，使用for循环来求得
2，由：PI/6 = 1/2 + Sn
得PI = 3 + 6Sn
问题2：
思路：
1，从键盘录入圆的半径
2，使用IO流读出半径，因为从控制台读取，所以使用InputStream
3,使用问题1中求出的PI来求圆的面积
4，输出结果，可继续输入半径求圆面积
5，如不在用IO流，则关闭流。
*/
import java.lang.Math.*;
import java.io.*;
class MathText
{
static double PI,Sn,T1,T2,T3,an; //定义求PI所须要的变量
static BufferedReader bufr = null;
static double radius; //用来保存圆半径
static double area; //用来保存圆面积
public static void main(String[] args)
{
//问题1
sunText();
//问题2
roundArea();
}
//问题1
public static void sunText()
{
//1，求出S值 ,Sn = a1+a2+a3+.....+an , an=T1*T2*T3
for(int n = 1; ;n++) //通过S的通式，叠加每一项,n从1开始取
{
//求T1
for(int i=1;i<=n;i++)
{
if(i==1) //第一次得第一项时，在此处初始化第一项
T1 = 0.5;
else
T1 = T1 * ((2.0*n-1)/(2.0*n)); //第二项开始使用公式得T1
}
//求T2
T2 = 1.0/(2.0*n+1);
//求T3
T3 = Math.pow(1.0/2.0,(2*n+1));
//求第an项
an = T1*T2*T3;
if( an<(1E-10) ) //当所加项小于1E-10则结束叠加
break; //然后结束叠加
Sn += an; //把每一项叠加起来 Sn = a1+a2+a3+.....+an
}
//2，求出PI
PI = 3 + 6*Sn; //结束循环就是加到要求的那个项了，则开始计算PI的值
System.out.println("\n问题1：计算得 PI = "+PI);
}
//问题2
public static void roundArea()
{
try
{
while(true)
{
//1，从键盘录入圆的半径，因为从控制台读取，所以使用InputStream
System.out.print("\n请输入圆的半径 radius = ");
bufr = new BufferedReader(new InputStreamReader(System.in));
//2，使用IO流读出半径
String s = bufr.readLine(); //读取失败抛IOException异常
if("over".equals(s) || "OVER".equals(s)) //输入over结束求圆面积
return;
radius = Double.parseDouble(s); //转换失败抛NumberFormatException异常
//3,使用问题1中求出的PI来求出圆的面积
area = PI*radius*radius;
//4，输出结果，可继续输入半径求圆面积
System.out.println("->该圆的面积为 area = "+area);
}
}
catch (IOException e)
{
System.out.println("读取数据失败");
}
catch(NumberFormatException ex)
{
//处理转换异常
System.out.println("输入半径有错，请从新输入！");
//半径输入错误，再从新输入求圆面积
roundArea();
}
finally
{
//5，如不在用IO流，则关闭流。
try
{
if(bufr!=null) //如果流创建成功，则才可关闭。
bufr.close();
}
catch (Exception e)
{
System.out.println("关闭流资源错误！");
}
}
}
}

复制代码

向阳泪无痕 · 向阳泪无痕

本帖最后由向阳泪无痕于 2013-11-20 05:32 编辑

先抢个楼……

jttsai · jttsai

本帖最后由 jttsai 于 2013-11-19 08:59 编辑

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
* 思路：从第二项开始观察（以加法来分开各个项），我们可以看出，第二项的第一个为1/2 ，而第三项的第一个为1/2 + 3/4,其中1/2 +
* 3/4比1/2多加了个3/4 其中3/4 可以看出（1+2）/(2+2),也就是分子分母都自增了2，第三个的第一项也是这个规律。
* 而各项的第二个数字分别为1/3,1/5,1/7,也是自增量为2 而各项的第三个数字，后一项是前一项的0.5*0.5倍。
* 输入半径匹配原则：开始字符只能为0-9数字而且一个或者多个，小数点有一个或者没有，如果有小数后面跟着一个0-9的小数，后面只能为0-9数字也可以有0个或者多个。
*
* @author Administrator
*
*/

public class TestNumSort {

      public static void main(String[] args) {

            double sum = 0.5, t, t1, t2, t3, p = 0.5 * 0.5;
            int odd = 1, even = 2;
            t = t1 = t2 = 1.0;
            t3 = 0.5;
            // 知道所加项小于1E-10
            while (t > 1e-10) {
                     t1 = t1 * odd / even;
                     // 自增2
                     odd += 2;
                     // 自增2
                     even += 2;
                     t2 = 1.0 / odd;
                     t3 = t3 * p;
                     t = t1 * t2 * t3;
                     sum += t;
            }
            System.out.println("π的值为: " + sum * 6);

            System.out.print("请输入半径:");

            String regex = "\\d+(\\.\\d)?\\d*";

            // 键盘录入
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

            String line = "";
            try {
                     line = br.readLine();
            } catch (IOException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
            }
            // 输入的半径规则判断
            if (!line.matches(regex)) {

                     System.out.print("输入数字不规范!");
                     return;
            }

            double r = Double.parseDouble(line);

            System.out.println("圆的面积为 :  " + (sum * 6 * r * r));

      }
}

输出结果:
π的值为: 3.1415926535153385
请输入半径:1.34
圆的面积为 :  5.641043768652143

王东 · 王东

package com.itheima;
import java.util.Scanner;
/*
根据公式求π的值，直到所加项小于1E-10位置。
解释：1E-10表示的是1.0*Math.pow(10,-10),10的-10次幂。
问题2：
根据第一题求出的π的值，求圆的面积，半径从键盘上录入。
* */
public class PIDemo {
public static void main(String[] args) {
getArea();
}
//求面积的函数
public static void getArea(){
//定义半径
double radius = 0 ;
//定义PI
double PI = getPI();
//定义异常的信息字符串
String ex = "";
try{
//输入半径
System.out.println("请输入半径");
Scanner sc = new Scanner(System.in);
radius = sc.nextDouble();
}catch(Exception e){
//如果出现异常，则将异常的信息传入ex字符串中
System.out.println("输入类型错误，请重新输入");
ex = e.toString();
}
//如果异常信息为空的话，则输出信息
if(ex == ""){
System.out.println("半径是"+radius);
System.out.println("π是"+PI);
System.out.println("面积是"+PI*radius*radius);
}
//如果异常不为空，则递归
else
getArea();
/*
这里有个疑问想问一下，希望帮助解答，谢谢大神
开始我的代码是这样的
public static void getArea(){
double radius = 0 ;
double PI = getPI();
String ex = "";
try{
System.out.println("请输入半径");
Scanner sc = new Scanner(System.in);
radius = sc.nextDouble();
}catch(Exception e){
System.out.println("输入类型错误，请重新输入");
//在这里，我想直接递归输出，可是每次输出来的结果都是0，原因我知道了，但是，有什么方法可以
// 改进这种直接在catch中递归的方法呢？？
//还有，论坛上有没有好的方法呢？谢谢
//活动结束后能不能把活动的优秀的代码发下来看一下呢？
//麻烦你了，谢谢
getArea();
}
return PI*radius*radius;
*/
}
//求π的函数
public static double getPI(){
double d = 1.0;
double d1 = 0;
double PI = 0.0;
for (int i = 3; ; i = i + 2) {
//求出每个函数中，出了(1.0 / i) * (1.0 * Math.pow(2, -i))之外的数
d = ((i - 2) * 1.0) / ((i - 1) * 1.0) * d;
//求出每个项
d1 = d * (1.0 / i) * (1.0 * Math.pow(2, -i));
//如果项项小于1E-10，则结束
if(d1 < 1.0*Math.pow(10,-10))
break;
//求出π/6
PI = PI + d1;
}
//求出π
PI = (PI + (1.0/2))*6;
return PI;
}
}

复制代码

问天 · 问天

已提交，感谢版主给出建议

赵晓海 · 赵晓海

赵晓海发表于 2013-11-18 16:35
做了个公式，希望采纳

哇塞，还有分可以加，谢谢坤哥！

赵晓海 · 赵晓海

做了个公式，希望采纳{:soso_e113:}

潇湘溪语 · 潇湘溪语

/*
1、观察规律，分析公式：
①从第二项，第三项，第四项的括号内容，可以看出是累积乘法；
②括号后面的内容是1/2、1/5、1/7，分母为逐渐加2递增；
③最后的指数的幂数是3、5、7，和②的分母递增规律一致；
④先把右边除去1/2的其它项累加和求出，再求pi值即可。

2、步骤：
①先利用for循环，求出括号内容的累积乘法；由于循环多少次暂且不清楚，查资料可利用最大值替代；
②后面的分数和指数规律一致，且只是递增，并没有累加，可以列出通项公式；
③当项的值小于10的-10次幂时，停止循环，此时有一个综止判断；
④求出通项累加和，再加1/2，再乘以6，就是pi的值；

3、定义半径，求圆的面积：
①可以把Pi的值和圆的面积公式封装成一个类；
②然后利用主函数的特性，调用封装的函数进行运算即可。
*/

//定义一个名称为Pi类
class Pi
{
public static void setR(int r)//设置半径r的值
{
double x = 1, y, temp = 0, pi = 0;

for ( int i = 1; i<Integer.MAX_VALUE; i++)//Integer.MAX_VALUE，最整数型的最大值，即初始设置循环最大次数；
{
x *=(2*i-1.0)/(2*i);//这是公式括号内的累积乘法，并循环

y=1.0/(2*i+1.0)*Math.pow(0.5,(2*i+1.0));//这是括号后面的递增分数和指数的运算

if( x*y<1.0*Math.pow(10,-10) )//判断：当项的值小于10的-10次幂时，停止运算；
break;

temp += x*y;//通项累加和

pi = 6.0*(temp + 0.5);
}
System.out.println("π="+pi);

//S=πr^2
System.out.println("r="+r);

if(r>0)
System.out.println("S="+pi*r*r);
else
System.out.println("error");//面积不能为0和负数，只能为正
}
}

//定义一个PiDemo的类，可以调用上一个对象
class PiDemo
{
public static void main(String[] args)
{
Pi.setR(8);//输入半径为8或者任意数，即可得到结果，如下所示
}
}

/*
π=3.141592653258738
r=8
S=201.06192980855923
*/

天ya~_琼楼 · 天ya~_琼楼

版主辛苦了！

aspoMAN · aspoMAN

MathPI类 ps：不知道是不是有计算失误或者不精确的原因，π值不准确
/*
* 分析：根据公式得出：π/6=(2*n-3)/(2*n-2) * 1.0/(2*n-1) * 1.0*Math.pow((1.0/2), (2*n-1));
* 详细分析见附件。
*
* 计算方法：（公式中第一项为1，第n项为n）
* 1.求出公式中第一个参数的值：采用递归获得当前想的值（第一个括号）
* 2.求出第二个参数：1/2n-1
* 3.求出第三个参数（第二个括号中的值）：1/2的2n-1次幂
* 4.求出前三个参数相乘的值并与1E-10相比较，得到第一个成立的n值为5.
* 5.带入公式求的π的值
*/
/*
* 此类用于
* 求π的值
*/
public class MathPI {
//求的值
final static double PI = getAllValue(5.0)*6;
public static void main(String[] args) {
// System.out.println(calFirst(5.0));
//1.循环求所加项小于1E-10
double i = 1;
/*while(true) {
if(getCurrentValue(i) < 1.0*Math.pow(10, -10)) {
System.out.println("所加项小于10的-10次幂时的n值：" + i);
return;
}
i ++;
}*/
//求π值
System.out.println("π的值：" + getAllValue(5.0)*6);
}
//方法一：计算参数的值（第一个括号内的值）
static double firstValue = 1.0;
public static double calFirst(double n) {
if(n == 1) {
return firstValue *= 1.0;
} else {
//递归调用，知道n等于1
return firstValue *= (2*n-3)/(2*n-2)*calFirst(n - 1);
}
}
//方法二：符合规律1/1,1/3,1/5,1/7
static double secondValue = 1;
public static double calSecond(double n) {
//得到1/2n-1
return secondValue = 1.0/(2*n-1);
}
//方法三：计算1/2的n次幂
static double thirdValue = 1.0;
public static double calThird(double n) {
//得到1/2的2n-1次幂
return thirdValue = 1.0*Math.pow((1.0/2), (2*n-1));
}
//求当前项的值（一个元素）
public static double getCurrentValue(double n) {
return calFirst(n)*calSecond(n)*calThird(n);
}
//求π/6的值（将所有元素加起来）
static double allValue = 0;
public static double getAllValue(double n) {
if(n == 1) {
return allValue += 1.0/2;
} else {
return allValue += calFirst(n)*calSecond(n)*calThird(n) + getAllValue(n - 1);
}
}
}

复制代码

求圆的面积：PIUtils
/*
* 利用MathPI中求得的π值求圆的面积
*
* 直接计算方法：getResult
*/
import java.util.Scanner;
public class PIUtils {
public static void main(String[] args) {
//从键盘录入数据
System.out.println("请输入半径（大于0）");
double r = 0;
Scanner s = new Scanner(System.in);
try{
//获取键盘录入的数据，进行异常捕捉
r = s.nextDouble();
} catch(Exception e) {
throw new RuntimeException("您输入的类型有误");
}
System.out.println("面积为：" + getResult(r));
}
public static double getResult(double r) {
//对得到的半径进行判断
if(r <= 0) {
System.out.println("您输入的值有误");
System.exit(0);
}
//返回面积
return MathPI.PI*r*r;
}
}

复制代码

张鹏 · 张鹏

/*
* 分析：每一项有三个部分：
* 1、由1到小于指数的数构成的分数相乘如1/2, 3/4, 5/6
* 2、分子为1，分母为指数的分数
* 3、1/2也就是0.5的指数次次方
*/
public class CalculatePI
{
// 计算每一项的值
public static double getItem(long index)
{
// 存每一项的值
double fraction = 1;
// 计算由1到小于指数的数构成的分数相乘
for ( long i = 1; i < index; i += 2 )
{
fraction *= (double) i / (i + 1);
}
// 乘以分子为1，分母为指数的分数
fraction *= 1 / (double) index;
// 乘以1/2也就是0.5的指数次次方
fraction *= Math.pow(0.5, index);
return fraction;
}
// 获取π的值
public static double getPI()
{
// 精确标准数
double precision = 1.0 * Math.pow(10, -10);
// 每一项的数
double result = 0;
// 每一项的和
double sum = 0;
// 指数，为奇数
long index = 1;
// 计算每一项的结果，并判断是否到达指定的精确数
while ( (result = getItem(index)) >= precision )
{
// 每一项相加
sum += result;
// 下一个指数
index += 2;
}
// 每一项的总和乘以6为π的值
return sum * 6;
}
public static void main(String[] args)
{
System.out.println("π的值为：" + getPI());
}
}

复制代码

import java.util.Scanner;
/*
* 计算圆的面积
*/
public class CalculateCircle
{
/*
* 求圆的面积
*/
public static double getArea(double radius)
{
// 圆的面积公式：π * R * R
return CalculatePI.getPI() * radius * radius;
}
@SuppressWarnings("resource")
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
System.out.println("请输入半径：");
double radius = 0;
try
{
// 接收输入数据
radius = input.nextDouble();
} catch (Exception e)
{
System.out.println("你输入的半径有误！");
return;
}
System.out.println("圆的面积为(小数)：" + CalculateCircle.getArea(radius));
System.out.println("圆的面积为(取整)：" +Math.round(CalculateCircle.getArea(radius)));
}
}

复制代码

孤独站士 · 孤独站士

本帖最后由孤独站士于 2013-11-18 14:24 编辑

/*
求π，就是在累乘的基础上做累加，解此题的关键在于怎么表示出累加的每一项；
观察得知每一项有一个通项表示：即num=(1.0/n)*leicheng(n)*Math.pow((1.0/2.0),n);
其中n为从1开始依次加2的奇数，而leicheng方法中，注意点就是最小项为1/2
*/
import javax.swing.JOptionPane;
class MyPI
{
public static void main(String[] args){
double π;
π=PI();
System.out.println("π="+π);
//半径,面积
double r=0.0,a=0.0;
//控制是否多次测试
String another="";
//定义变量接收用户输入的值，都是String类型
String str="";
do
{
str=JOptionPane.showInputDialog("请输入半径的值：");
//转换成数值类型
r=Double.parseDouble(str);
if(r<0){
//对话框作显示
JOptionPane.showMessageDialog(null,"半径不能为负数,继续测试");
                     another="y";
                     //跳到下一次循环
continue;
}
//调用面积方法
a=area(r);
JOptionPane.showMessageDialog(null,"半径为"+r+"\n面积为"+a);
another=JOptionPane.showInputDialog("是否继续测试：Y/N");
}while(another.equalsIgnoreCase("y"));
System.out.println("半径为"+r+" 面积为"+a);
}
//求π得方法，注意点是各种数值类型的取值范围。
public static double PI(){
//定义变量存储π
double π=0.0;
//计数器，从1开始，每一次加2
int n=1;
//代表每一项
double num=0.0;
//开始循环求值
do{
num=(1.0/n)*leicheng(n)*Math.pow((1.0/2.0),n);
π+=num;
n+=2;
}
while(num>1.0*Math.pow(10,-10));
return 6*π;
}
//代表括号里面的累乘，其中n只能是奇数
public static double leicheng(int n){
double a=1.0;
while(n!=1){
//代表累乘括号里面每一项，最小项为1/2
a*=(double)(n-2)/(n-1);
n-=2;
}
return  a;
}
//处理面积
public static double area(double i){
double tmp;
tmp=i*i*PI();
return tmp;
}
}

蜀仙 · 蜀仙

提交了, {:soso_e160:}

赵晓海 · 赵晓海

本帖最后由赵晓海于 2013-11-18 11:29 编辑

帐号		自动登录	找回密码
密码			加入黑马

---------------答题活动：求π的值---------------

40 个回复

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

浏览过的版块