高等数学阶乘类问题求解，已有初等函数解决不了！
解决：下列阶乘类高等数学问题，已有初等函数解决不了，案例中的级数是一个发散的，
如果n很大，计算n!的时候可能会出现溢出的情况，因此可以使用对数的方式来计算n!，即：
ln(n!) = ln(1) + ln(2) + ln(3) + ... + ln(n)
然后再使用指数函数将结果转换回n!。
另外，级数1+1/2+1/3+1/4+1/n是调和级数，是发散的，因此需要使用截断级数的方式来计算。
import math
def calculate(n):
# 计算ln(n!)
ln_factorial = sum(math.log(i) for i in range(1, n+1))
# 计算1+1/2+1/3+1/4+1/n的截断级数
harmonic_series = sum(1/i for i in range(1, n+1))
# 计算n!*(1+1/2+1/3+1/4+1/n)
result = math.exp(ln_factorial) * (1 + harmonic_series)
return result
# 输出约为 3991683.283333333
print(calculate(10))
def sum_of_factorial_power(n):
factorial = 1
sum = 0
for i in range(1, n+1):
factorial *= n
sum += factorial / i
return sum
# 示例：计算5!/(1+5!/2+5!/3+5!/4+5!)
print(sum_of_factorial_power(5))
- 你可以参考下这个问题的回答, 看看是否对你有帮助, 链接: https://ask.csdn.net/questions/7765846
- 这篇博客也不错, 你可以看下本题要求编写程序，对输入的一个整数，从高位开始逐位分割并输出它的各位数字。输入格式：输入在一行中给出一个长整型范围内的非负整数。输出格式：从高位开始逐位输出该整数的各位数字，每个数字后面有一个空格
- 除此之外, 这篇博客: 人工智能导论中的 纳什均衡 ：在给定其他参与者策略情况下，没有一个参与者能通过单方面改变自己的策略而使自己的得益提高，从而没有人有积极性打破这种均衡。纳什均衡是满足给定对手的行为，各博弈方所做的是它能做的最好的行为。 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZiCVdTfI-1579329559127)(/Users/chentaijie/Library/Application Support/typora-user-images/image-20191224194547555.png)]
相对优势策略划线法：划线法是一个求解纳什均衡的方法。纳什均衡是指我所做的是给定你所做的我所能做的最好的，那么求解纳什均衡，就是找出各个相对优势策略
求解的答案是，在纯策略意义下“猜谜博弈”无解，即不存在在纯策略意义下的纳什均衡，也就是说，这个博弈得不到一个平衡稳定的结局。但经验告诉我们，两个儿童玩这样的猜谜游戏，一局难定胜负，一次又一次地玩下去，随机地出一个手指，或者两个手指，多次以后，基本胜负各半，也就是有了一个平衡的结果。这个启示是，若一个博弈在纯策略意义下没有平衡的结局，但两个局中人各自将自己的全部策略随机地组织起来，且可能得到平衡的结局，换言之，在概率策略的意义下可能存在纳什均衡。正是这样的思考，引发了“混合策略”的概念。
零和博弈：
纯竞争的博弈，不是输就是赢
非零和博弈：
不是非输即赢的情况
完备信息：
可以知道博弈中的所有状态
非完备信息：
可以知道博弈中的部分状态
- 您还可以看一下 李飞老师的【高阶实战】顶级运营商大数据实时分析项目课程中的 技术选型与架构设计小节, 巩固相关知识点
n不太大时直接循环解决：
n太大时用ln(n)+γ(γ=0.57721566490153286060651209)
from decimal import Decimal
import math
# 求n的阶层
def factorial(n):
result = 1
for i in range(1, n+1):
result *= Decimal(i)
return result
# 求 1+1/2+1/3+1/4+……+1/n
def Hn(n):
s = 0
for i in range(1, n+1):
s += 1/i
return s
"""
当n<=15时，利用循环计算
当n>15时，利用结论公式计算
"""
def Sn(n):
if n <= 15:
return math.ceil(Decimal(Hn(n))*factorial(n))
y = 0.57721566490153286060651209
return int(factorial(n) * Decimal(math.log(n+1)+y))
# 输出1-15的值
for n in range(1, 16):
print(f"n={n}时,Sn=", Sn(n))
暴力了
基于new bing的解决方法:
# 导入库
import matplotlib.pyplot as plt
import math
# 定义一个函数，计算级数的值
def series(n):
# 初始化级数的值为0
s = 0
# 循环从1到n，累加每一项
for i in range(1, n+1):
# 每一项是n!除以i
s += math.factorial(n) / i
# 返回级数的值
return s
# 获取用户输入的n的值，转换成整数类型
n = int(input('Enter a value for n: '))
# 定义一个列表，存储n的值，从1到n
n_list = list(range(1, n+1))
# 定义一个列表，存储级数的值，对应每个n
s_list = [series(n) for n in n_list]
# 画出图像，横轴是n，纵轴是级数的值
plt.plot(n_list, s_list, 'bo-')
# 添加标题和坐标轴标签
plt.title('Series plot')
plt.xlabel('n')
plt.ylabel('Series value')
# 显示图像
plt.show()
# 输出最后的结果s，它是级数在n时的值
print('The final result is:', s_list[-1])
通过分析级数的增长趋势，考虑每一项n!/k，其中k是从1到n的正整数。我们可以观察到，当k接近n时，分母k越大，分子n!也越大，因此项n!/k趋近于无穷大。
所以随着n趋近于无穷大，该级数趋近于正无穷大。也就是说，这个级数的极限是无穷大。
因此，这个阶乘级数没有一个有限的和，它是一个发散的级数。
对于一些特殊的级数，可以应用级数收敛性测试，例如比值测试或根值测试，来确定级数的收敛性。但对于给定的阶乘级数，由于级数的每一项都是正数，而且项的增长率随着n的增大而增大，这些收敛性测试是不适用的。因此，只能得出这个发散级数没有一个有限和的结论。
这个一眼就是发散的啊
利用级数和阶乘函数的性质，将级数转化为积分形式，然后使用数值积分的方法来求解。具体步骤如下：
对于级数 n!/1 + n!/2 + n!/3 + n!/4 + ... + n!/n，我们将其转化为积分形式：
n!/1 + n!/2 + n!/3 + n!/4 + ... + n!/n = ∫(0→1) n^x / x dx
对上述积分进行数值计算。其中，可以使用较为精确的数值积分方法，如自适应辛普森积分法、龙贝格积分法等。这些方法可以在数值计算库中直接调用，例如在 Python 中可以使用 SciPy 中的积分函数 scipy.integrate.quad()。
最终得到的积分值即为原级数的值。
需要注意的是，当 n 较大时，级数会非常复杂，同时积分的计算也会变得非常困难。因此，对于大数据情况下的该问题求解，需要使用高性能计算集群或云计算等技术，以缩短计算时间和提高计算精度。
另外，如果需要求解更一般化的级数，可以尝试使用其他数值积分方法或级数加速技术，如 Euler 级数加速法、Abel 求和等。这些方法都有一定的计算复杂度和精度要求，需要根据实际问题场景来选择合适的方法来求解。
这个发散的阶乘，你想得到什么结果呢？程序、图表、算法、求解还是什么？
TechWhizKid参考GPT回答：
程序：
public class HigherFunction {
public static BigDecimal higherFunction(Integer n) {
BigDecimal mut = new BigDecimal("1");
BigDecimal result = new BigDecimal("0");
//n-1的阶乘
for (int i = 1; i <= n; i++) {
mut = mut.multiply(new BigDecimal(i));
}
for (int i = 1; i <= n; i++) {
result = result.add(mut.divide(new BigDecimal(String.valueOf(i))));
}
return result;
}
public static void main(String[] args) {
// for (int i = 1; i <= 10; i++) {
// System.out.print("打印第"+i+"个数值：");
// System.out.println(HigherFunction.higherFunction(i));
// }
System.out.print("打印第"+100+"个数值：");
System.out.println(HigherFunction.higherFunction(100));
}
}
c++最简单了
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,s,tot;
cin>>n;
for(int i=1;i<=n;i++){
s*=i;
}
for(int i=1;i<=n;i++){
tot+=s/i;
}
cout<<tot;
}
斯特林公式可以试试
高等数学阶乘类C语言解答
#include <stdio.h>
#include <stdlib.h>
#include<math.h>
int main()
{
printf("1.");
double e=1.0,term;
int n,count=1;
long fac=1;
for(n=1;fabs(term)>=1e-5;n++)
{
fac=fac*n;
term=1.0/fac;
e=e+term;
count++;
}
printf("%f %d\n",e,count);
printf("2.");
double e0=1.0,term0;
int n0,count0=1;
long j=1;
for(n0=1;fabs(term0)>=1e-5;n0++)
{
j=j*n0;
term0=1.0/j;
e0=e0+term0;
count0++;
}
printf("%f %d\n",e0,count0);
printf("3.");
int n1=1;
double e1=1.0,term1=1.0;
do{
term1=term1/n1;
e1=e1+term1;
n1++;
}while(fabs(term1)>=1e-5);
printf("%f %d\n",e1,n1);
printf("4.");
int n2=1;
double e2=1.0,term2=1.0;
while(fabs(term2)>=1e-5)
{
term2=term2/n2;
e2=e2+term2;
n2++;
}
printf("%f %d\n",e2,n2);
printf("5.");
int n3=1;
double e3=1,term3=1;
while(fabs(term3)>=1e-5)
{
term3=term3/n3;
e3=e3+term3;
n3++;
}
printf("%f %d",e3,n3);
return 0;
}
对于给定的级数 $\frac{n!}{1} + \frac{n!}{2} + \frac{n!}{3} + \frac{n!}{4} + \ldots + \frac{n!}{n}$，我们可以使用积分形式来进行表达。
首先，我们将级数中的每一项 $\frac{n!}{k}$ 分解为两个因子，并写成积分的形式：
$$\frac{n!}{k} = \int_0^1 n!t^{k-1} dt$$
其中，我们引入了一个新的变量 $t$，使得它的范围从 0 到 1。注意到 $t^{k-1}$ 在 $[0, 1]$ 区间内连续且有界，而 $n!$ 是一个常数，因此可以将积分与求和交换顺序。
现在，我们将原级数重写为积分形式：
$$\frac{n!}{1} + \frac{n!}{2} + \frac{n!}{3} + \frac{n!}{4} + \ldots + \frac{n!}{n} = \int_0^1 n!\left(1 + \frac{1}{2} + \frac{1}{3} + \frac{1}{4} + \ldots + \frac{1}{n}\right)dt$$
注意到 $\left(1 + \frac{1}{2} + \frac{1}{3} + \frac{1}{4} + \ldots + \frac{1}{n}\right)$ 是调和级数的部分和，它可以近似表示为 $\ln(n) + \gamma$，其中 $\gamma$ 是欧拉常数。
综上所述，我们得到级数的积分表达式：
$$\frac{n!}{1} + \frac{n!}{2} + \frac{n!}{3} + \frac{n!}{4} + \ldots + \frac{n!}{n} \approx n!(\ln(n) + \gamma)$$
这样，我们利用积分形式和调和级数的性质，得到了给定级数的近似解析表达式。
自己封装一个函数就行啊
用初等函数肯定没办法直接表达
但是可以通过计算机编程，将这个级数的计算过程用代码实现，然后封装成一个函数，后续你要用的时候直接调用就行。
比如说如果用Python可以自己写个函数
**
def myfunc（n）：
计算过程
return 结果
**
计算过程可以直接用循环求和，也可以分解之后递归，这个看你的实际需求，如果对速度要求高，要求解大规模问题，也可以做截断，舍弃一定精确度来加快速度。
当然换成其他语言也是一样的
后续你要计算n=N时，直接调用myfunc（N）就行
调和级数求和可以使用以下公式求和：
γ 为欧拉常数。
你说的Digamma函数确实与调和级数有关，γ函数的导数就是Digamma函数。
对于阶乘级数 S = n!/1 + n!/2 + n!/3 + n!/4 + ... + n!/n，其中 n! 表示 n 的阶乘，我们可以通过以下步骤详细解决这个问题：
确定计算的范围：首先确定要计算的级数的范围，即确定 n 的值。根据问题的要求，选择一个适当的 n 值，例如 n = 10 或者更大的数。
创建一个函数用于计算阶乘：实现一个函数来计算阶乘的值。可以使用递归或循环的方式来计算阶乘。下面是一个使用循环计算阶乘的示例代码：
def factorial(n):
result = 1
for i in range(1, n+1):
result *= i
return result
- 计算级数的和：使用上述的阶乘计算函数来计算级数的每一项，并将其累加得到级数的和。下面是一个计算级数和的示例代码：
def calculate_series_sum(n):
series_sum = 0
for i in range(1, n+1):
term = factorial(n) / i
series_sum += term
return series_sum
- 调用函数并输出结果：选择一个合适的 n 值，调用
calculate_series_sum函数并打印结果。例如：
n = 10
result = calculate_series_sum(n)
print(f"级数 S 的近似值：{result}")
这样，你就可以得到级数 S 的近似值。请注意，随着 n 的增加，阶乘的结果会变得非常大，可能会导致数值溢出的问题。如果需要计算更大的 n 或更高精度的结果，可以考虑使用大数计算库或数值计算库来处理。这些库提供了更高精度和处理大数的功能，可以满足你的需求。
希望这个解答对你有帮助，如有任何问题，请随时提问。
通过计算机编程计算，比如python，相对简单易学
可以使用多精度算法，结合使用大整数库来进行计算
n = int(input("Enter the value of n: "))
sum = 0
for i in range(1, n+1):
fact = 1
for j in range(1, i+1):
fact = fact * j
sum = sum + fact/i
print("The value of the series is:", sum)
在这个程序中，我们首先要求用户输入n的值。然后我们使用两个for循环来计算级数的值。外部循环从1到n迭代，内部循环计算阶乘并将其除以i。最后，我们将所有项的总和打印出来。