Basicamente é o seguinte:

• Se o número é par, então divida por dois.
• Se o número é ímpar, então multiplique por três e some por um.
• 

Agora que temos a função definida, vamos realizar essa operação repetidamente, começando com um inteiro positivo e depois usando o resultado em cada passo:

O interessante é que essa seqüência parece sempre resultar em .

Programando

O desafio enunciado no UVa Online Judge pede para se contar o maior número de m-cíclos em um determinado intervalo de inteiros n, m.

Como eu gosto de coisas simples, fiz um algoritmo em C bem simples. Não recomendo algoritmo complexos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <stdio.h>
 
int collatz(int n) {
	int i = 1;
	while(n > 1) {
		if((n % 2) != 0)
			n = (3*n) + 1;
		else
			n = n/2;
		++i;
	}
	return i;
}
 
int main (int argc, char const *argv[])
{
	int i, j;
	while(scanf("%d %d", &i, &j) == 2) {
		int i2, j2, k;
		int max = 0;
 
		if (j < i) {
			i2 = j;
			j2 = i;
		} else {
			i2 = i;
			j2 = j;
		}
 
		for (k = i2; k <= j2; ++k) {
			int atual = collatz(k);
			if (max < atual) {
				max = atual;
			}
		}
 
		printf("%d %d %d\n", i, j, max);
	}
	return 0;
}

ou pelo pastebin

Testando as seguintes entradas
1 10
100 200
201 210
900 1000
1 999999
1000 900

temos
1 10 20
100 200 125
201 210 89
900 1000 174
1 999999 476
1000 900 174

Parece tudo certo!

Agora fica de exercício descobrir a complexidade desse algoritmo.

Calculando

Tendo isso em mente é bem fácil criar um algoritmo que calcule o número de Fibonacci, certo?
Na internet normalmente encontramos um algoritmo usando um método de recursão simples. Algo parecido com:

Felipe: Esse artigo usa apenas exemplos em C++

fibo1.cpp

#include <iostream>
#include <cstdlib>
 
int F(int n)
{
    if (n == 0) return 0;
    if (n == 1) return 1;
    return F(n - 1) + F(n - 2);
}
 
int main(int argc, char *argv[])
{
    int n = atoi(argv[1]);
    std::cout << F(n) << std::endl;
    return 0;
}

código no pastebin

Compilando:

g++ -o fibo1 fibo1.cpp

Rodando:

./fibo1 8

Deu 21, certo? Isso mesmo.

Analisando a Função

Mas digo para você: Não use esse programa! É totalmente ineficiente. O número de chamadas para calcular é exatamente . A função calcula recursivamente o mesmo número quantas vezes a chamar. Como podemos ver, a taxa de crescimento do número de Fibonacci tende a Proporção áurea:

Lembrando que a razão áurea é definida por:

Sim, fibo1.cpp é uma função exponencial com Big Theta Notation, em função do tempo, de:

O tempo de execução para computar é vezes mais demorado que para calcular . Por exemplo, já que e percebemos que nosso computador leva um segundo para calcular , então levará mais de um minuto para calcular e mais de uma hora para calcular .

Podemos verificar isso calculando e

pet@felipe-opensuse:~/Projetos/C++/algoritmos> time ./fibo1 36
14930352

real 0m1.077s
user 0m1.040s
sys 0m0.008s
pet@felipe-opensuse:~/Projetos/C++/algoritmos> time ./fibo1 45
1134903170

real 0m54.927s
user 0m54.547s
sys 0m0.092s

Em contraste, usando o método de programação dinâmica temos um tempo proporcional a N.

Programação dinâmica

Esse método consiste em guardar os valores dos números já calculados em um array. Fazendo isso, apenas checamos se o array já foi memorizado, e então retornamos o número, caso contrário calculamos recursivamente e assim por diante.
Lembrando que para um int de 32 bits, será o maior numero a ser calculado.

fibo2.cpp

#include <iostream>
#include <cstdlib>
 
