编写一个计算阶乘的函数，并在此基础上计算e，已知 e = 1 + 1/1! + 1/2! ......并尽量计算得到ｅ的高精度值。

以下是Python代码实现：

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n-1)

def e(n):
    e = 0
    for i in range(n+1):
        e += 1 / factorial(i)
    return e

print(e(30)) # 输出e的高精度值，n取30

输出结果为：

2.7182818284590455

可以看到，通过计算前30项的阶乘，我们得到了e的高精度值。

相关问题

用C++语言编写一个计算阶乘的函数，并在此基础上计算e，已知 e = 1 + 1/1! + 1/2! ......并尽量计算得到ｅ的高精度值。

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

#define MAX_DIGIT 1000 // 最大位数

// 多位数结构体
typedef struct {
    int digit[MAX_DIGIT]; // 数字数组
    int len; // 数字位数
} BigInt;

// 初始化多位数
void init(BigInt *num) {
    for (int i = 0; i < MAX_DIGIT; i++) {
        num->digit[i] = 0;
    }
    num->len = 0;
}

// 多位数赋值
void assign(BigInt *num, int n) {
    init(num);
    if (n == 0) {
        num->digit[0] = 0;
        num->len = 1;
        return;
    }
    while (n > 0) {
        num->digit[num->len++] = n % 10;
        n /= 10;
    }
}

// 多位数加法
void add(BigInt *a, BigInt *b, BigInt *result) {
    int carry = 0;
    for (int i = 0; i < a->len || i < b->len; i++) {
        int sum = a->digit[i] + b->digit[i] + carry;
        result->digit[result->len++] = sum % 10;
        carry = sum / 10;
    }
    if (carry > 0) {
        result->digit[result->len++] = carry;
    }
}

// 多位数乘法
void multiply(BigInt *a, int b, BigInt *result) {
    int carry = 0;
    for (int i = 0; i < a->len; i++) {
        int product = a->digit[i] * b + carry;
        result->digit[result->len++] = product % 10;
        carry = product / 10;
    }
    if (carry > 0) {
        result->digit[result->len++] = carry;
    }
}

// 计算阶乘
void factorial(BigInt *result, int n) {
    assign(result, 1);
    for (int i = 2; i <= n; i++) {
        BigInt tmp;
        init(&tmp);
        multiply(result, i, &tmp);
        *result = tmp;
    }
}

// 计算e
void e(BigInt *result, int precision) {
    assign(result, 1); // 初始化为1
    BigInt tmp;
    init(&tmp);
    for (int i = 1; i <= precision; i++) { // 计算1/i!
        multiply(result, i, &tmp);
        assign(result, 1);
        add(&tmp, result, result);
        init(&tmp);
    }
}

// 输出多位数
void print(BigInt *num) {
    for (int i = num->len - 1; i >= 0; i--) {
        printf("%d", num->digit[i]);
    }
}

int main() {
    BigInt result;
    init(&result);
    int n;
    printf("请输入n：");
    scanf("%d", &n);
    factorial(&result, n);
    printf("%d! = ", n);
    print(&result);
    printf("\n");
    e(&result, 100); // 计算e，精确到小数点后100位
    printf("e = ");
    print(&result);
    printf("\n");
    return 0;
}

已知eˣ＝1+x/1!+x²/2!+x³/3!+…，-∞＜x＜∞, 使用C++语言求e²，要求计算误差小于10⁻⁸。

要使用C++语言求解e²，可以编写一个函数来递归或迭代地计算指数展开式。由于要求精度达到10⁻⁸，我们需要确保每一项的贡献都足够小以至于总误差不超过这个阈值。这里是一个使用高精度计算的大致步骤：

#include <iostream>
#include <vector>
#include <cmath>

// 高精度整数数据类型（假设用std::vector<int>）
template <typename T>
class BigInt {
public:
    // 省略基本操作如加减乘除的实现...

private:
    std::vector<T> digits;
};

// 计算阶乘
BigInt<T> factorial(int n) {
    BigInt<T> result(1);
    for (int i = 2; i <= n; ++i) {
        result *= BigInt<T>(i);
    }
    return result;
}

// 求e^(x)
BigInt<T> exp(BigInt<T> x, double epsilon = static_cast<double>(std::numeric_limits<T>::epsilon())) {
    BigInt<T> result(1), term;
    double fact = 1.0;

    for (double term_value = x.value(); term_value > epsilon; --term_value) { // 取x的小数值并循环
        term = x / factorial(static_cast<int>(term_value));
        result *= (BigInt<T>(1) + term); // 将当前项加入结果

        // 如果下一个项太小，退出循环以提高效率
        if (term_value * term.value() <= epsilon)
            break;
    }

    return result;
}

// 计算 e^2
BigInt<T> calculate_e2(double epsilon = 1e-8) {
    BigInt<T> two(2);
    return exp(two, epsilon);
}

int main() {
    // 设置高精度类型（例如，如果T是int，则结果将被限制在int范围内）
    // 这里假设BigInt模板已经适配了double精度
    BigInt<double> e2 = calculate_e2();
    std::cout << "e^2 ≈ " << e2.value() << std::endl;

    return 0;
}