package com.itheima;

/*
* 9、 求1000！的结果中包含多少个0？注：1000! = 1×2×3×4×5×...×999×1000
*/

/*
* 思路，打印出结果，把结果每个整数单位转换为数组元素，然后遍历，出现0计数一次。
*/
public class Test9{
        public static void main(String[] args) {
                //先循环遍历出1000！的结果
                long  sum = 1;
                for (long i = 1; i <=1000; i++) {//再大就超标了
                        sum = sum*i;
                }
                System.out.println(sum);
                //将long整数转换为字符串
                String str =String.valueOf(sum);
                //将这个字符串转换为一个字符数组
                char[]  ch=str.toCharArray();
                //定义一个计数的变量
                int count= 0;
                System.out.println(ch.length);
                //把字符数组里面的每一个元素遍历出来
                System.out.println(ch[3]);
                for (int i = 0; i < ch.length; i++) {
                        if(ch[i]=='0'){//记得写'0'
                                System.out.println(i);
                                count++;
                        }else{
                                continue;
                        }
        }
                System.out.println(count);
        }
}
因为1000！太大了数字不能打印出来导致后面的全错误了，希望你们给我个另外的方法做出这道题

楼主，弱弱的提醒你一下，你只需要查一下末位是0的数有多少个就好了、比如1000，你从个位数起，有三个，如果是50，从各位数起，有一个0，那么我如果是1000*50，就可以直接用3+1个0来计算了。当然了，这个只是计算从各位数起有多少个0.至于中间，我还没想到好办法。

1. import java.math.BigInteger;
   
2. 
   
3. 
   
4. /**
   
5. * @author Administrator
   
6. * 计算一个数的阶乘末尾有几个连续的0
   
7. * n! = n*(n-1)!=n*(n-1)*(n-2)!...=n*(n-1)(n-2)*..2;
   
8. */
   
9. public class ComputeSuffixZero {
   
10.         public static void main(String[] args){
    
11.                 //统计一个数的阶乘末尾总共包含几个0
    
12.                 int n = 1000;//被测试的数
    
13.                 int count = 0;//末尾0的个数
    
14.                 BigInteger k = BigInteger.valueOf(0);//n-i
    
15.                 BigInteger sum = BigInteger.valueOf(1);
    
16.                 //BigInteger bi = null;
    
17.                 for(int i = 0;i<n;i++){
    
18.                         k = BigInteger.valueOf(n-i);
    
19.                         //System.out.println("k = "+k);
    
20.                         sum = sum.multiply(k);
    
21.                         //bi = BigInteger.valueOf(sum);
    
22.                         if(k.mod(BigInteger.valueOf(5)) == BigInteger.valueOf(0))
    
23.                                 count++;
    
24.                 }
    
25.                
    
26.                 //统计一个数的阶乘总共包含几个0
    
27.                 String s = sum.toString();
    
28.                 int zero_count = 0;
    
29.                 char[] b = s.toCharArray();
    
30.                  for(int j = 0;j < s.length(); j++){
    
31.                          if(b[j]=='0')
    
32.                                  zero_count++;                         
    
33.                  }
    
34.                 System.out.println(n+"的阶乘为"+s);
    
35.                 System.out.println(n+"的阶乘末尾包含:"+count+"个0");
    
36.                 System.out.println(n+"的阶乘包含:"+zero_count+"个0");
    
37.                
    
38.         }
    
39. 
    
40. }
    

复制代码

这次好了，只要你计算机内存够大，就能显示出来了:lol

就看看 学习下

pk49800 发表于 2014-6-11 19:08

先谢了  我慢慢读一下:victory:

要是非要用1000！的话   ，我有一个想法，截取的方法，创建一个数组，开始阶乘循环，每当数字位数超过N位时，截取除去靠后的N位的数字，成为一个新元素(比如说123456789123456，我可以截取成123456和789123456)这就成了两个元素，在下一次循环的时候，两个数分别乘 i ;再把后面这个数超出N位的部分截出来加到前面这个数与 i 的乘积里面去，一只循环到 i =1001结束，我们再计算这个数组里面有多少0，就能得出结果了，不管你的数字多大都可以搞定了。

本人还在学习毕老师的课程，第一遍才看到第9天，所以这里只是提供一个想法给予参考。

24岁？？？ 发表于 2014-6-11 19:38
要是非要用1000！的话   ，我有一个想法，截取的方法，创建一个数组，开始阶乘循环，每当数字位数超过N位时 ...

谢了，共同学习，我也在学基础:handshake

人心如水 发表于 2014-6-11 19:41
谢了，共同学习，我也在学基础

:handshake

用数组可做.

1. import java.util.Scanner;
   
2. 
   
3. public class Test2 {
   
4.         public static void main(String[] args) {
   
5.                 int add;
   
6.                 int len,temp,i,j,count=0;;
   
7.                 int[] a= new int[10000];
   
8.                 Scanner sc = new Scanner(System.in);
   
9.                 int n=sc.nextInt();
   
10.                 a[0]=1;
    
11.                 len=1;
    
12.                 for(i=2;i<=n;i++){
    
13.                         for(j=1,add=0;j<=len;j++){
    
14.                                 temp=a[j-1]*i+add;
    
15.                                 a[j-1]=temp%10;
    
16.                                 add=temp/10;
    
17.                         }
    
18.                         while(add!=0){
    
19.                                 len++;
    
20.                                 a[len-1]=add%10;
    
21.                                 add/=10;
    
22.                         }
    
23.                 }
    
24.                 System.out.print(n+"的阶乘为:");
    
25.                 for(int k=len;k>=1;k--){
    
26.                         if(a[k-1]==0)
    
27.                                 count++;
    
28.                         System.out.print(a[k-1]);
    
29.                 }
    
30.                 System.out.println();
    
31.                 System.out.println("零的个数为:"+count);
    
32.         }
    
33. }
    

复制代码

用数组模拟阶乘

可以放弃基本类型，用string类型代替数字，底层拆解string做进位运算

BigInteger 也可以完成

1. import java.math.BigInteger;
   
2. import java.util.Scanner;
   
3. 
   
4. public class Test2 {
   
5.         public static void main(String[] args) {
   
6.                 Scanner sc = new Scanner(System.in);
   
7.                 int count=0;
   
8.                 int n = sc.nextInt();
   
9.                 System.out.println(digui(BigInteger.valueOf(n)));
   
10.                 String str = digui(BigInteger.valueOf(n)).toString();
    
11.                 for(int i =0;i<str.length();i++){
    
12.                         if('0'==str.charAt(i)){
    
13.                                 count++;
    
14.                         }
    
15.                 }
    
16.                 System.out.println("零的个数为:"+count);
    
17.                
    
18.         }
    
19. 
    
20.         static BigInteger digui(BigInteger s) {
    
21.                 if (s.equals(BigInteger.valueOf(1))) {
    
22.                         return BigInteger.valueOf(1);
    
23.                 } else {
    
24.                         return s.multiply(digui(s.subtract(BigInteger.valueOf(1))));
    
25.                 }
    
26.         }
    
27. }
    

复制代码

肯定啦，上千位数，除非用科学计数法

曲佳奇 发表于 2014-6-11 21:23
用数组模拟阶乘

{:2_42:}牛

1000的阶乘太大了装不下

用BigInteger！很好解决啊！