/* 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 uma string de entrada?n!
que caberia no seu tipo inteiro! Bem, talvez outra hora.Respostas:
Python 2, 27 bytes
Os zeros finais são limitados por fatores de 5. O número de múltiplos
5
que é no máximon
én/5
(com divisão de piso), mas isso não conta os fatores repetidos em múltiplos de25, 125, ...
. Para obtê-los, dividan
por 5 e recorra.fonte
Gelatina , 5 bytes
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!
fonte
Mornington Crescent,
19491909 bytes-40 bytes graças a NieDzejkob
fonte
Mornington Crescent
desafiados seria legal. :)Pitão, 6 bytes
Experimente aqui.
Alternativa de 7 bytes :
A redução cumulativa
.u/N5
divide repetidamente o piso5
até obter uma repetição, o que nesse caso acontece depois de atingir 0.O primeiro elemento é então removido (
t
) e o restante é somado (s
).fonte
Na verdade, 10 bytes
Experimente online!
Observe que o último caso de teste falha ao executar Seriamente no CPython porque
math.factorial
usa uma extensão C (que é limitada a números inteiros de 64 bits). Rodar seriamente no PyPy funciona bem, no entanto.Explicação:
fonte
Haskell, 26 bytes
O piso divide a entrada por
5
e adiciona o resultado à função chamada. A expressão(+)=<<f
recebe uma entradax
e saídasx+(f x)
.Encurtado de:
Uma expressão não recursiva forneceu 28 bytes:
fonte
i
um contador1..n
?log_5(n)
assuntos, o resto dá 0.MATL , 9 bytes
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
2
aparece como divisor do fatorial é maior ou igual ao número de vezes que5
aparece.fonte
05AB1E, 5 bytes
Seriam 4 bytes se pudéssemos garantir n> 4
Código:
Explicação:
Solução alternativa, muito mais rápida, de 6 bytes: inspirada na resposta MATL de Luis Mendo
Explicação:
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.
fonte
5¢
,5Q
deve funcionar. Boa resposta embora! :)Ó
é lentaÎ!Ó2é
. O bug foi corrigido ontem .Î!Ó7è
tem 8 bytes, e a solução "6 bytes" é 10 bytesMatlab
(59) (54)(39)Hey dawg !!!! nós ouvimos você gostar de matemática ....
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á
log5
disponí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
fonte
Mathematica, 20 bytes
IntegerExponent
conta os zeros. Por diversão, aqui está uma versão que não calcula o fatorial:fonte
Array
economiza um byte na segunda solução.C, 28 bytes
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 comn/5
. Destesn/5
, um quinto são múltiplos de 25, portanto, contribuem com mais cinco, e assim por diante. Terminamos com of(n) = n/5 + n/25 + n/125 + ...
que éf(n) = n/5 + f(n/5)
. Precisamos terminar a recursão quandon
atingir zero; também aproveitamos o ponto de sequência em?:
para dividirn
antes 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
Saída de teste
fonte
JavaScript ES6, 20 bytes
A mesma tática da resposta do xnor, mas mais curta.
fonte
Julia,
343130 bytesEsta é 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
n
como um tipo maior, como aBigInt
.Calculamos o fatorial de
n
(usar manualmenteprod
é mais curto que o internofactorial
), obtemos uma matriz deledigits
em ordem inversa,find
os í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!
fonte
C, 36
O mesmo método da resposta do @ xnor de contar 5s, mas apenas usando um loop for simples em vez de recursão.
Ideone .
fonte
Retina , 33 bytes
Recebe entrada em unário.
Retorna a saída em unário.
(Observe o avanço da linha à direita.)
Experimente online!
Como funciona:
O primeiro estágio:
Ligeiramente não destruído:
O que faz:
11111
possível disso.5
.(?=1)
garante que o número é positivo.+`
meios se repetem até serem idempotentes.Se a entrada for 100 (em unário), o texto será agora:
Segundo estágio:
Apenas remove todos os pontos e vírgulas.
fonte
Ruby, 22 bytes
Uma das poucas vezes em que o Ruby
0
realmente é um problema para a contagem de bytes.fonte
0
verdade?nil
efalse
são falsey, e nada mais é. Há muitos casos em que ajuda no golfe, já que0
ser verdadeiro significa que as funções de índice index e regex no Ruby retornamnil
se não houver correspondência em vez de-1
, e em alguns casos isso é um problema, como cadeias vazias ainda sendo verdadeiras.Perl 6 , 23 bytes
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
lazy
modificador entresum
e o gerador de sequência.Explicação:
Teste:
(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)
fonte
Mathcad, [tbd] bytes
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- $).
fonte
dc, 12 bytes
Isso define uma função
f
que 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:Programa de teste
Saída de teste
fonte
Jolf, 13 bytes
Define uma função recursiva que é chamada na entrada. Experimente aqui!
fonte
J,
281716 bytesPraticamente 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:
Embora não seja necessário, incluí
x:
nos casos de teste uma precisão estendida.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'
. Poisn = 15
, esse processo seria:Agora, usamos
;._1
para dividir a lista em seu primeiro elemento (zero), encaixotando cada resultado da divisão, produzindo uma caixa cheia de ases (a:
) ou execuções de1
s, da seguinte forma: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:
fonte
>:@i.
pode ser gravado1+i.
para salvar um byte.[:#.~'0'=":@!
13 bytes, alterando o método de contagem dos 1s à direita.Python 3, 52 bytes
fonte
Pyke, 5 bytes
Experimente aqui!
fonte
RETURN , 17 bytes
Try it here.
Operador recursivo lambda. Uso:
Explicação
fonte
Perl,
2422 + 1 (-p
sinalizador) = 23 bytesUsando:
Programa completo:
fonte
Java, 38 bytes
Programa completo, com método não destruído:
fonte
J, 7 bytes
Função monádica, tendo argumento à direita.
Se
x
for positivo,x q: y
retorna os expoentes em uma fatoração primária dey
, apenas para os primeirosx
primos. O3
-rd primo é 5 e{:
leva o final de uma lista.Observe que você precisa inserir números inteiros com um
x
no final, caso contrário, J os tratará como flutuadores.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.)fonte
Ruby,
70615149 bytesVersão 3 com agradecimentos a Kenny Lau e daniero
Edit: Acontece que você pode salvar dois bytes por mapeamento
to_i
antes de vocêreduce
. Estranho: PEssa função subtrai a soma dos
n
5 dígitos da basen
e 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
(2413
na base 5) menos seus 5 dígitos base.Divida
348
por4
e você começaf(358) = 87
.Versão 2 com agradecimentos a Kenny Lau
Esta função calcula
n!
em seguida, subtrai osize
den!
dasize
da(n!).reverse.to_i.to_s
, que remove todos os zeros, assim, retornando osize
dos próprios zeros.Versão 1
Essa é uma variação do "Quantos
5
s existem na fatoração primária den!
?" 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
Integer
daString
paraArray
, pegando parte doArray
e converter isso paraString
aInteger
novamente para oreduce
. Todas as sugestões de golfe são bem-vindas.fonte
to_i
antes de reduzir:->n{(n-n.to_s(5).chars.map(&:to_i).reduce(:+))/4}
(poupa dois bytes)Julia,
2119 bytesUsa a fórmula recursiva da resposta do xnor .
Experimente online!
fonte
Dyalog APL , 9 bytes
⎕
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 a0 1 0 1 1⊥⍨0 1 0 1 1
qual é 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).fonte