Gustavo Paes

Cron temporário utilizando bash

Se você tem um host onde a ativação de uma tarefa no cron pode levar alguns dias até o pessoal do suporte adicionar a entrada, mas você precisa desesperadamente testar um script ou um conjunto deles para verificar seu funcionamento no cron, crie o seu próprio cron. Crie um arquivo “run.sh” com o seguinte conteúdo:

#!/bin/sh

while [ 1 ];
do
    /usr/local/bin/php /caminho/ate/tarefa.php >> temp/log-exec.log
    sleep 1800
done

Depois, acesse via SSH seu servidor e execute:
$ chmod +x run.sh
$ ./run.sh > /dev/null &

Pronto, a cada 5 minutos o seu script será executado. Se quiser matar o processo:
$ ps x
$ kill -9 XXXXX

Onde XXXXX é o número do processo retornado pelo ps x.

Se quiser aumentar ou diminuir o tempo de execução, troque número 1800 do arquivo para o tempo desejado, em segundos.

Atenção: use com moderação e apenas para testes. Não utilize como uma forma definitiva de cron. Não tenho certeza sobre questões de desempenho ou segurança. Além do mais, qualquer restart no servidor irá fazer seu cron parar.

Firefox 3.6: acho que agora acertaram

Acabei de instalar o Firefox 3.6 e pelas primeiras impressões o bicho está bem mais rápido que nas versões anteriores. Vamos ver se posso voltar a usá-lo com meu histórico de 8 meses.

Procurando uma string em diversos arquivos

Tenho utilizado bastante SSH para desenvolvimento de um projeto e várias vezes tenho a necessidade de procurar por alguma função ou string qualquer em diversos arquivos.

Meu editor no Windows faz isso, mas não quando os arquivos estão em FTP, apenas local. Portanto tenho que fazer a busca via SSH, o que não é das piores coisas. Diria que é até melhor e mais rápido.

Utilizo um “juntado” de find com grep:

find ./ -name "*.php" -print0 | xargs -0 grep "nomeFuncao"

Isso vai procurar nomeFuncao em todos os arquivos php do projeto. Simples e rápido. Se quiser guardar o resultado em algum arquivo, utilize >>:

find ./ -name "*.php" -print0 | xargs -0 grep "nomeFuncao" >> resultado.txt

Project Euler: Problema 23

Ontem finalizei o problema 23 do Project Euler. O problema em si é de fácil solução, mas se você não pensar em otimizar ao máximo a execução do seu script, pode levar horas — como o meu levou — ou até mesmo dias, para conseguir o resultado final. E ainda pode conseguir um resultado errado.

O problema 23 explica o que é um número perfeito (aquele que a soma de seus divisores resultado no próprio número), número deficiente (aquele que a soma é menor que o próprio número) e número abundante (aquele que a soma é maior que o próprio número).

Como exemplo de um número perfeito, ele cita o 28, que possui os seguintes divisores:
1 + 2 + 4 + 7 + 14 = 28

E como exemplo de um número abundante, é citado o número 12:
1 + 2 + 3 + 4 + 6 = 16

Dito isso, o problema afirma que todos os números positivos inteiros maiores que 28123 podem ser encontrados através da soma de dois números abundantes. Mas que, de 0 até 28123, não é possível afirmar isso. E o problema pede no fim é que você encontre quais são os números que não podem ser encontrados através da soma de dois números abundantes e some eles. A resposta final essa.

Sabendo de tudo isso, algo que irá mudar sua vida a partir desse ponto, vamos pensar na solução. Primeira coisa que se precisa fazer é achar todos os números abundantes entre 0 e 28123. Para isso é preciso criar uma função que ache os divisores de um determinado número. Com ela, fica fácil descobrir quais são números abundantes e quais não são:

abundantes = []
for n in xrange(1, 28124):
	if sum(divisors(n)) > n:
		abundantes.append(n)

A função divisors retorna True ou False. Para conseguir achar tudo, a função leva cerca de meio minuto.

Com esses números em um array você tem duas opções:

1. Fazer um laço de 1 até 28123 verificando os números que podem ser encontrados através da soma de dois números abundantes;

2. Fazer todas as somas possíveis do números abundantes e guardar em um array para depois ir verificando de 1 a té 28123 qual deles existe nesse array.

A primeira opção foi a que eu escolhi primeiro (não tinha tido a segunda idéia ainda). Fiz o script sem grandes dificuldades mas logo percebi que a execução iria demorar, provavelmente, mais de dia.

Parti então para um segundo script — enquanto o primeiro ia ocupando 100% de um dos processadores — para tentar chegar a uma solução melhor. Foi quando pensei na segunda opção.

Mesmo com a segunda opção, que roda mais rápido que a primeira, o script levou quase 5 horas para encontrar o número final. O script é esse:

from divisors import divisors
import time

start = time.time()

# funcao que verifica se o parametro passado pode ser encontrado
# atraves da soma de algum dos numeros abundantes encontrado
def allSum(arr):
	all_sum = []
	limit = len(arr)

	f_index = 0 # primeiro indice
	s_index = 0 # segundo indice
	
	while f_index  n:
		abundantes.append(n)

print "... encontrados %d numeros" % len(abundantes)
print

print "Somando todos os abundantes entre si..."
all_sum = allSum(abundantes)

print "... encontrado %d resultados" % len(all_sum)
print

# percorre ate o limite
print "Descobrindo numeros que nao podem ser encontrados atraves da soma..."
numbers = []
for x in xrange(1, 28124):
	# apenas para controle no console
	if x%10 == 0:
		print x

	if x not in all_sum:
		numbers.append(x)

print
print
print sum(numbers)

print
print "achado em ", (time.time() - start) , "segundos"

Por sorte consegui chegar no resultado certo, senão seriam 5 horas de processamento jogados no lixo :)