如何计算大 n 的 2^n？

Question

我正在尝试编写一个程序，它将一个数字 n 作为输入，并输出 2 的结果为 n 的幂。问题是，n 可能非常大（最多 100,000）。本质上，我正在尝试为非常大的数字计算 pow(2, n);。

我认为这样做的方法是将数字存储在一个数组中，因为没有内置的数字类型可以保存这么大的值。

数字采用十进制格式（以 10 为底）。

我使用的是 C，而不是 C++，所以我不能使用 STL 向量和其他 C++ 容器。我也不能使用外部库，比如GMP。我需要用纯 C 手动实现算法。

Answer 1

问题不在于计算 2 的高次幂，而是将此数字转换为十进制表示：

• 让我们用无符号 32 位整数数组来表示大数。
• 计算 2ⁿ 就像设置一个位一样简单。
• 可以通过将此数字反复除以 1000000000 来转换为二进制，一次生成 9 位数字。

这是一个简单但快速的实现：

#include <stdint.h>
#include <stdio.h>

void print_2_pow_n(int n) {
    int i, j, blen = n / 32 + 1, dlen = n / 29 + 1;
    uint32_t bin[blen], dec[dlen];
    uint64_t num;

    for (i = 0; i < blen; i++)
        bin[i] = 0;
    bin[n / 32] = (uint32_t)1 << (n % 32);

    for (j = 0; blen > 0; ) {
        for (num = 0, i = blen; i-- > 0;) {
            num = (num << 32) | bin[i];
            bin[i] = num / 1000000000;
            num = num % 1000000000;
        }
        dec[j++] = (uint32_t)num;
        while (blen > 0 && bin[blen - 1] == 0)
            blen--;
    }
    printf("2^%d = %u", n, dec[--j]);
    while (j-- > 0)
        printf("%09u", dec[j]);
    printf("\n");
}

int main() {
    int i;
    for (i = 0; i <= 100; i += 5)
        print_2_pow_n(i);
    print_2_pow_n(1000);
    print_2_pow_n(10000);
    print_2_pow_n(100000);
    return 0;
}

输出：

2^0 = 1
2^5 = 32
2^10 = 1024
2^15 = 32768
2^20 = 1048576
2^25 = 33554432
2^30 = 1073741824
2^35 = 34359738368
2^40 = 1099511627776
2^45 = 35184372088832
2^50 = 1125899906842624
2^55 = 36028797018963968
2^60 = 1152921504606846976
2^65 = 36893488147419103232
2^70 = 1180591620717411303424
2^75 = 37778931862957161709568
2^80 = 1208925819614629174706176
2^85 = 38685626227668133590597632
2^90 = 1237940039285380274899124224
2^95 = 39614081257132168796771975168
2^100 = 1267650600228229401496703205376
2^1000 = 10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376
2^10000 = 1995063116880758384883742<...>91511681774304792596709376
2^100000 = 9990020930143845079440327<...>97025155304734389883109376

2¹⁰⁰⁰⁰⁰ 有 30103 个数字，正好是 floor(100000 * log10(2))。它在我的旧笔记本电脑上执行只需 33 毫秒。

Answer 2

只需制作一个位数组并设置第 n 位。然后除以 10，就好像位数组是 little-endian 编号并反向打印余数，以获得以 10 为底的 2 的 n 次方表示。

下面的这个快速程序可以做到这一点，它给我的结果与bc 相同，所以我想它可以工作。 打印例程可以使用一些调整。

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

uint_least32_t div32(size_t N, uint_least32_t Z[/*N*/], uint_least32_t X[/*N*/], uint_least32_t Y)
{
    uint_least64_t carry; size_t i;
    for(carry=0, i = N-1; i!=-1; i--)
        carry = (carry << 32) + X[i], Z[i] = carry/Y, carry %= Y;
    return carry;
}

void pr10(uint_least32_t *X, size_t N)
{
    /*very quick and dirty; based on recursion*/
    uint_least32_t rem=0;
    if(!X[N?N-1:0]) return;
    rem = div32(N,X,X,10);
    while(N && !X[N-1]) N--;
    pr10(X,N);
    putchar(rem+'0');
}
int main(int C, char **V)
{
    uint_least32_t exp = atoi(V[1]);
    size_t nrcells = exp/32+1;
    uint_least32_t *pow  = calloc(sizeof(uint_least32_t),nrcells);
    if(!pow) return perror(0),1;
    else pow[exp/32] = UINT32_C(1)<<(exp%32);
    pr10(pow,nrcells);

}

示例运行：

$ ./a.out 100
1267650600228229401496703205376

Answer 3

第 1 步：决定如何表示 bignums

