Escriba un programa o función que encuentre el número de ceros al final de n!en la base 10, donden hay un número de entrada (en cualquier formato deseado).

Se puede suponer que nes un número entero positivo, lo que significa que n!también es un número entero. No hay ceros después de un punto decimal n!. Además, se puede suponer que su lenguaje de programación puede manejar el valor de ny n!.

Casos de prueba

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

Este es el código de golf. Aplican reglas estándar. El código más corto en bytes gana.

Envíos

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores 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)

Los ceros finales están limitados por factores de 5. El número de múltiplos 5que son como máximo nes n/5(con división de piso), pero esto no cuenta los factores repetidos en múltiplos de 25, 125, .... Para obtenerlos, divídalos nentre 5 y recurse.

Jalea , 5 bytes

!Æfċ5

Utiliza el enfoque contraproducente de encontrar el factorial y luego factorizarlo nuevamente, verificando el exponente de 5 en la factorización prima.

Pruébalo en línea!

!              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 gracias a NieDzejkob

Pyth, 6 bytes

/P.!Q5

Pruébalo aquí

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

Alternativa de 7 bytes :

st.u/N5

La reducción acumulativa .u/N5 divide repetidamente el piso por 5hasta que se repite, lo que en este caso ocurre después de que llega a 0.

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

Luego se elimina el primer elemento ( t) y se suma el resto ( s).

En realidad, 10 bytes

!$R;≈$l@l-

Pruébalo en línea!

Tenga en cuenta que el último caso de prueba falla cuando se ejecuta en serio en CPython porque math.factorial usa una extensión C (que está limitada a enteros de 64 bits). Sin embargo, ejecutar Seriously en PyPy funciona bien.

Explicación:

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

Floor-divide la entrada por 5, luego agrega el resultado a la función invocada. La expresión (+)=<<ftoma una entrada xy salidasx+(f x) .

Acortado 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

Una expresión no recursiva dio 28 bytes:

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

MATL , 9 bytes

:"@Yf5=vs

Pruébalo en línea!

Esto funciona para números muy grandes, ya que evita calcular el factorial.

Al igual que otras respuestas, esto explota el hecho de que el número de veces que 2aparece como divisor del factorial es mayor o igual que el número de veces 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

Sería de 4 bytes si pudiéramos garantizar n> 4

Código:

Î!Ó7è

Explicación:

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

Solución alternativa, mucho más rápida, de 6 bytes: inspirada en la respuesta MATL de Luis Mendo

