階乗の計算

1. from functools import reduce
2. def factorial(num):
3. return reduce(lambda x,y:x * y,range(1,num+1))
5. factorial(5)

1. from functools import reduce
2. from operator import mul
3. def factorial(num):
4. return reduce(mul, range(1,num+1))
6. factorial(5)

1. factorial = lambda num:1 if num <= 1 else num*f(num -1)
3. factorial(5)

120

1. print(factorial(10),factorial(7)*factorial(6))
2. print(factorial(6),factorial(5)*factorial(3))
3. print(factorial(24),factorial(23)*factorial(4))
4. print(factorial(120),factorial(119)*factorial(5),sep='\n')

3628800 3628800
720 720
620448401733239439360000 620448401733239439360000
6689502913449127057588118054090372586752746333138029810295671352301633557244962989366874165271984981308157637893214090552534408589408121859898481114389650005964960521256960000000000000000000000000000
6689502913449127057588118054090372586752746333138029810295671352301633557244962989366874165271984981308157637893214090552534408589408121859898481114389650005964960521256960000000000000000000000000000

ある数の階乗が連続する2つの数の階乗の積で計算できるのは10!=6!×7!10!=6!×7!しかわかっていません。

連続しなくてもよければ、次のものがわかっています。

1. import sympy
2. n3=factorial(3)-factorial(2)+factorial(1)
3. print(n1,sympy.isprime(n3))
4. n4=factorial(4)-factorial(3)+factorial(2)-factorial(1)
5. print(n4,sympy.isprime(n4))
6. n5=factorial(5)-factorial(4)+factorial(3)-factorial(2)+factorial(1)
7. print(n5,sympy.isprime(n5))
8. n6=factorial(6)-factorial(5)+factorial(4)-factorial(3)+factorial(2)-factorial(1)
9. print(n6,sympy.isprime(n6))
10. n7=factorial(7)-factorial(6)+factorial(5)-factorial(4)+factorial(3)-factorial(2)+factorial(1)
11. print(n7,sympy.isprime(n7))

5 True
19 True
101 True
619 True
4421 True

1. for l in range(8,20):
2. sigma=0
3. pm=1
4. for i in range(l,0,-1):
5. sigma+=factorial(i)*pm
6. pm*=(-1)
7. print(l,sigma,sympy.isprime(sigma))

8 35899 True
9 326981 False
10 3301819 True
11 36614981 False
12 442386619 False
13 5784634181 False
14 81393657019 False
15 1226280710981 True
16 19696509177019 False
17 335990918918981 False
18 6066382786809019 False
19 115578717622022981 True

n=3から7まで素数になったので、永遠にそのまま続くかと思いましたがn=8で途切れてしまいました。

1. n=5
2. l=int(factorial(n+2)/factorial(n)-(n+1))
3. r=(n+1)**2
4. print(l,r)
5. l=int(factorial(n+2)/factorial(n)+(n+2))
6. r=(n+2)**2
7. print(l,r)
8. l=int(factorial(n+3)/factorial(n)+(n+2))
9. r=(n+2)**3
10. print(l,r)
11. l=int(factorial(n+4)/factorial(n)+1)
12. r=(n**2+5*n+5)**2
13. print(l,r)
14. l=int(factorial(n+5)/factorial(n)+5*(n+3)**3-4*(n+3))
15. r=(n+3)**5
16. print(l,r)

36 36
49 49
343 343
3025 3025
32768 32768

1. def l_s(num):
2. f=factorial(num)
3. f2=f*(num+1)*(num+2)
4. f3=f2*(num+3)
5. f4=f3*(num+4)
6. f5=f4*(num+5)
7. return int(f2/f-(n+1)),int(f2/f+(n+2)),int(f3/f+(n+2)),int(f4/f+1),int(f5/f+5*(n+3)**3-4*(n+3))
9. def r_s(num):
10. return((n+1)**2,(n+2)**2,(n+2)**3,(n**2+5*n+5)**2,(n+3)**5)
11. print(l_s(5),r_s(5))

(36, 49, 343, 3025, 32768) (36, 49, 343, 3025, 32768)

1. for i in range(1,10):
2. print(l_s(i))

(0, 13, 31, 121, 3248)
(6, 19, 67, 361, 5048)
(14, 27, 127, 841, 9248)
(24, 37, 217, 1681, 17648)
(36, 49, 343, 3025, 32768)
(50, 63, 511, 5041, 57968)
(66, 79, 727, 7921, 97568)
(84, 97, 997, 11881, 156968)
(104, 117, 1327, 17161, 242768)

効率的に処理する関数を作るうちに、なぜ左辺と右辺が等しいかわかってしまいますね。

1. factor=1
2. for i in range(2,11):
3. factor *= i
4. print(factor,2**(i-1))

2 2
6 4
24 8
120 16
720 32
5040 64
40320 128
362880 256
3628800 512

どんどん差が広がるので、この不等式は成立しそうです。

1. from decimal import *
2. getcontext().prec = 1000
4. factor=1
5. sigma=0
6. expon=10
7. for i in range(1,10001):
8. factor *= i
9. sigma+=1/Decimal(str(factor))
10. if i >=expon:
11. print(f'{i:>6} sigma={sigma}')
12. expon*=10

10 sigma=1.71828180114638447971781305114638447971781305114638447971781305114638447971781305114638447971781305114638447971781305114638447971781・・・（以下略）

小数点第160桁

n=10で1.718281801146384479、n=100で1.718281828459045235なので、小数点第8位で差が生じます。これがn=1000になると小数点160桁で差が生じます。