计算11的N次方，N非常大

11的N次方

最近在网上看到一道题，感觉还蛮有意思的，题目要求要用程序实现11的N次方，这个N可能会很大，所以结果要用字符串表示。

在写程序之前我们先把测试用例写出来，这里从11的0次方到21次方都有测试到：

func TestPowOfEleven(t *testing.T) {var checkList = []string{"1", "11", "121", "1331", "14641", "161051", "1771561", "19487171", "214358881", "2357947691", "25937424601", "285311670611","3138428376721", "34522712143931", "379749833583241", "4177248169415651", "45949729863572161", "505447028499293771", "5559917313492231481", "61159090448414546291","672749994932560009201", "7400249944258160101211"}for index, value := range checkList {if value == PowerOfEleven(index) {t.Logf("Power Of %v is right", index)} else {t.Logf("Power Of %v is wrong, right value is %s, calculate value is %s", index, value, PowerOfEleven(index))}}
}

其实11的N次方是有一定的数学规律的，它满足帕斯卡三角形（杨辉三角），其实101的幂，1001的幂，10001的幂，也都是满足的。感兴趣可以研究一下。相关资料在拓展阅读中。

这道题的基本思路是快速幂+大数相乘。因为N很大的话数字是装不下的，只能用字符串表示，用字符串的话就用大数相乘，这是一个比较好的解决方法。N次方的话，为了优化计算速度，就要用快速幂的思想，把时间复杂度降低到log(N).话不多说，看看代码：

//计算11的N次方主要函数
func PowerOfEleven(n int) string {if n == 0 {return "1"}if n == 1 {return "11"}var baseNums = "11"var res = "1"for n > 0 {if n&1 == 1 {res = bigNumMultiplication(res, baseNums)}baseNums = bigNumMultiplication(baseNums, baseNums)n >>= 1}return res
}// 大数相乘
func bigNumMultiplication(nums1, nums2 string) string {bytes1, bytes2 := []byte(nums1), []byte(nums2)len1, len2 := len(bytes1), len(bytes2)var erveryLevels []stringfor i := len1 - 1; i >= 0; i-- {n1 := int(bytes1[i] - '0')flag := falseflagNum := 0var tempRes []bytefor k := 0; k < len1-1-i; k++ {tempRes = append(tempRes, '0')}for j := len2 - 1; j >= 0; j-- {n2 := int(bytes2[j] - '0')temp := n1 * n2if flag {temp += flagNumflag = falseflagNum = 0}if temp >= 10 {flag = trueflagNum = temp / 10}tempRes = append([]byte{byte(temp%10 + '0')}, tempRes...)}if flag {tempRes = append([]byte{byte(flagNum%10 + '0')}, tempRes...)}erveryLevels = append(erveryLevels, string(tempRes))}res := "0"for _, value := range erveryLevels {res = bigNumsAdd(res, value)}return res
}// 大数相加
func bigNumsAdd(nums1, nums2 string) string {if len(nums1) == 0 || nums1 == "" || nums1 == "0" {return nums2}if len(nums2) == 0 || nums2 == "" || nums2 == "0" {return nums1}nums1Bytes, nums2Bytes := []byte(nums1), []byte(nums2)index1, index2 := len(nums1Bytes)-1, len(nums2Bytes)-1flag := falsevar res []bytefor index1 >= 0 || index2 >= 0 {if index1 < 0 {n2 := int(nums2Bytes[index2] - '0')if flag {n2++flag = false}if n2 >= 10 {flag = true}res = append([]byte{byte(n2%10 + '0')}, res...)index2--continue}if index2 < 0 {n1 := int(nums2Bytes[index1] - '0')if flag {n1++flag = false}if n1 >= 10 {flag = true}res = append([]byte{byte(n1%10 + '0')}, res...)index1--continue}n1 := int(nums1Bytes[index1] - '0')n2 := int(nums2Bytes[index2] - '0')temp := n1 + n2if flag {temp++flag = false}if temp >= 10 {flag = true}res = append([]byte{byte(temp%10 + '0')}, res...)index1--index2--}if flag {res = append([]byte{'1'}, res...)}return string(res)
}

代码写完，跑跑单测，都跑过了，太nice了：

优化

细细想来，其实这个算法还是有可以优化的地方的，主要体现在大数相乘上面，如果我要计算的N次方还没有到计算机数字表示不了的时候，我们是不是可以用数字来直接参与计算和表示呢？其实是可以的。我们知道计算机可以表示的最大的数应该是无符号int64整数，在go种是uint64，也就是1 << 64 - 1.那么我们怎么计算小于1 << 64 - 1的11的最大次幂呢？这个思路还是比较简单的，因为数字表示不下的时候，会溢出，无论计算机的溢出策略是怎样的。这个时候必定存在一个N，使得在计算机中11的N + 1次方 / 11的N次方 != 11.所以下面代码就可以计算出这个11的最大次幂：

func calculateMaxPowerOf11() int {res, tempRes := uint64(1), uint64(11)num := 0for tempRes/res == 11 {res = tempRestempRes *= 11num++}return num
}

这里计算出来的是18.所以在N小于等于18之前用数字计算，得到结果之后转成字符串就好。下面代码是数字快速幂计算方式：

// 计算可用数字表示的最大的11的N次方
func calculatePowerOf11InNum(n int) uint64 {if n == 0 {return 1}if n == 1 {return 11}var res uint64 = 1baseNum := uint64(11)for n != 0 {if n&1 == 1 {res *= baseNum}n >>= 1baseNum *= baseNum}return res
}

可以通过下面代码验证18这个数的正确性：

func TestCalculateMaxPowerOf11(t *testing.T) {fmt.Println(calculatePowerOf11InNum(18))fmt.Println(calculatePowerOf11InNum(19))fmt.Println(calculatePowerOf11InNum(19) / calculatePowerOf11InNum(18))fmt.Println(calculatePowerOf11InNum(17))fmt.Println(calculatePowerOf11InNum(18))fmt.Println(calculatePowerOf11InNum(18) / calculatePowerOf11InNum(17))
}

结果是这样的：

可以看到19次方除18次方结果不是11，而18次方除17次方是11。是因为在19次方这里就发生了溢出。

基于这一点，我们可以把PowerOfEleven函数优化成下面这样子：

func PowerOfEleven(n int) string {if n == 0 {return "1"}if n == 1 {return "11"}if n <= calculateMaxPowerOf11() {res := calculatePowerOf11InNum(n)return strconv.FormatUint(res, 10)}var baseNums = "11"var res = "1"for n > 0 {if n&1 == 1 {res = bigNumMultiplication(res, baseNums)}baseNums = bigNumMultiplication(baseNums, baseNums)n >>= 1}return res
}

再跑一次单测：

完美通过，nice！！今天的分享到这里结束啦，感谢大家！

拓展阅读

杨辉三角：https://baijiahao.baidu.com/s?id=1607063654204393620&wfr=spider&for=pc
快速幂：https://zhuanlan.zhihu.com/p/95902286
大数相乘：https://blog.csdn.net/u010983881/article/details/77503519

个人推广

以下是笔者公众号，欢迎多多关注，一起成长。