Ceros al final de un factorial

35

Escriba un programa o función que encuentre el número de ceros al final de n!en la base 10, donden hay un número de entrada (en cualquier formato deseado).

Se puede suponer que nes un número entero positivo, lo que significa que n!también es un número entero. No hay ceros después de un punto decimal n!. Además, se puede suponer que su lenguaje de programación puede manejar el valor de ny n!.


Casos de prueba

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

Este es el código de golf. Aplican reglas estándar. El código más corto en bytes gana.

Envíos

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Arcturus
fuente
¿Podemos suponer que n! cabe dentro del tipo entero nativo de nuestros idiomas?
Alex A.
@AlexA. Sí tu puedes.
Arcturus
Puede nser una cadena de entrada?
Conor O'Brien
15
¡Creo que esta sería una mejor pregunta si no se le permitiera asumir n!que encajaría en su tipo entero! Bueno, tal vez en otro momento.
Un Simmons

Respuestas:

43

Python 2, 27 bytes

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

Los ceros finales están limitados por factores de 5. El número de múltiplos 5que son como máximo nes n/5(con división de piso), pero esto no cuenta los factores repetidos en múltiplos de 25, 125, .... Para obtenerlos, divídalos nentre 5 y recurse.

xnor
fuente
19

Jalea , 5 bytes

!Æfċ5

Utiliza el enfoque contraproducente de encontrar el factorial y luego factorizarlo nuevamente, verificando el exponente de 5 en la factorización prima.

Pruébalo en línea!

!              Factorial
 Æf            List of prime factors, e.g. 120 -> [2, 2, 2, 3, 5]
   ċ5          Count number of 5s
Sp3000
fuente
44
yikes Hable acerca de las compensaciones! Para reducir el código a 5 bytes, aumente la memoria y el tiempo en cantidades 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 gracias a NieDzejkob

pppery
fuente
Y esta es ahora mi respuesta más votada.
pppery
3
Una breve explicación para aquellos de nosotros que somos Mornington Crescentdesafiados sería genial. :)
Robert Benson el
-40 bytes usando nombres de línea más cortos donde sea posible.
NieDzejkob
18

Pyth, 6 bytes

/P.!Q5

Pruébalo aquí

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

Alternativa de 7 bytes :

st.u/N5

La reducción acumulativa .u/N5 divide repetidamente el piso por 5hasta que se repite, lo que en este caso ocurre después de que llega a 0.

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

Luego se elimina el primer elemento ( t) y se suma el resto ( s).

xnor
fuente
13

En realidad, 10 bytes

!$R;≈$l@l-

Pruébalo en línea!

Tenga en cuenta que el último caso de prueba falla cuando se ejecuta en serio en CPython porque math.factorial usa una extensión C (que está limitada a enteros de 64 bits). Sin embargo, ejecutar Seriously en PyPy funciona bien.

Explicación:

!$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
fuente
3
Oh wow, me gusta cómo este método no usa el truco de dividir por 5.
Arcturus
Cuento
1
@Score_Under En realidad usa la página de códigos CP437, no UTF-8. Cada caracter es un byte.
Mego
9

Haskell, 26 bytes

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

Floor-divide la entrada por 5, luego agrega el resultado a la función invocada. La expresión (+)=<<ftoma una entrada xy salidasx+(f x) .

Acortado 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

Una expresión no recursiva dio 28 bytes:

f n=sum[n`div`5^i|i<-[1..n]]
xnor
fuente
¿Es iun contador de 1..n?
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Sí, aunque solo depende del log_5(n)asunto, el resto da 0.
xnor
8

MATL , 9 bytes

:"@Yf5=vs

Pruébalo en línea!

Esto funciona para números muy grandes, ya que evita calcular el factorial.

Al igual que otras respuestas, esto explota el hecho de que el número de veces que 2aparece como divisor del factorial es mayor o igual que el número de veces 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
fuente
6

05AB1E, 5 bytes

Sería de 4 bytes si pudiéramos garantizar n> 4

Código:

Î!Ó7è

Explicación:

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

Solución alternativa, mucho más rápida, de 6 bytes: inspirada en la respuesta MATL de Luis Mendo

