2017 Dr. Walter F. de Azevedo Jr.

(1)

© 2 0 1 7 Dr . W a lte r F . d e A z e v e d o Jr . 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000111111111110001100000000000 000000000001111111111111111111000000001 000000000111111111111111111111111000000 000000000111111111111111111111111000000 000000000011111111111111111111100000000 000000001111111111111111111111111000000 000011111111111111111111111111111000000 001111111111111111111111111111110000000 111111111111111111111111111110000000000 111111111111111111111111111110000000000 000011111111111111111111111111111110000 001111111111111111111111111111111111000 011111111111111111111111111111111111000 001111111111111111111111111111111111100 000000011111111111111111111111111111110 000000001111111111111111111111111111110 000000000001111111111111111111111111110 000000000000011111111111111111111111110 000000000000000111111111111111111111000 000000000000000000000000001111000000000 000000000000000000000000000000000000000 000000000000000000000000000000000000000 000000000000000000000000000000000000000 www.python.org 1

(2)

Consideremos um algoritmo que tem um tempo de execução t dado t = 5n2_+12n+18

(linha azul do gráfico abaixo), onde n é o tamanho da entrada. Dizemos que este algoritmo tem um tempo de execução de ordem quadrática, ou O(n2_{) pois este é o}

termo de mais alto grau do polinômio.

De uma forma geral, podemos determinar uma constante c para o qual a desigualdade

5n2_+12n+18_c.n2_{se verifica, assim o tempo de execução é uma função quadrática.}

Quando usamos essa aproximação, estamos usando a notação Big-O.

Notação Big-O www.python.org t(s) n t = 5n2_+12n+18 t = 35n2 2

(3)

O desenvolvimento de algoritmos para Bioinformática teve um grande crescimento nos últimos anos. Iremos descrever as ideias centrais das técnicas mais usadas na pesquisa científica em Bioinformática.

 Busca Exaustiva  “Branch-and-Bound”  “Greedy”  Aprendizado de Máquina  Algoritmos Randomizados  Dividir e Conquistar  Programação Dinâmica

Algoritmos para Bioinformática

www.python.org

(4)

Para ilustrar os conceitos atrás das técnicas de desenho de algoritmos, vamos considerar um problema hipotético de procurarmos um telefone sem fio em casa. Para complicar a situação estamos com as duas mãos ocupadas e está escuro, de forma que não podemos confiar na visão, como indicado abaixo (Jones & Pevzner, 2004).

Fonte: Jones, N. C. & Pevzner, P. A. An Introduction to Bioinformatics Algorithms. The MIT Press,Cambridge, 2004. Algoritmos para Bioinformática

www.python.org

(5)

O algoritmo de busca exaustiva, ou força bruta, testa todas as alternativas do problema, para encontrar uma solução particular. No exemplo do telefone, ignoramos o som do toque do telefone, e, assim, simplesmente procuramos por cada cm2_da

casa, até acharmos o telefone. Os algoritmos que seguem este desenho, são fáceis de entender, mas tem como principal problema o tempo de execução. Outra característica que podemos destacar, é como iremos dividir a casa para procurar o telefone, um parâmetro comumente considerado em algoritmos de busca. Por exemplo, se procurarmos em quadrados de 10 cm de lado teremos um tempo, e usarmos um quadrado de 1 cm de lado, teremos um tempo bem maior.

Algoritmo de Busca Exaustiva (ou Força Bruta)

www.python.org

Fonte: Jones, N. C. & Pevzner, P. A. An Introduction to

(6)

Nesta classe de algoritmo, ao iniciarmos o algoritmo de foça bruta, podemos omitir certas alternativas, diminuindo o tempo da busca. No exemplo do telefone, considere que ao chegarmos no segundo andar da casa escutamos a campainha do telefone como vinda do andar de cima. Nesta situação, podemos ignorar o andar inferior.

Algoritmo do Tipo “Branch-and-Bound”

www.python.org

(7)

Muitos algoritmos são iterativos, os algoritmos do tipo “greedy’ consideram em cada iteração a alternativa mais promissora. Tomando-se o exemplo do telefone, podemos considerar que nos movimentaremos na direção de onde vem o som do telefone. Isto pode causar alguns problemas, como ilustrado abaixo, mas é uma forma de reduzirmos as alternativas testadas. Em cada aplicação temos que identificar como determinar a solução mais atrativa.

Algoritmo do Tipo “Greedy”

www.python.org

(8)

