n!10 진수 의 끝에서 0의 숫자를 찾는 프로그램 또는 함수를 작성하십시오 . 여기서 n입력 숫자는 원하는 형식입니다.

n양의 정수인 것으로 가정 할 수 있으며 이는 n!또한 정수이기도합니다. 의 소수점 다음에 0이 없습니다 n!. 또한 프로그래밍 언어가 n및 의 값을 처리 할 수 ​​있다고 가정 할 수 있습니다 n!.

테스트 사례

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

이것은 코드 골프입니다. 표준 규칙이 적용됩니다. 바이트 단위의 가장 짧은 코드가 이깁니다.

제출물

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

# Language Name, N bytes

N제출물의 크기는 어디에 있습니까 ? 당신이 당신의 점수를 향상시킬 경우에, 당신은 할 수 있습니다 를 통해 눈에 띄는에 의해, 헤드 라인에 오래된 점수를 유지한다. 예를 들어 :

# Ruby, <s>104</s> <s>101</s> 96 bytes

헤더에 여러 숫자를 포함하려는 경우 (예 : 점수가 두 파일의 합계이거나 인터프리터 플래그 페널티를 별도로 나열하려는 경우) 실제 점수가 헤더 의 마지막 숫자 인지 확인하십시오 .

# Perl, 43 + 2 (-p flag) = 45 bytes

언어 이름을 링크로 만들어 리더 보드 스 니펫에 표시 될 수도 있습니다.

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

리더 보드

다음은 일반 리더 보드와 언어 별 수상자 개요를 생성하는 스택 스 니펫입니다.

/* Configuration */

var QUESTION_ID = 79762; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 43444; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

파이썬 2, 27 바이트

f=lambda n:n and n/5+f(n/5)

끝이 제로 (5)의 요소들에 의해 한정되는 배수의 수 5즉, 최대로되어 n있다 n/5(층으로 분할), 그러나 이것은 배수로 반복 인자를 계산하지 않는다 25, 125, .... 그것들을 얻으려면 n5로 나누고 재귀하십시오.

젤리 , 5 바이트

!Æfċ5

소인수를 구한 다음 다시 인수 분해하는 역효과적인 접근 방식을 사용하여 소인수 분해에서 지수 5를 확인합니다.

온라인으로 사용해보십시오!

!              Factorial
 Æf            List of prime factors, e.g. 120 -> [2, 2, 2, 3, 5]
   ċ5          Count number of 5s

모닝 턴 초승달, 1949 년 1909 바이트

Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Parsons Green
Take District Line to Cannon Street
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Turnham Green
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Turnham Green
Take District Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Blackfriars
Take Circle Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Blackfriars
Take District Line to Upminster
Take District Line to Temple
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Blackfriars
Take Circle Line to Hammersmith
Take District Line to Becontree
Take District Line to Cannon Street
Take District Line to Becontree
Take District Line to Cannon Street
Take District Line to Becontree
Take District Line to Blackfriars
Take Circle Line to Bank
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Angel
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

NieDzejkob 덕분에 -40 바이트

Pyth, 6 바이트

/P.!Q5

여기에서 시도하십시오.

/    5   Count 5's in
 P        the prime factorization of
  .!Q      the factorial of the input.

대체 7 바이트 :

st.u/N5

누적 은 반복이 반복 될 때까지 .u/N5반복적으로 층 나누기를 줄 5입니다.이 경우에는 0에 도달 한 후에 발생합니다.

34 -> [34, 6, 1, 0]

그런 다음 첫 번째 요소는 제거되고 ( t) 나머지는 합쳐집니다 ( s).

실제로 10 바이트

!$R;≈$l@l-

온라인으로 사용해보십시오!

math.factorialC 확장 (64 비트 정수로 제한됨)을 사용 하므로 CPython에서 심각하게 실행할 때 마지막 테스트 케이스가 실패합니다 . PyPy에서 심각하게 실행하면 정상적으로 작동합니다.

설명:

