Zeros no final de um fatorial

35

Escreva um programa ou função que encontre o número de zeros no final da n!base 10, onde nestá um número de entrada (em qualquer formato desejado).

Pode-se assumir que né um número inteiro positivo, o que significa que n!também é um número inteiro. Não há zeros após um ponto decimal em n!. Além disso, pode-se supor que sua linguagem de programação possa lidar com o valor de ne n!.


Casos de teste

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

Isso é código de golfe. Aplicam-se regras padrão. O código mais curto em bytes vence.

Submissões

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet da tabela de classificação:

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

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Arcturus
fonte
Podemos assumir que n! caberá no tipo de número inteiro nativo de nossos idiomas?
Alex A.
@AlexA. Sim você pode.
Arcturus
Pode nser uma string de entrada?
Conor O'Brien
15
Eu acho que essa seria uma pergunta melhor se você não tivesse permissão para assumir n!que caberia no seu tipo inteiro! Bem, talvez outra hora.
A Simmons

Respostas:

43

Python 2, 27 bytes

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

Os zeros finais são limitados por fatores de 5. O número de múltiplos 5que é no máximo né n/5(com divisão de piso), mas isso não conta os fatores repetidos em múltiplos de 25, 125, .... Para obtê-los, divida npor 5 e recorra.

xnor
fonte
19

Gelatina , 5 bytes

!Æfċ5

Utiliza a abordagem contraproducente de encontrar o fatorial e depois fatorá-lo novamente, verificando o expoente de 5 na fatoração primária.

Experimente online!

!              Factorial
 Æf            List of prime factors, e.g. 120 -> [2, 2, 2, 3, 5]
   ċ5          Count number of 5s
Sp3000
fonte
4
caramba. Fale sobre trade-offs! Para reduzir o código para 5 bytes, aumente a memória e o tempo em quantidades absurdas.
Ross Presser
19

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 graças a NieDzejkob

pppery
fonte
E agora é a minha resposta mais votada.
Pppery 17/05
3
Uma breve explicação para aqueles de nós que são Mornington Crescentdesafiados seria legal. :)
Robert Benson
-40 bytes usando nomes de linhas mais curtos, sempre que possível.
NieDzejkob 15/0318
18

Pitão, 6 bytes

/P.!Q5

Experimente aqui.

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

Alternativa de 7 bytes :

st.u/N5

A redução cumulativa .u/N5divide repetidamente o piso 5até obter uma repetição, o que nesse caso acontece depois de atingir 0.

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

O primeiro elemento é então removido ( t) e o restante é somado ( s).

xnor
fonte
13

Na verdade, 10 bytes

!$R;≈$l@l-

Experimente online!

Observe que o último caso de teste falha ao executar Seriamente no CPython porque math.factorialusa uma extensão C (que é limitada a números inteiros de 64 bits). Rodar seriamente no PyPy funciona bem, no entanto.

Explicação:

!$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)
Mego
fonte
3
Oh uau, eu gosto de como esse método não usa a divisão por 5 truques.
Arcturus 12/05
Eu conto 12 bytes neste aqui
Score_Under
11
@Score_Under Na verdade, usa a página de código do CP437, não o UTF-8. Cada caractere é um byte.
Mego
9

Haskell, 26 bytes

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

O piso divide a entrada por 5e adiciona o resultado à função chamada. A expressão(+)=<<f recebe uma entrada xe saídas x+(f x).

Encurtado de:

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

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

Uma expressão não recursiva forneceu 28 bytes:

f n=sum[n`div`5^i|i<-[1..n]]
xnor
fonte
É ium contador 1..n?
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Sim, embora apenas até log_5(n)assuntos, o resto dá 0.
xnor
8

MATL , 9 bytes

:"@Yf5=vs

Experimente online!

Isso funciona para números muito grandes, pois evita a computação do fatorial.

Como outras respostas, isso explora o fato de que o número de vezes que 2aparece como divisor do fatorial é maior ou igual ao número de vezes que 5aparece.

:     % 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
Luis Mendo
fonte
6

05AB1E, 5 bytes

Seriam 4 bytes se pudéssemos garantir n> 4

Código:

Î!Ó7è

Explicação:

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

Solução alternativa, muito mais rápida, de 6 bytes: inspirada na resposta MATL de Luis Mendo

