MAC 122 - PDA

2. Semestre de 2019 - prof. Marcilio – IME USP BMAC

Segunda Prova – 21 de novembro de 2019

Questão 1 2 3 4 5 6 7 8 Total
Valor 1 1 1 1 1 1 2 2 10,0
Nota

________________________________ _______________________________
Nome legível Assinatura: (como na lista de presença)

NUSP com 8 dígitos 8 5 8 7 5 4 4 3

Questão 1 (1 ponto):

Considere os 8 dígitos do seu NUSP. Some a cada um deles 10 x posição.

Inseri-los numa tabela HASH com 10 posições na mesma ordem.
Exemplos:
Se seu NUSP é 85875443 os números a inserir serão: 8 15 28 37 45 54 64 73
Se seu NUSP é 11100022 os números a inserir serão: 1 11 21 30 40 50 62 72

Portanto, com o seu NUSP os números a inserir serão:

Supondo NUSP = 85875443

8 15 28 37 45 54 64 73

Com esses 8 números, diga qual o conteúdo da tabela HASH nos casos abaixo:

a) Tabela HASH simples com função de HASH: x % 10 (resto da divisão por 10).

i 0 1 2 3 4 5 6 7 8 9
tab[i] 64 None None 73 54 15 45 37 8 28

b) Tabela HASH duplo com a mesma função de HASH e passo 3:

i 0 1 2 3 4 5 6 7 8 9
tab[i] 54 28 None 64 45 15 73 37 8 None
Questão 2 (1 ponto):

O Algoritmo de Boyer-Moore (versão 1) para procurar uma palavra A em um texto B, verifica qual o
próximo caractere de B para decidir qual o deslocamento de A para a próxima comparação com B. A
comparação é feita da direita para a esquerda.

Considere agora como texto A a string com seu NUSP de 8 dígitos. Com esse algoritmo, diga qual o
deslocamento a ser feito em A quando o próximo caractere de B for igual a um dos dígitos de 0 a 9.

Supondo NUSP = 85875443

Caractere Deslocamento
0 9
1 9
2 9
3 1
4 2
5 4
6 9
7 5
8 6
9 9
Questão 3 (1 ponto):

Considere o seu NUSP de 8 dígitos.

Supondo NUSP = 85875443

a) Dê uma permutação desse NUSP para a qual sejam necessárias 5 trocas usando o método da
Bolha para a classificação.

44557388

b) Idem para 7 trocas.

44557883

c) Considerando a permutação onde o seu NUSP tem os mesmos dígitos em ordem decrescente.
Exemplo: Se o seu NUSP é 43367432, em ordem decrescente seria: 76443332

Portanto, seu NUSP em ordem decrescente será:

8 8 7 5 5 4 4 3

Quantas trocas serão necessárias pelo método da Bolha?

25
Questão 4 (1 ponto):

Considere uma lista V com 8 elementos. Cada elemento contém um algarismo de seu NUSP.

Exemplo: Se o seu NUSP é 84783624 então:

Supondo NUSP = 84783624 (neste exemplo o último dígito também é 4)

i 0 1 2 3 4 5 6 7
V[i] – exemplo 8 4 7 8 3 6 2 4
V[i] com seu NUSP 8 4 7 8 3 6 2 4

a) Usando o algoritmo de partição da tabela usado pelo método Quick em que o último elemento é
o pivô (no exemplo acima o 4) qual seria a situação da tabela com seu NUSP no final da
primeira operação de partição.

i 0 1 2 3 4 5 6 7
V[i] 2 4 3 4 8 6 7 8

b) Idem se os dígitos do seu NUSP estivessem em ordem decrescente.

Exemplo: Se o seu NUSP é 84783624 então:

i 0 1 2 3 4 5 6 7
V[i] – exemplo 8 8 7 6 4 4 3 2
V[i] com seu NUSP 8 8 7 6 4 4 3 2
decrescente

i 0 1 2 3 4 5 6 7
V[i] 2 8 7 6 4 4 3 8
Questão 5 (1 ponto):

Considere uma lista V com os 8 dígitos do seu NUSP em ordem crescente.

Exemplo: Se o seu NUSP é 84783624 então:

Supondo NUSP = 84783624

i 0 1 2 3 4 5 6 7
V[i] – exemplo 2 3 4 4 6 7 8 8
V[i] com seu NUSP 2 3 4 4 6 7 8 8

Usando o algoritmo de busca binária em tabela ordenada, diga quantas comparações serão necessárias
com elementos da tabela para se procurar cada um dos dígitos de 0 a 9 nesta tabela:

Procurar o dígito Comparações necessárias

0 3
1 3
2 3
3 2
4 1
5 3
6 3
7 2
8 3
9 4
Questão 6 (1 ponto):

Para cada um dos algoritmos abaixo, diga qual a sua ordem em função de n (notação O(n)):

a) O(log n) – valores de i = 1, 10, 100, ...

def F1(n):
s, i = 0, 1
while i < n:
s = s + n * n
i = i * 10
return s

b) O(n) – variação de n: n, n-1, n-2, ..., 0

def F2(n):
s = 0
while n > 0:
s = s + n * n
n = n - 1
return s

c) O(n) – chamadas de F3 com: n, n-1, n-2, ..., 0

def F3(n):
if n < 1: return 0
return n + F3(n - 1)

d) O(log2 n) – função O(log n) dentro de uma repetição O(log n)

def F4(n):
s, i = 0, 1
while i <= n:
s = s + F1(n)
i = i * 10
return s

