Schreiben Sie ein Programm oder eine Funktion, die die Anzahl der Nullen am Ende von n!Basis 10 ermittelt, wobei nes sich um eine eingegebene Zahl handelt (in einem beliebigen Format).

Es kann davon ausgegangen werden, dass nes sich um eine positive ganze Zahl handelt, was bedeutet, dass n!es sich auch um eine ganze Zahl handelt. Nach dem Komma stehen in keine Nullen n!. Es kann auch davon ausgegangen werden, dass Ihre Programmiersprache den Wert von nund verarbeiten kann n!.

Testfälle

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

Das ist Code Golf. Es gelten Standardregeln. Der kürzeste Code in Bytes gewinnt.

Einreichungen

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten), stellen Sie sicher, dass die tatsächliche Punktzahl die letzte Zahl in der Kopfzeile ist:

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

Sie können den Namen der Sprache auch als Link festlegen, der dann im Leaderboard-Snippet angezeigt wird:

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

Bestenliste

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren.

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

Die Endung Nullen sind begrenzt durch Faktoren von 5. Die Anzahl der Vielfachen , 5dass es höchstens nist n/5(mit Boden Division), aber dies die wiederholten Faktoren in Vielfachen von nicht zählen 25, 125, .... Um diese zu erhalten, dividieren Sie ndurch 5 und wiederholen Sie den Vorgang.

Gelee , 5 Bytes

!Æfċ5

Verwendet den kontraproduktiven Ansatz, die Fakultät zu finden und sie dann erneut zu faktorisieren und in der Primfaktorisierung nach dem Exponenten von 5 zu suchen.

Probieren Sie es 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 dank NieDzejkob

Pyth, 6 Bytes

/P.!Q5

Probieren Sie es hier aus.

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

Alternative 7-Byte :

st.u/N5

Das kumulative Reduzieren .u/N5teilt sich 5so oft, bis es eine Wiederholung erhält, was in diesem Fall geschieht, nachdem es 0 erreicht hat.

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

Das erste Element wird dann entfernt ( t) und der Rest summiert ( s).

Eigentlich 10 Bytes

!$R;≈$l@l-

Probieren Sie es online!

Beachten Sie, dass der letzte Testfall fehlschlägt, wenn Seriously auf CPython ausgeführt wird, weil math.factorial eine C-Erweiterung verwendet wird (die auf 64-Bit-Ganzzahlen beschränkt ist). Seriously auf PyPy auszuführen, funktioniert jedoch einwandfrei.

Erläuterung:

!$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 dividiert die Eingabe durch 5und fügt das Ergebnis der aufgerufenen Funktion hinzu. Der Ausdruck (+)=<<fnimmt eine Eingabe xund Ausgaben x+(f x).

Gekürzt ab:

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

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

Ein nicht rekursiver Ausdruck ergab 28 Bytes:

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

MATL , 9 Bytes

:"@Yf5=vs

Probieren Sie es online!

Dies funktioniert bei sehr großen Zahlen, da die Fakultät nicht berechnet wird.

Wie bei anderen Antworten wird auch hier die Tatsache ausgenutzt, dass die Häufigkeit des 2Auftretens als Teiler der Fakultät größer oder gleich der Häufigkeit des Auftretens ist 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 Bytes

Wäre 4 Bytes, wenn wir garantieren könnten, dass n> 4 ist

Code:

Î!Ó7è

Erläuterung:

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

Alternative, viel schnellere 6-Byte-Lösung: Inspiriert von Luis Mendos MATL-Antwort

