Нули в конце факториала

35

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

Можно предположить, что nэто положительное целое число, то n!есть это также целое число. Там нет нулей после десятичной точки в n!. Также можно предположить, что ваш язык программирования может обрабатывать значения nи n!.


Контрольные примеры

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

Это код гольф. Стандартные правила применяются. Самый короткий код в байтах побеждает.

Материалы

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

# 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

Leaderboard

Вот фрагмент стека, который генерирует как регулярную таблицу лидеров, так и обзор победителей по языкам.

Арктур
источник
Можем ли мы предположить, что п! будет вписываться в родной целочисленный тип наших языков?
Алекс А.
@AlexA. Да, ты можешь.
Арктур
Может nбыть строка ввода?
Конор О'Брайен
15
Я думаю, что это был бы лучший вопрос, если бы вам не позволили предположить, n!что он соответствует вашему целочисленному типу! Ну, может быть, в другой раз.
Симмонс

Ответы:

43

Python 2, 27 байт

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

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

XNOR
источник
19

Желе , 5 байт

!Æfċ5

Использует контрпродуктивный подход: найти факториал, а затем снова разложить его на множители, проверяя показатель степени 5 в первичной факторизации.

Попробуйте онлайн!

!              Factorial
 Æf            List of prime factors, e.g. 120 -> [2, 2, 2, 3, 5]
   ċ5          Count number of 5s
Sp3000
источник
4
Хлоп. Разговор о компромиссах! Чтобы уменьшить размер кода до 5 байтов, увеличьте объем памяти и время на абсурдные суммы.
Росс Прессер
19

Морнингтон Кресент, 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

pppery
источник
И это теперь мой самый голосующий ответ.
pppery
3
Краткое объяснение для тех из нас, у кого есть Mornington Crescentвызов, было бы здорово. :)
Роберт Бенсон
-40 байт , используя более короткие имена строк, где это возможно.
NieDzejkob
18

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

XNOR
источник
13

На самом деле, 10 байтов

!$R;≈$l@l-

Попробуйте онлайн!

Обратите внимание, что последний тестовый пример не выполняется при запуске Seriously на 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)
Мего
источник
3
Ух ты, мне нравится, как этот метод не использует деление на 5 трюков.
Арктур
Я считаю 12 байт на этот
счет
1
@Score_Under На самом деле использует кодовую страницу CP437, а не UTF-8. Каждый символ - один байт.
Mego
9

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]]
XNOR
источник
Является ли iсчетчик от 1..n?
Конор О'Брайен
@ CᴏɴᴏʀO'Bʀɪᴇɴ Да, хотя только по log_5(n)делам, остальные дают 0.
xnor
8

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
Луис Мендо
источник
6

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: добавлено более эффективное решение для более высокого ввода в качестве сравнения.

Emigna
источник
Да, вместо того , 5Qчтобы работать. Хороший ответ, хотя! :)
Аднан
Я собирался протестировать большие входные данные с комментарием «не будет ли это неудачным, если выходной сигнал будет> 9», но реализация мальчика 05AB1E Óидет медленно
Sp3000
Кстати, первый код также может быть Î!Ó2é. Ошибка была исправлена вчера .
Аднан
Если вы используете utf-8, Î!Ó7èэто 8 байтов, а "6-байтовое" решение составляет 10 байтов
Score_Under
@Score_Under Да, это правильно. Однако 05AB1E использует кодировку CP-1252.
Аднан
6