Algoritmos de Aprendizado de Máquina (Machine Learning) usam o comportamento prévio do sistema para a decidir como varrer as alternativas. No exemplo do telefone, temos da experiência prévia que em 85 % da vezes o telefone estava sobre o sofá da sala, em 5 % das vezes no quarto do casal, em 4 % das vezes na cozinha, e em 6 % em outros locais. Assim, podemos começar procurando no sofá da sala e seguimos a ordem indicada.

Algoritmo com Aprendizado de Máquina

www.python.org

Fonte: Jones, N. C. & Pevzner, P. A. An Introduction to Bioinformatics Algorithms. The MIT Press,Cambridge, 2004.

85 %

5 % 4 %

(9)

No algoritmo estocástico, a faixa de alternativas a serem testadas é escolhida de forma aleatória. Assim, no exemplo do telefone, consideremos que temos uma casa com seis cômodos, podemos atribuir números de 1 a 6 aos cômodos e jogar um dado para escolher que cômodo começar. Podemos também pensar que jogamos uma moeda e decidimos se começamos com os cômodos da parte superior ou da inferior. Em todo caso, temos um componente aleatório na decisão.

Algoritmo Estocástico

www.python.org

(10)

A ideia atrás desta classe e dividir um problema maior em subproblemas, independentes. Depois os subproblemas são resolvidos e combinados de forma a obtermos a solução do problema original. O ponto crítico nesta classe de algoritmos é como combinar as soluções dos subproblemas para obtermos a solução do problema principal.

Algoritmo do Tipo Dividir e Conquistar

www.python.org

(11)

O algoritmo de programação dinâmica tem uma abordagem mais refinada do algoritmo de dividir em conquistar. Ao dividir o problema, em subproblemas menores, o algoritmo evita repetir computações já realizadas, usando valores armazenados de iterações anteriores. Vamos dar como exemplo o jogo das pedras.

No jogo das Pedras consideramos dois jogadores e duas pilhas de pedras. Cada jogador pode tirar uma pedra da pilha 1, ou uma pedra do pilha 2, ou duas pedras, sendo uma de cada pilha. Os jogadores não podem tirar duas pedras da mesma pilha. Vence o jogador que tirar a última pedra. Vamos montar um gráfico que ilustra o mapa de como ganhar o jogo. Para exemplificar, vamos considerar que temos duas pilhas de 10 pedras cada.

Algoritmo do Programação Dinâmica

www.python.org

(12)

O “W” considera a situação ganhadora e “L” a perdedora. A situação é ganhadora quando há pelo menos um movimento que leva você a vencer. Montaremos um mapa bidimensional considerando todas as situações para duas pilhas de 10 pedras.

0 1 2 3 4 5 6 7 8 9 10 0 W 1 W W 2 3 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(13)

Inicialmente consideremos um jogo com uma pedra na pilha A e zero pedras na pilha B, como indicado no mapa abaixo, ou seja, um jogo J_1,0, usando-se a notação matricial. Esta é uma situação vencedora, visto que ao tirar a pedra o jogador vence.

0 1 2 3 4 5 6 7 8 9 10 0 1 W 2 3 4 5 6 7 8 9 10 Pilha B Pilha A J_1,0

Jogo das Pedras

www.python.org

(14)

O mesmo é verdadeiro para um jogo J_0,1, que indica uma pedra na pilha B. 0 1 2 3 4 5 6 7 8 9 10 0 W 1 W 2 3 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(15)

Quando o jogador encontra-se na situação J_1,1, ele está numa situação vencedora, visto que ele pode tirar uma pedra de cada pilha.

0 1 2 3 4 5 6 7 8 9 10 0 W 1 W W 2 3 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(16)

No jogo J_2,0 temos uma situação perdedora, pois só podemos tirar uma pedra da pilha A, o que leva a situação do jogo J_1,0, que é vitoriosa para o adversário.

0 1 2 3 4 5 6 7 8 9 10 0 W 1 W W 2 L 3 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(17)

O mesmo é verdadeiro para no jogo J_0,2. Observe que o jogo é simétrico, o que vale para J_i,j é mantido para J_j,i.

0 1 2 3 4 5 6 7 8 9 10 0 W L 1 W W 2 L 3 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(18)

No jogo J_1,2 temos uma situação de vitória, pois podemos escolher tirar uma pedra da pilha A, o que leva o adversário a um jogo J_0,2, onde ele perde.

0 1 2 3 4 5 6 7 8 9 10 0 W L 1 W W W 2 L 3 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(19)

Por simetria. 0 1 2 3 4 5 6 7 8 9 10 0 W L 1 W W W 2 L W 3 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(20)

