Напишіть програму або функцію, яка знайде кількість нулів на кінці n!бази 10, де nє вхідне число (у будь-якому бажаному форматі).

Можна припустити, що nце додатне ціле число, тобто n!це ціле число. Немає нулів після десяткових знаків у n!. Крім того, можна припустити, що ваша мова програмування може обробляти значення nі n!.

Тестові справи

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

Це код гольфу. Діють стандартні правила. Виграє найкоротший код у байтах.

Подання

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

# Language Name, N bytes

де Nрозмір вашого подання. Якщо ви покращите свій рахунок, ви можете зберегти старі бали у заголовку, прокресливши їх. Наприклад:

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

Якщо ви хочете включити у свій заголовок декілька чисел (наприклад, тому що ваш результат - це сума двох файлів або ви хочете окремо перерахувати штрафні санкції для перекладача), переконайтесь, що фактичний результат - це останнє число у заголовку:

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

Ви також можете зробити ім'я мови посиланням, яке потім з’явиться у фрагменті таблиць лідерів:

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

Таблиця лідерів

Ось фрагмент стека для створення як звичайного табло, так і огляду переможців за мовою.

/* 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 байт

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

Кінцеві нулі обмежуються коефіцієнтами 5. Кількість кратних, 5що є максимум n, n/5(з поділом підлоги), але це не враховує повторюваних коефіцієнтів у кратних значеннях 25, 125, .... Щоб отримати їх, розділіть nна 5 і повторіть повтор.

Желе , 5 байт

!Æfċ5

Використовує контрпродуктивний підхід до знаходження факторіалу, а потім знову його факторизує, перевіряючи показник 5 на основній факторизації.

Спробуйте в Інтернеті!

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

Морнінгтон Півмісяць, 1949 1909 байт

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 байт завдяки NieDzejkob

Pyth, 6 байт

/P.!Q5

Спробуйте тут.

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

Альтернативно 7-байт :

st.u/N5

Кумулятивне зменшення .u/N5багаторазово ділиться на підлогу, 5поки воно не отримає повтор, що в цьому випадку відбувається після того, як він досягне 0.

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

Перший елемент видаляється ( t), а решта підсумовується ( s).

Власне, 10 байт

!$R;≈$l@l-

Спробуйте в Інтернеті!

Зауважте, що останній тестовий випадок виходить з ладу при серйозному запуску на CPython, оскільки math.factorialвикористовує розширення C (яке обмежено 64-бітовими цілими числами). Хоча Серйозно працює на PyPy, добре працює.

Пояснення:

!$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 байт

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

Підлога ділить вхід на 5, а потім додає результат до функції, викликаної ним. Вираз (+)=<<fприймає вхід xі виводить x+(f x).

Скорочено від:

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

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

Нерекурсивний вираз дав 28 байт:

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

MATL , 9 байт

:"@Yf5=vs

Спробуйте в Інтернеті!

Це працює для дуже великої кількості, оскільки це дозволяє уникнути обчислення факторіалу.

Як і інші відповіді, це використовує той факт, що кількість разів, що 2з’являється дільником факторіалу, більша або дорівнює кількості показаних разів 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 байт

Було б 4 байти, якби ми могли гарантувати n> 4

Код:

Î!Ó7è

Пояснення:

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

Чергове , набагато швидше, 6 -байтне рішення: Натхненний відповіддю MATL Луїса Мендо

LÒ€`5QO

Пояснення:

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

Редагувати: видалені розчини, використовуючи ¢ (підрахунок), оскільки всі праймери, що містять 5, зараховуються до 5, наприклад 53.

Редагування 2: додано більш ефективне рішення для більш високого введення в порівнянні.

Матлаб (59) (54)(39)

Гей, гауб !!!! ми чули, як ти любиш математику ....

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

• Це засновано на моїй створеній відповіді в огляді коду .

• крім того, що згадується у моїй відповіді в огляді коду, формула для кількості нулів у факторіалі (n) - сума (n / (5 ^ k)), де k змінюється між 1 і log_5 (n)

• Єдина банальна причина, чому він не може отримати гольфіст, - це те, що log5не доступний у matlab як вбудований, таким чином я замінив log (5) на 1.6, не має значення, тому що він буде в будь-якому випадку заваленим.

Спробувати

Математика, 20 байт

IntegerExponent[#!]&

IntegerExponentрахує нулі. Для задоволення, ось версія, яка не обчислює факторіал:

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

C, 28 байт

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

Пояснення

Кількість кінцевих нулів дорівнює кількості п'яти, що складають факторіал. З усіх 1..nп'ятих з них вносять п'ять, так що ми починаємо з n/5. З них n/5п'ята частина кратна 25, тому сприяють додатковій п'ятірці тощо. Ми закінчуємо тим f(n) = n/5 + n/25 + n/125 + ..., що є f(n) = n/5 + f(n/5). Нам потрібно припинити рекурсію, коли вона nдосягне нуля; також ми скористаємося точкою послідовності на ?:поділ nперед додаванням.

Як бонус, цей код набагато швидший, ніж той, який відвідує кожен 1..n(і набагато, набагато швидше, ніж обчислення факторіалу).

Тестова програма

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

Тестовий вихід

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 байт

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

Та сама тактика, що і у відповіді xnor, але коротша.

Джулія, 34 31 30 байт

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

Це анонімна функція, яка приймає будь-який підписаний цілий тип і повертає ціле число. Щоб викликати його, призначте його змінній. Більш тестові випадки вимагають передачі nяк більшого типу, наприклад, а BigInt.

Ми обчислюємо факторіал n(використовуючи вручну prodкоротше, ніж вбудований factorial), отримуємо його масив digitsу зворотному порядку, findіндекси ненульових елементів, отримуємо перший такий індекс і віднімаємо 1.

Спробуйте в Інтернеті! (включає всі, крім останнього тестового випадку, оскільки останній займає занадто багато часу)

Збережено байт завдяки Деннісу!

С, 36

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

Той самий метод, що і відповідь @ xnor підрахунку 5s, але просто використання простого циклу замість рекурсії.

Ідеон .

Сітківка , 33 байти

Здійснює введення в одинаковому режимі.

Повертає вихід уніар.

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

(Зверніть увагу на зворотний податок.)

Спробуйте в Інтернеті!

Як це працює:

Перший етап:

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

Трохи незворушений:

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

Що це робить:

• По-перше, знайдіть найбільшу кількість того, 11111що може відповідати.
• Замініть на це число
• Ефективно ділить підлогу на 5.
• Шукати (?=1)запевняє, що число позитивне.
• Засіб +`повторюють до безсилості.
• Отже, перший етап - це "повторний поділ на 5 на 5"

Якщо вхід 100 (унарний), текст зараз:

;;1111;11111111111111111111

Другий етап:

;

Просто видаляє всі напівколонки.

Рубін, 22 байти

Один з небагатьох випадків, коли Рубі, що 0є триумфом, є проблемою для кількості байтів.

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

Perl 6 , 23 байти

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

Я міг би скоротити його, якби ^...його додали до Perl 6 {sum $_,*div 5^...0} .
Він повинен бути ефективнішим для пам'яті для більшої кількості, якщо ви додали lazyмодифікатор між sumгенератором послідовностей.

Пояснення:

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

Тест:

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

(Цей останній рядок злегка вводить в оману, оскільки MoarVM повинен почати, завантажувати компілятор Perl 6 і час виконання, компілювати код і запускати його. Таким чином, це займає приблизно півтори секунди.
Це все ще значно швидше, ніж це було перевірити результат останнього тесту на WolframAlpha.com)

Mathcad, [tbd] байт

Mathcad - це свого роду математична "дошка", яка дозволяє вводити 2D виразів, тексту та графіків. Він використовує математичні символи для багатьох операцій, таких як підсумовування, диференціація та інтеграція. Оператори програмування - це спеціальні символи, які зазвичай вводяться як одні клавіатурні комбінації керування та / або переміщення на стандартній клавіші.

Те, що ви бачите вище, саме те, як виглядає робочий аркуш Mathcad під час його введення і як Mathcad оцінює його. Наприклад, зміна n з 2016 на будь-яке інше значення призведе до того, що Mathcad оновить результат від 502 до будь-якого нового значення.

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

Метод балів еквівалентності байт Mathcad ще не визначений. Приймаючи еквівалентність символів, рішення займає близько 24 "байт" (в той час як оператор може бути введений лише за допомогою комбінації клавіш "ctl-]" (або з панелі інструментів)). Метод Matlab Agawa001 займає близько 37 байт при перекладі в Mathcad (оператор підсумовування вводиться ctl-shft- $).

DC, 12 байт

[5/dd0<f+]sf

Це визначає функцію, fяка споживає свій вхід зверху стека, а свій вихід залишає у верхній частині стека. Дивіться мою відповідь С на математичній основі. Ми кілька разів ділимо на 5, накопичуючи значення на стеку, а потім додаємо всі результати:

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

Тестова програма

# 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

Тестовий вихід

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

Джольф, 13 байт

Ώmf?H+γ/H5ΏγH

Визначає рекурсивну функцію, яка викликається на вході. Спробуйте тут!

Ώ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 байт

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

Приблизно те саме, що нерекурсивна техніка з відповіді xnor.

Ось старішу версію, яку я зберегла тут, тому що мені особисто це більше подобається, працює на 28 байт:

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

Хоча це не потрібно, я включив x:у тестові приклади для розширеної точності.

   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

Останнє число не працює з цією функцією.

Пояснення

Це працює, обчислюючи n!, перетворюючи його в рядок і перевіряючи рівність кожного члена '0'. Бо n = 15цей процес буде таким:

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

Тепер ми використовуємо ;._1для розділення списку на його перший елемент (нуль), боксуючи кожен результат розбиття, отримуючи поле, заповнене aces ( a:) або пробілами 1s, наприклад:

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

Ми просто отримуємо останній член ( {:), розпаковуємо його ( >) і виконуємо підсумовування над ним +/, отримуючи число нулів.

Ось більш читаема версія:

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 байти

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

Пайк, 5 байт

SBP5/

Спробуйте тут!

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

ПОВЕРНЕННЯ , 17 байт

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

Try it here.

Рекурсивна лямбда оператора. Використання:

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

Пояснення

[             ]=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 ( -pпрапор) = 23 байти

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

Використання:

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

Повна програма:

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

Java, 38 байт

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

Повна програма, з методом unolfolf:

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 байт

Монадічна функція, беручи аргументи справа.

3{:@q:!

Якщо xє позитивним, x q: yповертає експоненти в основній факторизації yлише для перших xпрайменів. Перший 3прайм - 5 і {:займає хвіст списку.

Зауважте, що вам потрібно вводити цілі числа з а xв кінці, інакше J трактуватиме їх як поплавці.

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

Спробуйте самостійно на tryj.tk , однак застережте, що цей інтерпретатор скаржиться, якщо ви спробуєте щось більше, ніж 1343.

Якщо ви хочете щось, що не обчислює n ! і, отже, не потрібно, щоб воно вмістилося в ціле число, використовуйте рекурсивний розчин <.@%&5(+$:@)^:*. (tryj.tk все ще кричить на великих входах.)

Рубі, 70 61 51 49 байт

Версія 3 завдяки Кенні Лау та Даньєро

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

Редагувати: виявляється, ви можете зберегти два байти, зіставивши to_i перед собою карту reduce. Дивно: P

Ця функція віднімає суму nбазових 5 цифр від, nа потім ділить результат на 4. Це пов'язано з сумою геометричного ряду 1+5+25+..+5**n = (5**n+1)/4.

Як приклад (знову ж таки, завдяки Кенні Лау), розгляньте 358( 2413у базі 5) мінус його базові 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

Розділіться 348на 4і отримаєте f(358) = 87.

Версія 2 завдяки Кенні Лау

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

Ця функція обчислює n!потім віднімає sizeз n!з sizeз (n!).reverse.to_i.to_s, який видаляє всі нулі, таким чином, повертаючи sizeсамих нулі.

Версія 1

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

Це варіація "Скільки 5є у основній факторизації n!?" трюк, який використовує просту базову конверсію Ruby.

Гольф трохи болю , хоча, при конвертації з Integerдо Stringв Array, захоплюючи частину з Arrayі перетворення , що Stringв Integerзнову для reduce. Будь-які пропозиції щодо гольфу вітаються.

Юлія, 21 19 байт

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

Використовує рекурсивну формулу з відповіді xnor .

Спробуйте в Інтернеті!

Діалог APL , 9 байт

⊥⍨'0'=⍕!⎕

⎕ запит на номер

! факторизувати

⍕ строфіфікувати

'0'= перевірити рівність нулю символів

⊥⍨ підрахунок кінцевих істин *

* Буквально це конверсія змішаної бази до базової 10, використовуючи булівський список як номер, так і базовий:

⊥⍨0 1 0 1 1це те саме, 0 1 0 1 1⊥⍨0 1 0 1 1що є, 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1)що знову-таки два (кількість кінцевих 1).