위의 풀이대로 N!의 뒤쪽 0의 갯수는 5의 승수입니다. 물론 전 팩토리얼을 계산해 0을 새는것보다 5의 승수를 세어보는것이 효율적이긴합니다만.. 여기에서 한번 더 생각해보면...

N! 까지 5의 배수 갯수는 N / 5 입니다.

5! -> 1
10! -> 2
20! -> 4
25! -> 5
...
125! -> 25

5의 배수중에 다시 5로 나누어 지는 수는 나눈수에 다시 5를 나누어 구할 수있습니다.

5! -> 1 + 1/5
10! -> 2 + 2/5
20! -> 4 + 4/5
25! -> 5 + 5/5
...
125! -> 25 + 25/5

5 의 2 배수중에.. (이하생략)

5! -> 1 + 0
10! -> 2 + 0
20! -> 4 + 0
25! -> 5 + 1 + 1/5
...
125! -> 25 + 5 + 5/5

이런식으로 나누어 지지않을때까지 나누어서 더하면 O(N)의 복잡도로 답을 구할 수 있습니다.

# 루프
def zeros(n)
  zeros = 0
  zeros += n /= 5 while n >= 1
  zeros
end

# 재귀
def zeros(n)
  n < 5 ? 0 : (n / 5) + zeros(n / 5)
end

펄입니다
방법 1:팩토리얼연산+정규표현식

use bigint;
sub factorial{my$x=shift or return 1;$x*factorial($x-1)}
(my $r=factorial(($_=<STDIN>)))=~/[1-9](0+)$/;
print length $1,"\n";

리눅스 셸에서 다음과 같이 입력 합니다

perl -e 'use bigint;sub factorial{my$x=shift or return 1;$x*factorial($x-1)}(my $r=factorial(($_=<STDIN>)))=~/[1-9](0+)$/;print length $1,"\n"'
25

6

방법2:
1부터 시작되는 자연수들을 5개씩 쪼갠 뒤 각각의 자연수를 소인수분해 했을 때, 소수 2의 총 개수는 항상 소수 5의 총 개수보다 같거나 많습니다
1,2,3,4,5->1,2^1,3,2^2,5^1 : 2 4개 5 1개
121,122,123,124,125->121,61*2,123,31*2^2,5^3 : 2 3개 5 3개
이것이 왜 중요하냐면
예를 들어 10!의 경우를 보겠습니다
10!=3628800 즉 끝에 0이 2개 입니다
2개의 0은 어디서 나오는 것이냐면
(10) * 9 * 8 * 7 * 6 * (5) * 4 * 3 * 2 * 1 10과 5 두개에서 나오는 것입니다 소인수 2의 개수는 항상 5의 개수보다 같거나 많기 때문에 따로 셀 필요 없습니다
따라서 소인수 5의 개수만 세어주면 됩니다

my$input=<STDIN>;for(my$i=1;5**$i<=$input;$i++){$_+=($input/(5**$i))}print

리눅스 셸에서 다음과 같이 입력 합니다

$ perl -le 'my$input=<STDIN>;for(my$i=1;5**$i<=$input;$i++){$_+=($input/(5**$i))}print'

def f(n):
  if n<5 : return 0
  return int(n/5) + f(n/5)

print f(25)

Python 3.6 (한줄코딩) using math.factorial & itertools.takewhile

>>> from math import factorial
>>> from itertools import takewhile

>>> len(list(takewhile(lambda x:x=='0', str(factorial(25))[::-1])))
6

정수론 문제네요. N!의 trailing zero의 개수는 floor(N/5) + floor (N/5^2) + ... 입니다.

#include <iostream> 
#include <cstdio> 
#include <cmath> 
#include <algorithm> 
using namespace std; 

int main(){
    int n,cnt = 0,idx = 1; 
    scanf("%d",&n); 
    while (n/pow(5,idx)){
        cnt += n/pow(5,idx); 
        ++idx; 
    }   
    printf("%d\n",cnt); 
    return 0; 
}

def count_trailing_zero_factorial(x):
  cnt = 0
  for i in xrange(5, x+1):
    while i % 5 == 0:
      cnt += 1
      i /= 5
  return cnt

Scala

def count(n: Int): Int = {
    def fn(n: Int, count: Int): Int = {
        if(n != 0 && n % 5 == 0) {
            fn(n / 5, count + 1)
        } else {
            count
        }
    }

    (1 to n).map ( fn(_, 0) ).sum
}

println(count(12))
println(count(25))

require 'prime'

def trailing_zero(n)
  (1..n).
    select{|i| i % 5 == 0}.
    map{|i| Prime::prime_division(i).select{|p,_| p == 5}.flatten.last }.
    inject(:+)
end

trailing_zero(12) #=> 2
trailing_zero(25) #=> 6

clojure

(defn factorial
  ([n]
     (factorial n 1N))

  ([n acc]
     (if (= n 1)
       acc
       (recur (dec n) (* n acc)))))