No jogo J_2,2 não importa o movimento, o adversário ganha, então temos uma situação perdedora. Aplicando-se o mesmo raciocínio podemos preencher o mapa.

0 1 2 3 4 5 6 7 8 9 10 0 W L 1 W W W 2 L W L 3 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(21)

0 1 2 3 4 5 6 7 8 9 10 0 W L 1 W W W 2 L W L 3 W 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(22)

0 1 2 3 4 5 6 7 8 9 10 0 W L W 1 W W W 2 L W L 3 W 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(23)

0 1 2 3 4 5 6 7 8 9 10 0 W L W 1 W W W 2 L W L 3 W W 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(24)

0 1 2 3 4 5 6 7 8 9 10 0 W L W 1 W W W W 2 L W L 3 W W 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(25)

0 1 2 3 4 5 6 7 8 9 10 0 W L W 1 W W W W 2 L W L 3 W W W 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(26)

0 1 2 3 4 5 6 7 8 9 10 0 W L W 1 W W W W 2 L W L W 3 W W W 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(27)

0 1 2 3 4 5 6 7 8 9 10 0 W L W 1 W W W W 2 L W L W 3 W W W W 4 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(28)

0 1 2 3 4 5 6 7 8 9 10 0 W L W 1 W W W W 2 L W L W 3 W W W W 4 L 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(29)

0 1 2 3 4 5 6 7 8 9 10 0 W L W L 1 W W W W 2 L W L W 3 W W W W 4 L 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(30)

0 1 2 3 4 5 6 7 8 9 10 0 W L W L 1 W W W W 2 L W L W 3 W W W W 4 L W 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(31)

0 1 2 3 4 5 6 7 8 9 10 0 W L W L 1 W W W W W 2 L W L W 3 W W W W 4 L W 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(32)

0 1 2 3 4 5 6 7 8 9 10 0 W L W L 1 W W W W W 2 L W L W 3 W W W W 4 L W L 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(33)

0 1 2 3 4 5 6 7 8 9 10 0 W L W L 1 W W W W W 2 L W L W L 3 W W W W 4 L W L 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(34)

0 1 2 3 4 5 6 7 8 9 10 0 W L W L 1 W W W W W 2 L W L W L 3 W W W W 4 L W L W 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(35)

0 1 2 3 4 5 6 7 8 9 10 0 W L W L 1 W W W W W 2 L W L W L 3 W W W W W 4 L W L W 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(36)

0 1 2 3 4 5 6 7 8 9 10 0 W L W L 1 W W W W W 2 L W L W L 3 W W W W W 4 L W L W L 5 6 7 8 9 10 Pilha B Pilha A

Jogo das Pedras

www.python.org

(37)

Abaixo temos a tabela completa. 0 1 2 3 4 5 6 7 8 9 10 0 W L W L W L W L W L 1 W W W W W W W W W W W 2 L W L W L W L W L W L 3 W W W W W W W W W W W 4 L W L W L W L W L W L 5 W W W W W W W W W W W 6 L W L W L W L W L W L 7 W W W W W W W W W W W 8 L W L W L W L W L W L 9 W W W W W W W W W W W 10 L W L W L W L W L W L Pilha B Pilha A

Jogo das Pedras

www.python.org

(38)

Completamos com o jogo J_0,0 como uma situação hipotética de derrota. 0 1 2 3 4 5 6 7 8 9 10 0 L W L W L W L W L W L 1 W W W W W W W W W W W 2 L W L W L W L W L W L 3 W W W W W W W W W W W 4 L W L W L W L W L W L 5 W W W W W W W W W W W 6 L W L W L W L W L W L 7 W W W W W W W W W W W 8 L W L W L W L W L W L 9 W W W W W W W W W W W 10 L W L W L W L W L W L Pilha B Pilha A

Jogo das Pedras

www.python.org

(39)

A implementação da tabela abaixo identifica se dada uma posição de início, o jogador ganha ou perde. 0 1 2 3 4 5 6 7 8 9 10 0 L W L W L W L W L W L 1 W W W W W W W W W W W 2 L W L W L W L W L W L 3 W W W W W W W W W W W 4 L W L W L W L W L W L 5 W W W W W W W W W W W 6 L W L W L W L W L W L 7 W W W W W W W W W W W 8 L W L W L W L W L W L 9 W W W W W W W W W W W 10 L W L W L W L W L W L Pilha B Pilha A

Jogo das Pedras

www.python.org

(40)