已经存在为此的库。 GNU Multiple Precision Integer library 是一个常用的选项。 （但根据您的编辑，这不是一个选项。您可能仍会瞥一眼其中的一些以了解他们如何做事，但这不是必需的。）

如果你想自己滚动，我确实不建议存储十进制数字。如果这样做，则每次要对组件进行算术运算时，都需要在二进制表示形式之间进行转换。最好有一个类似uint32_ts 的链接列表，以及一个符号位。当你想读写时，你可以从/到十进制转换，但是用二进制做你的数学。

第 2 步：实现求幂

我将在这里假设链表 bignum 实现；您可以根据需要调整算法。

如果您只是计算 2 的幂，那很容易。它是一个 1 后跟 N 个 0，因此如果每个块存储 M 位并且您想表示 2^N，那么只需将 floor(N/M) 块全为 0，并将 1 << (N % M) 存储在最重要的块中。

如果您希望能够以有效的方式对 任意 基进行求幂，则应使用 exponentiation by squaring。这背后的想法是，如果你想计算 3^20，你不要乘以 3 * 3 * 3 * ... * 3。相反，你计算 3^2 = 3 * 3。然后3^4 = 3^2 * 3^2. 3^8 = 3^4 * 3^4. 3^16 = 3^8 * 3^8。您可以随时存储这些中间结果。然后，一旦达到再次平方会产生比您想要的更大的数字的程度，您就停止平方并从您拥有的部分组装最终结果。在这种情况下，3^20 = 3^16 * 3^4。

这种方法以 5 步而不是 20 步计算最终结果，并且由于时间是指数的对数，因此指数越大，速度增益越明显。即使计算 3^100000 也只需要 21 次乘法。