(defn f
  [n]
  (->> n
       factorial
       str
       reverse
       (take-while #(= % \0))
       count))

(f 12)
;=> 2
(f 25)
;=> 6

def f(x):
    numZeros = 0
    fact = 1
    for i in range(x):
        fact = fact * (i+1)
    fact = str(fact)
    for i in range(1, len(fact)+1):
        if fact[-i] != '0':
            break
        numZeros += 1

    return numZeros

n = input()

print f(n)

5의 n승을 구하는 풀이가 최적인 듯 합니다. 그런데

my$input=<STDIN>;for(my$i=1;5**$i<=$input;$i++){$_+=($input/(5**$i))}print

int($input/(5**$i))로 써주거나 use integer가 들어가야 하는데 빠져있어서

perl -Minteger -le'$i=<>;for($j=1;5**$j<=$i;$j++){$_+=($i/(5**$j))}print'

는 12를 넣었을 때 2를 출력하지만 위의 경우는 2.4를 출력합니다.

Ruby

def f(n)
    (2..n).inject(:*).to_s.scan(/0+$/)[0].size
end

파이썬 입니다. 5의 n승은 생각도 못하고 풀었습니다.

def func(n, count=0):
  for i in range(1, n): n = n*i 
  for i in range(len(str(n))):
    if str(n)[-i-1] == '0': count += 1
    else: break
  print count

func(12)
func(25)

def factorial(num):
    i, fac = 1, 1
    while i <= num:
        fac=fac*i
        i += 1
    return fac

def noz(num):
    string = str(num)
    length = len(string)
    i = 1
    cnt = 0
    while i<length:
        if string[length-i] == '0':
            cnt += 1
            i += 1
        else :
            break
    return cnt

print (noz(factorial(12)))
print (noz(factorial(25)))

python 3.4

승수를 적용하는 원리가 신기하네요. 수학적 방법을 잘 몰라서 반복문으로 처리 했습니다.

끝에서 시작하는 0의 연속된 개수를 구하는 문제라 이해를 했습니다.(끝이 0으로 시작하지 않으면 count는 무조건 0)

def f(n):
    mr = 1;
    #체크할 값을 구함
    for i in range(1,n+1):
        mr = mr * i

    #값을 문자열로 변환 후 뒤쪽 끝에서 부터 '0'을 카운터 한다.
    smr = str(mr)
    count = 0
    for i in range(len(smr)-1,-1,-1):
        if smr[i] == '0':
            count += 1
        else:
            break
    return count

print(f(12))
print(f(25))

Scala로 풀었습니다. 1부터 n까지 다 곱하고, 거꾸로 0으로 연속되는 문자열을 분리한 다음, 길이를 구했습니다.

def f(n:Int) = (1 to n).foldLeft(BigInt(1))(_ * _).toString.reverse.span(_=='0')._1.length

파이썬 2.7입니다.

def Factorial(x):
    if x == 1:
        return 1
    else:
        return x*Factorial(x-1)

N = [x for x in str(Factorial(25))]
N.reverse()
Temp = map(lambda x,y: x == y,N[0:-1],N[1:])

print "The number of '0':  %d" % (Temp.index(False)+1)

def factn(num):
    a = 1
    for i in range(1,num+1):
        a = a * i
    return a

def count0(num):
    count = 0
    while num % 10 == 0:
        num = num / 10
        count = count + 1
    return count

def f(num):
    return count0(factn(num))

print f(25)

그냥 문장 그대로 번역해보았습니다.

def fact(n):
    if n == 1:
        return 1
    else:
        return n * fact(n-1)

num = input()
s = str(fact(int(num)))
l = len(s)-1
cnt = 0
for a in range(l,0,-1):
    if s[a] == '0':
        cnt += 1
    else:
        break

print(cnt)

        Dim b As New BigInteger(1)

        For i As Integer = 1 To CInt(Console.ReadLine)
            b *= i
        Next

        Console.WriteLine(b.ToString.Length - b.ToString.TrimEnd("0"c).Length)

뒷부분 0을 제거후 전체 길이와 잘린길이를 뺍니다.

static int counts(BigInteger n)
        {
            string tms = n.ToString();
            int len = tms.Length - 1;
            int cnt = 0;

            for (int i = len; i > 0; i--)
            {
                if (tms[i] == '0')
                {
                    cnt++;
                }
                else
                {
                    break;
                }
            }

            return cnt; 
        }

        static BigInteger f(int n)
        {
            if (n<=1)
            {
                return 1;
            }
            else
            {
                return n * f(n - 1);
            }
        }

static void exce74()
    {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int cnt = 0, num0 = 0;

        while (n > 4)
        {
            cnt++;
            n /= 5;
        }

        for (int i = 1; i <= cnt; i++)
            num0 += i;

        System.out.printf("0의 갯수는 %d개\n", num0);

    }

        static void Main(string[] args)
        {
            Console.WriteLine(Zerocount(N(12)));
        }
        static int Zerocount(int value)
        {
            int count = 0;
            char[] str = value.ToString().ToArray();
            for(int i = str.Length-1;i > 0;i--)
            {
                if(str[i] == '0')
                {
                    count++;
                }
                else
                {
                    break;
                }
            }
            return count;
        }
        static int N(int n)
        {
            int result = 1;
            for(int i = 1;i <=n;i++)
            {
                result *= i;
            }
            Console.WriteLine(result);
            return result;
        }

def fac(n):
     if n<=0:
          return 1
     else:
          return n*fac(n-1)

def numb(n):
     x=str(fac(n))
     count=0
     i=len(x)-1
     while(x[i]=='0'):
          count+=1
          i-=1
     return count

파이썬 2.7


def fact(n):
    if n == 1:
        return 1
    elif n > 1:
        return n * fact(n-1)

def f(num):

    valu = fact(num)
    print valu, ' -> ',

    l = str(valu).replace('', ' ').split()

    result = 0  #뒤에 위치한 zero의 개수를 저장
    for i in range(len(l)):
        if l[-1-i] == '0':  #결과값(valu)의 맨 뒤부터 zero인 개수를 카운드함.
            result += 1
        else:
            break
    return result


print f(25) # 인수는 팩토리얼하는 숫자임

결과:
15511210043330985984000000  ->  6

def factorial(n, count_a):

    answer = 1
    while n>1:
        answer *= n
        n = n-1
    stringed = str(answer)
    print stringed
    a = stringed[::-1]

    zero_count = 0
    if a[0] =="0":
        k=1
        while a[k] =="0":
            zero_count +=1
            k = k+1
        return zero_count+1

    else:
        return "None"


n = 25
count_a = "0"
print factorial(n, count_a)

다른분들거 보다 길게 풀었습니다... 숫자를 문자화 한 다음에 "0"을 왼쪽부터 세기로 하였습니다. 만약 0이 아닌 다른 숫자가 오면 break 하였고 맨 처음 0 은 디폴트로 +1 해주었습니다.

Ruby

cnt_zeros_factorial = ->n { n<5? 0 : n/5 + cnt_zeros_factorial[n/5] }

Test

expect(cnt_zeros_factorial[12]).to eq 2
expect(cnt_zeros_factorial[25]).to eq 6

int NumOfZero(int n) {
        int result = factorial(n);
        String s = Integer.toString(result);
        int count = 0;
        int max = 0;

        for(int i=s.length()-1; i>=0; i--) {
            if(s.charAt(i) == '0') {
                count++;
            }
            else {
                max = Math.max(max, count);
                count = 0;
            }
        }
        return max;
    }

    private int factorial(int n) {
        if(n == 1) return 1;
        return n * factorial(n-1);
    }

java

파이썬3.4.4

팩토리얼 결과를 역순으로 뒤집고, '0'이 아니기 전까지 리스트로 만들어 길이를 구합니다.

from math import factorial
from itertools import takewhile

def f(n):
    return len(list(takewhile(lambda x: x == '0', reversed(str(factorial(n))))))

print(f(25))    #6

# 다른 풀이
import re

fac = lambda n: 1 if n == 1 else fac(n-1) * n
f = lambda n: re.search('[123456789]', str(fac(n))[::-1]).start()
print(f(25))    # 6

팩토리얼 값을 실제로 계산하지 않고, 다음과 같이 구합니다. N! 은 (당연히) 1 * 2 * 3 * 4 ... * N 인데, 이 값의 끝자리 0들은 이 값의 소인수 중에서 2 * 5 의 개수와 같습니다.

따라서, 각 자연수에 대해서 소인수 중에서 2와 5의 개수를 모두 세어 각각 합산하고 그 중 작은 값이 끝자리 0의 개수가 됩니다.

from functools import reduce
def p(n):
    if n < 2:
        return (0, 0)
    a, b = 0, 0
    while n % 2 == 0:
        a += 1
        n = n // 2
    while n % 5 == 0:
        b += 1
        n = n // 5
    return a, b

def do(n):
    a = [p(x) for x in range(1, n+1)]
    return min(*(reduce(lambda x, y: (x[0]+y[0], x[1]+y[1]), a, (0, 0))))

print(do(25))

각 곱하는 수의 factor중에서 2의 개수를 세고, 5의 개수를 세고, 10의 개수를 세어서 min(5,2) 값은 0을 의미하므로 10의 개수와 합쳤습니다.

    public int countFactor(int n, int number) {
        int count = 0;
        while( n > 0 ){
            if(number != 10) {
                if (n % number == 0 && n % 10 != 0) {
                    count++;
                    n = n / number;
                }
                else
                    return count;
            }else
                if(n % number == 0){
                    count++;
                    n = n / number;
                }
            else
                return count;

        }
        return count;

    }



    public int countZero(int n){
        int two_count = 0 , five_count = 0 , ten_count = 0;
        int num =0;
        for(int i = 1 ; i <= n ; i++){
            two_count += countFactor(i, 2);
            five_count += countFactor(i, 5);
            ten_count += countFactor(i, 10);

        }

        int result = (int)Math.min(two_count , five_count) + ten_count;
        System.out.println(result);
        return result;
    }

while __name__ == '__main__':
    result = 0; li = []; num = int(input('>>>')); i = 1
    while 5*i<=num: li.append(5*i); i += 1
    for x in li:
        while 1:
            if x%5 == 0:x/=5;result+=1
            else:break
    print(result)

이병곤 님의 설명에서 힌트를 얻어 더 최적화하였습니다. 전체를 확인하는 것보다 연산량이 매우 적습니다. 파이썬 3.5.1

#파이썬 3.4.2
from math import *
n = factorial(int(input()))
c = 0
for i in str(n)[::-1]:
    if i == '0':
        c += 1
    else:
        break
print(c)

import re
def nfac(a):
    n=1
    for i in range(1,a+1):
       n=n*i
    return n
n=int(input())
b=str(nfac(n))
p=re.compile(r"[0]+$")
text=p.findall(b)
print(len(text[0]))

Python 3.4.4

f = lambda x: x // 5 + x // 5 // 5
print(f(12))
print(f(25))

C#으로 작성했습니다. 이병곤 님의 알고리즘을 도움 받아 작성했습니다. 알고리즘을 몰랐다면 하나하나 곱해서 무식하게 계산했겠네요.

        public int CountZeros(int n)
        {
            var count = 0;
            for (int i = 5; i <= n; i+=5)
            {
                var temp = i;
                do
                {
                    if (temp % 5 == 0)
                    {
                        count++;
                        temp /= 5;
                    }
                    else break;
                } while (temp >= 5);
            }
            return count;
        }

python 2.7

def Factorial(n):
    F_num=1
    for i in range(2,n+1):
        F_num*=i
    return F_num

def Count_Zero(F_num):
    st=str(F_num)+'\0'
    Max=0
    count=0
    print st
    for i in st:
        if(i=='0'):
            count+=1
        else:
            if(Max<count):
                Max=count
            count=0

    print Max

n = int(raw_input("Num:"))
Count_Zero(Factorial(n))

파이썬 코드입니다.

n = int(input())

nf = 1
for i in range(1,n+1):
    nf *= i

count = 0
a = nf
while True:
    if nf%10 == 0:
        count += 1
        nf = nf//10
    else:
        break

print(a, count)

파이썬 초보입니다. 많은 피드백 부탁드립니다.

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <windows.h>
#include <stdio.h>
#include <string>

using namespace std;

void f(int);

int main(void) {
    int N;
    cout << "input : ";
    cin >> N;
    f(N);

    system("pause");
    return 0;

}
void f(int N) {
    int zero = 0;
    for(int i=1; i<=N; i++)
    {
        // 뒷자리가 0 이나오기 위해선 2 X 5 의 갯수를 세면된다
        // 6! 의 경우는
        // 1 X 2 X 3 X 4 X 5 X 6 즉, 1 X 2 X 3 X 2 X 2 X 5 X 2 X 3 이다 여기서 곱셈의 순서는 중요하지않다
        // 때문에 2를 약수로하는 수  5를 약수로하는수만 구하면 끝의 0의 갯수를 셀수 있다
        // 하지만 여기서 5라는 약수를 구하는데 있어 약수 2는 필히 나오게되기에 5의 수만 찾으면된다
        // 25의 경우 혹은 125의 경우는 5의 거듭제곱수로 5 X 5 , 5 X 5 X 5 가 되므로 count를 5의 갯수만큼 해야한다
        int num = i;
        if (num % 5 == 0) {
            zero++;
            //5의 거듭제곱수를 찾아 zero++을 하기위한 while 문
            while (num / 5 >= 5) {
                num = num / 5;
                if (num % 5 == 0) {
                    zero++;
                }
                else {
                    break;
                }
            }

        }

    }
    cout << "f(" << N << ")  -> " << zero << "  #" << endl;

}

import java.math.BigDecimal;
import java.text.DecimalFormat;

public class CountPostZero {

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        DecimalFormat df = new DecimalFormat("#");
        df.setMaximumFractionDigits(0);

        System.out.println(countZero(df.format(factorial1(12)))); //12345678
    }

    private static BigDecimal factorial1(int i){
        BigDecimal ret = new BigDecimal(1);
        BigDecimal bi = new BigDecimal(i);

        for (BigDecimal j = new BigDecimal(2); j.compareTo(bi) == -1 || j.compareTo(bi) == 0; j = j.add(new BigDecimal(1))) {
            ret = ret.multiply(j);
        }

        return ret;
    }

    private static int countZero(String str){
        System.out.println(str);
        int numOfZero = 0;

        for (int i = str.length() - 1; i >= 0; i--) {
            if ("0".equals(String.valueOf(str.charAt(i)))) {
                numOfZero++;
            }else{
                break;
            }
        }

        return numOfZero;
    }
}