LÒ€`5QO

Explicación:

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: soluciones eliminadas usando ¢ (contar) ya que todos los primos que contienen 5 se contarán como 5, por ejemplo, 53.

Edición 2: se agregó una solución más eficiente para una mayor entrada como comparación.

Emigna
fuente
Sí, en lugar de , 5Qdebería funcionar. Buena respuesta sin embargo! :)
Adnan
Iba a probar entradas más grandes con el comentario "¿no fallaría esto si la salida fuera> 9", pero la implementación del chico 05AB1E Óes lenta
Sp3000
Por cierto, el primer código también puede ser Î!Ó2é. El error fue corregido ayer .
Adnan
Si está utilizando UTF-8, Î!Ó7èes de 8 bytes, y la solución "de 6 bytes" es de 10 bytes
Score_Under
@Score_Under Sí, eso es correcto. Sin embargo, 05AB1E usa la codificación CP-1252.
Adnan
6

Matlab (59) (54)(39)

Hola dawg !!!! te escuchamos como matemáticas ...

  @(n)sum(fix(n./5.^(1:fix(log(n)/1.6))))
  • Esto se basa en mi respuesta creada en la revisión de código .

  • más allá de lo que se menciona en mi respuesta en la revisión de código, la fórmula para el número de ceros en factorial (n) es Sum (n / (5 ^ k)) donde k varía entre 1 y log_5 (n)

  • La única razón trivial por la que no puede volverse más golfista es que log5no está disponible en matlab como incorporado, por lo que reemplacé log (5) por 1.6, no importa porque de todos modos estará en el piso.

Darle una oportunidad

Abr001am
fuente
Un par de preguntas. 1. ¿Cómo ejecutas esto en Matlab? 2. ¿Cuál es el resultado para n = 1?
Stuart Bruff
@StuartBruff para ejecutar este tipo ans (1) y devuelve 0.
Abr001am
OKAY. Gracias. Interesante. No he usado muchos manejadores de funciones en Matlab, por lo que estaba un poco desconcertado sobre cómo ejecutarlo ... ¿por qué los ans () no cuentan para el total? Sin embargo, una buena respuesta, lo intenté en Mathcad, pero tuve que modificar el límite superior de la suma, ya que Mathcad reduce automáticamente la variable de suma si el "superior" es menor que el límite "inferior" (y, por lo tanto, mi pregunta sobre 0).
Stuart Bruff
5

Mathematica, 20 bytes

IntegerExponent[#!]&

IntegerExponentcuenta los ceros. Por diversión, aquí hay una versión que no calcula el factorial:

Tr[#~IntegerExponent~5&~Array~#]&
LegionMammal978
fuente
Creo que Arrayahorra un byte en la segunda solución.
Martin Ender
5

C, 28 bytes

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

Explicación

El número de ceros finales es igual al número de cinco que forman el factorial. De todos 1..n, una quinta parte de ellos aporta un cinco, así que comenzamos con n/5. De estos n/5, un quinto son múltiplos de 25, por lo que contribuyen con cinco adicionales, y así sucesivamente. Terminamos con f(n) = n/5 + n/25 + n/125 + ..., que es f(n) = n/5 + f(n/5). Necesitamos terminar la recursión cuando nllega a cero; También aprovechamos el punto de secuencia ?:para dividirn antes de la adición.

Como beneficio adicional, este código es mucho más rápido que el que visita cada uno 1..n(y mucho, mucho más rápido que calcular el factorial).

Programa de prueba

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

Prueba de salida

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

Toby Speight
fuente
+1 para una excelente explicación
Titus
4

JavaScript ES6, 20 bytes

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

La misma táctica que en la respuesta de xnor, pero más corta.

Conor O'Brien
fuente
4

Julia, 34 31 30 bytes

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

Esta es una función anónima que acepta cualquier tipo de entero con signo y devuelve un entero. Para llamarlo, asígnelo a una variable. Los casos de prueba más grandes requieren pasar ncomo un tipo más grande, como a BigInt.

Calculamos el factorial de n(el uso manual prodes más corto que el incorporado factorial), obtenemos una matriz digitsen orden inverso, findlos índices de los elementos distintos de cero, obtenemos el primer índice y restamos 1.

Pruébalo en línea! (incluye todos menos el último caso de prueba porque el último lleva demasiado tiempo)

¡Ahorré un byte gracias a Dennis!

Alex A.
fuente
3

C, 36

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

El mismo método que la respuesta de @ xnor de contar 5s, pero solo usando un bucle for simple en lugar de recursión.

Ideone .

Trauma digital
fuente
@TobySpeight ahí tienes.
Trauma digital
3

Retina , 33 bytes

Toma entrada en unario.

Devuelve la salida en unario.

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

(Tenga en cuenta el avance de línea final).

Pruébalo en línea!

Cómo funciona:

El primer escenario:

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

Ligeramente incólume:

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

Que hace:

  • En primer lugar, encuentre la mayor cantidad de 11111eso que pueda igualarse.
  • Reemplazar por ese número
  • Efectivamente el piso se divide por 5.
  • La anticipación (?=1)asegura que el número sea positivo.
  • Los +`medios se repiten hasta idempotentes.
  • Entonces, la primera etapa es "división de piso repetida por 5"