LÒ€`5QO

Explicación:

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: soluciones eliminadas usando ¢ (contar) ya que todos los primos que contienen 5 se contarán como 5, por ejemplo, 53.

Edición 2: se agregó una solución más eficiente para una mayor entrada como comparación.

Matlab (59) (54)(39)

Hola dawg !!!! te escuchamos como matemáticas ...

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

• Esto se basa en mi respuesta creada en la revisión de código .

• más allá de lo que se menciona en mi respuesta en la revisión de código, la fórmula para el número de ceros en factorial (n) es Sum (n / (5 ^ k)) donde k varía entre 1 y log_5 (n)

• La única razón trivial por la que no puede volverse más golfista es que log5no está disponible en matlab como incorporado, por lo que reemplacé log (5) por 1.6, no importa porque de todos modos estará en el piso.

Darle una oportunidad

Mathematica, 20 bytes

IntegerExponent[#!]&

IntegerExponentcuenta los ceros. Por diversión, aquí hay una versión que no calcula el factorial:

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

C, 28 bytes

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

Explicación

El número de ceros finales es igual al número de cinco que forman el factorial. De todos 1..n, una quinta parte de ellos aporta un cinco, así que comenzamos con n/5. De estos n/5, un quinto son múltiplos de 25, por lo que contribuyen con cinco adicionales, y así sucesivamente. Terminamos con f(n) = n/5 + n/25 + n/125 + ..., que es f(n) = n/5 + f(n/5). Necesitamos terminar la recursión cuando nllega a cero; También aprovechamos el punto de secuencia ?:para dividirn antes de la adición.

Como beneficio adicional, este código es mucho más rápido que el que visita cada uno 1..n(y mucho, mucho más rápido que calcular el factorial).

Programa de prueba

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

Prueba de salida

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

La misma táctica que en la respuesta de xnor, pero más corta.

Julia, 34 31 30 bytes

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

Esta es una función anónima que acepta cualquier tipo de entero con signo y devuelve un entero. Para llamarlo, asígnelo a una variable. Los casos de prueba más grandes requieren pasar ncomo un tipo más grande, como a BigInt.

Calculamos el factorial de n(el uso manual prodes más corto que el incorporado factorial), obtenemos una matriz digitsen orden inverso, findlos índices de los elementos distintos de cero, obtenemos el primer índice y restamos 1.

Pruébalo en línea! (incluye todos menos el último caso de prueba porque el último lleva demasiado tiempo)

¡Ahorré un byte gracias a Dennis!

C, 36

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

El mismo método que la respuesta de @ xnor de contar 5s, pero solo usando un bucle for simple en lugar de recursión.

Ideone .

Retina , 33 bytes

Toma entrada en unario.

Devuelve la salida en unario.

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

(Tenga en cuenta el avance de línea final).

Pruébalo en línea!

Cómo funciona:

El primer escenario:

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

Ligeramente incólume:

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

Que hace:

• En primer lugar, encuentre la mayor cantidad de 11111eso que pueda igualarse.
• Reemplazar por ese número
• Efectivamente el piso se divide por 5.
• La anticipación (?=1)asegura que el número sea positivo.
• Los +`medios se repiten hasta idempotentes.
• Entonces, la primera etapa es "división de piso repetida por 5"

Si la entrada es 100 (en unario), el texto ahora es:

;;1111;11111111111111111111

Segunda etapa:

;

Simplemente elimina todos los puntos y coma.

Ruby, 22 bytes

Una de las pocas veces en que Ruby 0es verdadero es un problema para el conteo de bytes.

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

Perl 6 , 23 bytes

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

Podría acortarlo si ^...se agregara a Perl 6 {sum $_,*div 5^...0} .
Debería ser más eficiente en la memoria para números más grandes si agrega un lazymodificador entresum y el generador de secuencia.

Explicación:

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

Prueba:

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

(Esa última línea es un poco engañosa, ya que MoarVM tiene que comenzar, cargar el compilador Perl 6 y el tiempo de ejecución, compilar el código y ejecutarlo. Por lo tanto, en realidad toma aproximadamente un segundo y medio en total.
Eso es significativamente más rápido que eso. fue verificar el resultado de la última prueba con WolframAlpha.com)

Mathcad, [tbd] bytes

Mathcad es una especie de "pizarra" matemática que permite la entrada en 2D de expresiones, texto y diagramas. Utiliza símbolos matemáticos para muchas operaciones, como suma, diferenciación e integración. Los operadores de programación son símbolos especiales, usualmente ingresados ​​como combinaciones de control y / o cambio de un solo teclado en una tecla estándar.

Lo que ve arriba es exactamente cómo se ve la hoja de trabajo de Mathcad a medida que se escribe y a medida que Mathcad la evalúa. Por ejemplo, cambiar n desde 2016 a cualquier otro valor hará que Mathcad actualice el resultado de 502 a cualquier valor nuevo.

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

El método de puntuación de equivalencia de bytes de Mathcad aún no se ha determinado. Tomando un símbolo de equivalencia, la solución toma aproximadamente 24 "bytes" (el operador while solo se puede ingresar usando la combinación de teclas "ctl-]" (o desde una barra de herramientas)). El método Matlab de Agawa001 toma aproximadamente 37 bytes cuando se traduce a Mathcad (el operador de suma se ingresa por ctl-shft- $).

dc, 12 bytes

[5/dd0<f+]sf

