Scrivi un programma o una funzione che trova il numero di zero alla fine di n!in base 10, dove si ntrova un numero di input (in qualsiasi formato desiderato).

Si può presumere che nsia un numero intero positivo, nel senso che n!è anche un numero intero. Non ci sono zero dopo un punto decimale in n!. Inoltre, si può presumere che il proprio linguaggio di programmazione sia in grado di gestire il valore di ne n!.

Casi test

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

Questo è il codice golf. Si applicano le regole standard. Vince il codice più breve in byte.

Inseriti

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

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

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

Gli zeri finali sono limitati da fattori di 5. Il numero 5massimo di multipli nè n/5(con divisione del pavimento), ma questo non conta i fattori ripetuti in multipli di 25, 125, .... Per ottenere quelli, dividere nper 5 e ricorrere.

Jelly , 5 byte

!Æfċ5

Usa l'approccio controproducente per trovare il fattoriale e poi fattorizzarlo di nuovo, verificando l'esponente di 5 nella fattorizzazione in prime.

Provalo online!

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

Mornington Crescent, 1949 1909 byte

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 byte grazie a NieDzejkob

Pyth, 6 byte

/P.!Q5

Provalo qui.

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

7 byte alternativi :

st.u/N5

La riduzione cumulativa si .u/N5divide ripetutamente di piano 5fino a quando non si ripete, cosa che in questo caso si verifica dopo aver colpito 0.

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

Il primo elemento viene quindi rimosso ( t) e il resto viene sommato ( s).

In realtà, 10 byte

!$R;≈$l@l-

Provalo online!

Si noti che l'ultimo caso di test fallisce quando si esegue Seriously su CPython perché math.factorial utilizza un'estensione C (che è limitata a numeri interi a 64 bit). Tuttavia, l'esecuzione seria su PyPy funziona bene.

Spiegazione:

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

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

Divide l'ingresso per 5, quindi aggiunge il risultato alla funzione richiamata. L'espressione (+)=<<faccetta un inputx e outputx+(f x) .

Accorciato da:

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

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

Un'espressione non ricorsiva ha dato 28 byte:

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

MATL , 9 byte

:"@Yf5=vs

Provalo online!

Questo funziona per numeri molto grandi, poiché evita di calcolare il fattoriale.

Come altre risposte, questo sfrutta il fatto che il numero di volte che 2appare come divisore del fattoriale è maggiore o uguale al numero di volte che 5appare.

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

Sarebbe 4 byte se potessimo garantire n> 4

Codice:

Î!Ó7è

Spiegazione:

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

Soluzione alternativa, molto più veloce, a 6 byte: ispirata alla risposta MATL di Luis Mendo