!$R;≈$l@l-
!           factorial of input
 $R         stringify, reverse
   ;≈$      make a copy, cast to int, then back to string (removes leading zeroes)
      l@l-  difference in lengths (the number of leading zeroes removed by the int conversion)

하스켈, 26 바이트

f 0=0
f n=(+)=<<f$div n 5

입력을로 나눈 5다음 결과를 호출 된 함수에 추가합니다. 식은 (+)=<<f입력을 x받아 출력 x+(f x)합니다.

단축 :

f 0=0
f n=div n 5+f(div n 5)

f 0=0
f n|k<-div n 5=k+f k

비 재귀 표현식은 28 바이트를 제공했습니다.

f n=sum[n`div`5^i|i<-[1..n]]

MATL , 9 바이트

:"@Yf5=vs

온라인으로 사용해보십시오!

계승 계산을 피하기 때문에 매우 많은 수의 경우 작동합니다.

다른 답변과 마찬가지로 이것은 2계승의 제수로 나타나는 횟수 가 나타나는 횟수 보다 크거나 같다는 사실을 이용합니다 5.

:     % Implicit input. Inclusive range from 1 to that
"     % For each
  @   %   Push that value
  Yf  %   Array of prime factors
  5=  %   True for 5, false otherwise
  v   %   Concatenate vertically all stack contents
  s   %   Sum

05AB1E, 5 바이트

n> 4를 보장 할 수 있다면 4 바이트가됩니다.

암호:

Î!Ó7è

설명:

Î        # push 0 then input
  !      # factorial of n: 10 -> 2628800
   Ó     # get primefactor exponents -> [8, 4, 2, 1]
    7è   # get list[7] (list is indexed as string) -> 2
         # implicit output of number of 5s or 0 if n < 5

훨씬 빠르고 빠른 6 바이트 솔루션 : Luis Mendo의 MATL 답변에서 영감을 얻음

LÒ€`5QO

설명:

L         # push range(1,n) inclusive, n=10 -> [1,2,3,4,5,6,7,8,9,10]
 Ò        # push prime factors of each number in list -> [[], [2], [3], [2, 2], [5], [2, 3], [7], [2, 2, 2], [3, 3], [2, 5]]
  €`      # flatten list of lists to list [2, 3, 2, 2, 5, 2, 3, 7, 2, 2, 2, 3, 3, 2, 5]
    5Q    # and compare each number to 5 -> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
      O   # sum -> 2

편집 : 5를 포함하는 모든 소수는 5로 계산되므로 ¢ (카운트)를 사용하여 제거 된 솔루션 은 53으로 계산됩니다.

편집 2 : 더 높은 입력을위한보다 효율적인 솔루션을 추가했습니다.

MATLAB (59) (54)(39)

dawg !!!! 우리는 당신이 수학을 좋아한다고 들었습니다 ....

  @(n)sum(fix(n./5.^(1:fix(log(n)/1.6))))

• 이것은 코드 검토에서 작성한 답변을 기반으로 합니다.

• 코드 검토에서 내 대답에 언급 된 것보다 factorial (n)의 0 수에 대한 공식은 Sum (n / (5 ^ k))이며 여기서 k는 1과 log_5 (n) 사이에서 다릅니다.

• 골퍼를 얻을 수없는 유일한 사소한 이유 log5는 matlab에서 내장으로 사용할 수 없기 때문에 log (5)를 1.6으로 대체했기 때문에 어쨌든 바닥이기 때문에 중요하지 않습니다.

시도 해봐

Mathematica, 20 바이트