평소에 BigDecimal을 쓸 일이 별로 없는데 이 기회에 많이 배웠습니다.~

BigInteger로 팩토리얼 계산해서 구했는데, 정수론 활용하면 되는군요. 많이 배우고 갑니다.

import static org.junit.Assert.assertEquals;

import java.math.BigInteger;

import org.junit.Test;

public class NumberOfTrailingZeros {

    public static void main(String[] args) {
    }

    public int countNumberOfTrailingZeros(int n) {
        String str = factorial(n);
        int count = 0;

        for(int i = str.length() - 1; i >= 0; i--) {
            if(str.charAt(i) != '0')
                break;
            else
                count++;
        }

        return count;
    }

    public String factorial(int n) {
        String result = null;

        BigInteger bi = BigInteger.ONE;

        for(int i = 2; i <= n; i++) {
            bi = bi.multiply(BigInteger.valueOf(i));
        }

        result = bi.toString();

        return result;
    }

    @Test
    public void testTrailing() {
        assertEquals(6, countNumberOfTrailingZeros(25)); 
    }
}

<내장 함수로 해결.>

N! 구하고 문자열로 변환,

문자열을 역순으로 배열,

정규표현식에서 첫번째 0이 아닌 인덱스 값 반환.

^^

import math
import re
def fac2cnt(n):
    cnt = 0
    f = math.factorial(n)
    rev_str = str(f)[::-1]
    cnt = re.search(r'[^0]',rev_str).start()
    return cnt

print(fac2cnt(25))

import re
from functools import reduce
def do(n):
    r = reduce(lambda x, y:x*y, range(1, n + 1))
    m = re.search(r'(0*)$', str(r))    
    print('{} # {}!은 {}'.format(m.group().count('0'), n, r))

do(12)
do(25)

Python 3.5.2에서 작성하였습니다.

다른 분들의 풀이를 보고 다시 작성해봤습니다.

def do(n):
    cnt = 0
    while n//5:
        cnt+=n//5
        n = n//5
    print(cnt)

do(12)    
do(25)

Haskell을 이용하여 단순무식하게 했습니다.

factorial n = product [1..n]

trailing_zeros_of_factorial = length . takeWhile (=='0') . reverse . show . factorial

수학적으로 생각해보면, 주어진 정수 N보다 작거나 같은 5의 배수의 개수가 곧 N!의 뒷부분에 있는 0의 개수입니다. 따라서 파이썬3으로 작성한 코드는 다음과 같습니다.

def count_zero(x):
    return x//5

result,count = 1,0
for x in str(eval('*'.join([str(x) for x in range(1,int(input())+1)])))[::-1]:
    if x == '0':
        count += 1
    else:
        break

print('0의 개수 : %d' % count)

#### 2017.01.05 D-413 ####

5로 나누어지는 수 + 5의 제곱수

#include <stdio.h>
#include <math.h>

void main() {
    int n = 25;
    int r = 1;
    int count=0;
    for(int i=1;i<=n;i++) {
        int temp = i;
        while(temp > 0 && temp%5==0) {  
            count++;
            temp = temp/5;
        }

    }
    printf("%d", count);

}

import java.util.Scanner;

public class NumberOfBackwardZeros {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println(factorial(n));
    }

    public static int factorial(int n) {
        return n < 5 ? 0 : (n / 5) + (factorial(n / 5));
    }
}

def zeross(n):
    return sum(sum(1 for j in range(1,n+1) if j%(5**i)==0) for i in range(1,n))
zeross(25)

파이썬 3.5.3 연습용 코드입니다.

a='2372700003040200000'

count = 0
start = 0

for x in range(1,len(a)+1):

    if start == 0:
        if a[-x] == '0':
            start = 1
            count += 1

    elif start == 1:
        if a[-x] == '0':
            count += 1


        elif a[-x] != '0':
            print(count)
            count = 0
            start = 0
            break

#include <iostream>

using namespace std;
int n, cnt;

int main()
{   
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        int t = i;
        while (1)
        {
            if (t % 5 == 0)
            {
                t = (int)t / 5;
                cnt++;
            }
            else
                break;
        }       
    }
    cout << cnt << endl;    
}

package training;

import java.math.BigInteger;

public class GetFinalZeroCount {