LÒ€`5QO

Spiegazione:

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

Modifica: rimosse le soluzioni usando ¢ (conteggio) poiché tutti i numeri primi contenenti 5 verrebbero conteggiati come 5, ad es. 53.

Modifica 2: aggiunta una soluzione più efficiente per input più elevati come confronto.

Matlab (59) (54)(39)

Ehi amico !!!! ti abbiamo sentito come la matematica ...

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

• Questo si basa sulla mia risposta creata nella revisione del codice .

• oltre a quanto menzionato nella mia risposta nella recensione del codice, la formula per il numero di zeri in fattoriale (n) è Somma (n / (5 ^ k)) dove k varia tra 1 e log_5 (n)

• L'unica banale ragione per cui non può diventare più golfista è che log5non è disponibile in matlab come incorporato, quindi ho sostituito log (5) con 1.6, non importa perché sarà comunque pavimentato.

Provaci

Mathematica, 20 byte

IntegerExponent[#!]&

IntegerExponentconta gli zeri. Per divertimento, ecco una versione che non calcola il fattoriale:

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

C, 28 byte

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

Spiegazione

Il numero di zeri finali è uguale al numero di cinque che compongono il fattoriale. Di tutti 1..n, un quinto contribuisce a cinque, quindi iniziamo con n/5. Di questi n/5, un quinto sono multipli di 25, quindi contribuisci con altri cinque e così via. Finiamo con f(n) = n/5 + n/25 + n/125 + ..., che èf(n) = n/5 + f(n/5) . Dobbiamo terminare la ricorsione quando nraggiunge lo zero; inoltre sfruttiamo il punto sequenza in cui ?:suddividere nprima dell'aggiunta.

Come bonus, questo codice è molto più veloce di quello che visita ciascuno 1..n (e molto, molto più veloce del calcolo del fattoriale).

Programma di test

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

Uscita di prova

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 byte

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

Stessa tattica della risposta di xnor, ma più breve.

Julia, 34 31 30 byte

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

Questa è una funzione anonima che accetta qualsiasi tipo intero con segno e restituisce un numero intero. Per chiamarlo, assegnarlo a una variabile. I casi di test più grandi richiedono il passaggio ncome tipo più grande, come ad esempio a BigInt.

Calcoliamo il fattoriale di n(l'utilizzo manuale prodè più breve di quello incorporatofactorial ), ne otteniamo una matrice digitsin ordine inverso,find gli indici degli elementi diversi da zero, otteniamo il primo indice e sottraggiamo 1.

Provalo online!(include tutto tranne l'ultimo caso di test perché l'ultimo richiede troppo tempo)

Salvataggio di un byte grazie a Dennis!

C, 36

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

Stesso metodo della risposta di @ xnor di del conteggio dei 5s, ma solo usando un semplice ciclo per anziché ricorsione.

Ideone .

Retina , 33 byte

Riceve input in unario.

Restituisce l'output in unario.

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

(Nota l'avanzamento della riga finale.)

Provalo online!

Come funziona:

Il primo stadio:

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

Leggermente non golfato:

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

Cosa fa:

• In primo luogo, trova il maggior numero di quelli 11111che possono essere abbinati.
• Sostituisci con quel numero
• Divide efficacemente il pavimento di 5.
• Il lookahead (?=1)assicura che il numero sia positivo.
• I +`mezzi si ripetono fino a quando non sono idempotenti.
• Quindi, il primo stadio è "ripetizione della divisione del pavimento per 5"

Se l'input è 100 (in unario), il testo è ora:

;;1111;11111111111111111111

Seconda fase:

;

Rimuove solo tutti i punti e virgola.

Rubino, 22 byte

Una delle poche volte in cui il Ruby 0è vero è un problema per il conteggio dei byte.

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

Perl 6 , 23 byte

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

Potrei accorciarlo se ^...fosse aggiunto a Perl 6 {sum $_,*div 5^...0} .
Dovrebbe essere più efficiente in termini di memoria per numeri più grandi se hai aggiunto un lazymodificatore tra sume il generatore di sequenza.

Spiegazione:

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

Test:

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