LÒ€`5QO

Explicação:

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

Editar: soluções removidas usando ¢ (contagem), como todos os números primos contendo 5 seriam contados como 5, por exemplo, 53.

Edit 2: adicionada uma solução mais eficiente para maior entrada como comparação.

Emigna
fonte
Sim, em vez de , 5Qdeve funcionar. Boa resposta embora! :)
Adnan
Eu ia testar entradas maiores com o comentário "isso não falharia se a saída fosse> 9", mas a implementação do menino 05AB1E Óé lenta
SP3000
Aliás, o primeiro código também pode ser Î!Ó2é. O bug foi corrigido ontem .
Adnan
Se você estiver usando utf-8, Î!Ó7è tem 8 bytes, e a solução "6 bytes" é 10 bytes
Score_Under
@Score_Under Sim, isso está correto. No entanto, 05AB1E usa a codificação CP-1252.
Adnan
6

Matlab (59) (54)(39)

Hey dawg !!!! nós ouvimos você gostar de matemática ....

  @(n)sum(fix(n./5.^(1:fix(log(n)/1.6))))
  • Isso se baseia na minha resposta criada na revisão de código .

  • além do que é mencionado na minha resposta na revisão de código, a fórmula para o número de zeros no fatorial (n) é Soma (n / (5 ^ k)), onde k varia entre 1 e log_5 (n)

  • A única razão trivial pela qual ele não pode ficar mais golfista é que ele não está log5disponível no matlab como um componente interno; portanto, substituí o log (5) por 1.6, não importa, porque ele ficará de qualquer maneira.

De uma chance

Abr001am
fonte
Algumas perguntas. 1. Como você realmente executa isso no Matlab? 2. Qual é o resultado para n = 1?
Stuart Bruff
@StuartBruff para executar este tipo ans (1) e retorna 0.
Abr001am 12/16/16
ESTÁ BEM. Obrigado. Interessante. Eu não usei muito os manipuladores de funções no Matlab, por isso fiquei um pouco confuso sobre como executá-lo ... por que o ans () não conta para o total? Resposta pura, porém, eu tentei no Mathcad, mas tive que modificar o limite superior da soma, pois o Mathcad autodecrementa a variável de soma se o "superior" for menor que o limite "inferior" (e, portanto, minha pergunta sobre 0).
Stuart Bruff
5

Mathematica, 20 bytes

IntegerExponent[#!]&

IntegerExponentconta os zeros. Por diversão, aqui está uma versão que não calcula o fatorial:

Tr[#~IntegerExponent~5&~Array~#]&
LegionMammal978
fonte
Eu acho que Arrayeconomiza um byte na segunda solução.
Martin Ender
5

C, 28 bytes

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

Explicação

O número de zeros à direita é igual ao número de cinco que compõem o fatorial. De todos 1..n, um quinto deles contribui com cinco, então começamos com n/5. Destes n/5, um quinto são múltiplos de 25, portanto, contribuem com mais cinco, e assim por diante. Terminamos com o f(n) = n/5 + n/25 + n/125 + ...que é f(n) = n/5 + f(n/5). Precisamos terminar a recursão quando natingir zero; também aproveitamos o ponto de sequência em ?:para dividir nantes da adição.

Como bônus, esse código é muito mais rápido do que aquele que visita cada 1..n (e muito, muito mais rápido que calcular o fatorial).

Programa de teste

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

Saída de teste

1: 0
4: 0
5: 1
24: 4
25: 6
124: 28
125: 31
666: 165
2016: 502
2147483644: 536870901
2147483647: 536870902

Toby Speight
fonte
+1 para uma excelente explicação
Tito
4

JavaScript ES6, 20 bytes

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

A mesma tática da resposta do xnor, mas mais curta.

Conor O'Brien
fonte
4

Julia, 34 31 30 bytes

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

Esta é uma função anônima que aceita qualquer tipo de número inteiro assinado e retorna um número inteiro. Para chamá-lo, atribua-o a uma variável. Os casos de teste maiores requerem aprovação ncomo um tipo maior, como a BigInt.

Calculamos o fatorial de n(usar manualmente prodé mais curto que o interno factorial), obtemos uma matriz dele digitsem ordem inversa, findos índices dos elementos diferentes de zero, obtemos o primeiro desses índices e subtraímos 1.

Experimente online!(inclui todos, exceto o último caso de teste, porque o último leva muito tempo)

Guardado um byte graças a Dennis!

Alex A.
fonte
3

C, 36

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

O mesmo método da resposta do @ xnor de contar 5s, mas apenas usando um loop for simples em vez de recursão.

Ideone .

Trauma Digital
fonte
@TobySpeight lá vai você.
Digital Trauma
3

Retina , 33 bytes

Recebe entrada em unário.

Retorna a saída em unário.

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

(Observe o avanço da linha à direita.)

Experimente online!

Como funciona:

O primeiro estágio:

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

Ligeiramente não destruído:

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

O que faz:

  • Primeiro, encontre o maior número 11111possível disso.
  • Substitua por esse número
  • Efetivamente divide o chão por 5.
  • O lookahead (?=1)garante que o número é positivo.
  • Os +`meios se repetem até serem idempotentes.
  • Então, o primeiro estágio é "divisão repetida do piso por 5"

