MAC 122 - PDA

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

Prova Substitutiva – 28 de novembro de 2019

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

______________________________ _______________________________
Nome legível Assinatura_(como na lista de presença)

NUSP com 8 dígitos

Questão 1 (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.

Uma Tentativa é a comparação de A com um novo trecho de B.

Considere agora como A a string com o seu NUSP de 8 dígitos e B a string abaixo. Mostre na tabela
abaixo quais as Tentativas de comparação que serão realizadas usando esse algoritmo.

Supondo NUSP = 53047891

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

Sobre o algoritmo de Busca Binária em tabela ordenada, quais afirmações abaixo são verdadeiras:

a) O algoritmo de Busca Binária é O(log N).

b) O número médio de comparações na Busca Binária é próximo do número máximo.

c) A tabela deve estar em ordem crescente ou decrescente.

d) A tabela não pode ter elementos iguais.

e) Para cada busca, é sempre melhor classificar a tabela e fazer busca binária do que fazer busca
sequencial.
Questão 3 (1 ponto):

Deseja-se inserir os números 35, 54, 46, 66, 68, 55, 43 (nesta ordem) numa tabela tipo Hash.

A tabela Hash possui 11 elementos.

Diga o conteúdo da tabela nos seguintes casos.

a) Tabela Hash simples usando H(x) = x % 11 como função de Hash

i 0 1 2 3 4 5 6 7 8 9 10
Tab[i] 66 55 35 46 68 43 None None None None 54

b) Tabela Hash duplo usando H(x) = x % 11 como função de Hash e passo 2.

i 0 1 2 3 4 5 6 7 8 9 10
Tab[i] 66 43 35 46 68 55 54
Questão 4 (1 ponto):

Sobre os métodos de classificação Seleção, Bolha, Merge, Quick e Heap, quais as informações abaixo
são verdadeiras:

a) Quando a tabela está invertida o número de trocas do Quick é máximo.

b) Se a quantidade de inversões da tabela é baixa, o Bolha é o melhor dos métodos.

c) O Quick é sempre o melhor método de todos.

d) Quando a tabela está ordenada, o Bolha não efetua trocas entre os elementos da tabela.

e) O número de trocas do Seleção e do Bolha é sempre a mesma.

f) Quando a tabela esta invertida o número de trocas do Bolha é máximo.

g) O método da Seleção é um pouco melhor que o Bolha porque efetua menos trocas.

h) A complexidade da Seleção e Bolha é O(N.N) e do Merge, Quick e Heap é O(N.log N).

i) O Heap ocupa mais espaço em memória que o Quick devido a árvore binária de Heap.

j) Merge e Heap precisam de mais memória para armazenar as sub-tabelas intermediárias.

k) Quando a tabela já está classificada o Heap não efetua trocas entre os elementos.

l) Uma vantagem do Quick sobre o Merge é que não é necessário o uso de memória adicional.

m) Mesmo quando a tabela já está classificada, o Heap efetua trocas entre os elementos.

n) O algoritmo de intercalação de tabelas já classificadas usado pelo Merge é O(N).

o) O algoritmo de partição de tabelas do Quick e melhor que o algoritmo de intercalamento do

Merge.

p) Quando a tabela já está classificada o Quick mesmo assim efetua trocas entre os elementos.

q) O Merge usa mais memória que o Quick e que o Heap.

r) Se a tabela tem muitas inversões, o Heap é o melhor dos cinco métodos.

s) Quando a tabela já está classificada, o Quick não efetua trocas entre os elementos.

t) Se a tabela tem muitas inversões, o Quick é o melhor dos cinco métodos.