Esto define una función fque consume su entrada desde la parte superior de la pila y deja su salida en la parte superior de la pila. Vea mi respuesta C para la base matemática. Dividimos repetidamente entre 5, acumulando los valores en la pila, luego agregamos todos los 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 prueba

# 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

Prueba de salida

./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 una función recursiva que se llama en la entrada. Pruébalo aquí!

Ώ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.)

Prácticamente lo mismo que la técnica no recursiva de la respuesta de xnor.

Aquí hay una versión anterior que he guardado aquí porque personalmente me gusta más, registrando 28 bytes:

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

Si bien no es necesario, he incluido x:en los casos de prueba para mayor precisión.

   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

El último número no funciona con esta función.

Explicación

Esto funciona calculando n!, convirtiéndolo en una cadena y verificando la igualdad con cada miembro '0'. Para n = 15, este proceso sería:

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

Ahora, usamos ;._1para dividir la lista en su primer elemento (cero), encuadrando cada resultado de división, produciendo un recuadro lleno de ases ( a:) o series de 1s, así:

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

{:Simplemente obtenemos el último miembro ( ), lo desempaquetamos ( >) y realizamos una suma sobre él +/, produciendo el número de ceros.

Aquí está la versión más legible:

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/

Pruébalo aquí!

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

RETORNO , 17 bytes

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

Try it here.

Operador recursivo lambda. Uso:

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

Explicación

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

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

Utilizando:

> 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, con método sin golf:

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

Función monádica, tomando argumentos a la derecha.

3{:@q:!

Si xes positivo, x q: ydevuelve los exponentes en una factorización prima de y, solo para los primeros xnúmeros primos. El 3-rd prime es 5 y {:toma la cola de una lista.

Tenga en cuenta que debe ingresar números enteros con un xal final, de lo contrario, J los tratará como flotantes.

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

Pruébelo usted mismo en tryj.tk , aunque tenga en cuenta que este intérprete en línea se quejará si intenta algo más grande que 1343.

Si quieres algo que no calcule n ! y por lo tanto no requiere que quepa en un número entero, use la solución recursiva <.@%&5(+$:@)^:*. (Tryj.tk todavía es llorón en entradas grandes).

Ruby, 70 61 51 49 bytes

Versión 3 con agradecimiento a Kenny Lau y daniero

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

Editar: resulta que usted puede ahorrar dos bytes de mapeo to_i antes de quereduce . Raro: P

Esta función resta la suma de nlos 5 dígitos base de ny luego divide ese resultado entre 4. Esto está relacionado con la suma de las series geométricas.1+5+25+..+5**n = (5**n+1)/4 .

Como ejemplo (de nuevo, gracias a Kenny Lau), considere 358( 2413en base 5) menos sus dígitos de base 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

Divide 348por 4y obtienes f(358) = 87.

Versión 2 con agradecimiento a Kenny Lau

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

Esta función calcula n!luego resta el sizede n!del sizede (n!).reverse.to_i.to_s, lo que elimina todos los ceros, por lo tanto, devuelve el sizede los mismos ceros.

Versión 1

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

Esta es una variación de "¿Cuántos 5s hay en la factorización prima de n!?" truco que utiliza las funciones integradas de conversión de bases simples de Ruby.

El golf es un poco de un dolor sin embargo, con la conversión de Integera Stringa Array, agarrando parte de la Arrayy la conversión que para Stringa Integerde nuevo para el reduce. Cualquier sugerencia de golf es bienvenida.

Julia, 21 19 bytes

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

Utiliza la fórmula recursiva de la respuesta de xnor .

Pruébalo en línea!

Dyalog APL , 9 bytes

⊥⍨'0'=⍕!⎕

⎕ solicitud de número

! factorizar

⍕ stringify

'0'= comprobar la igualdad con el carácter cero

⊥⍨ contar las pistas finales *

* Literalmente es una conversión de base mixta a base-10, utilizando la lista booleana como número y base:

⊥⍨0 1 0 1 1es lo mismo que 0 1 0 1 1⊥⍨0 1 0 1 1cuál es 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1)nuevamente dos (el número de 1s finales).