Se a entrada for 100 (em unário), o texto será agora:

;;1111;11111111111111111111

Segundo estágio:

;

Apenas remove todos os pontos e vírgulas.

Freira Furada
fonte
2

Ruby, 22 bytes

Uma das poucas vezes em que o Ruby 0realmente é um problema para a contagem de bytes.

f=->n{n>0?f[n/=5]+n:0}
Value Ink
fonte
espere por que é 0verdade?
Conor O'Brien
2
@ CᴏɴᴏʀO'Bʀɪᴇɴ Em Ruby, nile falsesão falsey, e nada mais é. Há muitos casos em que ajuda no golfe, já que 0ser verdadeiro significa que as funções de índice index e regex no Ruby retornam nilse não houver correspondência em vez de -1, e em alguns casos isso é um problema, como cadeias vazias ainda sendo verdadeiras.
Value Ink
@ KevinLau-notKenny Isso faz sentido.
Conor O'Brien
2

Perl 6 , 23 bytes

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

Eu poderia diminuí-lo se ^...fosse adicionado ao Perl 6 {sum $_,*div 5^...0} .
Deveria ser mais eficiente em memória para números maiores se você incluísse um lazymodificador entre sume o gerador de sequência.

Explicação:

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

Teste:

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

(Essa última linha é um pouco enganadora, pois o MoarVM precisa iniciar, carregar o compilador e o tempo de execução do Perl 6, compilar o código e executá-lo. Portanto, na verdade, leva cerca de um segundo e meio no total.
Isso ainda é significativamente mais rápido do que ele foi verificar o resultado do último teste com WolframAlpha.com)

Brad Gilbert b2gills
fonte
2

Mathcad, [tbd] bytes

insira a descrição da imagem aqui

O Mathcad é uma espécie de "quadro branco" matemático que permite a entrada em 2D de expressões, texto e gráficos. Ele usa símbolos matemáticos para muitas operações, como soma, diferenciação e integração. Os operadores de programação são símbolos especiais, geralmente inseridos como combinações de teclado único de controle e / ou deslocamento em uma tecla padrão.

O que você vê acima é exatamente a aparência da planilha do Mathcad à medida que é digitada e como o Mathcad avalia. Por exemplo, alterar n de 2016 para qualquer outro valor fará com que o Mathcad atualize o resultado de 502 para o novo valor.

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


O método de pontuação de equivalência de bytes do Mathcad ainda não foi determinado. Tomando uma equivalência de símbolo, a solução leva cerca de 24 "bytes" (o operador while só pode ser inserido usando a combinação de teclas "ctl-]" (ou em uma barra de ferramentas)). O método Matlab do Agawa001 leva cerca de 37 bytes quando traduzido para o Mathcad (o operador de soma é inserido por ctl-shft- $).

Stuart Bruff
fonte
Parece uma ferramenta impressionante de manusear, não vou poupar um segundo para baixá-lo!
Abr001am
2

dc, 12 bytes

[5/dd0<f+]sf

Isso define uma função fque consome sua entrada do topo da pilha e deixa sua saída no topo da pilha. Vejo minha resposta C para a base matemática. Dividimos repetidamente por 5, acumulando os valores na pilha e adicionamos todos os resultados:

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

Programa de teste

# 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

Saída de teste

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

Jolf, 13 bytes

Ώmf?H+γ/H5ΏγH

Define uma função recursiva que é chamada na entrada. Experimente aqui!

Ώ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
fonte
1

J, 28 17 16 bytes

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

Praticamente o mesmo que a técnica não recursiva da resposta do xnor.