(L'ultima riga è leggermente fuorviante, poiché MoarVM deve avviarsi, caricare il compilatore e il runtime Perl 6, compilare il codice ed eseguirlo. Quindi in realtà impiega circa un secondo e mezzo in totale.
Ciò è ancora significativamente più veloce di esso era controllare il risultato dell'ultimo test con WolframAlpha.com)

Mathcad, [tbd] byte

Mathcad è una sorta di "lavagna" matematica che consente l'inserimento 2D di espressioni, testo e grafici. Utilizza simboli matematici per molte operazioni, come la somma, la differenziazione e l'integrazione. Gli operatori di programmazione sono simboli speciali, generalmente inseriti come combinazioni di tastiera singole di controllo e / o spostamento su un tasto standard.

Quello che vedi sopra è esattamente come appare il foglio di lavoro di Mathcad mentre viene digitato e mentre Mathcad lo valuta. Ad esempio, cambiando n dal 2016 a qualsiasi altro valore, Mathcad aggiornerà il risultato da 502 a qualunque sia il nuovo valore.

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

Il metodo di calcolo del punteggio di equivalenza in byte di Mathcad deve ancora essere determinato. Prendendo un'equivalenza di simboli, la soluzione richiede circa 24 "byte" (l'operatore while può essere inserito solo usando la combinazione di tasti "ctl-]" (o da una barra degli strumenti)). Il metodo Matlab di Agawa001 impiega circa 37 byte quando tradotto in Mathcad (l'operatore di somma viene inserito da ctl-shft- $).

dc, 12 byte

[5/dd0<f+]sf

Questo definisce una funzione fche consuma il suo input dall'alto dello stack e lascia l'output in cima allo stack. Vedi la mia risposta in C per le basi matematiche. Dividiamo ripetutamente per 5, accumulando i valori nello stack, quindi aggiungiamo tutti i risultati:

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

Programma di test

# 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

Uscita di prova

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

Ώmf?H+γ/H5ΏγH

Definisce una funzione ricorsiva che viene chiamata sull'input. Provalo qui!

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

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

Praticamente uguale alla tecnica non ricorsiva dalla risposta di xnor.

Ecco una versione precedente che ho conservato qui perché personalmente mi piace di più, con un clock di 28 byte:

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

Sebbene non sia necessario, ho incluso x:nei casi di prova una precisione estesa.

   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

L'ultimo numero non funziona con questa funzione.

Spiegazione

Funziona calcolando n!, convertendolo in una stringa e controllando la parità di ciascun membro '0'. Per n = 15, questo processo sarebbe:

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

Ora, usiamo ;._1per dividere l'elenco sul suo primo elemento (zero), inscatolando ogni risultato diviso, producendo una scatola piena di assi ( a:) o serie di 1s, in questo modo:

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

Semplicemente otteniamo l'ultimo membro ( {:), scompattalo (> ) ed eseguiamo una somma su di esso +/, producendo il numero di zero.

Ecco la versione più leggibile:

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 byte

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

Pyke, 5 byte

SBP5/

Provalo qui!

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

INVIO , 17 byte

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

Try it here.

Operatore ricorsivo lambda. Uso:

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

Spiegazione

[             ]=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 ( -pflag) = 23 byte

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

usando:

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

Programma completo:

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

Java, 38 byte

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

Programma completo, con metodo non 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 byte

Funzione monadica, prendendo argomento a destra.

3{:@q:!

Se xè positivo, x q: yrestituisce gli esponenti in una scomposizione in fattori primi di y, solo per i primi xprimi. Il 3-rd primo è 5 e {:prende la coda di un elenco.

Nota che devi inserire numeri interi con un xalla fine, altrimenti J li tratterà come float.

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

Provalo tu stesso a tryj.tk , ma presente che questo interprete online si lamenterà se qualcosa di più grande di 1343.

Se vuoi qualcosa che non calcola n ! e quindi non richiede che si adatti a un numero intero, utilizzare la soluzione ricorsiva <.@%&5(+$:@)^:*. (tryj.tk è ancora lamentoso su input di grandi dimensioni.)

Rubino, 70 61 51 49 byte

Versione 3 con ringraziamenti a Kenny Lau e daniero

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

Modifica: si scopre che è possibile salvare due byte mappando to_i prima di te reduce. Strano: P

Questa funzione sottrae la somma delle n5 cifre di base da ne quindi divide il risultato per 4. Ciò è correlato alla somma delle serie geometriche1+5+25+..+5**n = (5**n+1)/4 .

Ad esempio (di nuovo, grazie a Kenny Lau), considera 358( 2413nella base 5) meno le sue cifre di 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

Dividi 348per 4e si ottiene f(358) = 87.

Versione 2 grazie a Kenny Lau

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

Questa funzione calcola n!quindi sottrae il sizedi n!dal sizedi (n!).reverse.to_i.to_s, che rimuove tutti gli zero, restituendo quindi sizegli stessi degli zero.

Versione 1

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

Questa è una variazione del "Quanti 5 s ci sono nella scomposizione in fattori primi di n!?" trucco che utilizza i semplici builtin di conversione base di Ruby.

Il golf è un po 'una seccatura, con la conversione da Integera Stringa Array, afferrando parte del Arraye convertendolo in Stringdi Integernuovo per il reduce. Tutti i suggerimenti per il golf sono i benvenuti.

Julia, 21 19 byte

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

Utilizza la formula ricorsiva dalla risposta di xnor .

Provalo online!

Dyalog APL , 9 byte

⊥⍨'0'=⍕!⎕

⎕ richiedere il numero

! factorialize

⍕ stringa i

'0'= controlla l'uguaglianza con il carattere zero

⊥⍨ conta le tracce finali *

* Letteralmente è una conversione da base mista a base 10, usando l'elenco booleano sia come numero che come base:

⊥⍨0 1 0 1 1è lo stesso 0 1 0 1 1⊥⍨0 1 0 1 1che è che è di 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1)nuovo due (il numero di 1 finali).