    public static void main(String[] args) {
        BigInteger iR = getN2(25);
        char[] ch = String.valueOf(iR).toCharArray();
        int iZeroCnt = 0;

        // 문자열 역으로 돌면서 0이 없어질때까지 카운트
        for(int i=ch.length-1;0<=i;i--){
            if(ch[i] == '0'){
                iZeroCnt++;
            } else {
                break;
            }
        }
        System.out.println(iZeroCnt);
    }

    public static BigInteger getN2(int n) {
        BigInteger iR = BigInteger.valueOf(1);

        for(int i=1;i<=n;i++){
            iR = iR.multiply(BigInteger.valueOf(i));
        }
        return iR;
    }
}

__author__ = r'jkkim'

from functools import reduce
from operator import mul

'''
N!를 정수로 변환 해 뒤에서 부터 연속되는 0의 갯수를 구하세요.
f(12) = 479001600 -> 2
'''


def factorial(n):
    return reduce(mul, range(1, n + 1))


def main(num):
    string = str(num)

    res = 0
    print(string[::-1])
    for i in string[::-1]:
        if i != "0":
            return res
        else:
            res += 1


if __name__ == '__main__':
    print(main(factorial(25)))

package hellojava;

import java.util.*;

public class practice {
     static long factorial(int num){
        long result = 1;
        for(int i =1;i<=num;i++){
            result = result * i;
        }
        return result;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();  //129000
        String stringfac = Long.toString(factorial(num));

        System.out.println(stringfac);
        String [] arrayfac = stringfac.split("");

        if(arrayfac[arrayfac.length-1].equals("0")){
            int k = 0;
            for(int i = arrayfac.length-1;0<i;i--){
                if(arrayfac[i].equals("0")){k++;}
                else{
                    System.out.println(k);
                    break;
                }
            }
        }
        sc.close();

        }
    }

javascript

var f = function(n) {
    return n < 5 ? 0 : Math.floor(n / 5) + f(n / 5);
}

console.log(f(12));
console.log(f(25));

Python 3으로 풀었습니다.

숫자 맨뒤에 0이 올 수 있는 경우는 10의 배수입니다.

문제에 언급된 내용으로는 N!의 뒤쪽 0 개수를 세어야 합니다.

곱셈의 순서가 순차적이므로 10의 원소인 2와 5 중 5의 개수만 세면 됩니다.

math.log 함수를 이용하면 아래와 같이 1줄로 간단히 구현할 수 있습니다.

import math
def count_of_suffix_0(n, x=5):
    return sum(int(n / (x ** (i+1))) for i in range(int(math.log(n, x))))

from math import factorial


def count0(n):
    cnt = 0
    while n % 10 == 0:
        cnt += 1
        n //= 10

    return cnt


N = int(input("N = "))
print(count0(factorial(N)))

import math

n = int(input("any number : "))
fn = math.factorial(n)
sn = str(fn)

n = -1
count = 0

while True :
    if sn[n] == '0' :
        count += 1
        n -= 1
        continue

    else :
        break

print(count)

def f(n):
    result = 1
    for i in range(1,n+1):
        result *= i
    print(result)

    i = 0
    while result%10 == 0:
        result = result//10
        i += 1
    print(i)

f(12)
f(25)

import re
b=1
try :
    a=int(input ("팩토리얼 숫자를 입력하세요 : "))
except :
    print("숫자가 아닙니다.")
for i in range (a , 1 , -1) :
    b=int(b)*i
k=re.findall(r"\d(0+)$",str(b))
print((len(str(k[0]))))

namespace _20170907
{
    class Program
    {
        static void Main(string[] args)
        {
            string b = Console.ReadLine();
            int num = Convert.ToInt32(b);
            decimal  m = 1;
            for(int a = 1; a<=num; a++)
            {
                m *= a;
            }
            string s = m.ToString();
            int zero_count = 0;
            for (int i = s.Length-1; i>0; i--)
            {
                char ch = s[i];
                if (ch == '0')
                {
                    zero_count++;
                }
                else
                {
                    break;
                }
            }
            Console.WriteLine(zero_count);
        }
    }
}

public class Example74 {

    public static void main(String[] args) {
        Example74 ex = new Example74();

        int num = ex.factorial(10);
        int count = ex.increaseCounter(num);

        System.out.println(num + ":" + count);
    }

    private int factorial(int n) {
        if (n < 2)
            return n;
        else
            return factorial(n - 1) * n;
    }

    private int increaseCounter(int n) {

        StringBuilder sb = new StringBuilder(String.valueOf(n));

        int count = 0;
        for (char c : sb.reverse().toString().toCharArray()) {
            if (c == '0') {
                count++;
            } else {
                break;
            }
        }

        return count;
    }
}

# python 3.6
def factorial(val):
    if val == 0:
        return 1
    else:
        val = val * factorial(val - 1)
        return val


inp = 25
rst = list(str(factorial(inp)))
count = 0
while not int(rst.pop()):
    count += 1
print(count)
# ans for 25:
# 6

public static int f(int n) {
    return n > 1 ? n/5 + f(n/5) : 0;
}

def cntOfDivisor(num, base):
    tot = 0
    q = num
    while 1:
        q, r = divmod(q, base)
        if r:
            return tot
        else:
            tot += 1

n = int(input('input number: '))

mult2 = 0
mult5 = 0
for i in range(2, n+1):
    mult2 += cntOfDivisor(i, 2)
    mult5 += cntOfDivisor(i, 5)
print(min(mult2, mult5))

package codingdojang;

import java.util.Scanner;

public class ex74 {

public static long EE(long x) {

    if(x<=1) return x;
    return x*EE(x-1);
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner sc = new Scanner(System.in);
    long n = sc.nextLong(); sc.nextLine();

    System.out.println(EE(n));
    String a = Long.toString(EE(n));
    int count = 0;

    for(int i=a.length()-1; i>=0; i--) {
        if(a.charAt(i) == '0') {
            count++;
        }
        else {
            System.out.println(count);
            break;
        }
    }
}

}

const countZero = number => {
  return number < 5 ? 0 : Math.floor(number / 5) + countZero(number / 5);
};

def f(num):
    tmp=1
    count=0
    while num>1:
        tmp*=num
        num-=1
    tmp=list(str(tmp))
    while True:
        if not int(tmp[-1]):
            count+=1
            tmp=tmp[:-1]
        else: break
    return(count)

n=int(input())
print(f(n))

def factorial(n): 
    if n ==1 : return 1
    else :        
        return n * factorial(n-1)        

result ,i, cnt = str(factorial(25)), 0, 0
while True :
    i -= 1
    if result[i] =="0" : cnt +=1
    else : break 
print(cnt)

파이썬 3.6

def backcountzero(n):
    N, count = 1, 0
    for i in range(1,n+1): N *= i
    N_str = str(N)
    for i in N_str[::-1]:
        if i == '0': count += 1
        else: break
    print(count,  "# %d!은 %d"%(n,N))

if __name__ == "__main__":
    n = int(input("N = "))
    backcountzero(n)

• 결과값

N = 12
2 # 12!은 479001600

N = 25
6 # 25!은 15511210043330985984000000

import java.util.Scanner;

public class level_2_serial_zero_count {

public static void main(String[] args) {

    System.out.println("정수값을 입력하세요.");
    int factorial = 1;
    int count = 0; // 팩토리얼 자리수 저장.
    int countzero = 0;
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    sc.close();

    for(; n > 0; n--) // 팩토리얼 계산.
    {
        factorial = factorial * n;          
    }
    count = (int) Math.log10(factorial) + 1; // 자리수 계산.
    int[] array = new int[count]; // 자리수 만큼 배열 생성.

    for(int i = 0; i < count; i++) // 한자리수씩 배열에 집어넣음.
    {
        array[count - i - 1] = factorial % 10;
        factorial = factorial / 10;
    }

    for(int i = array.length; i > 0; i--) // 0의 갯수.
    {
        if(array[i-1] == 0)
        {
            countzero++;
        }
        else
        {
            break;
        }
    }
    System.out.println("뒤에서 부터 연속되는 0의 갯수 : " + countzero);
}

}

