黄金连分数

黄金分割数0.61803... 是个无理数，这个常数十分重要，在许多工程问题中会出现。有时需要把这个数字求得很精确。

对于某些精密工程，常数的精度很重要。也许你听说过哈勃太空望远镜，它首次升空后就发现了一处人工加工错误，对那样一个庞然大物，其实只是镜面加工时有比头发丝还细许多倍的一处错误而已，却使它成了“近视眼”!!

言归正传，我们如何求得黄金分割数的尽可能精确的值呢？有许多方法。

比较简单的一种是用连分数：

                  1

黄金数 = ---------------------

                        1

             1 +-----------------

                          1

                 1 +-------------

                            1

                     1 +---------

                          1 +...

这个连分数计算的“层数”越多，它的值越接近黄金分割数。

请你利用这一特性，求出黄金分割数的足够精确值，要求四舍五入到小数点后100位。

小数点后3位的值为：0.618

小数点后4位的值为：0.6180

小数点后5位的值为：0.61803

小数点后7位的值为：0.6180340

（注意尾部的0，不能忽略）

你的任务是：写出精确到小数点后100位精度的黄金分割值。

注意：尾数的四舍五入！尾数是0也要保留！

显然答案是一个小数，其小数点后有100位数字，请通过浏览器直接提交该数字。

注意：不要提交解答过程，或其它辅助说明类的内容。

..字有点难看

总之，，，这个公式是不可能无限的，你试着把后面的部分忽略掉，把他当成0,,去发现这个分数 有一层的时候的值，和有两层时候的值，，，，显然这个分数的层数越多越精确

直接求出菲波那切数列足够大的相邻两位

由于数值较大，我们使用java中自带的大整数类， BigInteger

                BigInteger firstNum = BigInteger.ONE; //1
	        BigInteger secNum = BigInteger.ONE;
	        BigInteger res = BigInteger.ZERO;   //0
	 
	        
	        //BigInteger的斐波那契数列
	        for (int i = 0; i < 50000; i++) {  
	            if (i == 0 || i == 1) {
	                res = BigInteger.ONE;
	            }
	            res = secNum.add(firstNum); //两个BigInteger相加
	            firstNum = secNum;
	            secNum = res;
	        }

相除的时候，由于我们是不可能得到他的无限小数的，所以求他的后一百位近似值

利用计算机模拟这个手算过程

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.util.*;

public class Init57 {

	/**
	 * @param args
	 */
	  public static void main(String[] args) {
	        BigInteger firstNum = BigInteger.ONE; //1
	        BigInteger secNum = BigInteger.ONE;
	        BigInteger res = BigInteger.ZERO;   //0
	        BigInteger TEN = BigInteger.TEN;   //10
	        
	        //BigInteger的斐波那契数列
	        for (int i = 0; i < 50000; i++) {  
	            if (i == 0 || i == 1) {
	                res = BigInteger.ONE;
	            }
	            res = secNum.add(firstNum); //两个BigInteger相加
	            firstNum = secNum;
	            secNum = res;
	        }
	        
	       
	        //for循环实现了模拟手算除法
	        for (int i = 0; i < 101; i++) {
	            //选择斐波那契里两个连续的数，小的做被除数，大的做除数
	            //每一位是两者的商值
	            BigInteger ans = firstNum.divide(secNum);
	            //除数不变，被除数=余数*10
	            firstNum = (firstNum.mod(secNum)).multiply(TEN);
	            if (i!=0) {  //只输出后面的100位小数点
	                System.out.print(ans);    
	            }
	        }
	        System.out.println();
	    }


}

整体代码，或则使用扩大分子倍数，求整数部分的方法来获得100位近视值;

例如： 3/7   ::::我们将3*100/7，。我们得到的整数部分就是2位小数的近似值

package testBlue;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.util.*;

public class Init57 {

	/**
	 * @param args
	 */
	  public static void main(String[] args) {
	        BigInteger firstNum = BigInteger.ONE; //1
	        BigInteger secNum = BigInteger.ONE;
	        BigInteger res = BigInteger.ZERO;   //0
	        BigInteger TEN = BigInteger.TEN;   //10
	        
	        //BigInteger的斐波那契数列
	        for (int i = 0; i < 50000; i++) {  
	            if (i == 0 || i == 1) {
	                res = BigInteger.ONE;
	            }
	            res = secNum.add(firstNum); //两个BigInteger相加
	            firstNum = secNum;
	            secNum = res;
	        }
	        
	       
	        //用比较懒的方法生成一个100
	        String multNum = "1";
	        for(int i=0;i<100;i++){
	        	multNum+="0";
	        }
	        BigInteger one =  firstNum.multiply(new BigInteger(multNum)).divide(secNum);
	        System.out.println(one);
	        System.out.println();
	    }


}

但是....

这里涉及到一个精确度的问题，四舍五入，，，，可想而知，计算完成后再四舍五入是多么费心。

使用

BigDecimal类

超大型，小数

package testBlue;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.util.*;

public class Init57 {

	/**
	 * @param args
	 */
	  public static void main(String[] args) {
	        BigInteger firstNum = BigInteger.ONE; //1
	        BigInteger secNum = BigInteger.ONE;
	        BigInteger res = BigInteger.ZERO;   //0
	        BigInteger TEN = BigInteger.TEN;   //10
	        
	        //BigInteger的斐波那契数列
	        for (int i = 0; i < 50000; i++) {  
	            if (i == 0 || i == 1) {
	                res = BigInteger.ONE;
	            }
	            res = secNum.add(firstNum); //两个BigInteger相加
	            firstNum = secNum;
	            secNum = res;
	        }
	        
	       
	        //将要计算的分子分母转化成BigDecimal
	        BigDecimal fenzi = new BigDecimal(firstNum);
	        BigDecimal fenmu = new BigDecimal(res);
	        
	        //如果结果为无限小数会报错，，所以
	        BigDecimal num = fenzi.divide(fenmu,100,BigDecimal.ROUND_HALF_UP);
	        //使用BigDecimal内置方法
	        //精确到小数点100位，
	        //使用四舍五入的精确模式
	        System.out.println(num);
	    }


}

....这道题难点

发现斐波那契 规律，，

，，，，学会怎么去求小数近似值

现在时间 2018/3/29

之前看别人写的答案把我误导。 这道题可以直接使用暴力解决的。简单方便。不必要去找什么规律。

考虑100位的精确度。依旧使用BigDecimal类进行计算

原理套用公式 y(x)  =  x + (x +y(x+1))

import java.math.BigDecimal;
import java.util.TreeSet;
import java.util.function.BiConsumer;

public class Main {
    public static void main(String[] args) {
    	BigDecimal b = BigDecimal.ZERO;
    	BigDecimal one = BigDecimal.ONE;
    	for(int i=0;i<10000;i++){
    		b = one.divide(one.add(b),100,BigDecimal.ROUND_HALF_UP);
    	}
    	System.out.println(b);	
    }
}