namespace Fibonacci {
    int *memory;
    int F(int n)
    {
        // int inicializa como 0
        if (memory[n] != 0) return memory[n];
        int aux = n;
        if (n < 0) return 0;
        if (n > 1) aux = F(n-1) + F(n-2);
        return memory[n] = aux;
    }
}
 
int main(int argc, char *argv[])
{
    int n = atoi(argv[1]);
    Fibonacci::memory = new int[n+1];
    std::cout << Fibonacci::F(n) << std::endl;
    delete [] Fibonacci::memory;
    return 0;
}

código no pastebin

Compilando:

g++ -o fibo2 fibo2.cpp

Rodando:

./fibo2 8

Deu 21, de novo? =)

Aplicamos aqui uma técnica chamada bottom-up dynamic programming. Se aplica em uma função recursiva que podemos salvar tempo por armazenar valores anteriores que serão usados depois. Essa técnica tem sido usada para uma gama grande de algoritmos e aplicações. E essa simples mudança fez com que nosso algoritmo passasse de exponencial para linear.

Agora temos uma função, em relação ao tempo, proporcional ao N.

Comparando

Fazendo vários testes, podemos chegar em uma tabela de resultados, em função do tempo:

arquivo
fibo1.cpp	0m0.009s	0m1.156s	0m54.927s	1m29.403s
fibo2.cpp	0m0.007s	0m0.007s	0m0.006s	0m0.007s

fibo2.cpp é constante? Sim! Para N relativamente pequeno fibo2.cpp calcula em tempo constante.

Será interessante ver até quanto esse algoritmo agüenta(ta errado né? hehe ¬¬) fazer em tempo constante. Alguém se habilita?

Josephus foi um historiador judeu do primeiro século. A lenda conta que ele e 40 de seus homens estavam presos em uma caverna pelos Romanos. Eles decidiram suicidar-se à ser capturados. Formaram um circulo e começaram a se matar, da 3ª à 3ªa pessoa em ordem da fila. Como Josephus não queria morrer, ele foi capaz de escolher o melhor lugar, afim de sobreviver, e juntar-se os Romanos que o capturaram.

O Problema

Na prática o problema teria N pessoas em um círculo, iria ser percorrido M – 1 pessoas e o M iria ser morto, assim por diante, até sobrar uma única pessoa.

A Solução

Podemos representar a solução por uma função recursiva, para N par e M = 2:

e para N ímpar e M = 2, temos:

Não vou postar a solução genérica aqui pois exige uma grande explicação e esse não é o objetivo do post. Você pode ver na wikipedia ou então comprar o livro, caso queria saber mais.

O interessante é que o algoritmo para solução genérica é bem simples em C++. Usando listas ligadas(linked lists) é simples, fácil de entender e super rápido a execução do programa.

Josephus.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include <iostream>
#include <cstdlib>
 
struct Pessoa {
	int num;
	Pessoa *prox;
	Pessoa(int x, Pessoa *p) {
		num = x;
		prox = p;
	}
};
 
int main(int argc, char *argv[]) {
	//'a' recebe primeira pessoa criada
	//e 'a' é linkado para si mesmo
	//depois 'b' é criado apontado para 'a'
	int N = atoi(argv[1]), M = atoi(argv[2]);
	Pessoa *a = new Pessoa(1, 0);
	a->prox = a;
	Pessoa *b = a;
 
	// Aloca na memória todas as pessoas
	// e 'b' recebe a última(enésima pessoa)
	// pois a contagem começa pela primeira('a')
	for (int i = 2; i <= N; ++i)
		b = (b->prox = new Pessoa(i, a));
 
	// Loop enquanto 'b' não estiver apontado
	// o próximo para ele mesmo
	while (b != b->prox) {
		// 'b' recebe a emésima pessoa
		for (int i = 1; i < M; ++i)
			b = b->prox;
		a = b->prox;
		b->prox = a->prox;
		delete a; // 'a' é morto =/
	}
 
	// O sobrevivente _o/
	std::cout << b->num << std::endl;
}

Ou então se preferir um link para o pastebin.

Analisando o Resultado

após compilar

g++ -o Josephus Josephus.cpp