LÒ€`5QO

Erläuterung:

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

Bearbeiten: Entfernte Lösungen mit ¢ (count), da alle Primzahlen mit 5 als 5 gezählt würden, z. B. 53.

Edit 2: Es wurde eine effizientere Lösung für höhere Eingaben als Vergleich hinzugefügt.

Matlab (59) (54)(39)

Hey dawg !!!! Wir haben gehört, dass du Mathe magst ...

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

• Dies basiert auf meiner Antwort in der Codeüberprüfung .

• weiter als in meiner Antwort in der Codeüberprüfung erwähnt, lautet die Formel für die Anzahl der Nullen in der Fakultät (n) Summe (n / (5 ^ k)), wobei k zwischen 1 und log_5 (n) variiert.

• Der einzige triviale Grund, warum es nicht Golfspieler werden kann, ist, dass log5es in Matlab nicht als eingebautes Programm verfügbar ist. Daher habe ich log (5) durch 1.6 ersetzt. Das spielt keine Rolle, da es sowieso mit Fußboden ausgelegt sein wird.

Versuche es

Mathematica, 20 Bytes

IntegerExponent[#!]&

IntegerExponentzählt die Nullen. Zum Spaß ist hier eine Version, die die Fakultät nicht berechnet:

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

C 28 Bytes

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

Erläuterung

Die Anzahl der nachgestellten Nullen entspricht der Anzahl der Fünfer, aus denen sich die Fakultät zusammensetzt. Von all dem 1..nträgt ein Fünftel eine Fünf bei, also fangen wir an n/5. Von diesen n/5ist ein Fünftel ein Vielfaches von 25, tragen also weitere fünf bei und so weiter. Wir landen mit f(n) = n/5 + n/25 + n/125 + ..., was ist f(n) = n/5 + f(n/5). Wir müssen die Rekursion beenden, wenn nNull erreicht wird. Wir nutzen auch den Sequenzpunkt ?:, um nvor der Addition zu teilen .

Als Bonus ist dieser Code viel schneller als derjenige, der jeden besucht 1..n (und viel schneller als die Berechnung der Fakultät).

Testprogramm

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

Ausgang testen

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

Gleiche Taktik wie bei xnors Antwort, aber kürzer.

Julia, 34 31 30 Bytes

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

Dies ist eine anonyme Funktion, die jeden vorzeichenbehafteten Ganzzahltyp akzeptiert und eine Ganzzahl zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu. Die größeren Testfälle erfordern das Bestehen nals größerer Typ, wie z BigInt.

Wir berechnen die Fakultät von n(die manuelle Verwendung prodist kürzer als die eingebaute factorial), erhalten ein Array digitsin umgekehrter Reihenfolge, finddie Indizes der Nicht-Null-Elemente, erhalten den ersten solchen Index und subtrahieren 1.

Probieren Sie es online! (Beinhaltet alle bis auf den letzten Testfall, da der letzte zu lange dauert)

Dank Dennis ein Byte gespart!

C, 36

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

Die gleiche Methode wie bei @ xnor, bei der 5s gezählt werden, jedoch nur eine einfache for-Schleife anstelle einer Rekursion verwendet wird.

Ideone .

Retina , 33 Bytes

Nimmt unäre Eingaben auf.

Gibt die Ausgabe in Unary zurück.

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

(Beachten Sie den nachfolgenden Zeilenumbruch.)

Probieren Sie es online!

Wie es funktioniert:

Die erste Stufe:

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

Leicht ungolfed:

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

Was es macht:

• Erstens, finden Sie die größte Anzahl 11111, die abgeglichen werden kann.
• Ersetzen Sie durch diese Nummer
• Effektiv teilt Boden durch 5.
• Der Lookahead (?=1)versichert, dass die Zahl positiv ist.
• Die +`Mittel wiederholen sich bis zum Idempotenten.
• So ist die erste Stufe "wiederholte Unterteilung durch 5"

Wenn die Eingabe 100 ist (in Unary), lautet der Text jetzt:

;;1111;11111111111111111111

Zweite Etage:

;

Entfernt einfach alle Semikolons.

Ruby, 22 Bytes

Eines der wenigen Male, in denen die 0Wahrheit des Rubins ein Problem für die Byteanzahl ist.

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

Perl 6 , 23 Bytes

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

Ich könnte es kürzer machen, wenn ^...es zu Perl 6 hinzugefügt würde {sum $_,*div 5^...0}.
Bei größeren Zahlen sollte es speichereffizienter sein, wenn Sie lazyzwischen sumund dem Sequenzgenerator einen Modifikator einfügen.

Erläuterung:

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

Prüfung:

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

(Diese letzte Zeile ist leicht irreführend, da MoarVM starten, den Perl 6-Compiler und die Laufzeit laden, den Code kompilieren und ausführen muss. Es dauert also insgesamt ungefähr anderthalb Sekunden.
Das ist immer noch erheblich schneller als es ist war das Ergebnis des letzten Tests mit WolframAlpha.com zu überprüfen)

Mathcad, [tbd] Bytes

Mathcad ist eine Art mathematisches "Whiteboard", das die 2D-Eingabe von Ausdrücken, Text und Zeichnungen ermöglicht. Es werden mathematische Symbole für viele Operationen wie Summation, Differenzierung und Integration verwendet. Programmieroperatoren sind spezielle Symbole, die normalerweise als einzelne Tastenkombinationen von Steuerung und / oder Umschalttaste auf einer Standardtaste eingegeben werden.

Was Sie oben sehen, ist genau, wie das Mathcad-Arbeitsblatt so aussieht, wie es eingegeben und wie es von Mathcad ausgewertet wird. Wenn Sie beispielsweise n von 2016 auf einen anderen Wert ändern, aktualisiert Mathcad das Ergebnis von 502 auf den neuen Wert.

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

