Sistemas de Informação IFMG - Ouro Branco

6º Período Diego Santos Seabra

21/12/2020 0040251

Tarefa 1
Projeto e Análise de Algoritmos

Contents
Exercício 1 2
I. Exemplo do Mundo Real . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
II. Medidas de Eficiência . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
III. Estrutura de Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
IV. Melhor Solução x Solução Aproximada . . . . . . . . . . . . . . . . . . . . 3

Exercício 2 4

Apêndice 1 - Comparação Gráfica dos Algoritmos de Ordenação 4

02 5 1
Apêndice 2 - Cálculo da Tabela de Complexidades 4

00 4

1
1) Forneça uma análise sobre os seguintes pontos:

I. Pense em um exemplo do mundo real no qual apareça o problema de

ordenação
Solução:

1. Visualização de items em uma loja virtual onde há filtros de ordenação (menor

preço, mais vendidos, etc)
2. Alguns bancos de dados usam algoritmos de ordenação para verificar se um con-
junto de dados é grande demais para ser inseridos “de uma só vez” na memória da
máquina
3. A pesquisa binária (dicionário) depende de um pré-processamento dos dados (or-
denação) para a devida classificação das chaves.
4. Classificação de times de futebol baseada em pontos
5. Classificação das vendas de uma empresa

II. Além do tempo de execução, que outras medidas de eficiência poderiam

ser usadas?
Solução:
1. Quantidade de instruções

02 5 1
4
2. Velocidade de processamento das instruções na máquina

00
3. Quantidade de memória utilizada
4. Tamanho do arquivo executável final
5. Custo dos recursos utilizados

III. Selecione uma estrutura de dados que você já tenha visto antes e discuta
seus pontos fortes e suas limitações
Solução:
Estrutura: Array
Prós
1. Fácil de ser implementada. Maioria das linguagens apresenta a estrutura “out-of-
the-box”
2. Índices diretos. Complexidade: O(1)
3. Acesso sequencial. Complexidade: O(n)

2
Contras
1. Dificuldade de alocação de novos espaços (estrutura estática)
2. Ordenação. Complexidade: O(n log(n))
3. Pesquisa. Complexidade: O(n)
4. Inserção e Exclusão de Itens. Complexidade: O(n)
Complexidades retiradas do site Big O Cheat Sheet

IV. Mostre um problema real no qual apenas a melhor solução servirá. Em

seguida, apresente um problema em que baste uma solução que seja “aprox-
imadamente” a melhor.
Solução:
Melhor Solução: Calcular a quantidade de combustível necessária para atravessar uma
ponte
Solução Aproximada: Encontrar um ponto de combustível mais próximo

02 5 1
00 4

3
2) Preencha a tabela proposta na aula. Considere que o computador uti-
lizado para executar cada algoritmo executa 1000000 de instruções por se-
gundo. Nas linhas dessa tabela, são apresentadas as complexidades de cada
algoritmo e nas colunas estão representados os tamanhos de cada instância
do problema:

10 20 30 40 50 60
log(n)
n
n · log(n)
n2
n3
n5
2n
3n

Solução:

10 20 30 40 50 60
log(n) 0.0000033 0.0000043 4.90−6 5.32−6 5.64−6 5.90−6
n 0.00001 0.00002 3−5 4−5 5−5 6−5

n2 0.0001 0.0004

02 5 1
n.log(n) 0.0000332 0.0000864 1.47−4
9−4
2.12−4
1.60−3
2.82−4
2.50−3
3.54−4
3.60−3
n3
n
2n
3n
5
0.001

00
0.1
0.001
0.059
4
0.008
3.2
1.04
3486.78
0.027
24.3
1.073
2.058
0.064
102.4
1.096
1.2113
0.125
312.5
1.129
7.1717
0.216
777.6
1.1512
4.2322

Diego Santos Seabra

0040251

4
apendice1 21/12/20 17:07

Apêndice 1 - Comparação Gráfica dos

Algoritmos de Ordenação
In [88]: import matplotlib.pyplot as plt
import math
import pandas as pd
import numpy as np

def insercao(n):
return 8 * math.pow(n,2)

def intercalacao(n):
return 64 * n * math.log(n,2)

def intersection(lst1, lst2):

lst3 = [value for value in lst1 if value in lst2]
return lst3

def plot(minimum, maximum):

x_vals = pd.Series(np.linspace(minimum,maximum,maximum))
inserts = []
intercs = []
for i in range(minimum,maximum + 1):
inserts.append(insercao(i))
intercs.append(intercalacao(i))