r로 풀었습니다.

f<-function(n){
  a<-0
  b<-0
  i<-1
  j<-1
  while(2**i<=n){
    a<-a+n%/%(2**i)
    i<-i+1
  }
  while(5**j<=n){
    b<-b+n%/%(5**j)
    j<-j+1
  }
  print(min(a,b))
}

f(12)
f(25)

  zero<-function(n){
    i<-1
    while((n%/%(5^i))>0){
      result<-c(result,n%/%(5**i))
      i<-i+1
    }
    print(sum(result)-1)
  }
zero(25)

# 파이썬


def factorial_zeroes(i):
    square = 0
    no_5 = 0
    while i > 5**square:
        square += 1
    for m in range(1, square+1):
        no_5 += i // 5**m
    return no_5


print(factorial_zeroes(12), factorial_zeroes(25))

def zeros(n):
    a = 0
    i = 1
    while 5**i <= n:
        a += n//5**i
        i += 1
    return a


print(zeros(int(input())))

def Factorial(n):
    result=1
    if n==0:
        return 1
    for num in range(1,n+1):
        result*=num
    return result


N=int(input("숫자를 입력하세요:"))
num=Factorial(N)
counter=0

for num in str(num)[::-1]:
    if num=='0':
        counter+=1
    else:
        print(counter)
        break

def countzero(n):
    nf = eval('*'.join([str(x) for x in range(1, n + 1)]))
    count = 0
    for a in str(nf)[::-1]:
        if a == '0':
            count = count + 1
        else: break
    return count

import java.util.Scanner;

public class zerO{
 public static void main (String[] args){
  Scanner sc = new Scanner(System.in);

  System.out.print("팩토리얼 N을 입력하시오.\nN= ");
  int n = sc.nextInt();
  int a =0 , b = 0, c;

  for(int i=0;i<n-1;i++){
   c = i+2;
   for(int j=0;j!=(-1);j++){
    if(c != 1 && c % 2 == 0){
     c = c/2;
     a++;
    }
    else if(c !=1 && c % 5 == 0){
     c = c/5;
     b++;
    }
    else
     break;
   }
  }

  if(a<=b)
  System.out.println("0의 갯수는" + a + "개");  
  else
  System.out.println("0의 갯수는" + b + "개"); 
 }
}

def f(num):
    result=1
    for i in range(1,num+1):
        result=result*i
    cnt=0
    while int(result) == result:
        result = result / 10
        cnt+=1
    return print("0의 개수는 : " ,cnt-1, "개",sep="")