Die Methode zur Bewertung der Byte-Äquivalenz von Mathcad muss noch ermittelt werden. Bei einer Symboläquivalenz benötigt die Lösung etwa 24 "Bytes" (der while-Operator kann nur über die Tastenkombination "ctl-]" (oder über eine Symbolleiste) eingegeben werden. Die Matlab-Methode von Agawa001 benötigt bei der Übersetzung in Mathcad ca. 37 Byte (der Summationsoperator wird mit ctl-shft- $ eingegeben).

Gleichstrom, 12 Bytes

[5/dd0<f+]sf

Dies definiert eine Funktion, fdie ihre Eingabe vom oberen Ende des Stapels verbraucht und ihre Ausgabe am oberen Ende des Stapels belässt. Siehe meine C-Antwort für die mathematische Basis. Wir teilen wiederholt durch 5, akkumulieren die Werte auf dem Stapel und addieren dann alle Ergebnisse:

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

Testprogramm

# 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

Ausgang testen

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

Definiert eine rekursive Funktion, die am Eingang aufgerufen wird. Probieren Sie es hier aus!

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

Ziemlich dasselbe wie die nicht-rekursive Technik aus der Antwort von xnor.

Hier ist eine ältere Version, die ich hier behalten habe, weil es mir persönlich besser gefällt und ich mit 28 Bytes anfange:

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

Obwohl nicht benötigt, habe ich x:in die Testfälle für erweiterte Präzision aufgenommen.

   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

Die letzte Nummer funktioniert mit dieser Funktion nicht.

Erläuterung

Dies funktioniert, indem berechnet n!, in eine Zeichenfolge konvertiert und jedes Element auf Gleichheit mit überprüft wird '0'. Denn n = 15dieser Prozess wäre:

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

Nun ;._1teilen wir die Liste auf das erste Element (Null) auf , wobei wir jedes Teilungsergebnis boxen und eine Box mit Assen ( a:) oder Läufen von 1s erhalten, wie folgt:

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

Wir erhalten einfach das letzte Mitglied ( {:), entpacken es ( >) und addieren es +/, wobei wir die Anzahl der Nullen erhalten.

Hier ist die besser lesbare Version:

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/

Probieren Sie es hier aus!

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

RETURN , 17 Bytes

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

Try it here.

Rekursiver Operator Lambda. Verwendung:

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

Erläuterung

[             ]=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 Bytes

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

Verwenden von:

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

Volles Programm:

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

Volles Programm mit ungolfed Methode:

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

Monadische Funktion, rechts argumentierend.

3{:@q:!

Wenn xpositiv, werden x q: ydie Exponenten in einer Primfaktorisierung von ynur für die ersten xPrimzahlen zurückgegeben. Die 3-rd-Primzahl ist 5 und steht {:am Ende einer Liste.

Beachten Sie, dass Sie ganze Zahlen mit einem xam Ende eingeben müssen, andernfalls werden sie von J als Gleitkommazahlen behandelt.

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

Probieren Sie es selbst bei tryj.tk jedoch, dass sich dieser Online-Dolmetscher beschwert, wenn Sie etwas versuchen, das größer als 1343 ist.

Wenn Sie etwas wollen, das n nicht berechnet ! und daher muss es nicht in eine ganze Zahl passen, verwenden Sie die rekursive Lösung <.@%&5(+$:@)^:*. (tryj.tk meckert immer noch bei großen Eingaben.)

Ruby, 70 61 51 49 Bytes

Version 3 mit Dank an Kenny Lau und daniero

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

Bearbeiten: Es hat sich herausgestellt, dass Sie durch Zuordnen to_i vor Ihnen zwei Bytes sparen können reduce. Seltsam: P

Diese Funktion subtrahiert die Summe der nfünf Stellen der Basis von nund dividiert das Ergebnis durch 4. Dies bezieht sich auf die Summe der geometrischen Reihen1+5+25+..+5**n = (5**n+1)/4 .

Betrachten Sie als Beispiel (erneut dank Kenny Lau) 358( 2413in Basis 5) minus der 5-stelligen Basis.

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

Teilen Sie 348durch 4und Sie bekommen f(358) = 87.

Version 2 mit Dank an Kenny Lau

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

Diese Funktion berechnet n!und subtrahiert dann das sizevon n!vom sizevon (n!).reverse.to_i.to_s, wodurch alle Nullen entfernt werden und somit das sizevon den Nullen selbst zurückgegeben wird.

Version 1

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

Dies ist eine Variation der "Wie viele 5s gibt es in der Primfaktorisierung von n!?" Trick, der Rubys einfache integrierte Basisumwandlung verwendet.

Der Golf ist ein bisschen wie ein Schmerz aber, mit der Umwandlung von Integerbis Stringzu Array, einen Teil des für die Heimelf Arrayund Umwandeln dass Stringzu Integerwieder für die reduce. Anregungen zum Golfen sind willkommen.

Julia, 21 19 Bytes

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

Verwendet die rekursive Formel aus der Antwort von xnor .

Probieren Sie es online!

Dyalog APL , 9 Bytes

⊥⍨'0'=⍕!⎕

⎕ Aufforderung zur Eingabe der Nummer

! faktorisieren

⍕ stringifizieren

'0'= Überprüfen Sie die Gleichheit mit dem Zeichen Null

⊥⍨ zähle nachfolgende Wahrheiten *

* Es handelt sich buchstäblich um eine gemischte Basis-Basis-10-Konvertierung, wobei die Boolesche Liste sowohl als Zahl als auch als Basis verwendet wird:

⊥⍨0 1 0 1 1ist das Gleiche wie 0 1 0 1 1⊥⍨0 1 0 1 1das, 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1)was wiederum zwei ist (die Anzahl der nachgestellten Einsen).