由代码实现求(1^n+2^n+3^n+....+X^n)公式(n为已知)

一日无聊，
推算1+2²+3²+4²+…+X²公式
再算1+2³+3³+4³+…+X³
直到算到6,突然想到，身为程序员，为何自己算，用计算机代码实现
代码

package simple.guzy.test.num;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class Cifang {

	private long[] cishu;//第0位是底数

	public Cifang(long[] cc1) {
		cishu = new long[cc1.length];
		for (int i = 0; i < cc1.length; i++) {
			cishu[i] = cc1[i];
		}
	}

	public Cifang() {
	}

	public long[] getCishu() {
		return cishu;
	}

	public void setCishu(long[] cishu) {
		this.cishu = cishu;
	}

	//两个相乘
	public void chengyi(Cifang c2) {
		long[] newCishu = new long[this.getLength() + c2.getLength() - 2];
		for (int i = 1; i < cishu.length; i++) {
			for (int j = 1; j < c2.getLength(); j++) {
				newCishu[i + j - 1] = newCishu[i + j - 1] + cishu[i] * c2.getCishu()[j];
			}
		}
		newCishu[0] = cishu[0] * c2.getCishu()[0];
		cishu = newCishu;
		this.jianhua();
	}

	public void jiashang(Cifang c2) {
		long[] newCishu = new long[this.getLength() > c2.getLength() ? this.getLength() : c2.getLength()];
		for (int i = 0; i < newCishu.length; i++) {
			long cishui = 0;
			long cishu2i = 0;
			if (cishu.length > i) {
				cishui = cishu[i];
			}
			if (c2.getCishu().length > i) {
				cishu2i = c2.getCishu()[i];
			}
			newCishu[i] = cishui * c2.getCishu()[0] + cishu2i * cishu[0];
		}
		newCishu[0] = cishu[0] * c2.getCishu()[0];
		cishu = newCishu;
		this.jianhua();
	}

	private int getLength() {
		return cishu.length;
	}

	public void quda() {
		long[] newCishu = new long[this.getLength() - 1];
		for (int i = 0; i < newCishu.length; i++) {
			newCishu[i] = cishu[i];
		}
		cishu = newCishu;
	}

	public void jiayi() {
		cishu[1] = cishu[1] + cishu[0];

	}

	public void jianyi() {
		cishu[1] = cishu[1] - cishu[0];

	}

	public void qiuhe() {

	}

	public static Map<Integer, Cifang> qiuheMap = new HashMap<Integer, Cifang>();

	//核心思想：
	//1+2^n+3^n...
	//(1+X)^(n+1) = X^(n+1)+(n+1)*X^n...
	//(1+X)^(n+1) - X^(n+1) = (n+1)*X^n...
	//合并(1+X)^(n+1) - 1 = Sn +(n+1)n/2*S(n-1) +...
	public static Cifang qiuhe(long weishu) {
		//如果有记录，省的计算
		if (qiuheMap.containsKey(weishu)) {
			return qiuheMap.get(weishu);
		}
		long[] cc1 = new long[3];
		cc1[0] = 1;//分母
		cc1[1] = 1;
		cc1[2] = 1;
		Cifang c1 = new Cifang(cc1);
		c1.cifang(weishu + 1);//(X+1)的次方
		long[] newCi = c1.getCishu();
		Cifang c2 = new Cifang(newCi);
		c2.jianyi();//此时为(1+X)^(n+1) - 1 (等式左边)
		for (int i = 1; i < c1.getCishu().length - 2; i++) {
			Cifang quhe = qiuhe(i - 1).chengyi(newCi[i] * (-1));//把低次方的算出来扣除
			c2.jiashang(quhe);
		}
		Cifang newCifang = new Cifang(c2.getCishu());
		newCifang.chuyi(c1.getCishu()[2]);//除以倍数n
		newCifang.jianhua();
		return newCifang;
	}

	private Cifang chengyi(long num) {
		for (int i = 1; i < cishu.length; i++) {
			cishu[i] = cishu[i] * num;
		}
		this.jianhua();
		return this;
	}

	public void cifang(long i) {
		Cifang cc = new Cifang(this.getCishu());
		for (long j = 0; j < i - 1; j++) {
			this.chengyi(cc);
		}
		this.jianhua();
	}

	public void chuyi(long i) {
		cishu[0] = cishu[0] * i;
	}

	@Override
	public String toString() {
		return Arrays.toString(cishu);
	}

	public double shixian(long i) {
		long num = 0;
		for (int j = 1; j < cishu.length; j++) {
			num += Math.pow(i, j - 1) * cishu[j];
		}
		return (num + 0.0) / cishu[0];
	}

	public void jianhua() {
		long gongyueshu = getgongyueshu();
		for (int j = 0; j < cishu.length; j++) {
			cishu[j] = cishu[j] / gongyueshu;
		}
	}

	private long getgongyueshu() {
		long[] he = new long[cishu.length];
		for (int i = 0; i < cishu.length; i++) {
			he[i] = Math.abs(cishu[i]);
		}
		long gongyue = 1;
		for (long i = 1; i <= minest(he); i++) {
			if (zhengchu(he, i)) {
				gongyue = i;
			}
		}
		return gongyue;
	}

	private boolean zhengchu(long[] he, long num) {
		for (int i = 0; i < he.length; i++) {
			if (he[i] % num != 0) {
				return false;
			}
		}
		return true;
	}

	private long minest(long[] he) {
		long minest = he[0];
		for (int i = 1; i < he.length; i++) {
			if (he[i] < minest && he[i] != 0) {
				minest = he[i];
			}
		}
		return minest;
	}

	public void yinshifenjie() {
		long[] ccshu = copyOf(cishu);
		String fenjieStr = "[";
		while (ccshu.length > 3) {
			Map<String, long[]> map = getByccshu(ccshu);
			if (!map.containsKey("yinshi")) {
				break;
			}
			long[] yinshi = map.get("yinshi");
			ccshu = map.get("ccshu");
			fenjieStr += getStr(yinshi) + "*";
		}

		fenjieStr += getStr2(ccshu) + "]/" + ccshu[0];
		System.out.println(fenjieStr.replace("*(1)", ""));
	}

	private String getStr2(long[] yinshi) {
		String str = "";
		for (int i = 1; i < yinshi.length; i++) {
			if (yinshi[i] == 0) {
				continue;
			}
			if (yinshi[i] == 1) {
				if ((i - 1) == 0) {
					str = "+" + 1 + str;
				} else if ((i - 1) == 1) {
					str = "+" + "X" + str;
				} else {
					str = "+" + "X" + "^" + (i - 1) + str;
				}
				continue;
			}
			if (yinshi[i] == -1) {
				if ((i - 1) == 0) {
					str = "-" + 1 + str;
				} else if ((i - 1) == 1) {
					str = "-" + "X" + str;
				} else {
					str = "-" + "X" + "^" + (i - 1) + str;
				}
				continue;
			}
			if (yinshi[i] < 0) {
				if ((i - 1) == 0) {
					str = yinshi[i] + str;
				} else if ((i - 1) == 1) {
					str = yinshi[i] + "*" + "X" + str;
				} else {
					str = yinshi[i] + "*" + "X" + "^" + (i - 1) + str;
				}
				continue;
			}
			if ((i - 1) == 0) {
				str = "+" + yinshi[i] + str;
			} else if ((i - 1) == 1) {
				str = "+" + yinshi[i] + "*" + "X" + str;
			} else {
				str = "+" + yinshi[i] + "*" + "X" + "^" + (i - 1) + str;
			}
		}
		if ("+".equals(str.substring(0, 1))) {
			str = str.substring(1);
		}
		if ("X".equals(str)) {
			return str;
		}
		return "(" + str + ")";
	}

	private String getStr(long[] yinshi) {
		String str = "";
		for (int i = 0; i < yinshi.length; i++) {
			if (yinshi[i] == 0) {
				continue;
			}
			if (yinshi[i] == 1) {
				if (i == 0) {
					str = "+" + 1 + str;
				} else if (i == 1) {
					str = "+" + "X" + str;
				} else {
					str = "+" + "X" + "^" + i + str;
				}
				continue;
			}
			if (yinshi[i] < 0) {
				if (i == 0) {
					str = yinshi[i] + str;
				} else if (i == 1) {
					str = yinshi[i] + "*" + "X" + str;
				} else {
					str = yinshi[i] + "*" + "X" + "^" + i + str;
				}
				continue;
			}
			if (i == 0) {
				str = "+" + yinshi[i] + str;
			} else if (i == 1) {
				str = "+" + yinshi[i] + "*" + "X" + str;
			} else {
				str = "+" + yinshi[i] + "*" + "X" + "^" + i + str;
			}
		}
		if ("+".equals(str.substring(0, 1))) {
			str = str.substring(1);
		}
		if ("X".equals(str)) {
			return str;
		}
		return "(" + str + ")";
	}

	public Map<String, long[]> getByccshu(long[] ccshu) {
		Map<String, long[]> map = new HashMap<String, long[]>();
		long tou = ccshu[ccshu.length - 1];
		long wei = Math.abs(ccshu[1]);
		long[] chushu = new long[2];
		for (int i = 1; i <= tou; i++) {
			for (int j = (int) (0 - wei); j <= wei; j++) {
				chushu[0] = j + 0l;
				chushu[1] = i + 0l;
				if (zhengchu(ccshu, chushu)) {
					map.put("yinshi", chushu);
					ccshu = zhengchujieguo(ccshu, chushu);
					map.put("ccshu", ccshu);
					return map;
				}
			}
		}
		chushu = new long[3];
		for (int i = 1; i <= tou; i++) {
			for (int j = (int) (0 - wei); j <= wei; j++) {
				for (int k = -100; k <= 100; k++) {
					chushu[0] = j + 0l;
					chushu[1] = k + 0l;
					chushu[2] = i + 0l;
					if (zhengchu(ccshu, chushu)) {
						map.put("yinshi", chushu);
						ccshu = zhengchujieguo(ccshu, chushu);
						map.put("ccshu", ccshu);
						return map;
					}
				}
			}
		}
		return map;
	}

	private long[] zhengchujieguo(long[] ccshu, long[] chushu) {
		long[] answer = new long[ccshu.length - chushu.length + 1];
		for (int i = answer.length - 1; i > 0; i--) {
			answer[i] = ccshu[i + chushu.length - 1] / chushu[chushu.length - 1];
			ccshu = jianshu(ccshu, chushu, answer[i], i);
		}
		answer[0] = ccshu[0];
		return answer;
	}

	private long[] jianshu(long[] ccshu, long[] chushu, long l, int i) {
		for (int j = 0; j < chushu.length; j++) {
			ccshu[j + i + 0] = ccshu[j + i + 0] - chushu[j] * l;
		}
		return ccshu;
	}

	private boolean zhengchu(long[] ccshu, long[] chushu) {
		long[] cccshu = copyOf(ccshu);
		long[] answer = new long[cccshu.length - chushu.length + 1];
		for (int i = answer.length - 1; i > 0; i--) {
			if (cccshu[i + chushu.length - 1] % chushu[chushu.length - 1] != 0) {
				return false;
			}
			answer[i] = cccshu[i + chushu.length - 1] / chushu[chushu.length - 1];
			cccshu = jianshu(cccshu, chushu, answer[i], i);
		}
		for (int i = 1; i < cccshu.length; i++) {
			if (cccshu[i] != 0) {
				return false;
			}
		}
		return true;
	}

	private long[] copyOf(long[] cishu2) {
		long[] ccshu = new long[cishu2.length];
		for (int i = 0; i < ccshu.length; i++) {
			ccshu[i] = cishu2[i];
		}
		return ccshu;
	}

}

测试

import simple.guzy.test.num.Cifang;

public class Test0121 {
	public static void main(String[] args) {
		for (int i = 0; i <= 10; i++) {
			Cifang c = Cifang.qiuhe(i);
			c.jianhua();
			c.yinshifenjie();
		}
	}
}

结果

[X]/1
[X*(X+1)]/2
[X*(X+1)*(2*X+1)]/6
[X*X*(X+1)*(X+1)]/4
[X*(X+1)*(2*X+1)*(3*X^2+3*X-1)]/30
[X*X*(X+1)*(X+1)*(2*X^2+2*X-1)]/12
[X*(X+1)*(2*X+1)*(3*X^4+6*X^3-3*X+1)]/42
[X*X*(X+1)*(X+1)*(3*X^4+6*X^3-X^2-4*X+2)]/24
[X*(X+1)*(2*X+1)*(5*X^6+15*X^5+5*X^4-15*X^3-X^2+9*X-3)]/90
[X*X*(X+1)*(X+1)*(X^2+X-1)*(2*X^4+4*X^3-X^2-3*X+3)]/20
[X*(X+1)*(2*X+1)*(X^2+X-1)*(3*X^6+9*X^5+2*X^4-11*X^3+3*X^2+10*X-5)]/66