def f(N):
    N = int(N)
    sum = 0
    while(N // 5 != 0):
        a = N // 5 
        sum = sum + a
        N = N // 5
    return sum

class Data {

int factorial(int n) {
    if (n == 0)
        return 1;
    else
        return n * factorial(n - 1);
}

int countZero(int n) {
    int num = factorial(n);
    String snum = String.valueOf(num);
    int cnt = 0;
    for (int i = snum.length() - 1; i > 0; i--) {
        if (snum.charAt(i) != '0') 
            break;
        if (snum.charAt(i) == '0') 
            cnt++;
    }
    return cnt;
}

public static void main(String[] args) {
    Data c = new Data();
    System.out.println(c.countZero(12));
}

}```{.java}

```

user_input = int(input())

def fact(n): # n is integer
    if n == 1:
        return 1
    else:
        return n * fact(n-1)

res = fact(user_input)
count = 0
for number in str(res)[::-1]:
    if number == '0':
        count += 1
    elif number != '0':
        print(count)
        break

Python

def factorial(n):
    if n > 1:
        return n * factorial(n-1)
    else:
        return 1


def func(n):
    cnt = 0
    for c in str(factorial(n))[::-1]:
        if c == "0":
            cnt += 1
        else:
            print(cnt)
            return


func(12)
func(25)

import sys
from functools import reduce
import re

r = len(re.split(r"[1-9]", str(reduce(lambda x, y: x*y, [x for x in range(1,int(sys.argv[1])+1)]))[::-1])[0])

print("{}".format(r))

import java.io.*;
import java.math.*;
import java.util.*;

public class Main{
    public static void main(String[] args) {
        BigInteger total=BigInteger.ONE;
        List<Character>list=new ArrayList<Character>();

        Scanner sc=new Scanner(System.in);
        System.out.println("팩토리얼 수 N을 입력하세요 : ");
        int count=sc.nextInt();

        for(int i=1;i<=count;i++) {
            total=total.multiply(BigInteger.valueOf(i));
        }

        System.out.println(total);

        StringBuilder sb=new StringBuilder(total.toString());

        sb.reverse();

        for(int i=0;i<sb.length();i++) {
            if(sb.charAt(i)=='0') {
                list.add(sb.charAt(i));
            }else {
                break;
            }
        }

        System.out.println("0의 개수 : "+list.size()+"개");
    }
}

파이썬 3.

def factor(a, b): #자연수a을 인수분해했을 때 b의 개수
    count = 0
    temp = a
    while True:
        if temp % b == 0:
            count += 1
            temp = temp / b
        else:
            return count

def zero_count(n):
    count_2 = 0
    count_5 = 0
    for i in range(1, n+1):
        count_2 += factor(i, 2)
        count_5 += factor(i, 5)
    return min(count_5, count_2)

print(zero_count(25))

다른 분들이 넘나 잘하셔서 저는 성능 테스트나...

def factory(n):
    if n == 1:
        return n
    return n * factory(n-1)

def countZero(N):
    count = 0
    for i in str(N)[::-1]:
        if i == '0':
            count += 1
        else:
            break
    return count

def isDiv5(n):
    if n and n%5 == 0:
        return 1 + isDiv5(n/5)
    else:
        return 0

def div5(N):
    count = 0
    for i in range(5, N+1):
        count += isDiv5(i)
    return count

def div55(N):
    count = 0
    for i in range(5, N+1, 5):
        count += isDiv5(i)
    return count

%timeit countZero(factory(1000))
490 µs ± 11.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit div5(1000)
186 µs ± 819 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

%timeit div55(1000)
73.4 µs ± 241 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

n = int(input())
cnt = 0
for i in range(5,n+1,5):
    while not i%5:
        i = i//5
        cnt += 1
print(cnt)

from math import factorial
def fac1(n):
     n,x,ans = list(reversed(list(str(factorial(n))))),0,0
     while True:
          if n[x] == '0':
               ans += 1
               x += 1
          else:
               break

     print(ans)

def f(n):

    a=[str(i) for i in range(1,n+1)]
    result=str(eval('*'.join(a)))
    count=-1
    res=0
    while True:
        if result[count] =='0':
            res +=1   
            count -=1
        else:
            print(n,'->',res, n,'!은',result)
            break
f(12)
f(25)

수학적인 알고리즘 보다 간단한 팁을 이용하였습니다.

숫자를 문자열로 변환후 역순으로 복사 (ex 479001600 --> 006100974)

다시 숫자로 변환하면 앞의 "0" 이 제거됩니다 (006100974 --. 6100974)

따라서 원 문자열의 자리수에서 "0"이 제거된 문자열의 자리수를 빼면 "0"의 개수가 구해집니다.

def factorial(n):
    m = 1
    for i in range(1, n + 1):
        m = m * i
    print(len(str(m)) - len(str(int(str(m)[::-1]))))

import math

n = int(input("Type in N: "))
number = math.factorial(n)
l = list(reversed(str(number)))

c = 1
i = 0
while i in range(0, len(l)):
    if l[i] == '0':
        j = i + 1
        if l[j] == '0':
            c += 1
            i = j
        else:
            break
    else:
        c = 0
print(c)

Type in N: 25 6

from itertools import takewhile

def nf(n):
    tot = 1
    for i in range(1,n+1):
        tot *= i

    return str(tot)

v = input('Enter Number!:')
r = nf(int(v))

l=list(takewhile(lambda x: x == '0', r[::-1] ))
print(len(l))
'''
count = 0
for z in range(len(r)-1,0,-1):
    if r[z] == '0':
        count += 1
    else:
        break

print(count)
'''

import java.util.Scanner; 

public class KimSanghyeop
{
    public static void main(String[] args)
    {
        int res= 1; 

        Scanner sc =new Scanner (System.in);
        System.out.println("숫자를 입력하세요 ");
        int num = sc.nextInt();
        int cnt =0;

        int temp=1;
        for(int f1=1;f1<=num;f1++)
        {
            res = res *f1;


            while(res%10 ==0)
            {
                cnt+=1;
                res = res /10;
            }

            res = res%1000;
        }

        System.out.println("영의 개수 : "+cnt);     
    }
}

def get_Zero_Factorial(number):
    res, tot = 1,0
    for i in range(1,number+1): res*=i
    for j in str(res):
        if j=="0":
            tot+=1
    return tot


a = int(input("숫자를 입력하세요!: "))
print(get_Zero_Factorial(a))

def factorial(N):
    if N == 1:
        return 1
    return N * factorial(N-1)

N = int(input())
lst_N = list(str(factorial(N)))
count = 0
for i in range(len(lst_N)-1, -1, -1):
    if lst_N[i] == '0':
        count +=1
    else:
        print(count)
        break

def f(num):
    factori = 1
    i = factori

    while i <= num:
        factori *= i
        i += 1

    return factori

numFact = int(input("Enter the factorial number: "))
numZero = 0

for s in str(f(numFact)):
    if s == '0':
        numZero += 1

print("f(%d) -> %d" % (numFact, numZero))

n = int(input("정수 입력 : "))
factorial = 1
for i in range(1, n + 1) :
    factorial *= i
f2str = ' '.join(str(factorial))
f2list = f2str.split()
f2list.reverse()
for zero, k in enumerate(f2list) :
    if k != '0' :
        print("f(%d) -> %d # %d!은 %d"%(n, zero, n, factorial))
        break

2, 5, 10으로 나누어 떨어지는 숫자의 곱이 0의 숫자를 결정함

곱의 크기를 줄인 다음에, str로 변환 후 0의 개수 세기

Python 3
def f(n):
  num_list = []
  for i in range(1, n+1):
    if ((i % 2==0) | (i % 5==0) | (i % 10==0)):
      num_list.append(i)

  mul = 1
  for i in num_list:
    mul = mul * i

  return(str(mul).count('0'))

while True:
    n=int(input("Input number: "))
    sum=0
    while n!=0:
        sum+=n//5
        n=n//5
    print(sum)

import java.util.Scanner;

public class practice {

    public static void main(String[] args) {

            Scanner sc = new Scanner(System.in);
            int n, cnt = 0, multi = 1; 
            n = sc.nextInt();
            while ( n/ Math.pow(5, multi) > 0 ){
                cnt += n/ Math.pow(5, multi); 
                ++multi; 
            }   
            System.out.println(cnt);       
    }
}

N!의 뒷자리 0의 개수를 구하기 위해서는 10이 몇번 곱해졌는지 보면 된다. 그런데 N!의 2의 지수는 5의 지수보다 항상 많기 때문에 5의 지수를 보는 것만으로 충분하다. 주어진 N에 대해 N보다 작은 수들중 5의 배수만 걸러서 곱한후 5의 지수값을 구하면 된다.

def lastOnes(n):
    t = 1
    for i in range(5, n+1, 5):
        t *= i
    k = 0
    while t%5 == 0:
        t = t//5
        k += 1
    return k

print(lastOnes(25))

def number(x):
    def fact(x):
        if x <= 0:
            return 1
        return x*fact(x-1) 
    c=0
    for i in str(fact(x))[::-1]:
        if i == '0':
            c += 1
        elif i != '0':
            break
    return fact(x),c

num = int(input("입력:"))
res = 1
for i in range(1,num+1):
    res *= i
res = str(res)
cnt = 1
for i in range(1,len(res)):
    if res[-1] == '0':
        if res[-1*i] == res[-1*(i+1)]:
            cnt += 1
        else:
            break

print("{} # {}!은 {}".format(cnt,num,res))

그냥 N보다 큰 5^i (i >= 1)의 배수의 개수 다 더해주면 됨요~

#include <iostream>
using namespace std;
int main()
{
    int N;
    int numOf5 = 0;
    cin >> N;

    for(int i = 5; i <= N; i*=5)
    {
        numOf5 += N / i;
    }


    cout << numOf5 << endl;
    return 0;
}

def jou(N,p):
    if N==0:
        return p   
    return jou(int(N/5),p+int(N/5))

print(jou(int(input()),0))

완전탐색법을 쓰려다가 어디선가 많이 본 문제 같아서 분석을 해 본 결과, 맨 뒤의 0의 갯수는 N계승의 2와5의 곱의 개수에 의하여 결정이 된다는 사실을 알아내었읍니다. 그리고 5가 2보다 크기 때문에 1~N까지의 수 중에는 반드시 2의배수가 5의 배수보다 더 많이 나오므로 결국 5가 곱해진 횟수만큼 뒤에 0이 생긴다는 사실을 알아내었읍니다. 덕분에 재귀함수의 길이 자체도 많이 간단화가 되었군요.12,25는 물론,999999999999999999999999999999999999999같은 엄청나게 큰 수의 경우에도 단숨에 결과가 나옵니다.^^

def f(n) :
    def fac(n) :
        result = 1
        for i in range(1, n+1) :
            result *= i
        return result
    i = 0
    while (fac(n) // 10**i) % 10 == 0 :
        i += 1
    return i

def pactor(n):
    if n==1:
        return n
    else:
        return n*pactor(n-1)
a=int(input("N 입력: "))
result=str(pactor(a))
print(result)
i=-1
while result[i]=='0':
    i=i-1
print(abs(i)-1)

def factorial(x):
    if x<2:
        return 1
    return x * factorial(x-1)
def prob():
    x = int(input('input data x : '))
    num = factorial(x)
    print(str(num).count('0'))

prob()

def f(x): countzero = 0 a = 1 for i in range(x): a = a * (i+1) print(a) b = str(a) for i in range(1, len(b)+1): if b[-i] != '0': break countzero += 1 return countzero

n = int(input("input your number : ")) print(f(n))

from math import factorial as fct
inp, cou = str(fct(int(input("input : ")))), 0
for k in range(1, len(inp)+1) :
    if inp[-k] == '0' :
        cou += 1
    elif inp[-k] != 0 :
        break
print(cou)

결과

input : 25

6

def factorial(data):
    sum = 1
    str_sum = ""
    count = 0
    for i in range(1,data+1):
        sum = sum * i
    str_sum = str(sum)
    print(str_sum)

    for j in range(len(str_sum)-1,0,-1):
        if str_sum[j] == '0':
            count += 1
        else:
            break
    print(count)

factorial(12)
factorial(25)

import java.util.*;
public class 뒤쪽0의갯수구하기 {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int a =1;
        int count = 0;
        for(int i=1; i<n+1; i++) {
            if(i%5==0) {
                a=a*i;
                for(int j=1; j<=i/5; j++) {
                    if(a%5==0) {
                        a=a/5;
                        count++;
                        if(a<5) {
                            break;
                        }
                }
                }
            }
        }   
        System.out.println("f("+n+") -> "+"0의 갯수는 : "+count);
    }
}

import java.util.*;
public class 뒤쪽0의갯수구하기 {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int a =1;
        int count = 0;
        for(int i=1; i<n+1; i++) {
                a=1;
                a=a*i;
                for(int j=1; j<=i/5; j++) {
                    if(a%5==0) {
                        a=a/5;
                        count++;
                        if(a<5) {
                            break;
                        }
                }
                    else {
                        break;
                    }
                }
        }   
        System.out.println("f("+n+") -> "+"0의 갯수는 : "+count);
    }
}

