Escreva um programa ou função que encontre o número de zeros no final da n!base 10, onde nestá um número de entrada (em qualquer formato desejado).

Pode-se assumir que né um número inteiro positivo, o que significa que n!também é um número inteiro. Não há zeros após um ponto decimal em n!. Além disso, pode-se supor que sua linguagem de programação possa lidar com o valor de ne n!.

Casos de teste

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

Isso é código de golfe. Aplicam-se regras padrão. O código mais curto em bytes vence.

Submissões

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

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

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

/* 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>

Python 2, 27 bytes

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

Os zeros finais são limitados por fatores de 5. O número de múltiplos 5que é no máximo né n/5(com divisão de piso), mas isso não conta os fatores repetidos em múltiplos de 25, 125, .... Para obtê-los, divida npor 5 e recorra.

Gelatina , 5 bytes

!Æfċ5

Utiliza a abordagem contraproducente de encontrar o fatorial e depois fatorá-lo novamente, verificando o expoente de 5 na fatoração primária.

Experimente online!

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

Mornington Crescent, 1949 1909 bytes

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

-40 bytes graças a NieDzejkob

Pitão, 6 bytes

/P.!Q5

Experimente aqui.

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

Alternativa de 7 bytes :

st.u/N5

A redução cumulativa .u/N5divide repetidamente o piso 5até obter uma repetição, o que nesse caso acontece depois de atingir 0.

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

O primeiro elemento é então removido ( t) e o restante é somado ( s).

Na verdade, 10 bytes

!$R;≈$l@l-

Experimente online!

Observe que o último caso de teste falha ao executar Seriamente no CPython porque math.factorialusa uma extensão C (que é limitada a números inteiros de 64 bits). Rodar seriamente no PyPy funciona bem, no entanto.

Explicação:

!$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)

Haskell, 26 bytes

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

O piso divide a entrada por 5e adiciona o resultado à função chamada. A expressão(+)=<<f recebe uma entrada xe saídas x+(f x).

Encurtado de:

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

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

Uma expressão não recursiva forneceu 28 bytes:

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

MATL , 9 bytes

:"@Yf5=vs

Experimente online!

Isso funciona para números muito grandes, pois evita a computação do fatorial.

Como outras respostas, isso explora o fato de que o número de vezes que 2aparece como divisor do fatorial é maior ou igual ao número de vezes que 5aparece.

:     % 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 bytes

Seriam 4 bytes se pudéssemos garantir n> 4

Código:

Î!Ó7è

Explicação:

Î        # 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

Solução alternativa, muito mais rápida, de 6 bytes: inspirada na resposta MATL de Luis Mendo

LÒ€`5QO

Explicação:

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

Editar: soluções removidas usando ¢ (contagem), como todos os números primos contendo 5 seriam contados como 5, por exemplo, 53.

Edit 2: adicionada uma solução mais eficiente para maior entrada como comparação.

Matlab (59) (54)(39)

Hey dawg !!!! nós ouvimos você gostar de matemática ....

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

• Isso se baseia na minha resposta criada na revisão de código .

• além do que é mencionado na minha resposta na revisão de código, a fórmula para o número de zeros no fatorial (n) é Soma (n / (5 ^ k)), onde k varia entre 1 e log_5 (n)

• A única razão trivial pela qual ele não pode ficar mais golfista é que ele não está log5disponível no matlab como um componente interno; portanto, substituí o log (5) por 1.6, não importa, porque ele ficará de qualquer maneira.

De uma chance

Mathematica, 20 bytes

IntegerExponent[#!]&

IntegerExponentconta os zeros. Por diversão, aqui está uma versão que não calcula o fatorial:

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

C, 28 bytes

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

Explicação

O número de zeros à direita é igual ao número de cinco que compõem o fatorial. De todos 1..n, um quinto deles contribui com cinco, então começamos com n/5. Destes n/5, um quinto são múltiplos de 25, portanto, contribuem com mais cinco, e assim por diante. Terminamos com o f(n) = n/5 + n/25 + n/125 + ...que é f(n) = n/5 + f(n/5). Precisamos terminar a recursão quando natingir zero; também aproveitamos o ponto de sequência em ?:para dividir nantes da adição.

Como bônus, esse código é muito mais rápido do que aquele que visita cada 1..n (e muito, muito mais rápido que calcular o fatorial).

Programa de teste

#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));
    }
}

Saída de teste

1: 0
4: 0
5: 1
24: 4
25: 6
124: 28
125: 31
666: 165
2016: 502
2147483644: 536870901
2147483647: 536870902

JavaScript ES6, 20 bytes

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

A mesma tática da resposta do xnor, mas mais curta.

Julia, 34 31 30 bytes

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

Esta é uma função anônima que aceita qualquer tipo de número inteiro assinado e retorna um número inteiro. Para chamá-lo, atribua-o a uma variável. Os casos de teste maiores requerem aprovação ncomo um tipo maior, como a BigInt.

Calculamos o fatorial de n(usar manualmente prodé mais curto que o interno factorial), obtemos uma matriz dele digitsem ordem inversa, findos índices dos elementos diferentes de zero, obtemos o primeiro desses índices e subtraímos 1.

Experimente online!(inclui todos, exceto o último caso de teste, porque o último leva muito tempo)

Guardado um byte graças a Dennis!

C, 36

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

O mesmo método da resposta do @ xnor de contar 5s, mas apenas usando um loop for simples em vez de recursão.

Ideone .

Retina , 33 bytes

Recebe entrada em unário.

Retorna a saída em unário.

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

(Observe o avanço da linha à direita.)

Experimente online!

Como funciona:

O primeiro estágio:

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

Ligeiramente não destruído:

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

O que faz:

• Primeiro, encontre o maior número 11111possível disso.
• Substitua por esse número
• Efetivamente divide o chão por 5.
• O lookahead (?=1)garante que o número é positivo.
• Os +`meios se repetem até serem idempotentes.
• Então, o primeiro estágio é "divisão repetida do piso por 5"

Se a entrada for 100 (em unário), o texto será agora:

;;1111;11111111111111111111

Segundo estágio:

;

Apenas remove todos os pontos e vírgulas.

Ruby, 22 bytes

Uma das poucas vezes em que o Ruby 0realmente é um problema para a contagem de bytes.

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

Perl 6 , 23 bytes

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

Eu poderia diminuí-lo se ^...fosse adicionado ao Perl 6 {sum $_,*div 5^...0} .
Deveria ser mais eficiente em memória para números maiores se você incluísse um lazymodificador entre sume o gerador de sequência.

Explicação:

{ # 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
}

Teste:

#! /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

(Essa última linha é um pouco enganadora, pois o MoarVM precisa iniciar, carregar o compilador e o tempo de execução do Perl 6, compilar o código e executá-lo. Portanto, na verdade, leva cerca de um segundo e meio no total.
Isso ainda é significativamente mais rápido do que ele foi verificar o resultado do último teste com WolframAlpha.com)

Mathcad, [tbd] bytes

O Mathcad é uma espécie de "quadro branco" matemático que permite a entrada em 2D de expressões, texto e gráficos. Ele usa símbolos matemáticos para muitas operações, como soma, diferenciação e integração. Os operadores de programação são símbolos especiais, geralmente inseridos como combinações de teclado único de controle e / ou deslocamento em uma tecla padrão.

O que você vê acima é exatamente a aparência da planilha do Mathcad à medida que é digitada e como o Mathcad avalia. Por exemplo, alterar n de 2016 para qualquer outro valor fará com que o Mathcad atualize o resultado de 502 para o novo valor.

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

O método de pontuação de equivalência de bytes do Mathcad ainda não foi determinado. Tomando uma equivalência de símbolo, a solução leva cerca de 24 "bytes" (o operador while só pode ser inserido usando a combinação de teclas "ctl-]" (ou em uma barra de ferramentas)). O método Matlab do Agawa001 leva cerca de 37 bytes quando traduzido para o Mathcad (o operador de soma é inserido por ctl-shft- $).

dc, 12 bytes

[5/dd0<f+]sf

Isso define uma função fque consome sua entrada do topo da pilha e deixa sua saída no topo da pilha. Vejo minha resposta C para a base matemática. Dividimos repetidamente por 5, acumulando os valores na pilha e adicionamos todos os resultados:

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

Programa de teste

# 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

Saída de teste

./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  

Jolf, 13 bytes

Ώmf?H+γ/H5ΏγH

Define uma função recursiva que é chamada na entrada. Experimente aqui!

Ώ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 bytes

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

Praticamente o mesmo que a técnica não recursiva da resposta do xnor.

Aqui está uma versão mais antiga que eu mantive aqui, porque eu pessoalmente gosto mais, com 28 bytes:

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

Embora não seja necessário, incluí x:nos casos de teste uma precisão estendida.

   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

O último número não funciona com esta função.

Explicação

Isso funciona calculando n!, convertendo-o em uma sequência e verificando a igualdade de cada membro com '0'. Pois n = 15, esse processo seria:

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

Agora, usamos ;._1para dividir a lista em seu primeiro elemento (zero), encaixotando cada resultado da divisão, produzindo uma caixa cheia de ases ( a:) ou execuções de 1s, da seguinte forma:

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

Simplesmente obtemos o último membro ( {:), unbox-lo ( >) e fazemos um somatório sobre ele+/ , produzindo o número de zeros.

Aqui está a versão mais legível:

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'&= @ ": @ ! )

Python 3, 52 bytes

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

Pyke, 5 bytes

SBP5/

Experimente aqui!

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

RETURN , 17 bytes

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

Try it here.

Operador recursivo lambda. Uso:

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

Explicação

[             ]=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 ( -psinalizador) = 23 bytes

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

Usando:

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

Programa completo:

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

Java, 38 bytes

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

Programa completo, com método não destruído:

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 bytes

Função monádica, tendo argumento à direita.

3{:@q:!

Se xfor positivo, x q: yretorna os expoentes em uma fatoração primária de y, apenas para os primeiros xprimos. O 3-rd primo é 5 e{: leva o final de uma lista.

Observe que você precisa inserir números inteiros com um xno final, caso contrário, J os tratará como flutuadores.

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

Experimente você mesmo em tryj.tk , mas que esse intérprete on-line irá reclamar se você tentar algo maior que 1343.

Se você quer algo que não computa n ! e, portanto, não exige que ele se ajuste a um número inteiro, use a solução recursiva <.@%&5(+$:@)^:*. (tryj.tk ainda é choroso em entradas grandes.)

Ruby, 70 61 51 49 bytes

Versão 3 com agradecimentos a Kenny Lau e daniero

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

Edit: Acontece que você pode salvar dois bytes por mapeamento to_i antes de vocêreduce . Estranho: P

Essa função subtrai a soma dos n5 dígitos da base ne depois divide o resultado por 4. Isso está relacionado à soma das séries geométricas1+5+25+..+5**n = (5**n+1)/4 .

Como exemplo (novamente, com agradecimentos a Kenny Lau), considere 358( 2413na base 5) menos seus 5 dígitos base.

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

Divida 348por 4e você começa f(358) = 87.

Versão 2 com agradecimentos a Kenny Lau

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

Esta função calcula n!em seguida, subtrai o sizede n!da sizeda (n!).reverse.to_i.to_s, que remove todos os zeros, assim, retornando o sizedos próprios zeros.

Versão 1

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

Essa é uma variação do "Quantos 5s existem na fatoração primária de n!?" truque que usa os componentes básicos de conversão simples do Ruby.

O golfe é um pouco de dor, porém, com a conversão Integerda Stringpara Array, pegando parte do Arraye converter isso para Stringa Integernovamente para o reduce. Todas as sugestões de golfe são bem-vindas.

Julia, 21 19 bytes

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

Usa a fórmula recursiva da resposta do xnor .

Experimente online!

Dyalog APL , 9 bytes

⊥⍨'0'=⍕!⎕

⎕ solicitar o número

! fatorializar

⍕ stringify

'0'= verifique a igualdade com o caractere zero

⊥⍨ contar trilhas finais *

* Literalmente, é uma conversão de base mista para base 10, usando a lista booleana como número e base:

⊥⍨0 1 0 1 1é igual a 0 1 0 1 1⊥⍨0 1 0 1 1qual é qual é 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1)novamente dois (o número de 1s à direita).