rode o programa com N = 10 e M = 2

./Josephus 10 2

O valor deu 5? Verifique com a função. Bateu os valores?
Agora vá testando para 1 <= N <= 16 e M = 2.

for n in `seq 16`; do echo -n “$n: “; ./Josephus $n 2; done

Saída do loop:

1: 1
2: 1
3: 3
4: 1
5: 3
6: 5
7: 7
8: 1
9: 3
10: 5
11: 7
12: 9
13: 11
14: 13
15: 15
16: 1

Perceberam um certo padrão entre as respostas? A função genérica usa justamente esse padrão binário para solução.

Ultimamente eu estou mais dedicado ao estudo de algoritmos, C++, C e Python(é claro). Depois pretendo postar uma analise desse algoritmo passo a passo.

A história começa quando vim para o Canadá para trabalhar com Java e no fim das contas comecei a trabalhar com ASP.NET. Eu não tenho nada contra ASP.NET, pelo contrário, é uma ótima tecnologia.
Mas o problema é que aqui na empresa onde trabalho, eles não utilizam meu potencial(não que eu tenha muito). Aqui eu fico arrumando layout e controller ASP.NET, tabulando, fazendo relatórios e assim por diante. PELO AMOR NÉ?
E eu percebi que estava enferrujando em programação, prática e inclusive meu conhecimento.

Mas tudo bem. 5 Meses passaram…

Quando eu e o Luiz Vitor estavamos resolvendo o exercício do Alien Numbers (Google Code Jam 2007). E depois de 5 horas conseguimos hehe aquela alegria!!!

from __future__ import alien_number

Aí começamos a fazer do Maze(Labirinto). Tentamos, tentamos, tentamos e aí não deu mais tempo porque comecou o Google Code Jam 2008.

Os 2 primeiros exercícios da primeira fase eram fáceis. Um era sobre serach engine e outro era de esquema de trens. Não era necessários algoritmos complexos para resolver, apenas lógica.
Aí tudo bem, comecei a fazer o primeiro. Depois de uns 15 minutos entendi o que era para fazer e fui jantar. Jantando fui pensando o que iria fazer para resolver o problema. E tinha chegado numa conclusão simples.
Cheguei no meu computador e fui começar meu código. Em 30 min +- mandei minha versão e bééééééé: ERRADO. Aí fui repensar e vi o que estava errado e mandei de novo: bééééééé.
Aí comecei a ficar encucado. E em quanto isso o Bruno Gola e Lameiro já tinham resolvido. E eu e o Luiz nos elogiando: “Cara, nós somos muito burros!!!! hahahah” “Eu sou uma porta, pelo amor!!!”

Hoje comecei o exercício dos treins. Mais fácil do que o primeiro. Entendi a lógica, comecei a codar. E NADA hehehe Fiz um monte de coisa, vários davam certo mas uns davam errado e percebi de novo que era erro de código. Aí agora desisti já, nóis é muito burro e ano que vêm estamos aí. Só agora vou estudar muito! Comprei uns livros feras d+ de algoritmos, que por sinal recomendo a todos que querem ser bons programadores!

Mas falando a verdade, o Bruno Gola e o Lameiro e inclusive o Luiz são muito bons, muito melhor que eu. Mas eu fiquei injuriado pelo fato de eu não ter conseguido CODAR esses problemas, que estavam resolvidos na minha cabeça.

E agora a moral da história, voltando ao começo do post.

Nunca, mas NUNCA, vá trabalhar em um lugar(ou o que seja) onde não te estimulem e exija seu potencial! NUNCA

Poison

Sinceramente, se eu não tivesse para mudar de empresa agora no final do mês, eu largava tudo aqui, tudo mesmo. E voltava para o Brasil.
Prefiro ser pobre, morar num lugar onde a política é sinônimo de palhaçada, ao que desaprender tudo e ser um inútil.

Conversando com o Jader fui inspirado a escrever esse post.