python 3

def factorial(num):
  i = 1
  for j in range(1, num+1):
    i = i*j
  return i

def count_zero(num):
  r = factorial(num)
  c = 0
  for s in str(r)[::-1]:
    if s == '0':
      c += 1 
    else:
      break
  return c

print(count_zero(12))
print(count_zero(25))

def factorial(n): #N!을 구하기
    if n==0 or n==1:
        return 1
    else:
        return n*factorial(n-1)

n=int(input("숫자를 입력하십시오: "))
count, i=0, 0
while i<len(str(factorial(n))):
    if str(factorial(n))[::-1][i]=="0":
        count+=1
    else:
        break
    i+=1
print(count)

파이썬 3입니다.

두 가지 방법으로 이 문제를 풀어봤습니다.

우선 입력을 받습니다

N = int(input())

--- 첫 번째 풀이 ---

이 풀이는 N!를 직접 구해서 0의 개수를 세는 방법입니다.

def fact(n):
    if n == 1:
        return 1
    return n * fact(n - 1)


print(len(str(fact(N))) - len(str(fact(N)).strip('0')))

--- 두 번째 풀이 ---

이 풀이는 N!에 곱해진 5의 개수를 세는 방법입니다. 뒷 자리의 0은 2와 5가 얼마나 곱해졌느냐에 따라 달라지는데, 임의의 N에 대해 N!의 2의 개수는 5의 개수보다 많으므로 5의 개수를 세면 뒤에 0이 얼마나 생기는지 알 수 있습니다.

count_five = 0
i = 1
while N // (5**i) != 0:
    count_five += N // (5**i)
    i += 1
print(count_five)

python3

num = 25


def exe(num):
    tmp = str(ft(num))
    lst = [i for i in tmp]

    cnt = 0
    for j in tmp[::-1]:
        if j == "0":
            cnt += 1
        else:
            break
    print(cnt)


exe(num)

Ninput = int(input())
N = 1
for i in range(1,Ninput+1):
    N *= i
strN = str(N)
lenN = len(strN)
finish = 0
while(lenN > 1):
    lenN -= 1
    if strN[lenN] != '0':
        break
    if strN[lenN] == '0':
        finish += 1
print(finish)

n=int(input())
print ('f('+str(n)+') -> ',end='')

fac=1
while(n>0):
fac=fac*n
n=n-1

fact=[]
fact=str(fac)

i=len(fact)

num=0
while (1):
i=i-1
if (fact[i]=='0'):
num=num+1
else:
break

print (num)

def fac(num):
    if num == 1:
        return 1
    else:
        return num * fac(num-1)

def main():
    num = 25
    cnt = 0
    f = fac(num)
    v = str(f)
    for i in range(len(v)-1, 0, -1):
        if v[i] == '0':
            cnt += 1
        else:
            break

    print('f({}) -> {} # {}!은 {}'.format(num, cnt, num, f))

if __name__ == '__main__':
    main()

def f(inp):
    out = 1
    zero = 0
    for i in range(int(inp)):
        out *= i + 1
    for i in range(out):
        if str(out)[len(str(out))-i-1] == '0':
            zero += 1
        else:
            break
    return zero, out
print(f(input()))

def fac(n):
    result = 1
    count = 0
    for i in range(n, 0, -1):
        result = result * i

    for j in range(1, len(str(result))):
        if str(result)[-j] == '0':
            count += 1
        else:
            break
    print(count)

fac(12)
fac(25)

def count_num_of_tailing_zeros(n):
    def find_power_5(x, count = 0):
        if x % 5 != 0: 
            return count
        else: 
            return find_power_5(int(x / 5), count + 1)
    return sum([find_power_5(5 * i) for i in range(1, int(n / 5) + 1)])

import math
N = int(input())
result = str(math.factorial(N))
print(result)

cnt = 0
for i in range(1,len(result)):
    if int(result[len(result)-i]) == 0:
        cnt += 1
    else:
        break
print(cnt)

def cnt_zero(n):
    n=abs(n)
    cnt_zero = 0
    while n:
        x,y = divmod(n,5)
        cnt_zero += x
        n=x    
    return cnt_zero

print(cnt_zero(n))

# ex )print(cnt_zero(12345678987654321)) =>3086419746913569

파이썬3입니다.

def f(n) :
    Fac = 1
    for x in range(1,n+1) :    
        Fac *= x
    count = 0
    for x in range(len(str(Fac))) :    
        if Fac % 10 == 0 :
            count += 1
            Fac //= 10
        else :
            break
    return count 

n = int(input())

print(f'{n}! has contiunous {f(n)} zero digit.')

package test;
import java.util.*;
import java.math.*;

public class Test{
    public static void main(String[] args) {
        int count = 0;
        BigInteger num = BigInteger.ONE;
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();

        for(int i = 1; i <= n; i++) {
            num = num.multiply(BigInteger.valueOf(i));
        }

        String str = num.toString();

        for(int i = str.length()-1; i > 0; i--) {
            if(str.charAt(i) == '0')
                count++;
            else {break;}
        }
        System.out.println(count);
        sc.close();
    }
}

import java.math.BigDecimal;
import java.util.*;

public class test11 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("수를 입력하시오 : ");
        int N = scanner.nextInt();
        int result = 0;

        BigDecimal X = BigDecimal.valueOf(N);

        System.out.println(N+"! : "+hatena(X));

        BigDecimal M = hatena(X);

        while(M.remainder(BigDecimal.TEN).equals(BigDecimal.ZERO)) {
            result++;
            M = M.divide(BigDecimal.TEN);
        }

        System.out.print("0의 갯수 :" + result);
    }

    public static BigDecimal hatena (BigDecimal input) {
        if(input.equals(BigDecimal.ONE)) return BigDecimal.ONE;
        else return hatena(input.subtract(BigDecimal.valueOf(1))).multiply(input);

    }
}

저어는 바보입니다

#include<stdio.h>

int main()
{
    int a,i,b;
    int N=1;
    int c=0;

    scanf("%d",&a);

    for(i=1;i<=a;i++)
        N=N*i;

    b=N;
    while(1)
    {
        if(N%10==0)
        {
            N=N/10;
            c++;
        }
        else    break;
    }

    printf("%d #%d!은 %d",c,a,b);
    return 0;
}

def factorial(n):
    result = n
    while n != 1:
        result *= n-1
        n -= 1
    for i in range(0,len(str(result))-1):
        if str(result)[::-1][i] == '0' and str(result)[::-1][i] != str(result)[::-1][i+1]:
            print(i+1)
            break
        if str(result)[::-1][i] != '0':
            print(0)
            break


factorial(12)
factorial(25)

package main;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = 0;
        num = sc.nextInt();
        long temp =1;
        int cnt = 0;
        for (int i = 1; i <= num; i++) {
            temp *= i;
        }
        System.out.println(temp);
        String str = temp+"";
        for (int i = 0; i < str.length()-1; i++) {
            if(str.charAt(i)=='0'&&str.charAt(i+1)=='0') {
                cnt++;
            }
        }
        System.out.println(cnt);
    }

}

def fac(number):

  answer=1

  for i in range(1,number+1,1):

    answer=answer*i

  return answer

def find_zero_inback(number):

  count=0

  strnumber=str(number)

  for i in range(-1,-len(str(number))-1,-1):

    if strnumber[i]=='0':

      count+=1

    elif strnumber[i]!='0':

      break

  return count

def main():

  q=int(input("write yout number :"))

  print(find_zero_inback(fac(q)))

main()

from math import factorial
import re

print(len(re.findall('0+',str(factorial(25)))[-1]))

def factorial_(number):
    N = number
    _factorial = 1
    while N > 1:
        _factorial = _factorial * N
        N = N - 1

    _remain = _factorial
    count = 0
    while _remain > 10:
        if _remain % 10 == 0:
            count += 1
            _remain = _remain // 10
        else:
            break

    return print(_factorial, count)

