求1000的阶乘结果中所有零的个数。{:2_41:}

使用数组也可以解决（不用BigInteger类），大家可以尝试下哈

我的测试题答案：

1. package com.itheima;
   
2. 
   
3. import java.math.BigInteger;
   
4. 
   
5. /**
   
6. * 第9题：求1000！的结果中包含多少个0？注：1000! = 1×2×3×4×5×...×999×1000
   
7. * 思路：
   
8. * 1，创建BigInteger对象
   
9. * 2，定义一个变量计数
   
10. * 3，for循环计算1000！结果装入BigInteger对象中
    
11. * 4，把BigInteger对象转为String类型
    
12. * 5，for循环遍历String，若遇'0'，则计数变量加1
    
13. * 6，打印计数结果
    
14. * @author
    
15. */
    
16. public class Test9 {
    
17.         public static void main(String[] args) {
    
18.                 // 创建值为1的BigInteger对象factorial
    
19.                 BigInteger factorial = new BigInteger("1");
    
20.                 // 定义一个变量count计数
    
21.                 int count = 0;
    
22.                 // for循环计算1000！结果装入factorial中
    
23.                 for (int i = 2; i <= 1000; i++) {
    
24.                         factorial = factorial.multiply(new BigInteger(i + ""));
    
25.                 }
    
26.                 // 把factorial转为String类型
    
27.                 String s = factorial.toString();
    
28.                 // 遍历s，若遇'0'，则count++计数
    
29.                 for (int i = 0; i < s.length(); i++) {
    
30.                         if (s.charAt(i) == '0')
    
31.                                 count++;
    
32.                 }
    
33.                 // 输出计数结果
    
34.                 System.out.println("1000!的结果包含0的个数为：" + count);
    
35.         }
    
36. }

复制代码

1. import java.math.*;
   
2. /**
   
3. * 第9题  求1000！的结果中包含多少个0？注：1000! = 1×2×3×4×5×...×999×1000
   
4. */
   
5. public class Test9 {
   
6. 
   
7.         /*
   
8.          * 思路：
   
9.          * 1000！这种大数乘法，需要使用BigInteger
   
10.          * 先计算出1000！的结果，然后循环取出字符串中的字符，
    
11.          * 判断一共有多少个0.
    
12.          */
    
13.         public static void main(String[] args)
    
14.         {
    
15.                 String jieChengRes = jieCheng().toString();
    
16.                 prin("1000!的运算结果为："+jieChengRes);
    
17.                
    
18.                 int zeroCount = returnZeroCount(jieChengRes);
    
19.                 prin("结果中一共包含： "+zeroCount+" 个零。");
    
20.         }
    
21.         
    
22.         //1.计算出1000！的结果。
    
23.         public static BigInteger jieCheng()
    
24.         {
    
25.                 BigInteger result = new BigInteger("1");
    
26.                
    
27.                 for (int i = 1; i <= 1000; i++)
    
28.                 {
    
29.                         BigInteger num = new BigInteger(String.valueOf(i));
    
30.                         
    
31.                         // 大数运算与基本数据类型不同，不能使用*运算符，用独有的multiply()方法
    
32.                         result = result.multiply(num);
    
33.                 }
    
34.                
    
35.                 return result;
    
36.         }
    
37.         
    
38.         //循环取出字符串中的字符，并记录一共有多少个0.
    
39.         public static int returnZeroCount(String res)
    
40.         {
    
41.                 int count = 0;
    
42.                 for (int i = 0; i < res.length(); i++)
    
43.                 {
    
44.                         String str = String.valueOf(res.charAt(i));
    
45.                         if(str.equals("0"))
    
46.                         {
    
47.                                 count++;
    
48.                         }
    
49.                 }
    
50.                 return count;
    
51.         }
    
52. 
    
53.         //换行打印通用方法
    
54.         public static void prin(Object obj)
    
55.         {
    
56.                 System.out.println(obj);
    
57.         }
    
58. }

复制代码

一切尽在代码之中~。

kang3214 发表于 2014-11-15 14:02
用递归决解

兄弟啊，递归不行的，结果的位数2000多位。。。

用递归决解

欢迎大家来讨论哈，说说自己的想法也好