Muitos, assim como eu, tiveram essa grande idéia de virar freelancer. Ser seu próprio chefe, escolher seus trabalhos, trabalhar com o que gosta, são idéias atrativas né?
Mas tudo o que é bom pode ficar ruim, ou péssimo!
Por que estou falando isso? Não é para assustar não, mas para você refletir sobre sua situação.

Perguntas para reflexão:
- Você já possui um trabalho? Você não gosta dele? Você têm benefícios(refeição, seguro, saúde …)?
Lembrete: como freelancer você não terá mais nada disso

- O que te faz pensar que como freelancer será melhor?
- Contato é a coisa mais importante para um freelancer, você têm bons contatos?
- Você é responsável? Cumpre horário? É disciplinado?
Lembrete: Você terá que acordar cedo, se policiar em msn/plurk/twitter

- Têm responsabilidades para com família? O que eles esperam de você?

- Está disposto a correr os riscos?
Se você responder que sim. Espero que seja o melhor!
É um desafio e não é dos fáceis. Mas pode trazer ótimos frutos e realizações.

Freelancer é uma boa, eu fui por 6 meses. Aprendi bastante, ralei bastante. Fiz palestras, projetos opensource, ajudei em projetos e etc. Foi muito proveitoso para mim. Mas no meu caso o que me atrapalhou foi a questão da disciplina.

Então, antes de tomar uma decisão pense! pense muito! E sejamos todos felizes!

E você? É freelancer? Relate sua experiência e dicas!

É, dizem que nada é impossível mesmo. Mas até quando temos que ficar sonhando?

Bom, apesar de ter menos de 2 anos de experiência eu já trabalhei em 4 empresas, desde pequenas até gigantes. Sempre tentando achar um emprego perfeito.

Como você define algo bom? Salário? Benefícios? Projetos? Tecnologia usada? Aprendizado?

Para nós que somos geeks(linuxeros) isso é mais difícil ainda! Gostamos de Python, PHP, Linux, Vim etc etc. Mas muitas vezes temos que engulir seco por trabalhar com ASP.NET (meu caso).
É, estou me cansando de novo. Não gosto da environment de trabalho, do projeto e principalmente da tecnologia usada. Meu direito, certo?

Mas até onde compensa ficar pulando de trabalho em trabalho, tentando achar algo que você se adapte? Ou então trabalhar por conta?
Muitas vezes você não pode fazer isso. Por falta de oportunidade ou “simplesmente” responsabilidades a cumprir.

Bom, eu já estava deixando essa coisa de ter emprego perfeito de lado. Até que me apareceu uma oportunidade para trabalhar com Linux, Python, PHP, C++/Qt GTK. Tudo opensource. Parece até um sonho. Aceitei na hora!

Mas e você? Acha que um dia vai para ser um Guido van Rossum do Google? O que faz para que isso um dia possa ser realizado? Vale a pena lutar por isso? Ou, talvez, não esquenta cabeça mais com isso?

Aqui eu dei um exemplo pessoal, mas não necessariamente você gosta de Linux.

Conte sua história

Mas o que será esse projeto?

RobotQt será um projeto com foco educativo e acadêmico. Com esse software, o usuário poderá simular sua programação autônoma de seu robô. Por exemplo em projeto como o FIRST.

Objetivo do projeto

Temos como o objetivo principal(por enquanto) motivar e incentivar o uso da robótica em escolas e universidades. Com o nosso software não será preciso ter um hardware físico para fazer testes. Outro fator positivo é que iremos portar nosso software para Windows, Mac e Linux.

Como funciona?

A idéia inicial(depois explico o porquê inicial) do projeto é fazer com que um usuário configure seu robôzinho com motores e sensores. Fazendo assim testes de uso dos sensores e motores.
O legal disso é que a engine pode ser estendida, fazendo com que você possa crias suas próprias classes. Exemplo: Você vai usar um tipo de sensor que não tem por padrão no software, então é só extender a classe abstrata Sensor e criar o seu próprio.
A parte mais legal do projeto é a programação da parte autônoma. Isso será feito com Lua(incentivo ao software livre brasileiro ). Todos os sensores e motores será acessado pelo seu programinha feito em Lua. Podendo fazer testes, loops e tudo que um autônomo têm direito.