Si la entrada es 100 (en unario), el texto ahora es:

;;1111;11111111111111111111

Segunda etapa:

;

Simplemente elimina todos los puntos y coma.

Monja permeable
fuente
2

Ruby, 22 bytes

Una de las pocas veces en que Ruby 0es verdadero es un problema para el conteo de bytes.

f=->n{n>0?f[n/=5]+n:0}
Tinta de valor
fuente
espera por qué es 0verdad?
Conor O'Brien
2
@ CᴏɴᴏʀO'Bʀɪᴇɴ En Ruby, nily falsefalsey, y nada más lo es. Hay muchos casos en los que ayuda en el golf, ya que 0ser sincero significa que el índice y las funciones de índice regex en Ruby regresan nilsi no hay coincidencia en lugar de hacerlo -1, y algunos en los que es un problema, como las cadenas vacías siguen siendo verdaderas.
Value Ink
@ KevinLau-notKenny Eso tiene sentido.
Conor O'Brien
2

Perl 6 , 23 bytes

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

Podría acortarlo si ^...se agregara a Perl 6 {sum $_,*div 5^...0} .
Debería ser más eficiente en la memoria para números más grandes si agrega un lazymodificador entresum y el generador de secuencia.

Explicación:

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

Prueba:

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

(Esa última línea es un poco engañosa, ya que MoarVM tiene que comenzar, cargar el compilador Perl 6 y el tiempo de ejecución, compilar el código y ejecutarlo. Por lo tanto, en realidad toma aproximadamente un segundo y medio en total.
Eso es significativamente más rápido que eso. fue verificar el resultado de la última prueba con WolframAlpha.com)

Brad Gilbert b2gills
fuente
2

Mathcad, [tbd] bytes

ingrese la descripción de la imagen aquí

Mathcad es una especie de "pizarra" matemática que permite la entrada en 2D de expresiones, texto y diagramas. Utiliza símbolos matemáticos para muchas operaciones, como suma, diferenciación e integración. Los operadores de programación son símbolos especiales, usualmente ingresados ​​como combinaciones de control y / o cambio de un solo teclado en una tecla estándar.

Lo que ve arriba es exactamente cómo se ve la hoja de trabajo de Mathcad a medida que se escribe y a medida que Mathcad la evalúa. Por ejemplo, cambiar n desde 2016 a cualquier otro valor hará que Mathcad actualice el resultado de 502 a cualquier valor nuevo.

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


El método de puntuación de equivalencia de bytes de Mathcad aún no se ha determinado. Tomando un símbolo de equivalencia, la solución toma aproximadamente 24 "bytes" (el operador while solo se puede ingresar usando la combinación de teclas "ctl-]" (o desde una barra de herramientas)). El método Matlab de Agawa001 toma aproximadamente 37 bytes cuando se traduce a Mathcad (el operador de suma se ingresa por ctl-shft- $).

Stuart Bruff
fuente
Parece una herramienta impresionante para manejar, ¡no perdonaré un segundo descargándola!
Abr001am
2

dc, 12 bytes

[5/dd0<f+]sf

Esto define una función fque consume su entrada desde la parte superior de la pila y deja su salida en la parte superior de la pila. Vea mi respuesta C para la base matemática. Dividimos repetidamente entre 5, acumulando los valores en la pila, luego agregamos todos los 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 prueba

# 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

Prueba de salida

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

Jolf, 13 bytes

Ώmf?H+γ/H5ΏγH

Define una función recursiva que se llama en la entrada. Pruébalo aquí!

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

J, 28 17 16 bytes

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

Prácticamente lo mismo que la técnica no recursiva de la respuesta de xnor.


