题目20：算出100！的各位之和

永恒的蓝色梦想

1. from math import factorial
   
2. print(sum(ord(char) - 48 for char in str(factorial(100)))))

复制代码

数据小随从

1. #include<stdio.h>
   
2. #define N 500
   
3. 
   
4. 
   
5. void main()
   
6. {
   
7.         int sum = 0;//此变量用来计算统计结果各位数字之和
   
8.         int count = 1;//用来统计计算结果的长度，也是fact数组被用了多少个元素
   
9.         int i, j, carry = 0;//carry用来保存每次的进位
   
10.         int fact[N] = { 1 };//将fact[0]初始化为1，方便后面的计算
    
11.         for (i = 1; i <= 100; i++)
    
12.         {
    
13.                 for (j = 0; j < count; j++)//手动模拟乘法
    
14.                 {
    
15.                         fact[j] = fact[j] * i + carry;//让fact数组每一位与i相乘，再加上进制位
    
16.                         carry = fact[j] / 10;
    
17.                         fact[j] %= 10;//fact数组的每一位数组都在0-9之间
    
18.                 }
    
19.                 while (carry > 0)//当for循环结束，最高为仍然可能产生进位，需要处理
    
20.                 {
    
21.                         fact[count++] = carry;
    
22.                         if (fact[count - 1] > 9)
    
23.                         {
    
24.                                 carry = fact[count - 1] / 10;
    
25.                                 fact[count - 1] %= 10;
    
26. 
    
27.                         }
    
28.                         else
    
29.                         {
    
30.                                 carry = 0;
    
31.                         }
    
32.                 }
    
33.         }
    
34.         printf("100的阶乘结果为\n");
    
35.         for (i = count - 1; i >= 0; i--)
    
36.                 printf("%d", fact[i]);
    
37.         printf("\n");
    
38.         for (i = count - 1; i >= 0; i--)
    
39.                 sum += fact[i];
    
40.         printf("100!的和 = %d\n", sum);
    
41.         getchar();
    
42. }

复制代码

输出结果为：
100的阶乘结果为
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
100!的和 = 648

gonorth

import math as m

num = int (m.factorial(100))

n = str(num)
s = 0
for i in n:
    s = s + int(i)

print (s)

a1351468657

我觉得这种大数运算用python真的没意思。我刚去用python写了下， 1分钟就写出来了。建议大家用C或者其他语言写下。

a1351468657

数据小随从 发表于 2020-6-26 20:44
输出结果为：
100的阶乘结果为
9332621544394415268169923885626670049071596826438162146859296389521 ...

牛！ 好想法！

a1351468657

数据小随从 发表于 2020-6-26 20:44
输出结果为：
100的阶乘结果为
9332621544394415268169923885626670049071596826438162146859296389521 ...

while (carry)//当for循环结束，最高为仍然可能产生进位，需要处理
                {
                        fact[count] = carry % 10;
                        carry /= 10;
                        count++;
                }
这处可以修改成这样， 应该效率更高

卢本伟牛逼

在这道题目开始感受到数据类型深深的恶意，python是真的爽

ft215378

#100的阶乘各位和
#求阶乘
num = 100
result = 1
while num:
    result *= num
    num -= 1
#求和
s = str(result)
sum = 0
for i in s:
    sum += int(i)
print(sum)

guosl

1. /*
   
2. 答案：648
   
3. 耗时：0.0000694秒
   
4. */
   
5. #include <iostream>
   
6. #include <cstring>
   
7. #include <cmath>
   
8. using namespace std;
   
9. 
   
10. struct stBigInt //作一个高精度整数类
    
11. {
    
12.   short a[192];
    
13.   stBigInt(void) //构造函数
    
14.   {
    
15.     memset(a, 0, sizeof(a));
    
16.   }
    
17.   stBigInt(short k)//构造函数
    
18.   {
    
19.     memset(a, 0, sizeof(a));
    
20.     int i = 0;
    
21.     while (k > 0)
    
22.     {
    
23.       a[i++] = k % 10;
    
24.       k /= 10;
    
25.     }
    
26.   }
    
27.   void operator*(int k)//数乘运算
    
28.   {
    
29.     short s = 0;
    
30.     for (int i = 0; i < 192; ++i)
    
31.     {
    
32.       a[i] = a[i] * k;
    
33.       a[i] += s;
    
34.       s = a[i];
    
35.       a[i] = s % 10;
    
36.       s /= 10;
    
37.     }
    
38.   }
    
39.   int GetSum(void)//取得各位数字之和
    
40.   {
    
41.     int nSum = 0;
    
42.     for (int i = 0; i < 192; ++i)
    
43.       nSum += a[i];
    
44.     return nSum;
    
45.   }
    
46. };
    
47. 
    
48. int main(void)
    
49. {
    
50.   stBigInt x(1);
    
51.   for (int i = 2; i <= 100; ++i)
    
52.     x* i;
    
53.   cout << x.GetSum() << endl;
    
54.   return 0;
    
55. }

复制代码

B1tetheDust

1. import time as t
   
2. 
   
3. start = t.perf_counter()
   
4. 
   
5. 
   
6. def calc_factorial(num):
   
7.     factorial = 1
   
8.     for i in range(num):
   
9.         factorial *= (i + 1)
   
10.     return factorial
    
11. 
    
12. 
    
13. res = calc_factorial(100)
    
14. print(sum(int(j) for j in str(res)))
    
15. print("It costs %f s" % (t.perf_counter() - start))

复制代码

Asss-whom

1. use num::bigint::ToBigUint;
   
2. use std::time::Instant;
   
3. 
   
4. fn main() {
   
5.     let now = Instant::now();
   
6.     let mut value = 1.to_biguint().unwrap();
   
7.     for i in 1..101u32 { value *= i }
   
8.     let num: i32 = value
   
9.         .to_string()
   
10.         .bytes()
    
11.         .map(|x| (x - 48) as i32)
    
12.         .sum();
    
13.     println!("cost {} ms.", now.elapsed().as_millis());
    
14.     println!("{num}")
    
15. }

复制代码

cost 0 ms.
648

mathtimes

1. #include <fmt/core.h>
   
2. #include <cstdint>
   
3. #include <vector>
   
4. #include <algorithm>
   
5. 
   
6. void mul(std::vector<char>& bits, uint64_t i) {
   
7.     int carry = 0;
   
8.     for (auto& j : bits) {
   
9.         uint64_t var = uint64_t(j) * i + carry;
   
10.         carry = var / 10;
    
11.         j = var % 10;
    
12.     }
    
13.     while (carry) {
    
14.         bits.push_back(carry % 10);
    
15.         carry /= 10;
    
16.     }
    
17. }
    
18. 
    
19. int main () {
    
20.     auto bits = *new std::vector<char>{1};
    
21.     for (uint64_t i = 2; i < 100; i++)
    
22.         mul(bits, i);
    
23.     uint64_t count = 0;
    
24.     for (auto i : bits)
    
25.         count += i;
    
26.     fmt::print("{}\n", count);
    
27.     return 0;
    
28. }

复制代码

648
0.005816 seconds