Matlab (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, не имеет значения, потому что он в любом случае будет зависать.

Попробуй

Abr001am
источник
Пара вопросов. 1. Как вы на самом деле запускаете это в Matlab? 2. Каков результат для n = 1?
Стюарт Бруфф
@StuartBruff для запуска этого типа ans (1) и он возвращает 0.
Abr001am
ХОРОШО. Спасибо. Интересный. В Matlab я мало использовал дескрипторы функций, поэтому был немного озадачен тем, как его запускать ... почему ans () не учитывается в общем количестве? Хороший ответ, однако, я попробовал это в Mathcad, но мне пришлось изменить верхний предел суммы, так как Mathcad автоматически уменьшает переменную суммирования, если «верхний» меньше «нижнего» предела (и, следовательно, мой вопрос о 0).
Стюарт Бруфф
5

Mathematica, 20 байтов

IntegerExponent[#!]&

IntegerExponentсчитает нули. Для забавы, вот версия, которая не рассчитывает факториал:

Tr[#~IntegerExponent~5&~Array~#]&
LegionMammal978
источник
Я думаю, что Arrayэкономит байт на втором решении.
Мартин Эндер
5

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

Тоби Спейт
источник
+1 за отличное объяснение
Тит
4

JavaScript ES6, 20 байт

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

Та же тактика, что и в ответе xnor, но короче.

Конор О'Брайен
источник
4

Юлия, 34 31 30 байт

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

This is an anonymous function that accepts any signed integer type and returns an integer. To call it, assign it to a variable. The larger test cases require passing n as a larger type, such as a BigInt.

We compute the factorial of n (manually using prod is shorter than the built-in factorial), get an array of its digits in reverse order, find the indices of the nonzero elements, get the first such index, and subtract 1.

Try it online! (includes all but the last test case because the last takes too long)

Saved a byte thanks to Dennis!

Alex A.
источник
3

C, 36

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

Same method as @xnor's answer of counting 5s, but just using a simple for loop instead of recursion.

Ideone.

Digital Trauma
источник
@TobySpeight there you go.
Digital Trauma
3

Retina, 33 bytes

Takes input in unary.

Returns output in unary.

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

(Note the trailing linefeed.)

Try it online!

How it works:

The first stage:

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

Slightly ungolfed:

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

What it does:

  • Firstly, find the greatest number of 11111 that can be matched.
  • Replace by that number
  • Effectively floor-divides by 5.
  • The lookahead (?=1) assures that the number is positive.
  • The +` means repeat until idempotent.
  • So, the first stage is "repeated floor-division by 5"

If the input is 100 (in unary), then the text is now:

;;1111;11111111111111111111

Second stage:

;

Just removes all semi-colons.

Leaky Nun
источник
2

Ruby, 22 bytes

One of the few times where the Ruby 0 being truthy is a problem for byte count.

f=->n{n>0?f[n/=5]+n:0}
Value Ink
источник
wait why is 0 truthy?
Conor O'Brien
2
@CᴏɴᴏʀO'Bʀɪᴇɴ In Ruby, nil and false are falsey, and nothing else is. There are a lot of cases where helps out in golf, since having 0 be truthy means the index and regex index functions in Ruby return nil if there is no match instead of -1, and some where it is a problem, like empty strings still being truthy.
Value Ink
@KevinLau-notKenny That does make sense.
Conor O'Brien
2

Perl 6, 23 bytes

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

I could get it shorter if ^... was added to Perl 6 {sum $_,*div 5^...0}.
It should be more memory efficient for larger numbers if you added a lazy modifier between sum and the sequence generator.

Explanation:

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

( That last line is slightly misleading, as MoarVM has to start, load the Perl 6 compiler and runtime, compile the code, and run it. So it actually takes about a second and a half in total.
That is still significantly faster than it was to check the result of the last test with WolframAlpha.com )

Brad Gilbert b2gills
источник
2

Mathcad, [tbd] bytes

enter image description here

Mathcad is sort of mathematical "whiteboard" that allows 2D entry of expressions, text and plots. It uses mathematical symbols for many operations, such as summation, differentiation and integration. Programming operators are special symbols, usually entered as single keyboard combinations of control and/or shift on a standard key.

What you see above is exactly how the Mathcad worksheet looks as it is typed in and as Mathcad evaluates it. For example, changing n from 2016 to any other value will cause Mathcad to update the result from 502 to whatever the new value is.

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


Mathcad's byte equivalence scoring method is yet to be determined. Taking a symbol equivalence, the solution takes about 24 "bytes" (the while operator can only be entered using the "ctl-]" key combination (or from a toolbar)). Agawa001's Matlab method takes about 37 bytes when translated into Mathcad (the summation operator is entered by ctl-shft-$).

Stuart Bruff
источник
Sounds a stunning tool to handle, I wont spare a second downloading it !
Abr001am
2

dc, 12 bytes

[5/dd0<f+]sf

This defines a function f which consumes its input from top of stack, and leaves its output at top of stack. See my C answer for the mathematical basis. We repeatedly divide by 5, accumulating the values on the stack, then add all the results:

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

Test program

# 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

Test output

./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  
Toby Speight
источник
1

Jolf, 13 bytes

Ώmf?H+γ/H5ΏγH

Defines a recursive function which is called on the input. Try it here!

Ώmf?H+γ/H5ΏγH  Ώ(H) = floor(H ? (γ = H/5) + Ώ(γ) : H)
Ώ              Ώ(H) =
       /H5                           H/5
      γ                         (γ =    )
     +    Ώγ                              + Ώ(γ)
   ?H       H               H ?                  : H
 mf                   floor(                        )
               // called implicitly with input
Conor O'Brien
источник
1

J, 28 17 16 bytes

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

Pretty much the same as the non-recursive technique from xnor's answer.


Here's an older version I have kept here because I personally like it more, clocking in at 28 bytes:

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

Whilst not needed, I have included x: in the test cases for extended precision.

   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

The last number doesn't work with this function.

Explanation

This works by calculating n!, converting it to a string, and checking each member for equality with '0'. For n = 15, this process would be:

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

Now, we use ;._1 to split the list on its first element (zero), boxing each split result, yielding a box filled with aces (a:) or runs of 1s, like so:

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

We simple obtain the last member ({:), unbox it (>), and perform a summation over it +/, yielding the number of zeroes.

Here is the more readable 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'&= @ ": @ ! )
Conor O'Brien
источник
>:@i. can be written 1+i. to save a byte.
algorithmshark
Your older version can be made into [:#.~'0'=":@! for 13 bytes by changing the method of counting the trailing 1s.
cole
1

Python 3, 52 bytes

g=lambda x,y=1,z=0:z-x if y>x else g(x,y*5,z+x//y)
Magenta
источник
This doesn't work, try the test cases.
xnor
It should work now.
Magenta
1

RETURN, 17 bytes

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

Try it here.

Recursive operator lambda. Usage:

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

Explanation

[             ]=F  Lambda -> Operator F
 $                 Check if top of stack is truthy
  [       ][]?     Conditional
   5÷\%$F+         If so, do x/5+F(x/5)
Mama Fun Roll
источник
1

Perl, 24 22 + 1 (-p flag) = 23 bytes

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

Using:

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

Full program:

while (<>) {
# code above added by -p
    while ($_) {
        $\ += $_ = int($_ / 5);
    }
} {
# code below added by -p
    print;  # prints $_ (undef here) and $\
}
Denis Ibaev
источник
1

Java, 38 bytes

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

Full program, with ungolfed method:

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));
    }
}
Leaky Nun
источник
1

J, 7 bytes

Monadic function, taking argument on the right.

3{:@q:!

If x is positive, x q: y returns the exponents in a prime factorization of y, for only the first x primes. The 3-rd prime is 5 and {: takes the tail of a list.

Note that you have to input integers with an x at the end, or else J will treat them as floats.

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

Try it yourself at tryj.tk, though be warned that this online interpreter will complain if you try anything larger than 1343.

If you want something that doesn't compute n! and hence doesn't require it fit in an integer, use the recursive solution <.@%&5(+$:@)^:*. (tryj.tk is still whiny on large inputs.)

algorithmshark
источник
1

Ruby, 70 61 51 49 bytes

Version 3 with thanks to Kenny Lau and daniero

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

Edit: Turns out you can save two bytes by mapping to_i before you reduce. Weird :P

This function subtracts the sum of n's base 5 digits from n and then divides that result by 4. This is related to the sum of the geometric series 1+5+25+..+5**n = (5**n+1)/4.

As an example (again, with thanks to Kenny Lau), consider 358 (2413 in base 5) minus its base 5 digits.

2413-2-4-1-3 
= (2000-2) + (400-4) + (10-1) + (3-3)
# consider that 1000-1=444 and you'll see why every 5**n is multiplied by 4
= 2*444 + 4*44 + 1*4 + 3*0
= 2*(4*5**0+4*5**1+4*5**2) + 4*(4*5**0+4*5**1) + 1*(4*5**0) + 3*()
= 348

Divide 348 by 4 and you get f(358) = 87.

Version 2 with thanks to Kenny Lau

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

This function calculates n! then subtracts the size of n! from the size of (n!).reverse.to_i.to_s, which removes all the zeroes, thus, returning the size of the zeroes themselves.

Version 1

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

This a variation of the "How many 5s are there in the prime factorization of n!?" trick that uses Ruby's simple base conversion builtins.

The golfing is a bit of a pain though, with converting from Integer to String to Array, grabbing part of the Array and converting that to String to Integer again for the reduce. Any golfing suggestions are welcome.

Sherlock9
источник
It's slightly shorter to map to_i before reducing: ->n{(n-n.to_s(5).chars.map(&:to_i).reduce(:+))/4} (saves two bytes)
daniero
@daniero I would not have expected that. Thanks :D
Sherlock9
1

Dyalog APL, 9 bytes

⊥⍨'0'=⍕!⎕

prompt for number

! factorialize

stringify

'0'= check equality to character zero

⊥⍨ count trailing trues*


*Literally it is a mixed-base to base-10 conversion, using the boolean list as both number and base:

⊥⍨0 1 0 1 1 is the same as 0 1 0 1 1⊥⍨0 1 0 1 1 which is 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1) which again is two (the number of trailing 1s).

Adám
источник