Aqui está uma versão mais antiga que eu mantive aqui, porque eu pessoalmente gosto mais, com 28 bytes:

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

Embora não seja necessário, incluí x:nos casos de teste uma precisão estendida.

   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

O último número não funciona com esta função.

Explicação

Isso funciona calculando n!, convertendo-o em uma sequência e verificando a igualdade de cada membro com '0'. Pois n = 15, esse processo seria:

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

Agora, usamos ;._1para dividir a lista em seu primeiro elemento (zero), encaixotando cada resultado da divisão, produzindo uma caixa cheia de ases ( a:) ou execuções de 1s, da seguinte forma:

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

Simplesmente obtemos o último membro ( {:), unbox-lo ( >) e fazemos um somatório sobre ele+/ , produzindo o número de zeros.

Aqui está a versão mais legível:

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
fonte
>:@i.pode ser gravado 1+i.para salvar um byte.
algorithmshark
Sua versão mais antiga pode ser convertida em [:#.~'0'=":@!13 bytes, alterando o método de contagem dos 1s à direita.
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
fonte
Isso não funciona, tente os casos de teste.
xnor 12/05
Deve funcionar agora.
Magenta
1

Pyke, 5 bytes

SBP5/

Experimente aqui!

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

RETURN , 17 bytes

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

Try it here.

Operador recursivo lambda. Uso:

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

Explicação

[             ]=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
fonte
1

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

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

Usando:

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

Programa completo:

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

Java, 38 bytes

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

Programa completo, com método não destruído:

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));
    }
}
Freira Furada
fonte
1

J, 7 bytes

Função monádica, tendo argumento à direita.

3{:@q:!

Se xfor positivo, x q: yretorna os expoentes em uma fatoração primária de y, apenas para os primeiros xprimos. O 3-rd primo é 5 e{: leva o final de uma lista.

Observe que você precisa inserir números inteiros com um xno final, caso contrário, J os tratará como flutuadores.

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

Experimente você mesmo em tryj.tk , mas que esse intérprete on-line irá reclamar se você tentar algo maior que 1343.

Se você quer algo que não computa n ! e, portanto, não exige que ele se ajuste a um número inteiro, use a solução recursiva <.@%&5(+$:@)^:*. (tryj.tk ainda é choroso em entradas grandes.)

algoritmshark
fonte
1

Ruby, 70 61 51 49 bytes

Versão 3 com agradecimentos a Kenny Lau e daniero

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

Edit: Acontece que você pode salvar dois bytes por mapeamento to_i antes de vocêreduce . Estranho: P

Essa função subtrai a soma dos n5 dígitos da base ne depois divide o resultado por 4. Isso está relacionado à soma das séries geométricas1+5+25+..+5**n = (5**n+1)/4 .

Como exemplo (novamente, com agradecimentos a Kenny Lau), considere 358( 2413na base 5) menos seus 5 dígitos base.

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

Divida 348por 4e você começa f(358) = 87.

Versão 2 com agradecimentos a Kenny Lau

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

Esta função calcula n!em seguida, subtrai o sizede n!da sizeda (n!).reverse.to_i.to_s, que remove todos os zeros, assim, retornando o sizedos próprios zeros.

Versão 1

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

Essa é uma variação do "Quantos 5s existem na fatoração primária de n!?" truque que usa os componentes básicos de conversão simples do Ruby.

O golfe é um pouco de dor, porém, com a conversão Integerda Stringpara Array, pegando parte do Arraye converter isso para Stringa Integernovamente para o reduce. Todas as sugestões de golfe são bem-vindas.

Sherlock9
fonte
É ligeiramente mais curto para mapear to_iantes de reduzir: ->n{(n-n.to_s(5).chars.map(&:to_i).reduce(:+))/4}(poupa dois bytes)
daniero
@daniero Eu não esperava isso. Graças: D
Sherlock9
1

Dyalog APL , 9 bytes

⊥⍨'0'=⍕!⎕

solicitar o número

! fatorializar

stringify

'0'= verifique a igualdade com o caractere zero

⊥⍨ contar trilhas finais *


* Literalmente, é uma conversão de base mista para base 10, usando a lista booleana como número e base:

⊥⍨0 1 0 1 1é igual a 0 1 0 1 1⊥⍨0 1 0 1 1qual é qual é 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1)novamente dois (o número de 1s à direita).

Adão
fonte