Questão 5 (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.

Escreva uma função MaxABB(R) que recebe uma ABB R e devolve o elemento com o maior valor de
info desta ABB.

Abaixo 2 versões. Recursiva e não recursiva.

# Devolve o elemento com o maior valor de info da ABB R

# Versão Recursiva
def MaxABB(R):
if R == None: return None # R é uma ABB vazia
# Verifica se tem parte direita, onde devem estar
# os maiores.
if R.dprox != None:
# Continua a busca à direita
return MaxABB(R.dprox)
# Se não há parte direita, esse é o maior
return R

# Devolve o elemento com o maior valor de info da ABB R

# Versão Não Recursiva
def MaxABB2(R):
if R == None: return None # R é uma ABB vazia
# Repete até achar elemento com parte direita vazia
p = R
while p.dprox != None:
p = p.dprox
# Se não há parte direita, esse é o maior
return p
Questão 6 (2 pontos)

Considere o algoritmo de Busca Binária em tabela ordenada.

a) Escreva uma função recursiva BBR(L, X, Base, N) que procura X nos N elementos da
lista L, a partir do elemento Base ou seja, de L[Base] até L[Base + N - 1].
Devolve o índice do elemento procurado ou -1 se não encontrou.

Assim, a chamada inicial desta função será:

k = BBR(L, X, 0, N) # procura X em L[0] até L[N-1].

# Procura X em L[Base], ..., L[Base + N - 1]

# Busca binária em tabela ordenada - versão recursiva
def BBR(L, X, Base, N):
if N == 0: return -1 # terminou a busca
# meio da tabela
meio = Base + N // 2
if L[meio] == X: return meio
# Cálculo do tamanho da parte de cima e da parte de baixo
if N % 2 == 0:
# N é par
tam_inf, tam_sup = N // 2, N // 2 - 1
else:
# N é impar
tam_inf, tam_sup = N // 2, N // 2
# Continua a busca na parte de cima ou de baixo.
if X > L[meio]: return BBR(L, X, meio + 1, tam_sup)
return BBR(L, X, Base, tam_inf)

b) Idem para a função BBNR(L, X, Base, N) que faz o mesmo porém de forma não
recursiva.
# Procura X em L[Base], ..., L[Base + N - 1]
# Busca binária em tabela ordenada - versão não recursiva
def BBNR(L, X, Base, N):
# Continua a busca enquanto N > 0
while N > 0:
# meio da tabela
meio = Base + N // 2
if L[meio] == X: return meio
# Cálculo do tamanho da parte de cima e da parte de baixo
if N % 2 == 0:
# N é par
tam_inf, tam_sup = N // 2, N // 2 - 1
else:
# N é impar
tam_inf, tam_sup = N // 2, N // 2
# Continua a busca na parte de cima ou de baixo.
if X > L[meio]:
Base, N = meio + 1, tam_sup
else:
 N = tam_inf
# Se saiu do while - não encontrou
return -1
Questão 7 (2 pontos):

Uma lista TAB contém em cada elemento as seguintes informações separadas por vírgula:

<identificação>,<nome>,<data nascimento>

Exemplo:

["32343245100,Jose de Castro,10/12/2001",
"43456790236,Maria das Dores e Silva,25/01/2005",
"22589349475,Antonio Paixao dos Santos,30/05/2012",
...
"27383783675,Francisco de Souza,25/22/2001"
]

Escreva uma função Bolha(TAB) que recebe essa lista TAB, classifica em ordem crescente pelo campo <nome> e dentro
deste pela <identificação>. Use o algoritmo da Bolha.

def Bolha(TAB):
n = len(TAB)
# tenta subir TAB[i], i = 1, 2, ..., n-1
for i in range(1, n):
# sobe Tab[i] até encontrar o lugar adequado
j = i
while True:
if j == 0: break
# Compara TAB[j] com TAB[j-1], pelo <nome>
# e dentro do <nome> pela <identificação>
tj = TAB[j].split(',')
tj1 = TAB[j-1].split(',')
# Comparação – pelo nome e se nome igual então identificação
if tj[1] < tj1[1] or tj[1] == tj1[1] and tj[0] < tj1[0]:
# troca TAB[j] com TAB[j - 1]
TAB[j], TAB[j-1] = TAB[j-1], TAB[j]
# Continua subindo
j = j - 1
else:
# Se não trocou é porque chegou no lugar
break