/* 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>
n
ser una cadena de entrada?n!
que encajaría en su tipo entero! Bueno, tal vez en otro momento.Respuestas:
Python 2, 27 bytes
Los ceros finales están limitados por factores de 5. El número de múltiplos
5
que son como máximon
esn/5
(con división de piso), pero esto no cuenta los factores repetidos en múltiplos de25, 125, ...
. Para obtenerlos, divídalosn
entre 5 y recurse.fuente
Jalea , 5 bytes
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!
fuente
Mornington Crescent,
19491909 bytes-40 bytes gracias a NieDzejkob
fuente
Mornington Crescent
desafiados sería genial. :)Pyth, 6 bytes
Pruébalo aquí
Alternativa de 7 bytes :
La reducción acumulativa
.u/N5
divide repetidamente el piso por5
hasta que se repite, lo que en este caso ocurre después de que llega a 0.Luego se elimina el primer elemento (
t
) y se suma el resto (s
).fuente
En realidad, 10 bytes
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:
fuente
Haskell, 26 bytes
Floor-divide la entrada por
5
, luego agrega el resultado a la función invocada. La expresión(+)=<<f
toma una entradax
y salidasx+(f x)
.Acortado de:
Una expresión no recursiva dio 28 bytes:
fuente
i
un contador de1..n
?log_5(n)
asunto, el resto da 0.MATL , 9 bytes
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
2
aparece como divisor del factorial es mayor o igual que el número de veces que5
aparece.fuente
05AB1E, 5 bytes
Sería de 4 bytes si pudiéramos garantizar n> 4
Código:
Explicación:
Solución alternativa, mucho más rápida, de 6 bytes: inspirada en la respuesta MATL de Luis Mendo
Explicación:
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.
fuente
5¢
,5Q
debería funcionar. Buena respuesta sin embargo! :)Ó
es lentaÎ!Ó2é
. El error fue corregido ayer .Î!Ó7è
es de 8 bytes, y la solución "de 6 bytes" es de 10 bytesMatlab
(59) (54)(39)Hola dawg !!!! te escuchamos como matemáticas ...
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
log5
no 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
fuente
Mathematica, 20 bytes
IntegerExponent
cuenta los ceros. Por diversión, aquí hay una versión que no calcula el factorial:fuente
Array
ahorra un byte en la segunda solución.C, 28 bytes
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 conn/5
. De estosn/5
, un quinto son múltiplos de 25, por lo que contribuyen con cinco adicionales, y así sucesivamente. Terminamos conf(n) = n/5 + n/25 + n/125 + ...
, que esf(n) = n/5 + f(n/5)
. Necesitamos terminar la recursión cuandon
llega 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
Prueba de salida
fuente
JavaScript ES6, 20 bytes
La misma táctica que en la respuesta de xnor, pero más corta.
fuente
Julia,
343130 bytesEsta 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
n
como un tipo más grande, como aBigInt
.Calculamos el factorial de
n
(el uso manualprod
es más corto que el incorporadofactorial
), obtenemos una matrizdigits
en orden inverso,find
los í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!
fuente
C, 36
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 .
fuente
Retina , 33 bytes
Toma entrada en unario.
Devuelve la salida en unario.
(Tenga en cuenta el avance de línea final).
Pruébalo en línea!
Cómo funciona:
El primer escenario:
Ligeramente incólume:
Que hace:
11111
eso que pueda igualarse.5
.(?=1)
asegura que el número sea positivo.+`
medios se repiten hasta idempotentes.Si la entrada es 100 (en unario), el texto ahora es:
Segunda etapa:
Simplemente elimina todos los puntos y coma.
fuente
Ruby, 22 bytes
Una de las pocas veces en que Ruby
0
es verdadero es un problema para el conteo de bytes.fuente
0
verdad?nil
yfalse
falsey, y nada más lo es. Hay muchos casos en los que ayuda en el golf, ya que0
ser sincero significa que el índice y las funciones de índice regex en Ruby regresannil
si no hay coincidencia en lugar de hacerlo-1
, y algunos en los que es un problema, como las cadenas vacías siguen siendo verdaderas.Perl 6 , 23 bytes
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
lazy
modificador entresum
y el generador de secuencia.Explicación:
Prueba:
(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)
fuente
Mathcad, [tbd] bytes
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- $).
fuente
dc, 12 bytes
Esto define una función
f
que 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:Programa de prueba
Prueba de salida
fuente
Jolf, 13 bytes
Define una función recursiva que se llama en la entrada. Pruébalo aquí!
fuente
J,
281716 bytesPrá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:
Si bien no es necesario, he incluido
x:
en los casos de prueba para mayor precisión.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'
. Paran = 15
, este proceso sería:Ahora, usamos
;._1
para dividir la lista en su primer elemento (cero), encuadrando cada resultado de división, produciendo un recuadro lleno de ases (a:
) o series de1
s, así:{:
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:
fuente
>:@i.
se puede escribir1+i.
para guardar un byte.[:#.~'0'=":@!
13 bytes cambiando el método de contar los 1 finales.Python 3, 52 bytes
fuente
Pyke, 5 bytes
Pruébalo aquí!
fuente
RETORNO , 17 bytes
Try it here.
Operador recursivo lambda. Uso:
Explicación
fuente
Perl,
2422 + 1 (-p
bandera) = 23 bytesUtilizando:
Programa completo:
fuente
Java, 38 bytes
Programa completo, con método sin golf:
fuente
J, 7 bytes
Función monádica, tomando argumentos a la derecha.
Si
x
es positivo,x q: y
devuelve los exponentes en una factorización prima dey
, solo para los primerosx
números primos. El3
-rd prime es 5 y{:
toma la cola de una lista.Tenga en cuenta que debe ingresar números enteros con un
x
al final, de lo contrario, J los tratará como flotantes.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).fuente
Ruby,
70615149 bytesVersión 3 con agradecimiento a Kenny Lau y daniero
Editar: resulta que usted puede ahorrar dos bytes de mapeo
to_i
antes de quereduce
. Raro: PEsta función resta la suma de
n
los 5 dígitos base den
y 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
(2413
en base 5) menos sus dígitos de base 5.Divide
348
por4
y obtienesf(358) = 87
.Versión 2 con agradecimiento a Kenny Lau
Esta función calcula
n!
luego resta elsize
den!
delsize
de(n!).reverse.to_i.to_s
, lo que elimina todos los ceros, por lo tanto, devuelve elsize
de los mismos ceros.Versión 1
Esta es una variación de "¿Cuántos
5
s hay en la factorización prima den!
?" 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
Integer
aString
aArray
, agarrando parte de laArray
y la conversión que paraString
aInteger
de nuevo para elreduce
. Cualquier sugerencia de golf es bienvenida.fuente
to_i
antes de reducir:->n{(n-n.to_s(5).chars.map(&:to_i).reduce(:+))/4}
(ahorra dos bytes)Julia,
2119 bytesUtiliza la fórmula recursiva de la respuesta de xnor .
Pruébalo en línea!
fuente
Dyalog APL , 9 bytes
⎕
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 1
es lo mismo que0 1 0 1 1⊥⍨0 1 0 1 1
cuál es0×(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).fuente