Para o futuro do projeto, pretendemos suportar um maior numero de padrões de robótica e também hardware. Além da dar suporte para Python.
E pelo fato de ser software livre, acreditamos ter um suporte muito bom da comunidade e principalmente com código para dar uma maior extensão ao nosso suporte à sensores, etc.

Desenvolvimento

Projeto será desenvolvido com C++ e Qt4. Terá suporte a scripting em Lua.
E estamos também participando no Qt-Contest.

Quer ajudar no projeto?

Ainda não temos nenhum release, estamos em fase de planejamento. Mas todo tipo de ajuda será bem vinda!
Acesse o site do projeto!

Fiquem atentos, vou sempre estar postando mais sobre o projetinho.

Technorati Tags: RobotQt, C++, Qt, Robot, Simulation, Opensource

No caso aqui em casa usamos 2 computadores conectados por fio e 1 sem fio.

Se você já conectou tudo certinho no roteador, só falta o nosso slack reconhecer basta fazer assim:

# ifconfig eth1 192.168.0.4 netmask 255.255.255.0 up
# route add default gw 192.168.0.1
# dhcpcd eth1

Só unica coisa aí, é que você precisa saber qual porta eth vai ser necessária “upar” e qual o final do seu ip dentro da rede(no meu caso é o 4), mas tanto faz isso.

Vamos ver que é bem simples esse desafio.

Primeiro coisa a fazer é ler o desafio e perceber que temos 2 coisas importantes alí:

1. Mensagem criptografada
2. Senha da mensagem.

Feito isso já podemos matar o problema. Como?
Primeiro escolha a linguagem de programação que você quer resolver. No caso vamos utilizar Python.
Você pode baixar o blowfish.py aqui.

Se você abrir o código, pode perceber que no final do arquivo têm uns exemplos de uso. Ou simplesmente faça:

$ tail blowfish.py -n 20

A saída será essa:

if __name__ == '__main__':
    key = 'This is a test key'
    cipher = Blowfish (key)    print "Testing encryption:"
    xl = 123456
    xr = 654321
    print "\tPlain text: (%s, %s)" %(xl, xr)
    cl, cr = cipher.cipher (xl, xr, cipher.ENCRYPT)
    print "\tCrypted is: (%s, %s)" %(cl, cr)
    dl, dr = cipher.cipher (cl, cr, cipher.DECRYPT)
    print "\tUnencrypted is: (%s, %s)" %(dl, dr)
    print "Testing buffer encrypt:"
    text = 'testtest'
    print "\tText: %s" %text
    crypted = cipher.encrypt (text)
    print "\tEncrypted: %s" %crypted
    decrypted = cipher.decrypt (crypted)
    print "\tDecrypted: %s" %decrypted

Agora já sabemos como faz para chamar o método de criptografar e descriptografar.

Mas peraí, no exemplo acima o mensagem era uns números e não vários caracteres como na do nosso desafio.
Aí vem a primeira pegadinha..
nossa string foi convertida para codificação base 64.
Então teremos de converter toda a string para uma string conhecida pelo blowfish(ou não, temos que ver).

import base64
base64.b64decode('string_do_desafio')

Beleza, agora sabemos que está tudo ok. Temos que conhecer o Blowfish.

Para isso vamos dar uma pesquisada na internet.

…10 minutos depois…

Bom, pelo que eu vi aqui na wikipedia e vejo isso: A entrada para essa parte do algoritmo são 64 bits…
Com complexas contas chegamos que 64 bits = 8 Bytes = 8 caracteres. Para quem não entendeu ainda, fizemos 64 bits / 8 bits = 8 Bytes

Então quer dizer que o blowfish só recebe em blocos de 8 caracteres as entradas.. hmmmm interessante..
Sabendo isso, vamos ter que separar nossa string com muitos caracteres em várias de 8 caracteres apenas.

Faremos isso com um for normal e vamos cortar a string em vários blocos de 8 caracteres. Mas e se o último bloco conter apenas 6 caracteres? Para termos certeza de que a string contem 8 caracteres podemos forcar com o método string.ljust(variavel, 8 )

