[quote=flaleite]Willerson,
Vc pode fazer a uma versão para os “rubyzeros” entenderem. 
(…)
Brincadeirinha… Paz… :lol: :lol: [/quote]
a) Só tem um “l”.
b) Ei, o “rubyzeros” é alguma crítica oculta? :lol: Se for, se ferrou, eu sou Ruby-enthusiast também. 
c) Eu procurei manter a convenção de linhas com no máximo 80 caracteres.
Brincadeirinha again. :lol:
[quote=#@®®¡$][quote=flaleite]Willerson,
Vc pode fazer a uma versão para os “rubyzeros” entenderem.
(…)
Brincadeirinha… Paz… :lol: :lol: [/quote]
a) Só tem um “l”.
b) Ei, o “rubyzeros” é alguma crítica oculta? :lol: Se for, se ferrou, eu sou Ruby-enthusiast também.
c) Eu procurei manter a convenção de linhas com no máximo 80 caracteres.
Brincadeirinha again. :lol:[/quote]
Desculpe pelo l a mais :oops:
Eu tbm sou pró Ruby e acho uma Rails fantastico. Mas eu só fiz essa brincadeira para mostrar que uma boa solução independe da qtde de linhas ou caracteres.
Versões em Python, Smalltalk, Lisp, Pascal, COBOL, PL1, Natural, VB, Clipper, Brainf*ck, Ada … são bem-vindas! 
Versao Ruby "clonada" da versao Groovy do Rafael Afonso :lol:
def limpaDir(nameDir, diasAtras)
diaMinimo = Time.now - diasAtras*24*60*60
Dir.glob("#{nameDir}/*.*").each do |f|
File.delete(f) if (File.mtime(f) < diaMinimo)
end
end
limpaDir("/temp/backup", 7)flw!
[quote=WNS]Versao Ruby "clonada" da versao Groovy do Rafael Afonso :lol:
def limpaDir(nameDir, diasAtras)
diaMinimo = Time.now - diasAtras*24*60*60
Dir.glob("#{nameDir}/*.*").each do |f|
File.delete(f) if (File.mtime(f) < diaMinimo)
end
end
limpaDir("/temp/backup", 7)flw![/quote]
Legal WNS, tinha feito algo muito parecido também, mas tu chegou antes. Mas confesso que estava fazendo mais artesanalmente, não conhecia o Dir.glob
Reload. Novo code contest: http://nullability.org/?p=49
Aproveitem o tempo ocioso de vocês e, ao invés de ficarem batendo boca sobre estas coisas do Fantástico, quebrem a cabeça com algo divertido
Credo, nunca achei que fatorial pudesse ser tão complicado… hehehe… (;
Em Python é fácil. Já deixei meu post lá. Só não sei quanto tempo leva para calcular 200000!
Em MIT Scheme Lisp há uma implementação recursiva na própria documentação que não funciona para n > 30000 aproximadamente; vou ter de reescrever uma implementação iterativa.
Já arriscou Haskell Daniel???Para que tanto trabalho…
fato::Int->Int
fato n
| n==0=1
| otherwise =n*fato(n-1)Ou ainda usando a funca product:
fato::Int
fato=product[1..10]O chato é por para rodar um valor tão alto, vai demorar um teeempo…
Em Ruby:
def fatorial(n)
i = fat = 1
n.times do
fat = fat * i
i = i + 1
end
fat
end
init = Time.now
puts fatorial(200000)
fini = Time.now
puts "Tempo: " + (fini-init).to_s + "s"Da última vez que eu testei esse código ele tinha conseguido calcular o fatorial de 10000. O de 200000 eu estou testando agora, se der certo eu aviso!
Edit: Quanto tempo isso demora??? :shock: :shock:
Edit 2: Finalmente! 4219,35 segundos… Uma hora e dez minutos, aproximadamente. E acho que os números gerados pelo programa em Ruby e em Java são iguais… Para criar o arquivo eu simplesmente redirecionei a saída para um arquivo. Depois apaguei tudo que não era fatorial de 200000 dos arquivos gerados pelo ruby e pelo java e usei diff para compará-los.
Em groovy:
import java.math.BigInteger
def fatorial(n) {
BigInteger result = BigInteger.ONE
aux = 1
n.times { result *= aux++ }
result
}
init = System.currentTimeMillis()
println fatorial(200000)
fini = System.currentTimeMillis()
println "Tempo: ${ (fini-init) } ms"Vale lembrar que o desafio em si não é quem consegue calcular fatorial com a menor quantidade de linhas de código possível, mas quem consegue calcular o fatorial de um número beeeeeem grande de maneira beeeeeem rápida. No exemplo em Java que foi mostrado como referência, calcular 200000! em um Pentium 4 3.06Ghz (Dual Core), com 1 Gb de RAM usando a JVM 1.5.0_06 sem nenhum tipo de tuning leva aproximadamente 150 segundos (2 minutos e meio).
No modo threaded ou simple? A minha máquina é um Sempron 2.1Ghz com 512MB de RAM.
Daniel,
Seria interessante você ou alguem botar para rodar todas as versões em uma mesma máquina.
Ou usar um denominador comum para equalizar os tempos em diferentes máquinas.
O modo threaded rodou quase 10x mais rápido que o simple na minha máquina aqui do trampo (P4 3.00 GHZ, 512 RAM JVM 1.5.0_04 ), uns 170 segundos.
[quote=flaleite]Daniel,
Seria interessante você ou alguem botar para rodar todas as versões em uma mesma máquina.
Ou usar um denominador comum para equalizar os tempos em diferentes máquinas.
[/quote]
Eu tento, Flávio. Mas é complicado: como vou botar uma aplicação Haskell para executar um fatorial de 200.000! que vai levar quase um dia inteiro?
[quote=Daniel Quirino Oliveira][quote=flaleite]Daniel,
Seria interessante você ou alguem botar para rodar todas as versões em uma mesma máquina.
Ou usar um denominador comum para equalizar os tempos em diferentes máquinas.
[/quote]
Eu tento, Flávio. Mas é complicado: como vou botar uma aplicação Haskell para executar um fatorial de 200.000! que vai levar quase um dia inteiro? [/quote]
hahahaha… as que vc não conseguir rodar por ai, por falta de tempo ou de ambiente peça ao pessoal que enviar (ou que puder) que rode anote o tempo e envia a spec da máquina.
eu estou des de ontem no final da tarde tentando rodar o fatorial de 200.000.000 :D:D:D
Vou rodar em c++ usando a lib MAPM e ver o que dá, mas me parece que java vai levar vantagem…
#include "stdafx.h"
#include "stdio.h"
#include "m_apm.h"
#include "iostream.h"
#include <sys/timeb.h>
#include <time.h>
MAPM Factorial(MAPM n)
{
MAPM i;
MAPM product=1;
for (i=2; i<=n; i++)
product*=i;
return product;
}
int main(int argc, char* argv[])
{
struct _timeb timebuffer;
char *timeline;
char obuf[256];
_ftime( &timebuffer );
timeline = ctime( & ( timebuffer.time ) );
printf( "The time is %.19s.%hu %s", timeline, timebuffer.millitm, &timeline[20] );
MAPM n = Factorial(200000);
timeline = ctime( & ( timebuffer.time ) );
t.toString(obuf, 50);
printf("n = [%s] \n",obuf);
printf( "The time is %.19s.%hu %s", timeline, timebuffer.millitm, &timeline[20] );
return 0;
}
Threaded.
Mas vocês podem usar a estratégia que vocês quiserem para calcular 200000!. A questão é saber como vocês vão fazer isso executar rápido.