Aquí hay una versión anterior que he guardado aquí porque personalmente me gusta más, registrando 28 bytes:

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

Si bien no es necesario, he incluido x:en los casos de prueba para mayor precisión.

   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

El último número no funciona con esta función.

Explicación

Esto funciona calculando n!, convirtiéndolo en una cadena y verificando la igualdad con cada miembro '0'. Para n = 15, este proceso sería:

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

Ahora, usamos ;._1para dividir la lista en su primer elemento (cero), encuadrando cada resultado de división, produciendo un recuadro lleno de ases ( a:) o series de 1s, así:

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

{:Simplemente obtenemos el último miembro ( ), lo desempaquetamos ( >) y realizamos una suma sobre él +/, produciendo el número de ceros.

Aquí está la versión más legible:

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
fuente
>:@i.se puede escribir 1+i.para guardar un byte.
algorithmshark
Su versión anterior se puede convertir en [:#.~'0'=":@!13 bytes cambiando el método de contar los 1 finales.
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
fuente
Esto no funciona, prueba los casos de prueba.
xnor
Debería funcionar ahora.
Magenta
1

Pyke, 5 bytes

SBP5/

Pruébalo aquí!

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

RETORNO , 17 bytes

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

Try it here.

Operador recursivo lambda. Uso:

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

Explicación

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

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

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

Utilizando:

> 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
fuente
1

Java, 38 bytes

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

Programa completo, con método sin golf:

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));
    }
}
Monja permeable
fuente
1

J, 7 bytes

Función monádica, tomando argumentos a la derecha.

3{:@q:!

Si xes positivo, x q: ydevuelve los exponentes en una factorización prima de y, solo para los primeros xnúmeros primos. El 3-rd prime es 5 y {:toma la cola de una lista.

Tenga en cuenta que debe ingresar números enteros con un xal final, de lo contrario, J los tratará como flotantes.

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

Pruébelo usted mismo en tryj.tk , aunque tenga en cuenta que este intérprete en línea se quejará si intenta algo más grande que 1343.

Si quieres algo que no calcule n ! y por lo tanto no requiere que quepa en un número entero, use la solución recursiva <.@%&5(+$:@)^:*. (Tryj.tk todavía es llorón en entradas grandes).

Algoritmo de tiburón
fuente
1

Ruby, 70 61 51 49 bytes

Versión 3 con agradecimiento a Kenny Lau y daniero

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

Editar: resulta que usted puede ahorrar dos bytes de mapeo to_i antes de quereduce . Raro: P

Esta función resta la suma de nlos 5 dígitos base de ny luego divide ese resultado entre 4. Esto está relacionado con la suma de las series geométricas.1+5+25+..+5**n = (5**n+1)/4 .

Como ejemplo (de nuevo, gracias a Kenny Lau), considere 358( 2413en base 5) menos sus dígitos de base 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

Divide 348por 4y obtienes f(358) = 87.

Versión 2 con agradecimiento a Kenny Lau

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

Esta función calcula n!luego resta el sizede n!del sizede (n!).reverse.to_i.to_s, lo que elimina todos los ceros, por lo tanto, devuelve el sizede los mismos ceros.

Versión 1

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

Esta es una variación de "¿Cuántos 5s hay en la factorización prima de n!?" truco que utiliza las funciones integradas de conversión de bases simples de Ruby.

El golf es un poco de un dolor sin embargo, con la conversión de Integera Stringa Array, agarrando parte de la Arrayy la conversión que para Stringa Integerde nuevo para el reduce. Cualquier sugerencia de golf es bienvenida.

Sherlock9
fuente
Es un poco más corto de mapear to_iantes de reducir: ->n{(n-n.to_s(5).chars.map(&:to_i).reduce(:+))/4}(ahorra dos bytes)
daniero
@daniero, no hubiera esperado eso. Gracias: D
Sherlock9
1

Dyalog APL , 9 bytes

⊥⍨'0'=⍕!⎕

solicitud de número

! factorizar

stringify

'0'= comprobar la igualdad con el carácter cero

⊥⍨ contar las pistas finales *


* Literalmente es una conversión de base mixta a base-10, utilizando la lista booleana como número y base:

⊥⍨0 1 0 1 1es lo mismo que 0 1 0 1 1⊥⍨0 1 0 1 1cuál es 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1)nuevamente dos (el número de 1s finales).

Adán
fuente