Não se esqueça que a senha também não deve ter menos de 8 caracteres, então está a outra dica: Usar o ljust() na senha também.

Depois disso é só você criar seu código. Eu criei uma classe bem simples que criptograda e descriptografa.

Na verdade é bem simples sim. Vou postar meu código aqui e quem quiser baixar ele fique a vontade..

Tente desvendar o mistério e resolva o desafio!!!

Agora só falta postarem o resultado, ficou fácil né? hehe

Faça download do cript.py

cript.py

#
# Feito em 22/08/2007
#
 
import sys
import string
import base64
import blowfish
 
__author__ = "Felipe Ferreri Tonello <felipe.tonello@gmail.com>"
 
class BFCript:
    """
Classe que usa criptografia Blowfish juntamente com encodificacao Base64
 
uso: cript.py cript|descript 'senha' 'texto'
 
PS: Quando for descriptografar, o texto deve estar codificado em Base64
    """
    CRIPTOGRAFAR = 0
    DESCRIPTOGRAFAR = 1
 
    def cript(self,  sKey,  sTxt,  iAction):
        bf = blowfish.Blowfish((len(sKey) < 8 and [string.ljust(sKey, 8)] or [sKey])[0])
 
        if iAction == self.DESCRIPTOGRAFAR:
            sTxt = base64.b64decode(sTxt)
 
        sCript = ""
 
        for i in [x*8 for x in range(0,  len(sTxt)/8+1)] :
            sSBox = sTxt[i:i+8]
            if len(sSBox) > 0 :
                if iAction == self.CRIPTOGRAFAR:
                    sCript += bf.encrypt(string.ljust(sSBox,  8))
                elif iAction == self.DESCRIPTOGRAFAR:
                    sCript += bf.decrypt(sSBox)
 
        if iAction == self.CRIPTOGRAFAR:
            return base64.b64encode(sCript)
        elif iAction == self.DESCRIPTOGRAFAR:
            return sCript
 
##################################################
 
if __name__ == "__main__" :
    bfc = BFCript()
    if len(sys.argv) != 4 or (sys.argv[1] != "cript" and sys.argv[1] != "descript"):
        print BFCript.__doc__
        sys.exit(0)
    elif sys.argv[1] == "cript" :
        print bfc.cript(sys.argv[2], sys.argv[3],  bfc.CRIPTOGRAFAR)
    elif sys.argv[1] == "descript" :
        print bfc.cript(sys.argv[2],  sys.argv[3],  bfc.DESCRIPTOGRAFAR)

Para quem não ta afim de ler tudo lá: Resumidamente nos mostra, por um raciocínio, que os detalhes fazem a diferença. E realmente faz. Em tudo em nossa vida.

Quando você vai comprar um tênis, e olha aquele da adidas lindo cheio de 3 listrinhas da marca, bonitão. Você decide comprar ele.
Mas quando olha pra plaquinha do preço dele, você cai de cara no chão! “R$400,00. O cara acha que sou o que?!”. Exatamente, os detalhes custam mais caro né. Se você tiver o dinheiro, ótimo, mas se não o tiver, já era! Vai ter que comprar aquele olimpikus de 100 conto.

Agora vamos analisar em nossos projetos. Colocar detalhes a mais com certeza deixaria o cliente mais satisfeito ainda. Não importa onde, no layout do sistema, no código do sistema, na acessibilidade, e assim por diante. Mas e aí, você cobraria por esses detalhes?

Será que fazendo isso não perderia o cliente?!

Mas agora, será que fazer detalhes no seu desenvolvimento que não tomaria tanto tempo, ou não seria algo muito complexo de se fazer, não compensaria? O seu cliente ficaria muito mais satisfeito, pois você fez além e pelo mesmo valor, e com certeza em um outro trabalho ele lembrará de você: “Aquele cara me fez um ótimo trabalho, em um valor acessível e com detalhes que fizeram a diferença!” (tá bom, eu sei que exagerei um pouco agora hehe)

Lembre-se sempre disso. Pode fazer a diferença!