e) O(n.log n) – função O(n) dentro de uma repetição O(log n)

def F5(n):
s, i = 0, 1
while i <= n:
s = s + F2(n)
i = i * 10
return s
Questão 7 (2 pontos):

A classe Árvore Binária de Busca (ABB) tem seguinte método construtor:

class ABB:
# método construtor
def __init__ (self, inforaiz):
self.info = inforaiz
self.eprox = None
self.dprox = None

Uma ABB é uma estrutura onde todos os elementos à esquerda de um determinado elemento possuem
info menores e os da direita maiores ou iguais.

A solução tem que ser recursiva (ou com a ajuda de uma pilha) porque temos que analisar a parte
esquerda, voltar a raiz para imprimir ou “appendar” e em seguida verificar a parte direita.
Trata-se então de percorrer a ABB na seguinte sequência: parte esquerda, raiz, parte direita.

a) Escreva uma função ImprimeMI (R, x) que recebe uma ABB R e um valor x. Imprime todos os
elementos da ABB (campo info) maiores ou iguais a x em ordem crescente.

# Imprime todos os maiores ou iguais a x

# Em ordem crescente da ABB R:
# imprime todos os infos de R.eprox (parte esquerda)
# imprime R.info
# imprime todos os infos de R.dprox (parte direita)
def ImprimeMI(R, x):
if R == None: return
if R.info < x:
ImprimeMI(R.dprox, x)
elif R.info == x:
print(R.info)
ImprimeMI(R.dprox, x)
else:
ImprimeMI(R.eprox, x)
print(R.info)
ImprimeMI(R.dprox, x)

A solução acima só verifica a parte esquerda quando necessário, pois se R,info == x os maiores oi
iguais estarão sempre a direita. Mas também funciona verificar a parte esquerda quando é igual embora
desnecessário. As duas variações abaixo fazem isso:

def ImprimeMI2(R, x):

if R == None: return
if R.info < x:
ImprimeMI2(R.dprox, x)
else:
ImprimeMI2(R.eprox, x)
print(R.info)
ImprimeMI2(R.dprox, x)
Ou ainda:

def ImprimeMI3(R, x):

if R == None: return
ImprimeMI3(R.eprox, x)
if R.info >= x: print(R.info)
ImprimeMI3(R.dprox, x)

b) Escreva uma função MontaTabMI(R, x, Tab) que recebe uma ABB R, um valor x e uma lista
Tab (inicialmente vazia). Coloca em Tab todos os elementos (campo info) da ABB maiores ou
iguais a x em ordem crescente. Análoga a anterior. Em vez de imprimir, monta uma lista.

# Monta lista com todos os maiores ou iguais a x

# Em ordem crescente da ABB R em Tab: mesma ordem da anterior
# Chamada inicial:
# t = []
# MontaTabMI(r, t)
def MontaTabMI(R, x, Tab):
if R == None: return
if R.info < x:
MontaTabMI(R.dprox, x, Tab)
elif R.info == x:
Tab.append(R.info)
MontaTabMI(R.dprox, x, Tab)
else:
MontaTabMI(R.eprox, x, Tab)
Tab.append(R.info)
MontaTabMI(R.dprox, x, Tab)

Idem para as duas variações abaixo:

def MontaTabMI2(R, x, Tab):

if R == None: return
if R.info < x:
MontaTabMI2(R.dprox, x, Tab)
else:
MontaTabMI2(R.eprox, x, Tab)
Tab.append(R.info)
MontaTabMI2(R.dprox, x, Tab)

Ou ainda:

def MontaTabMI3(R, x, Tab):

if R == None: return
MontaTabMI3(R.eprox, x, Tab)
if R.info >= x: Tab.append(R.info)
MontaTabMI3(R.dprox, x, Tab)
Questão 8 (2 pontos) :

Escreva uma função ImprimePE(v)que recebe uma lista v, com números inteiros, calcula e imprime
o produto escalar de v por todas as sequências de mesmo tamanho contendo apenas zeros e uns.

Exemplo:
Supondo v = [2 -2 1], imprimir:
[2 -2 1] . [0, 0, 0] = 0
[2 -2 1] . [0, 0, 1] = 1
[2 -2 1] . [0, 1, 0] = -2
[2 -2 1] . [0, 1, 1] = -1
...
[2 -2 1] . [1, 1, 1] = 1

A solução deve funcionar para qualquer lista v não somente para lista de tamanho 3 como no exemplo.
Trata-se de gerar todas as sequencias do tamanho de v que contenham apenas zeros e uns e multiplicar
por v. Equivalente a gerar todos os números na base 2 de [0, 0, ..., 0] até [1, 1, ..., 1]. É o primeiro
algoritmo de enumeração visto no curso.

# Imprime o produto escalar do vetor v (lista v[0..n-1])

# por todos os vetores contendo apenas zeros e uns
def ImprimePE(v):
# primeiro vetor com zeros e uns
n = len(v)
s = n * [0] # primeira sequência – todos zeros
while True:
# produto escalar de v por s
soma = 0
for k in range(n):
soma += v[k] * s[k]
print(v, " . ", s, " = ", soma)
# Gera a próxima sequência (vetor) s somando 1 (módulo 2)
# Aqui está o algoritmo para gerar a próxima sequência
# a partir da anterior.
t = n - 1
while t >= 0:
if s[t] == 0:
s[t] = 1
break
s[t] = 0
t = t - 1
# se t ficou < 0 acabou
if t < 0: return