First of all, a vector is a logical definition from the Set Theory.

Let R be an equivalence relation for a set K. We define the Quotient Set, denoted by the symbol $K/R$, as:

$K/R := \{ [X]_R | X \in K \}$

Results that $K/R$ is a partition of K, i.e., $K/R$ is a class of non-empty subsets of K, pairwise disjoint and whose union is the class K.

In summary, we have the following important result:
If R an equivalence relation on a set K, than, the quotient set of K for R is a partition of K.

R is a relation defined in class K from all oriented segments in the plane, as follows:

$xy\ R\ uz$ if, and only if, the length of xy is same as uz, the line which support xy is parallel to uz and xy has the same direction as uz.
Results that R is an equivalence in K. Therefore:

$K/R = \{ [PQ]_R | PQ \in K \}$ is a partition of K. So,

$PQ \ R\ P'Q' \leftrightarrow [PQ]_R = [P'Q']_R$

Remembering that $[X]_R := \{ Y \in K | Y\ R\ X \} \subset K$. If you want to know more about, check the Equivalence Class.

So, a vector from the plane is, by definition, any one element of the quotient set $K/R$. Thus we have,

$PQ\ R\ P'Q' \leftrightarrow \vec{PQ} = \vec{P'Q'}$

If you think this is too much. There is an easy approach.
Vector is a set of all equipolent oriented segments together. i.e.

$\vec{AB} = \{ A'B' | A'B' \sim AB \}$

You have never wondered why it is correct to use equal sign ($=$) for "different but similar" vectors and it is incorrect to use equal sign for "different but similar" oriented segments? The truth is, since you are comparing sets(vectors) with the same elements(oriented segments), it is true when you say $\vec{a} = \vec{b}$. Now, if $a$ and $b$ were oriented segments, you will only be able to use the equal sign if a and b are really the same element in the plane(the same set of points).

Yes, logics is much more than computer algorithm or stuff like that.

Bom, o que parece é que o pessoal do GCC também não foi muito com a cara desse long long não.

long long long #fail no gcc

#FAIL para a ISO C99 ou pro GCC? Fica a dúvida.

Se você estiver procurando o melhor host que existe para hospedar seu site ou blog, descubra como ganhar esse desconto agora!

Fazendo isso, você estará contribuindo para que seja pago meu plano de hospedagem. Muito obrigado!

Se tiver alguma dúvida ou sugestão, fique à vontade para comentar.

É, 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

Pior que tinha muita coisa personalizada por lá, e a preguiça de fazer tudo de novo?

Será que tem alguma alma caridosa por aí para me doar um .vimrc?

Na verdade eu estou com uma idéia, vou ver se matuto nela essa semana e posto aqui!

Enquanto isso postem seus .vimrc para todos

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)

Desafio!!

Agora vamos para o legal.
O desafio é bem simples também.

Quem descriptografar essa mensagem vai ganhar um post aqui no meu blog além de se divertir um pouquinho heheh

9M39agUxnX8PRznCylaC1/6rEXVP5R85QTO/be8XAO+WRJ2nAGDQ4PWq
SOGSQe/CRDkegrH242gpfOcBHPZ6TURUMcQZXkSV8g7WcEIQiCLTuejOt0HCExewS
XUgxg8wRlvO6G2ZrKOv6YLzcsXmBHB/JbZ5nuMnlIYQNGj1ncYHbxyJrGHj1Xr7Q696E+u
WfcZAm9z/iRfZ9rb79EXY7f/5BBEvdkluxDpedPzam33CQLZoEVixSOwVI18USigj45W6fDk+
yFTGkLF1tmh5Zg==

O detalhe é que não existe essas quebras de linha, só coloquei por questão de não destruir o layout.
A senha da mensagem criptografada é: desafio

Blowfish para Python (está em arquivo .txt porque meu servidor não deixa baixar script direto )
Blowfish para PHP(pear package)
Blowfish para Java
Blowfish para C++
Blowfish para C
Blowfish para Pascal
Blowfish para Perl

O desafiante pode usar qualquer tipo de linguagem de programação. O Blowfish existe em qualquer linguagem, até Javascript. É só dar uma pesquisada.

Se você não conhecer criptografia e muito menos blowfish, a ideia principal é dar uma pesquisada como que descriptografa usando a técnica blowfish..

PS: Esse desafio é simples, mas existe pegadinhas nele. hehehe

Resposta do desafio!

Sem os blogs, o que poderia ser de nós?

85%How Addicted to Blogging Are You?

Mingle² - Dating Site

E você quantos % é viciado? hehe

Está rolando uma campanha para que no dia 24 de março as pessoas desliguem seus computadores e façam outras coisas. Claro que isso se aplica aos geeks e nerds.

Participe também. Entre no site oficial do Shutdown day e cadastre-se.

E aí, você consegue? Irá fazer o que no dia? Eu vou passar o dia com amigos.