Chamaremos este algoritmo, de programação dinâmica, de Rocks(n,m), ele retorna a string “W” ou “L” e tem como entrada o números de pedras em cada pilha.

0 1 2 3 4 5 6 7 8 9 10 0 L W L W L W L W L W L 1 W W W W W W W W W W W 2 L W L W L W L W L W L 3 W W W W W W W W W W W 4 L W L W L W L W L W L 5 W W W W W W W W W W W 6 L W L W L W L W L W L 7 W W W W W W W W W W W 8 L W L W L W L W L W L 9 W W W W W W W W W W W 10 L W L W L W L W L W L Pilha B Pilha A

Jogo das Pedras

www.python.org

(41)

Rocks(n,m) J_0,0 = “L” Para i de 1 até n Se J_i-1,0 == “W” J_i,0 = “L” Senão J_i,0 = “W” Para j de 1 até m Se J_{0, j-1} == “W” J_0,j = “L” Senão J_0,j = “W” Para i de 1 até n Para j de 1 até m Se J_{i-1, j-1} == “W” e J_{i, j-1} == “W” e J_{i-1, j} == “W” J_i,j = “L” Senão J_0,j = “W” Retorna J_n,m

Segue o pseudocódigo de Rocks(n,m).

Algoritmo do Programação Dinâmica (Rocks)

www.python.org

(42)

Se olharmos com atenção para a tabela veremos um padrão que facilita a programação. Veja que, quando i e j são pares, temos “L”. Nos outros casos temos “W”. 0 1 2 3 4 5 6 7 8 9 10 0 L W L W L W L W L W L 1 W W W W W W W W W W W 2 L W L W L W L W L W L 3 W W W W W W W W W W W 4 L W L W L W L W L W L 5 W W W W W W W W W W W 6 L W L W L W L W L W L 7 W W W W W W W W W W W 8 L W L W L W L W L W L 9 W W W W W W W W W W W 10 L W L W L W L W L W L Pilha B Pilha A

Algoritmo do Programação Dinâmica (FastRocks)

www.python.org

(43)

FastRocks(n,m)

Se n e m são ambos pares retorna “L”

Senão

retorna “W”

Segue o pseudocódigo de FastRocks(n,m).

Algoritmo do Programação Dinâmica (FastRocks)

www.python.org

(44)

O algoritmo de Needleman & Wunsch (Needleman and Wunsch, 1970) tem como foco o alinhamento global de sequências de DNA e proteínas. Com a explosão dos dados genômicos no final do século passado, um problema central nos estudos genômicos foi o alinhamento de sequências. Esses alinhamentos permitem inferir similaridade sequencial e relacionar com as aspectos biológicos, como evolução, função, conservação de estrutura tridimensional entre outros. O algoritmo de Needleman & Wunsch será descrito aqui como modelo para entendermos as principais características computacionais do alinhamento de sequências.

Algoritmo de Needleman & Wunsch

www.python.org

Referência:

Needleman, S. B. & Wunsch, C. D. (1970) "A General Method Applicable to the Search for Similarities in the Amino Acid Sequence of Two Proteins," J. Mol. Biol., 48, 443-453.

(45)

Considerando-se os tipos de algoritmos vistos até o momento, temos que o algoritmo de Needleman & Wunsch é de programação dinâmica.

O algoritmo de Needleman & Wunsch é dividido nas seguintes etapas:

1) Inicialização da matriz caminho; 2) Preenchimento da matriz caminho; 3) Alinhamento.

Para ilustrar o funcionamento do algoritmo, vamos considerar o alinhamento de duas sequências:

GAATTCAGTTA (sequência #1) (temos m bases na sequência) GGATCGA (sequência #2) (temos n bases na sequência)

Algoritmo de Needleman & Wunsch

www.python.org

(46)

Na fase de inicialização do algoritmo, montamos uma matriz m x n, como indicado abaixo. Essa matriz é chamada matriz caminho (path matrix). Na matriz caminho, às primeiras coluna e linha atribuímos zero, visto que estamos considerando um alinhamento sem penalidade de gap inicial.

Algoritmo de Needleman & Wunsch (Inicialização)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 G 0 A 0 T 0 C 0 G 0 A 0 Sequência #2 Sequência #1 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 8 9 10 11 46

(47)

Para o preenchimento da matriz, consideramos o início a partir da esquerda superior da matriz. Para cada elemento M_i,j da matriz, determinaremos a seguinte função

escore:

M_i,j = MAXIMUM[

M_{i-1, j-1} + S_i,j (coincidência ou não na diagonal da matriz), M_i,j-1 + w (gap na sequência #1),

M_i-1,j + w (gap na sequência #2)]

Onde w é o peso para inserção de um gap (intervalo), consideramos w = 0.

S_i,j = 1 se a base na posição i da sequência #1 é a mesma da posição j na sequência #

2 (escore de coincidência), caso contrário,

S_i,j = 0 (escore para não coincidência)

Algoritmo de Needleman & Wunsch (Preenchimento)

www.python.org

(48)

Aplicando-se o critério temos: M_1,1 = MAXIMUM[

M_{0, 0} + S_1,1 (coincidência ou não na diagonal da matriz), M_1,0 + w (gap na sequência #1),

M_0,1 + w (gap na sequência #2)] = MAXIMUM[1,0,0], ou seja, M_1,1 = 1

www.python.org Sequência #2 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 A 0 T 0 C 0 G 0 A 0 Sequência #1 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 8 9 10 11 48

(49)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 1 A 0 T 0 C 0 G 0 A 0 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 49

(50)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 1 A 0 1 T 0 C 0 G 0 A 0 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 50

(51)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 1 A 0 1 T 0 1 C 0 G 0 A 0 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 51

(52)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 A 0 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 52

(53)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 53

(54)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 54

(55)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 55

(56)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 56

(57)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 57

(58)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 58

(59)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 59

(60)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 60

(61)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 61

(62)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 62

(63)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 63

(64)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 64

(65)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 A 0 1 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 65

(66)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 A 0 1 2 T 0 1 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 66

(67)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 A 0 1 2 T 0 1 2 C 0 1 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 67

(68)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 A 0 1 2 T 0 1 2 C 0 1 2 G 0 1 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 68

(69)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 A 0 1 2 T 0 1 2 C 0 1 2 G 0 1 2 A 0 1 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 69

(70)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 A 0 1 2 T 0 1 2 C 0 1 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 70

(71)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 A 0 1 2 T 0 1 2 C 0 1 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 71

(72)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 A 0 1 2 T 0 1 2 C 0 1 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 72

(73)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 A 0 1 2 T 0 1 2 C 0 1 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 73

(74)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 A 0 1 2 T 0 1 2 C 0 1 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 74

(75)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 A 0 1 2 T 0 1 2 C 0 1 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 75

(76)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 A 0 1 2 T 0 1 2 C 0 1 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 76

(77)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 A 0 1 2 T 0 1 2 C 0 1 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 77

(78)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 A 0 1 2 T 0 1 2 C 0 1 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 78

(79)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 T 0 1 2 C 0 1 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 79

(80)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 2 T 0 1 2 C 0 1 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 80

(81)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 2 T 0 1 2 2 C 0 1 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 81

(82)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 2 T 0 1 2 2 C 0 1 2 2 G 0 1 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 82

(83)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 2 T 0 1 2 2 C 0 1 2 2 G 0 1 2 2 A 0 1 2 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 83

(84)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 2 T 0 1 2 2 C 0 1 2 2 G 0 1 2 2 A 0 1 2 3 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 84

(85)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 2 2 T 0 1 2 2 C 0 1 2 2 G 0 1 2 2 A 0 1 2 3 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 85

(86)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 2 2 2 T 0 1 2 2 C 0 1 2 2 G 0 1 2 2 A 0 1 2 3 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 86

(87)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 2 2 2 2 T 0 1 2 2 C 0 1 2 2 G 0 1 2 2 A 0 1 2 3 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 87

(88)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 2 2 2 2 2 T 0 1 2 2 C 0 1 2 2 G 0 1 2 2 A 0 1 2 3 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 88

(89)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 2 2 2 2 2 2 T 0 1 2 2 C 0 1 2 2 G 0 1 2 2 A 0 1 2 3 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 89

(90)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 2 2 2 2 2 2 2 T 0 1 2 2 C 0 1 2 2 G 0 1 2 2 A 0 1 2 3 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 90

(91)

www.python.org 0 G A A T T C A G T T A 0 0 0 0 0 0 0 0 0 0 0 0 0 G 0 1 1 1 1 1 1 1 1 1 1 1 G 0 1 1 1 1 1 1 1 2 2 2 2 A 0 1 2 2 2 2 2 2 2 2 2 T 0 1 2 2 C 0 1 2 2 G 0 1 2 2 A 0 1 2 3 Sequência #1 0 1 2 3 4 5 6 7 Sequência #2 0 1 2 3 4 5 6 7 8 9 10 11 91