据我所知，没有一种聪明的乘法方法；您可能可以按照您在小学学习的基本长乘法算法做一些事情，但是在块级别：我们之前使用uint32_ts 而不是 uint64_t`s 的原因是我们可以将操作数转换为较大的类型并将它们相乘而不会有丢失进位溢出的风险。

从二进制转换为十进制以进行打印

首先，找出比你的数小 10 的最大倍数。
我将高效留给读者作为练习，但是您可以通过求幂来管理它，通过平方来找到一个上限，然后减去各种存储的中间值以更快地得到实际值比你反复除以 10 的方式。

或者你可以通过反复乘以10来找到数字；无论第一部分如何处理，其余部分都将是线性的。

但是不管你怎么理解，你有一个q 这样q = k * 10, 10 * q > n, q <= n，你一次只能循环一个十进制数字：

for (; q; q /= 10) {
   int digit = n / q; //truncated down to floor(n/q)
   printf("%d", digit);
   n -= digit * q;
}

在某处的文献中可能有一种更有效的方法，但我不熟悉一种副手。但这不是什么大不了的事情，只要我们在写输出时只需要做低效的部分即可；无论算法如何，这都很慢。我的意思是，打印所有 100,000 个数字可能需要一两毫秒。当我们显示供人类消费的数字时，这无关紧要，但如果我们不得不在某个地方的循环中等待一毫秒作为计算的一部分，它会加起来并变得非常低效。这就是我们从以十进制表示形式存储数字的原因：通过在内部将其表示为二进制，我们在输入和输出时执行一次低效的部分，但介于两者之间的一切都很快。

Answer 4

由于原始问题陈述没有指定输出基数，这里是一个笑话实现：

#include <stdio.h>

void print_2_pow_n(int n) {
    printf("2^%d = 0x%d%.*d\n", n, 1 << (n % 4), n / 4, 0);
}

int main() {
    int i;
    for (i = 0; i < 16; i++)
        print_2_pow_n(i);
    print_2_pow_n(100);
    print_2_pow_n(100000);
    return 0;
}

输出：

2^0 = 0x1
2^1 = 0x2
2^2 = 0x4
2^3 = 0x8
2^4 = 0x10
2^5 = 0x20
2^6 = 0x40
2^7 = 0x80
2^8 = 0x100
2^9 = 0x200
2^10 = 0x400
2^11 = 0x800
2^12 = 0x1000
2^13 = 0x2000
2^14 = 0x4000
2^15 = 0x8000
2^100 = 0x10000000000000000000000000
2^100000 = 0x10...<0 repeated 24998 times>...0

Answer 5

这是一个相当幼稚和低效的解决方案。根据要求，这些数字以十进制数字数组表示。我们通过将数字 2 与自身重复相加来计算指数 2ⁿ： 从e := 2 开始并重复e := e + e n 次。

要为 digits 数组的长度设定上限，我们使用以下方法：

• 以 b 为底的数字 x 的表示形式有 ⌈log_b(x)⌉ 位。
• 比较任何数字 x 的二进制和十进制表示之间的位数，我们发现如果我们忽略四舍五入 (⌈⌉)，它们只会相差一个常数因子。
  log₂(x) / log₁₀(x) = 1 / log₁₀(2) = 3.3219... > 3
• 2ⁿ 有 log₂(2ⁿ) = n 个二进制数字。
• 因此 2ⁿ 大约有 n / 3 个十进制数字。由于四舍五入的问题，我们为此添加了 +1。

void print(int digits[], int length) {
    for (int i = length - 1; i >= 0; --i)
        printf("%d", digits[i]);
    printf("\n");
}
void times2(int digits[], int length) {
    int carry = 0;
    for (int i = 0; i < length; ++i) {
        int d = 2 * digits[i] + carry;
        digits[i] = d % 10;
        carry = d / 10;
    }
}
int lengthOfPow2(int exponent) {
    return exponent / 3 + 1;
}
// works only for epxonents > 0
void pow2(int digits[], int length, int exponent) {
    memset(digits, 0, sizeof(int) * length);
    digits[0] = 2;
    for (int i = 1; i < exponent; ++i)
        times2(digits, length);
}
int main() {
    int n = 100000;
    int length = lengthOfPow2(n);
    int digits[length];
    pow2(digits, length, n);
    print(digits, length);
    return 0;
}

在类 unix 系统上，您可以使用以下方法检查固定 n 的正确性

diff \
  <(compiledProgram | sed 's/^0*//' | tr -d '\n') \
  <(bc <<< '2^100000' | tr -d '\n\\')

正如已经指出的那样，这种解决方案效率不高。使用clang -O2 编译，计算 2^100'000 在 Intel i5-4570 (3.2GHz) 上耗时 8 秒。

加快速度的下一步是重复将您的数字乘以 2，而不是重复乘以 2。即使是简单的立方体步骤实现，这也应该比此答案中提供的实现更快。

如果您需要更高效，可以使用 Karatsuba 算法甚至快速傅立叶变换 (FFT) 等方法来实现立方体步骤。使用立方方法和 FFT，您可以在 O(n·log(n)) 左右计算 2ⁿ（由于 FFT 中的舍入问题，可能会有额外的 log(log(n)) 因子） .

Answer 6

我无法找到对数复杂度的解决方案（乘方求幂），但我确实设法编写了一个时间复杂度为 O(noOfDigits*pow), noOfDigits in 2^ 的简单实现n 将是 n*log10(2)+1;

我只检查了https://www.mathsisfun.com/calculator-precision.html的前几位数字的答案，它似乎是正确的。

#include <stdio.h>
#include <math.h>
//MAX is no of digits in 2^1000000
#define MAX 30103
int a[MAX];
int n;
void ipow(int base, int exp,int maxdigits)
{
    a[0]=1;
    for (;exp>0;exp--){
            int b=0;
            for(int i=0;i<maxdigits;i++){
                a[i]*=base;
                a[i]+=b;
                b=a[i]/10;
                a[i]%=10;
            }
    }
}
int main()
{
    int base=2;
    int pow=100000;
    n=log10(2)*pow+1;
    printf("Digits=%d\n",n);
    ipow(base,pow,n);
    for(int i=n-1;i>=0;i--){
        printf("%d",a[i]);
    }
    return 0;
}

我还编写了通过平方但未优化的乘法函数求幂的代码。这似乎比上述实现更快。

#define MAX 30103
int a[MAX];
int b[MAX];
int z[MAX];
//stores product in x[]; mul of large arrays implemented in n^2 complexity
//n and m are no of digits in x[] and y[]
//returns no of digits in product
int mul(int x[],int y[],int n,int m){
    for(int i=0;i<n+m;i++)
        z[i]=0;
    for(int j=0;j<m;j++){
        int c=0;
        for(int i=0;i<n+m;i++){
            z[i+j]+=x[i]*y[j];
            z[i+j]+=c;
            c=z[i+j]/10;
            z[i+j]%=10;
        }
    }
    for(int i=0;i<n+m;i++){
            x[i]=z[i];
    }
    if(x[n+m-1]==0)
        return n+m-1;
    return n+m;
}
//stores answer in x[]
int ipow(int base, int exp)
{
    int n=1,m=0;
    for(int i=0;base>0;i++){
        b[i]=base%10;
        base/=10;
        m++;
    }
    a[0]=1;
    for (;;)
    {
        if (exp & 1)
            n=mul(a,b,n,m);
        exp >>= 1;
        if (!exp)
            break;
        m=mul(b,b,m,m);
    }
}
int main()
{
    int base=2;
    int pow=100000;
    n=log10(2)*pow+1;
    printf("Digits=%d\n",n);
    ipow(base,pow);
    printf("\n");
    for(int i=n-1;i>=0;i--){
        printf("%d",a[i]);
    }
    return 0;
}