plt.plot(x_vals, inserts, label="inserção")

plt.plot(x_vals, intercs, label="intercalação")
plt.xlabel('Valores de n')
plt.ylabel('Etapas')
plt.title('Exercício 1 - Comparação de Algoritmos de Ordenação')
plt.legend()
plt.show()

plot(1,100)
plot(1,43)

# Testes
# print(insercao(10))
# print(intercalacao(10))
# print(insercao(44))
# print(intercalacao(44))

file:///Users/dseabra/Downloads/apendice1.html Page 1 of 2
apendice1 21/12/20 17:07

In [ ]:

file:///Users/dseabra/Downloads/apendice1.html Page 2 of 2
apendice2 21/12/20 17:07

Apêndice 2 - Cálculo da Tabela de

Complexidades
In [2]: import math
import numpy as np
import pandas as pd

# Instruções por segundo

inst = 1000000
x_vals = pd.Series(np.linspace(10,60,6))

def logn(n):
return math.log(n,2) / inst

def nn(n):
return n / inst

def nlogn(n):
return (n * math.log(n,2)) / inst

def n2(n):
return math.pow(n,2) / inst

def n3(n):
return math.pow(n,3) / inst

def n5(n):
return math.pow(n,5) / inst

def _2n(n):
return math.pow(2,n) / inst

def _3n(n):
return math.pow(3,n) / inst

lognarr = ['log(n)']
for n in x_vals:
lognarr.append(logn(n))

narr = ['n']
for i in x_vals:
narr.append(nn(i))

nlognarr = ['n.log(n)']
for n in x_vals:
nlognarr.append(nlogn(n))

n2arr = ['n^2']
for n in x_vals:
n2arr.append(n2(n))

n3arr = ['n^3']
for n in x_vals:

file:///Users/dseabra/Downloads/apendice2.html Page 1 of 4
apendice2 21/12/20 17:07

n3arr.append(n3(n))

n5arr = ['n^5']
for n in x_vals:
n5arr.append(n5(n))

_2narr = ['2^n']
for n in x_vals:
_2narr.append(_2n(n))

_3narr = ['3^n']
for n in x_vals:
_3narr.append(_3n(n))

lst = [lognarr, narr, nlognarr, n2arr, n3arr, n5arr, _2narr, _3narr]

df = pd.DataFrame(lst, columns=['Algoritmos', '10', '20', '30', '40', '50',
df = df.set_index('Algoritmos')
# pd.options.display.float_format = '{:.7f}'.format
df

Out[2]: 10 20 30 40 50

Algoritmos

5.643856e-
log(n) 0.000003 0.000004 4.906891e-06 5.321928e-06 5.906891e-06
06

4.000000e- 5.000000e- 6.000000e-

n 0.000010 0.000020 3.000000e-05
05 05

n.log(n) 0.000033 0.000086 1.472067e-04 2.128771e-04 2.821928e-04 3.544134e-04

2.500000e- 3.600000e-
n^2 0.000100 0.000400 9.000000e-04 1.600000e-03
03

6.400000e-
n^3 0.001000 0.008000 2.700000e-02 1.250000e-01 2.160000e-01
02

n^5 0.100000 3.200000 2.430000e+01 1.024000e+02 3.125000e+02 7.776000e+02

2^n 0.001024 1.048576 1.073742e+03 1.099512e+06 1.125900e+09 1.152922e+12

3^n 0.059049 3486.784401 2.058911e+08 1.215767e+13 7.178980e+17 4.239116e+22

file:///Users/dseabra/Downloads/apendice2.html Page 2 of 4
apendice2 21/12/20 17:07

In [2]: def plot(lst):

df = pd.DataFrame(lst, columns=['Algoritmos', '10', '20', '30', '40', '50'
df = df.set_index('Algoritmos')
# df.round(7)
df.to_csv('ex4.csv')
df.plot()

lst = [lognarr, narr, nlognarr]

plot(lst)

lst = [n2arr, n3arr, n5arr]

plot(lst)

lst = [_2narr, _3narr]

plot(lst)

lst = [lognarr, narr, nlognarr, n2arr, n3arr, n5arr, _2narr, _3narr]

plot(lst)

file:///Users/dseabra/Downloads/apendice2.html Page 3 of 4
apendice2 21/12/20 17:07

In [ ]:

file:///Users/dseabra/Downloads/apendice2.html Page 4 of 4