在网上看到一道题，听说是曾经微软出的题，暂时没看出来头绪。。


写一个程序实现：输入一个数，求它的阶乘后面有多少个连续的0，将其连续0 的个数输出。

可能有同学不知道阶乘，简单说一下：例如所要求的数是n，则阶乘式是1×2×3×……×n，设得到的积是x，x就是n的阶乘。
能写出来的上来秀秀！

1. import java.util.regex.Matcher;
   
2. import java.util.regex.Pattern;
   
3. /**
   
4. * 输入一个数，求它的阶乘后面有多少个连续的0，将其连续0 的个数输出。
   
5.        例如所要求的数是n，则阶乘式是1×2×3×……×n，设得到的积是x，x就是n的阶乘。
   
6.        分析：阶乘容易求出，将阶乘转成字符串，判断尾部是否有0.
   
7.        设置一个正则表达式，将其取出即可
   
8. * @author Administrator
   
9. *
   
10. */
    
11. public class JieCheng {
    
12. 
    
13.         public static void main(String[] args) {
    
14.                 // TODO Auto-generated method stub
    
15.                 getEndZero(20);
    
16.         }
    
17.         public static void getEndZero(int x ){
    
18.                 int b = 1;
    
19.                 //long b = 1; 没测试过
    
20.                 for(int a=1;a<=x;a++){
    
21.                         b = b*a;
    
22.                 }
    
23.                 //b这里定义的int类型，貌似给的数过大的话
    
24.                 //其阶乘就超出int的取值范围，b就为负数了，考虑用long类型
    
25.                 //x的值超过16就为负数了
    
26.                 System.out.println("阶乘："+b);
    
27.                 String str = b+"";
    
28.                 //System.out.println(str);
    
29.                 String reg = "0+$";
    
30.                 if(str.endsWith("0")){
    
31.                         Pattern p = Pattern.compile(reg);
    
32.                         Matcher m = p.matcher(str);
    
33.                         while(m.find()){
    
34.                                 System.out.println(m.group());
    
35.                                 System.out.println("后面0的个数："+(m.end()-m.start()));
    
36.                         }
    
37.                 }else{
    
38.                         System.out.println(-1);
    
39.                 }
    
40.         }
    
41. }

复制代码

看看这个代码可行不？

个人建议楼上用BigInteger

今天刚好看完for循环视频，尝试用for循环写了一下，这个数好像不能太大，不然超过long的范围，望高人指正

1. /*
   
2. 1、任意数先分为0和非0
   
3. 2、非0时用for循环求阶乘积，分为正数、负数
   
4. 3、用阶乘积与10取模看其余数是否为0，如果是则计数器加1，
   
5. 然后用阶乘积除以10，相当于最后一个0去掉，再与10取模，
   
6. 如此循环，直到去掉N个0后的阶乘积与10取模的余数不为0时
   
7. 跳出循环。
   
8. */
   
9. class CountZero
   
10. {
    
11.         public static void main(String[] args)
    
12.         {
    
13.                 int x=15;      
    
14.                 long sum=1l;      
    
15.                 int count=0;           
    
16.                 if(x!=0)                     
    
17.                 {
    
18.                         if(x>0)                     
    
19.                         {
    
20.                                 for(int i=1;i<=x;i++)        
    
21.                                 {
    
22.                                         sum=sum*i;
    
23.                                 }
    
24.                         }
    
25.                         else if(x<0)            
    
26.                         {
    
27.                                 for(int i=-1;i>=x;i--)   
    
28.                                 {
    
29.                                         sum=sum*i;
    
30.                                 }
    
31.                         }
    
32.                         for(long i=sum ;i%10==0 ;i=i/10)      
    
33.                         {                                                      
    
34.                                 count++;                                    
    
35.                         }        
    
36.                 }
    
37.                 else                                                
    
38.                 {
    
39.                         count=1;
    
40.                         sum=0;
    
41.                 }
    
42.                 System.out.println(sum);      
    
43.                 System.out.println(count);
    
44.         }
    
45. }
    

复制代码

学习一下。

学习一下...谢谢分享...

张百振 发表于 2014-5-26 23:43
个人建议楼上用BigInteger

刚刚看了下BigInteger，好像确实更好一些，谢谢。
3楼的想法很好。

四楼输入的数超过20貌似就挂了，最多就能求出来4个0

都很厉害！！！

三楼的思路很不错，学习了。

西门吹风 发表于 2014-5-27 00:29
今天刚好看完for循环视频，尝试用for循环写了一下，这个数好像不能太大，不然超过long的范围，望高人指正

...

写的很好

21的阶乘已经超过了long的最大

只需要求出包含几个2和5，还有几个10的倍数就轻松搞定了不是？想一下，阶乘里只要乘以10，最后肯定多一个0，还有只要包含一个2和5这一对数，就又会多一个0，哈哈哈，多么简单呀，我现在时间太紧了，正在准备面试，要不然就代码写出来了

张百振 发表于 2014-5-26 23:43
个人建议楼上用BigInteger

如果超出了BigInteger呢？这个要想真的很好的解决，我觉得还是要先转化为字符转来解决，毕竟字符串的长度要大于数值型。

vampire.007 发表于 2014-5-27 13:00
如果超出了BigInteger呢？这个要想真的很好的解决，我觉得还是要先转化为字符转来解决，毕竟字符串的长度 ...

你想多了吧？10000的阶乘BigInteger都没问题，你还想用String？

1. public class ComputeZero {
   
2.        
   
3.         <p style="line-height: 30px; text-indent: 2em;">public static void main(String[] args){
   
4.                 int count = 0;//末尾0的個數
   
5.                 int i = 16;//被計算的數，如果太大則需要將計算結果擴充範圍
   
6.                 Long sum = 1L;//計算結果
   
7.                 while(i!=0){
   
8.                         sum = sum*i;
   
9.                         i--;
   
10.                 }
    
11.                 System.out.println(i+"的階乘為："+sum);
    
12.                
    
13.                 while(sum%5==0){
    
14.                         sum = sum/5;
    
15.                         count++;
    
16.                 }
    
17.                
    
18.                 System.out.println("末尾包含:"+count+"個0");
    
19.                
    
20.         }</p>
    
21. 
    
22. }

复制代码

這個是求階乘末尾的0，如果階乘分解因式之後包含的N個10（2*5這種也算在內），那這個階乘結果的末尾0就有N個

好难啊！！！！！！！

学习了！

。。。。。。。。。。。。

。。。。。。。。。。。。。。。。。