factorial_(25)

def count0(n):
    def f(n):
        if n == 1:
            return 1
        return n * f(n-1)
    result = f(n)

    count = 0
    for i in range(len(str(result))):
        if list(str(result))[-1-i] == '0':
            count += 1
        else:
            break
    return count

if __name__ == '__main__':
    n = int(input("Input Number : "))
    print(count0(n))

def f(num):
    a=1
    cnt = 1
    for i in range(1,num+1):
        a*=i
    print("%d!: %d"%(num,a))
    for i in range(1,len(str(a))):
        if str(a)[-i]==str(a)[-i-1]=='0':
            cnt+=1
        else:
            break
    print(cnt)

f(25)

def f(N):
    count = 1
    for i in range(1,N+1):
        count = count*i
    c = 1
    while 1:
        r = str(count)[::-1]
        if r[0]=='0' :
            if r[c-1]==r[c]:
                c+=1
            else :
                print(f'#{c}')
                break
        else : break


print(f(25))

from functools import reduce
n = int(input('1보다 큰 수:'))
numstr = str(reduce(lambda acc, cur: acc*cur, list(range(1,n+1)), 1))
print(min({numstr[::-1].find(str(k)) for k in list(range(1,10)) if str(k) in numstr}))

#N! 함수 구현하기

def f(N):
    n = 1
    result = 1
    while n < N:
        n += 1
        result *= n
    return result

def zero(N):
    list = [i for i in str(f(N))]
    Re = list[::-1]
    num = 0
    for i in range(len(Re)+1):
        if Re[i] == '0':
            num += 1
        else: break
    return print(num)

zero(12)

python 3.9.6입니다. 팩토리얼에서 5의 승수와 뒤쪽 0의 개수는 같다는 것과 로그함수를 이용했습니다. 소스 코드입니다.

# 뒤쪽 0의 개수 구하기
import math
print('N을 입력받으면 N!의 뒤쪽 0의 개수를 구합니다.')
n = int(input('정수 N을 입력하세요. '))
result = 0
for num in range(1, int(math.log(n, 5))+1): result += n // (5**num)
print(f'뒤쪽 0의 개수는 {result}개입니다.')

실행 결과입니다.

N을 입력받으면 N!의 뒤쪽 0의 개수를 구합니다.
정수 N을 입력하세요. 25
뒤쪽 0의 개수는 6개입니다.
N을 입력받으면 N!의 뒤쪽 0의 개수를 구합니다.
정수 N을 입력하세요. 12
뒤쪽 0의 개수는 2개입니다.

#codingdojing_count_last_zero

#1 계산한다음 뒤쪽부터 0의 개수 세기
#2 rstrip으로 오른쪽부터 0제거 하고 len으로 비교하기


def cntLastzero(n):

    a = str(eval('*'.join([str(x) for x in range(1,n+1)])))  #n!
    print(len(a) - len(a.rstrip('0')))

cntLastzero(12)
cntLastzero(25)

def Fac(x):
    fac =1
    for i in range(1, x+1):
        fac *= i
    return fac

n = int(input(""))
conlist = [x  for x in str(Fac(n))]
conlist.reverse()
print(conlist)
while True:
    count = 0
    for x in conlist :
        if x == "0":
            count += 1
            continue
        else :
            print(count)
            count = 0
            break
    break

def Factorial (a) :
    sum =1
    for i in range(1,a+1):
        sum *=i
    return sum

def Count_zero (n):
    sum = Factorial(n)
    a = str(sum)
    b = a.rstrip("0")

    return print(len(a)-len(b))

Count_zero(25)

어차피 우측 문자열의 '0'을 제거 한뒤 전/후의 문자열 길이의 차이를 이용해봤습니다

def n_factorial_zero(num) :
    n = 1
    count =0
    for i in range(2,num+1): n = n * i
    n= list(str(n))
    n.reverse()
    while n.pop(0) == '0': count+=1
    return count

_input = int(input())

print(n_factorial_zero(_input))

// Rust

// 5의 승수를 세어 답을 내는 프로그램입니다

fn factorial_zero(n:usize) -> usize {

assert!(n>=2);
let mut count = 0;
for i in 2..=n {
    let mut j = i;
    while j % 5 == 0 {
        j /= 5;
        count += 1;
    }
}
count

}

[test]

fn test() {

assert_eq!(factorial_zero(12), 2);
assert_eq!(factorial_zero(25), 6);

}

a=str(math.factorial(25))
count = 0
while a[-1] == '0':
    count +=1
    a = a[:-1]

print(count)

팩토리얼 값이 int형의 범주를 벗어나는 경우에는 값을 구하지 못하는 미숙한 코드입니다.

package org.javaturotials.ex;
import java.util.*;
import java.util.stream.Collectors;

public class test {
    public static void main(String[] args) {    
        int count=0;
        Scanner sc= new Scanner(System.in);
        int num =sc.nextInt();
        int sum=1;
        for(int i=1; i<=num; i++) {
            sum=i*sum;
        }
    String str = String.valueOf(sum);
    StringBuffer str2 = new StringBuffer(str);
    String str3 = str2.reverse().toString();
    String[] arr = str3.split("");
    for(int i=0; i<str3.length(); i++) {
    int t = Integer.valueOf(arr[i]);
    if(t==0){
        count++;
    }
    if(t!=0) {
        break;
    }
    }
    System.out.println("f(" +num +") -> " + count + " # " + num + "!은 " + sum);
    }
    }

def count0(a):
    pac=1
    for i in range(1,a+1):
        pac*=i
    list_pac=list(str(pac))
    cnt=0
    while list_pac.pop()=='0':
        cnt+=1
    return cnt

x=int(input('n은?'))
print(count0(x))

def fac(n): if n==1: return 1 return(fac(n-1))*n count=0 for i in str(fac(25))[::-1]: if i=='0': count+=1 else: break print(count)

def f(n):
    if n==1:
        return 1
    return(f(n-1))*n
count=0
for i in str(f(12))[::-1]:
    if i=='0':
        count+=1
    else:
        print(count)
        break

자바로 풀어봤습니다.

import java.util.Scanner;
import java.math.BigInteger;

public class countZero {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);

        // 입력 받기
        int N;
        while(true) {
            System.out.print("자연수 N을 입력하시오.:");
            N = scan.nextInt();

            if(N<1) {
                System.out.println("잘못입력하셨습니다.");
            }else {
                break;
            }
        }

        // bigInteger 클래스를 이용하여 factorial 계산
        BigInteger factorial = new BigInteger("1");

        for(int i=2; i<=N; i++) {
            factorial = factorial.multiply(BigInteger.valueOf(i));
        }

        // 뒷자리 0의 갯수 계산
        int countZero = 0;
        BigInteger ten = new BigInteger("10");
        BigInteger units;

        while(true) {
            units = factorial.remainder(ten);
            if(units.intValue()==0) {
                countZero++;
                factorial = factorial.divide(ten);
            }else {
                break;
            }       
        }

        // 결과 출력
        System.out.printf("뒤쪽 0의 갯수: %d", countZero);
    }
}

def f(N):
    n = 1
    for i in range(1,N+1):
        n = n * i
    count = 0
    for i in str(n)[::-1]:
        if i == '0':
            count += 1
        else:
            return count

def factorial(N):
    num_list = []
    a = 1

    for n in range(0, N):
        if N == 0:
            break

        else:
            num_list.append(N)

            N -= 1

    for i in num_list:
        a = a * i

    return a

def count_zero(N):                              #0의 갯수를 새는 함수
    zero = 0
    N_list = list(map(int, str(N)))

    for i in range(1, len(N_list)+1):
        if N_list[-i] == 0:
            zero += 1

        else:
            break

    return zero

print(count_zero(factorial(25)))

N = int(input('N!의 N ?: '))
cnt = 0
print('f({}) ->'.format(N), end=' ')
while N > 1:
    N = N//5
    cnt += N
print(cnt)