Napisz program lub funkcję, która znajdzie liczbę zer na końcu n!w podstawie 10, gdzie njest liczbą wejściową (w dowolnym żądanym formacie).

Można założyć, że njest to dodatnia liczba całkowita, co oznacza, że n!jest również liczbą całkowitą. Po kropce dziesiętnej nie ma zer n!. Można również założyć, że Twój język programowania obsługuje wartości ni n!.

Przypadki testowe

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

To jest kod golfowy. Obowiązują standardowe zasady. Najkrótszy kod w bajtach wygrywa.

Zgłoszenia

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

# Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik to suma dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie tabeli wyników:

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

Tabela liderów

Oto fragment kodu, który pozwala wygenerować zarówno zwykłą tabelę wyników, jak i przegląd zwycięzców według języka.

/* 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 bajtów

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

Zakończenie zera są ograniczone przez czynniki 5. Liczba wielokrotność 5że są co najwyżej njest n/5(z podziałem piętro), ale to się nie liczy powtarzające się czynniki wielokrotność 25, 125, .... Aby je zdobyć, podziel nprzez 5 i powtórz.

Galaretka , 5 bajtów

!Æfċ5

Stosuje odwrotne do zamierzonego podejście do znajdowania silni, a następnie faktoryzowania go ponownie, sprawdzając wykładnik 5 w pierwszej faktoryzacji.

Wypróbuj online!

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

Mornington Crescent, 1949 1909 bajtów

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 bajtów dzięki NieDzejkob

Pyth, 6 bajtów

/P.!Q5

Wypróbuj tutaj.

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

Alternatywny 7-bajtowy :

st.u/N5

Skumulowane zmniejszenie .u/N5wielokrotnie dzieli podłoga przez, 5aż do uzyskania powtórzenia, co w tym przypadku następuje po osiągnięciu 0.

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

Pierwszy element jest następnie usuwany ( t), a reszta jest sumowana ( s).

Właściwie 10 bajtów

!$R;≈$l@l-

Wypróbuj online!

Zauważ, że ostatni przypadek testowy kończy się niepowodzeniem, gdy działa poważnie na CPython, ponieważ math.factorialużywa rozszerzenia C (które jest ograniczone do 64-bitowych liczb całkowitych). Jednak uruchamianie serialu na PyPy działa dobrze.

Wyjaśnienie:

!$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 bajtów

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

Piętro dzieli dane wejściowe przez 5, a następnie dodaje wynik do wywoływanej funkcji. Wyrażenie (+)=<<fprzyjmuje dane wejściowe xi wyjściowe x+(f x).

Skrócono z:

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

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

Nierekurencyjne wyrażenie dało 28 bajtów:

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

MATL , 9 bajtów

:"@Yf5=vs

Wypróbuj online!

Działa to w przypadku bardzo dużych liczb, ponieważ pozwala uniknąć obliczania silni.

Podobnie jak inne odpowiedzi, wykorzystuje to fakt, że liczba razy 2pojawia się, ponieważ dzielnik silni jest większy lub równy niż liczba razy 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 bajtów

Byłoby 4 bajty, gdybyśmy mogli zagwarantować n> 4

Kod:

Î!Ó7è

Wyjaśnienie:

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

Alternatywne, znacznie szybsze, 6-bajtowe rozwiązanie: Zainspirowany odpowiedzią MATL Luisa Mendo

LÒ€`5QO

Wyjaśnienie:

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

Edycja: usunięte rozwiązania przy użyciu ¢ (liczba), ponieważ wszystkie liczby pierwsze zawierające 5 byłyby liczone jako 5, np. 53.

Edycja 2: dodano bardziej wydajne rozwiązanie dla wyższych nakładów jako porównanie.

Matlab (59) (54)(39)

Cześć Dawg !!!! słyszeliśmy, że lubisz matematykę ....

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

• Jest to oparte na mojej utworzonej odpowiedzi w przeglądzie kodu .

• dalej niż to, co wspomniano w mojej odpowiedzi w przeglądzie kodu, wzór na liczbę zer w silni (n) to Suma (n / (5 ^ k)), gdzie k zmienia się między 1 a log_5 (n)

• Jedynym trywialnym powodem, dla którego nie można uzyskać golfiera, jest to, że log5nie jest on dostępny w Matlabie jako wbudowany, dlatego zastąpiłem log (5) przez 1.6, nie ma to znaczenia, ponieważ i tak zostanie zmienione.

Spróbuj

Mathematica, 20 bajtów

IntegerExponent[#!]&

IntegerExponentliczy zera. Dla zabawy, oto wersja, która nie oblicza silni:

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

C, 28 bajtów

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

Wyjaśnienie

Liczba końcowych zer jest równa liczbie piątek, które składają się na silnię. Spośród wszystkich 1..n, jedna piąta z nich wnosi pięć, więc zaczynamy n/5. Spośród nich n/5, piąty są wielokrotnością 25, więc przyczynić się dodatkowo pięć, i tak dalej. Skończyło się na tym f(n) = n/5 + n/25 + n/125 + ..., że jest f(n) = n/5 + f(n/5). Musimy zakończyć rekurencję, gdy nosiągnie zero; również korzystamy z punktu sekwencji w, ?:aby podzielić nprzed dodaniem.

Jako bonus, ten kod jest znacznie szybszy niż ten, który odwiedza każdy z nich 1..n(i znacznie, znacznie szybciej niż obliczanie silni).

Program testowy

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

Wyjście testowe

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 bajtów

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

Ta sama taktyka jak w odpowiedzi Xnora, ale krótsza.

Julia, 34 31 30 bajtów

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

Jest to anonimowa funkcja, która przyjmuje dowolny typ liczby całkowitej ze znakiem i zwraca liczbę całkowitą. Aby go wywołać, przypisz go do zmiennej. Większe przypadki testowe wymagają przekazania njako większego typu, takiego jak aBigInt .

Obliczamy silnię n(użycie ręczne prodjest krótsze niż wbudowane factorial), otrzymujemy jej tablicę digitsw odwrotnej kolejności,find indeksy niezerowych elementów, otrzymujemy pierwszy taki indeks i odejmujemy 1.

Wypróbuj online!(obejmuje wszystkie przypadki testowe oprócz ostatniego, ponieważ ostatni trwa zbyt długo)

Oszczędność bajtu dzięki Dennisowi!

C, 36

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

Ta sama metoda, co odpowiedź @ xnor liczenia 5s, ale tylko prosta pętla for zamiast rekurencji.

Ideone .

Siatkówka , 33 bajty

Pobiera dane wejściowe jednoargumentowe.

Zwraca wynik w jednostkowej.

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

(Zwróć uwagę na końcowe podawanie linii).

Wypróbuj online!

Jak to działa:

Pierwszy etap:

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

Nieznacznie nie golfista:

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

Co to robi:

• Po pierwsze, znajdź największą ich liczbę 11111.
• Zastąp tym numerem
• Skutecznie dzieli podłogę przez 5.
• Spojrzenie w przód (?=1)zapewnia, że ​​liczba jest dodatnia.
• Te +`środki powtarzać aż idempotent.
• Tak więc pierwszym etapem jest „powtarzany podział podłogi na 5”

Jeśli wartość wejściowa to 100 (w jedności), tekst jest teraz:

;;1111;11111111111111111111

Drugi etap:

;

Po prostu usuwa wszystkie średniki.

Ruby, 22 bajty

Jednym z niewielu przypadków, w których Ruby 0jest prawdą, jest problem z liczeniem bajtów.

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

Perl 6 , 23 bajtów

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

Mógłbym go skrócić, gdyby ^...został dodany do Perla 6 {sum $_,*div 5^...0} .
Powinno być bardziej wydajne pod względem pamięci dla większych liczb, jeśli dodano lazymodyfikator pomiędzysum i generator sekwencji.

Wyjaśnienie:

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

(Ta ostatnia linia jest nieco myląca, ponieważ MoarVM musi się uruchomić, załadować kompilator i środowisko wykonawcze Perl 6, skompilować kod i uruchomić go. Tak więc zajmuje to w sumie około półtorej sekundy.
To wciąż znacznie szybciej niż to było sprawdzenie wyniku ostatniego testu z WolframAlpha.com)

Mathcad, [tbd] bajty

Mathcad jest swego rodzaju matematyczną „tablicą”, która umożliwia wprowadzanie 2D wyrażeń, tekstu i wykresów. Wykorzystuje symbole matematyczne do wielu operacji, takich jak sumowanie, różnicowanie i integracja. Operatory programowania są specjalnymi symbolami, zwykle wprowadzanymi jako pojedyncze kombinacje klawiszy sterowania i / lub shift na standardowym klawiszu.

To, co widzisz powyżej, jest dokładnie tym, jak wygląda arkusz Mathcad, gdy jest wpisywany i gdy Mathcad go ocenia. Na przykład zmiana n z 2016 na dowolną inną wartość spowoduje, że Mathcad zaktualizuje wynik z 502 do dowolnej nowej wartości.

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

Metoda punktacji równoważności bajtów Mathcada nie została jeszcze ustalona. Biorąc równoważność symbolu, rozwiązanie zajmuje około 24 „bajtów” (operator while można wprowadzić tylko za pomocą kombinacji klawiszy „ctl-]” (lub z paska narzędzi)). Metoda Matlaba Agawa001 zajmuje około 37 bajtów po przetłumaczeniu na Mathcad (operator sumowania jest wprowadzany przez ctl-shft- $).

dc, 12 bajtów

[5/dd0<f+]sf

Definiuje funkcję, fktóra pobiera dane wejściowe z góry stosu i pozostawia dane wyjściowe na górze stosu. Zobacz moją odpowiedź C dla podstawy matematycznej. Wielokrotnie dzielimy przez 5, kumulując wartości na stosie, a następnie dodajemy wszystkie wyniki:

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

Program testowy

# 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

Wyjście testowe

./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 bajtów

Ώmf?H+γ/H5ΏγH

Definiuje funkcję rekurencyjną, która jest wywoływana na wejściu. Wypróbuj tutaj!

Ώ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 bajtów

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

Prawie tak samo, jak technika nierekurencyjna z odpowiedzi xnor.

Oto starsza wersja, którą tu zachowałem, ponieważ osobiście bardziej mi się podoba, licząc 28 bajtów:

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

Chociaż nie jest to konieczne, dołączyłem x:do przypadków testowych dla większej precyzji.

   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

Ostatni numer nie działa z tą funkcją.

Wyjaśnienie

Działa to poprzez obliczanie n!, konwertowanie go na ciąg i sprawdzanie, czy każdy element jest równy z '0'. Ponieważ n = 15proces ten byłby następujący:

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

Teraz używamy ;._1do dzielenia listy na jej pierwszym elemencie (zero), boksując każdy wynik podziału, uzyskując pole wypełnione asami ( a:) lub ciągami 1s, w ten sposób:

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

Po prostu uzyskujemy ostatniego członka ( {:), rozpakowujemy go ( >) i wykonujemy nad nim sumę+/ , uzyskując liczbę zer.

Oto bardziej czytelna wersja:

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 bajty

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

Pyke, 5 bajtów

SBP5/

Wypróbuj tutaj!

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

ZWROT , 17 bajtów

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

Try it here.

Operator rekurencyjny lambda. Stosowanie:

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

Wyjaśnienie

[             ]=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 ( -pflaga) = 23 bajty

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

Za pomocą:

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

Pełny program:

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

Java, 38 bajtów

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

Pełny program, z metodą bez golfa:

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 bajtów

Funkcja monadyczna z argumentem po prawej stronie.

3{:@q:!

Jeśli xjest dodatnia, x q: yzwraca wykładniki w pierwszym rozkładzie na czynniki pierwsze y, tylko dla pierwszych xliczb pierwszych. 3-Rd pierwsza jest 5 i {:wykonuje ogon listy.

Zauważ, że musisz wprowadzić liczby całkowite z xna końcu, bo J potraktuje je jako zmiennoprzecinkowe.

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

Spróbuj sam na tryj.tk , ale ostrzegaj, że ten internetowy tłumacz będzie narzekał, jeśli spróbujesz czegoś większego niż 1343.

Jeśli chcesz czegoś, co nie oblicza n ! i dlatego nie wymaga dopasowania do liczby całkowitej, użyj rozwiązania rekurencyjnego <.@%&5(+$:@)^:*. (tryj.tk wciąż płacze przy dużych nakładach).

Rubin, 70 61 51 49 bajtów

Wersja 3 z podziękowaniami dla Kenny'ego Lau i Daniero

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

Edycja: Okazuje się, że można zapisać dwa bajty, mapując to_i wcześniej sobą reduce. Dziwne: P

Ta funkcja odejmuje sumę n5 cyfr podstawyn a następnie dzieli wynik przez 4. Jest to związane z sumą szeregu geometrycznego 1+5+25+..+5**n = (5**n+1)/4.

Jako przykład (ponownie, dzięki dzięki Kenny'emu Lau), rozważ 358( 2413w bazie 5) minus jej 5 cyfr podstawy.

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

Podziel 348się 4i dostaniesz f(358) = 87.

Wersja 2 z podziękowaniami dla Kenny'ego Lau

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

Funkcja oblicza n!następnie odejmowana sizeod n!z sizeo (n!).reverse.to_i.to_s, co usuwa wszystkie zera, a tym samym zawracania sizesamych zer.

Wersja 1

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

To odmiana „Ilu 5jest tam pierwszych faktoryzacji n!?” trik wykorzystujący proste wbudowane konwersje bazowe Ruby.

Golfa jest nieco bólu chociaż z konwersji z Integeraby Stringsię Array, chwytając część obrzeża Arrayi przetwarzania, które na Stringsię Integerponownie z reduce. Wszelkie sugestie dotyczące gry w golfa są mile widziane.

Julia, 21 19 bajtów

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

Używa rekurencyjnej formuły z odpowiedzi xnor .

Wypróbuj online!

Dyalog APL , 9 bajtów

⊥⍨'0'=⍕!⎕

⎕ monit o numer

! rozkładać na czynniki

⍕ skreślić

'0'= sprawdź równość znaku zero

⊥⍨ policz końcowe ślady *

* Dosłownie jest to konwersja mieszanej bazy na bazę 10, przy użyciu listy boolowskiej jako liczby i bazy:

⊥⍨0 1 0 1 1jest taki sam, jak 0 1 0 1 1⊥⍨0 1 0 1 1który, 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1)który znowu jest dwa (liczba końcowych 1s).