IntegerExponent[#!]&

IntegerExponent0을 센다. 재미를 위해 계승을 계산하지 않는 버전이 있습니다.

Tr[#~IntegerExponent~5&~Array~#]&

C, 28 바이트

f(n){return(n/=5)?n+f(n):n;}

설명

후행 0의 수는 계승을 구성하는 5의 수와 같습니다. 전체 1..n중 5 분의 1이 5를 기여하므로로 시작합니다 n/5. 이 중 n/55 분의 1은 25의 배수이므로 5 분의 1을 더 기부하십시오. 우리와 끝까지 f(n) = n/5 + n/25 + n/125 + ...이다, f(n) = n/5 + f(n/5). n0에 도달하면 재귀를 종료해야 합니다. 또한 우리는 시퀀스 포인트를 이용 하여 추가하기 전에 ?:나눕니다 n.

보너스 로이 코드는 각각을 방문하는 것보다 훨씬 빠릅니다 1..n(계승을 계산하는 것보다 훨씬 빠릅니다).

테스트 프로그램

#include<stdio.h>
#include<stdlib.h>
int main(int argc, char **argv) {
    while(*++argv) {
        int i = atoi(*argv);
        printf("%d: %d\n",i,f(i));
    }
}

테스트 출력

1 : 1
4 : 1
5 : 1
24 4
25 6
124 28
125 31
666 165
2016 502
2147483644 : 536,870,901
2,147,483,647 : 536,870,902

자바 스크립트 ES6, 20 바이트

f=x=>x&&x/5+f(x/5)|0

xnor의 답변과 같은 전술이지만 더 짧습니다.

줄리아, 34 31 30 바이트

n->find(digits(prod(1:n)))[]-1

이것은 부호있는 정수 유형을 허용하고 정수를 리턴하는 익명 함수입니다. 호출하려면 변수에 지정하십시오. 더 큰 테스트 사례는와 n같은 더 큰 유형으로 전달해야 합니다 BigInt.

우리는 계승을 계산하고 n(수동으로 prod내장보다 짧음 factorial), 배열을 digits역순으로 배열하고 find, 0이 아닌 요소의 인덱스를 얻고, 첫 번째 인덱스를 빼고 1을 뺍니다.

온라인으로 사용해보십시오! (마지막 테스트 시간이 너무 오래 걸리기 때문에 마지막 테스트 케이스를 제외한 모든 것을 포함)

Dennis 덕분에 바이트를 절약했습니다!

C, 36

r;f(n){for(r=0;n/=5;)r+=n;return r;}

5를 세는 @xnor의 답변 과 같은 방법 이지만 재귀 대신 간단한 for 루프를 사용합니다.

Ideone .

레티 나 , 33 바이트

단항으로 입력합니다.

단항으로 출력을 반환합니다.

+`^ (? = 1) (1 {5}) * 1 *
$ # 1 $ * 1; $ # 1 $ *
;

(마지막 줄 바꿈에 유의하십시오.)

온라인으로 사용해보십시오!

작동 방식 :

첫 단계 :

+`^(?=1)(1{5})*1*
$#1$*1;$#1$*

약간 골퍼되지 않음 :

+`^(?=1)(11111)*1*\b
$#1$*1;$#1$*1

그것이하는 일 :

• 먼저 11111일치시킬 수있는 가장 큰 수를 찾으십시오 .
• 해당 번호로 교체
• 로 층을 효과적으로 나눕니다 5.
• 미리보기 (?=1)는 숫자가 양수임을 보증합니다.
• 이 +`방법은 until 등원까지 반복된다.
• 첫 번째 단계는 "반복 된 층 나누기 5"입니다.

입력이 100 (단항)이면 텍스트는 다음과 같습니다.

;;1111;11111111111111111111

두 번째 단계:

;

모든 세미콜론을 제거하십시오.

루비, 22 바이트

루비 0가 진실한 몇 안되는 시간 중 하나는 바이트 수의 문제입니다.

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

펄 6 , 23 바이트

{[+] -$_,$_,*div 5…0}
{sum -$_,$_,*div 5...0}

Perl 6^... 에 추가 되면 더 짧아 질 수 있습니다 . 시퀀스 생성기와 사이 에 수정자를 추가 한 경우 더 큰 숫자에 대해 메모리 효율성이 높아야합니다 . {sum $_,*div 5^...0}
lazysum

설명:

{ # implicitly uses $_ as its parameter
  sum

    # produce a sequence
    -$_,     # negate the next value
     $_,     # start of the sequence

     * div 5 # Whatever lambda that floor divides its input by 5

             # the input being the previous value in the sequence,
             # and the result gets appended to the sequence

     ...     # continue to do that until:

     0       # it reaches 0
}

테스트:

#! /usr/bin/env perl6

use v6.c;
use Test;

my @test = (
     1,   0,
     5,   1,
   100,  24,
   666, 165,
  2016, 502,
  1234567891011121314151617181920,
        308641972752780328537904295461,

  # [*] 5 xx 100
  7888609052210118054117285652827862296732064351090230047702789306640625,
        1972152263052529513529321413206965574183016087772557511925697326660156,
);

plan @test / 2;

# make it a postfix operator, because why not
my &postfix:<!0> = {[+] -$_,$_,*div 5...0}

for @test -> $input, $expected {
  is $input!0, $expected, "$input => $expected"
}

diag "runs in {now - INIT now} seconds"

1..7
ok 1 - 1 => 0
ok 2 - 5 => 1
ok 3 - 100 => 24
ok 4 - 666 => 165
ok 5 - 2016 => 502
ok 6 - 1234567891011121314151617181920 => 308641972752780328537904295461
ok 7 - 7888609052210118054117285652827862296732064351090230047702789306640625 => 1972152263052529513529321413206965574183016087772557511925697326660156
# runs in 0.0252692 seconds

(그 마지막 줄에 약간 오해의 소지가 MoarVM 시작하는 등, 펄 6 컴파일러와 런타임을로드하는 코드를 컴파일하고 실행합니다. 실제로 두 번째 총에 반 정도 걸립니다 그래서입니다.
즉, 그보다 훨씬 더 빨리 여전히 WolframAlpha.com으로 마지막 테스트 결과를 확인하는 것이 었습니다)

Mathcad, [tbd] 바이트

Mathcad는 표현식, 텍스트 및 플롯의 2D 입력을 허용하는 일종의 수학 "화이트 보드"입니다. 합산, 미분 및 적분과 같은 많은 연산에 수학 기호를 사용합니다. 프로그래밍 연산자는 특수 기호로, 일반적으로 표준 키에서 단일 키보드 조합의 제어 및 / 또는 Shift로 입력됩니다.

위에서 본 것은 Mathcad 워크 시트가 입력되고 Mathcad가 평가할 때의 모양과 정확히 같습니다. 예를 들어, n을 2016에서 다른 값으로 변경하면 Mathcad가 결과를 502에서 새 값으로 업데이트합니다.

http://www.ptc.com/engineering-math-software/mathcad/free-download

Mathcad의 바이트 당량 스코어링 방법은 아직 결정되지 않았습니다. 기호 상당을 취하면 약 24 "바이트"가 소요됩니다 (반면 연산자는 "ctl-]"키 조합 (또는 도구 모음)을 통해서만 입력 할 수 있음). Agawa001의 Matlab 방법은 Mathcad로 변환 될 때 약 37 바이트를 사용합니다 (합산 연산자는 ctl-shft- $로 입력).

dc, 12 바이트

[5/dd0<f+]sf

이것은 f스택 맨 위에서 입력을 소비하고 스택 맨 위에 출력을 남기는 함수 를 정의합니다 . 수학적으로 내 C 답변 을 참조하십시오 . 반복적으로 5로 나누고 스택의 값을 누적 한 다음 모든 결과를 추가합니다.

5/d   # divide by 5, and leave a copy behind
d0<   # still greater than zero?
f+    # if so, apply f to the new value and add

테스트 프로그램

# read input values
?
# print prefix
[  # for each value
    # print prefix
    [> ]ndn[ ==> ]n
    # call f(n)
    lfx
    # print suffix
    n[  
]n
    # repeat for each value on stack
    z0<t
]
# define and run test function 't'
dstx

테스트 출력

./79762.dc <<<'1234567891011121314151617181920 2016 666 125 124 25 24 5 4 1'

1 ==> 0  
4 ==> 0  
5 ==> 1  
24 ==> 4  
25 ==> 6  
124 ==> 28  
125 ==> 31  
666 ==> 165  
2016 ==> 502  
1234567891011121314151617181920 ==> 308641972752780328537904295461  

줄프, 13 바이트

Ώmf?H+γ/H5ΏγH

입력에서 호출되는 재귀 함수를 정의합니다. 여기 사용해보십시오!

Ώmf?H+γ/H5ΏγH  Ώ(H) = floor(H ? (γ = H/5) + Ώ(γ) : H)
Ώ              Ώ(H) =
       /H5                           H/5
      γ                         (γ =    )
     +    Ώγ                              + Ώ(γ)
   ?H       H               H ?                  : H
 mf                   floor(                        )
               // called implicitly with input

J, 28 17 16 바이트

<.@+/@(%5^>:@i.)

xnor의 답변에서 비 재귀 기술과 거의 동일합니다.

여기에 개인적으로 더 좋아하기 때문에 28 바이트로 클럭킹하기 때문에 여기에 보관 한 이전 버전이 있습니다.

+/@>@{:@(0<;._1@,'0'&=@":@!)

필요하지 않지만, x:정밀성을 높이기 위해 테스트 케이스에 포함 시켰 습니다.

   tf0 =: +/@>@{:@(0<;._1@,'0'&=@":@!@x:)
   tf0 5
1
   tf0 100
24

   tf0g =: tf0"0
   tf0g 1 5 100 666 2016
0 1 24 165 502

마지막 숫자는이 기능으로 작동하지 않습니다.

설명

이것은을 계산 n!하고 문자열로 변환 한 다음 각 멤버가와 같은지 확인하여 작동 '0'합니다. 의 n = 15경우이 프로세스는 다음과 같습니다.

15
15! => 1307674368000
": 1307674368000 => '1307674368000'
'0' = '1307674368000' => 0 0 1 0 0 0 0 0 0 0 1 1 1

이제 ;._1첫 번째 요소 (0)로 목록을 분할하고 각 분할 결과를 복싱하여 aces ( a:) 또는 1s로 채워진 상자를 생성합니다 .

┌┬─┬┬┬┬┬┬┬─────┐
││1│││││││1 1 1│
└┴─┴┴┴┴┴┴┴─────┘

마지막 멤버 ( {:)를 가져 와서 개봉 ( >)하고 그에 대한 합산을 수행하여 +/0의 수를 산출합니다.

더 읽기 쉬운 버전은 다음과 같습니다.

split =: <;._1@,
tostr =: ":
is =: =
last =: {:
unbox =: >
sum =: +/
precision =: x:
n =: 15

NB. the function itself
tf0 =: sum unbox last 0 split '0' is tostr ! precision n
tf0 =: sum @ unbox @ last @ (0 split '0'&is @ tostr @ ! @ precision)
tf0 =: +/ @ > @ {: @ (0 <;._1@, '0'&= @ ": @ ! )

파이썬 3, 52 바이트

g=lambda x,y=1,z=0:z-x if y>x else g(x,y*5,z+x//y)

파이크, 5 바이트

SBP5/

여기 사용해보십시오!

S     -    range(1,input()+1)
 B    -   product(^)
  P   -  prime_factors(^)
   5/ - count(^, 5)

RETURN , 17 바이트

[$[5÷\%$F+][]?]=F

Try it here.

재귀 연산자 람다. 용법:

[$[5÷\%$F+][]?]=F666F

설명

[             ]=F  Lambda -> Operator F
 $                 Check if top of stack is truthy
  [       ][]?     Conditional
   5÷\%$F+         If so, do x/5+F(x/5)

Perl, 24 22 + 1 ( -p플래그) = 23 바이트

$\+=$_=$_/5|0while$_}{

사용 :

> echo 2016 | perl -pe '$\+=$_=$_/5|0while$_}{'

전체 프로그램 :

while (<>) {
# code above added by -p
    while ($_) {
        $\ += $_ = int($_ / 5);
    }
} {
# code below added by -p
    print;  # prints $_ (undef here) and $\
}

자바, 38 바이트

int z(int n){return n>0?n/5+z(n/5):0;}

풀링되지 않은 방법으로 전체 프로그램 :

import java.util.Scanner;

public class Q79762{
    int zero_ungolfed(int number){
        if(number == 0){
            return 0;
        }
        return number/5 + zero_ungolfed(number/5);
    }
    int z(int n){return n>0?n/5+z(n/5):0;}
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.close();
        System.out.println(new Q79762().zero_ungolfed(n));
        System.out.println(new Q79762().z(n));
    }
}

J, 7 바이트

오른쪽에 인수를 취하는 모나 딕 함수.

3{:@q:!

경우 x긍정적, x q: y의 소인수 분해의 지수를 반환 y첫 번째를 들어, x소수. - 3소수는 5이며 {:목록의 꼬리를 갖습니다 .

x끝에 끝에 정수를 입력해야합니다. 그렇지 않으면 J가 정수로 처리합니다.

   3{:@q:! 100x
24
   3{:@q:! 666x
165
   3{:@q:! 2016x
502

tryj.tk 에서 직접 사용해보십시오 . 1343보다 큰 것을 시도하면이 온라인 통역사가 불만을 표명합니다.

n을 계산하지 않는 것을 원한다면 ! 따라서 정수에 맞을 필요가 없으므로 재귀 솔루션을 사용하십시오 <.@%&5(+$:@)^:*. (tryj.tk는 여전히 큰 입력에서 무시됩니다.)

루비, 70 61 51 49 바이트

Kenny Lau 및 daniero 덕분에 버전 3

->n{(n-n.to_s(5).chars.map(&:to_i).reduce(:+))/4}

편집 : 당신 밝혀 매핑에 의해 2 바이트를 저장할 수 있습니다 to_i 전에 당신 reduce. 이상한 : P

이 함수는 n기본 5 자리의 합을 빼고 n그 결과를 4로 나눕니다. 이것은 기하학적 시리즈의 합과 관련이 1+5+25+..+5**n = (5**n+1)/4있습니다.

예를 들어 (다시, 케니 라우 덕분에), 고려 358( 2413뺀 기본 5 자리 기본 5).

2413-2-4-1-3 
= (2000-2) + (400-4) + (10-1) + (3-3)
# consider that 1000-1=444 and you'll see why every 5**n is multiplied by 4
= 2*444 + 4*44 + 1*4 + 3*0
= 2*(4*5**0+4*5**1+4*5**2) + 4*(4*5**0+4*5**1) + 1*(4*5**0) + 3*()
= 348

분할 348에 의해 4당신이 얻을 f(358) = 87.

Kenny Lau 덕분에 버전 2

->n{s=(1..n).reduce(:*).to_s;s.size-s.reverse.to_i.to_s.size}

이 기능은 계산 n!후 감산 size의를 n!로부터 size의 (n!).reverse.to_i.to_s복귀, 따라서 모든 제로를 제거하는 size제로 자체를.

버전 1

->n{s=n.to_s(5).chars;(0...s.size).reduce{|a,b|a+(s[0,b]*'').to_i(5)}}

의 이것을 변화 "얼마나 많은 5들의 소인수 분해에있다 n!?" Ruby의 간단한 기본 변환 내장을 사용하는 트릭.

골프를 가진 변환은, 비록 약간의 통증이다 Integer행 String까지 Array의 부분을 잡고 Array, 그 변환을 String행 Integer다시 reduce. 모든 골프 제안은 환영합니다.

줄리아, 21 19 바이트

!n=n<5?0:!(n÷=5)+n

xnor 's answer 의 재귀 수식을 사용합니다 .

온라인으로 사용해보십시오!

Dyalog APL , 9 바이트

⊥⍨'0'=⍕!⎕

⎕ 번호를 묻다

! 계승하다

⍕ 끈으로 묶다

'0'= 문자 0과 같은지 확인

⊥⍨ 후행 사실 수를 계산 *

* 부울리스트를 숫자와 밑수로 사용하여 문자를 10 진수로 변환 한 것입니다.

⊥⍨0 1 0 1 1것과 동일 0 1 0 1 1⊥⍨0 1 0 1 1하다 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1)다시 두 (후행 1의 개수)이다.