Módulo 3 EDA¶

In [7]:
import matplotlib.pyplot as plt
import math
import numpy as np
  • Exercício 1
In [8]:
def y1():
    result = []
    for i in range(0, 101):
        y = 100*i + i**2
        result.append(y)
    x = list(range(0, 101))
    return plt.plot(x, result)


def f1(x):
    return 100*x + x**2


def f2(x):
    return x**2
In [9]:
def listvalues(f, args):
    return [f(i) for i in args]
In [14]:
def draw(x):
    plt.plot(x1,y1(x1), label = 'y1')
    plt.plot(x1, y2(x1), label = 'y2')
    plt.show()
    
    
for j in [100,300,500,1000,10000]:
    plt.plot(range(j+1),listvalues(f1, range(j+1)))
    plt.plot(range(j+1),listvalues(f2, range(j+1)))
    plt.show()


for j in [100, 300, 500,1000, 10000, 100000]:
    plt.plot(np.arange(0, j+1, 1), f1(np.arange(0, j+1, 1)))
    plt.plot(range(j+1), [f2(x) for x in range(j+1)])
    plt.show()

x1 = np.arange(0,101,1)
x2 = np.arange(0,10001,1)


def graf1(x):
    if x == 100:
        plt.plot(range(101), listvalues(f1, range(101)))
        plt.plot(range(101), listvalues(f2, range(101)))
        plt.show()
    elif x == 300:
        plt.plot(range(301), listvalues(f1, range(301)))
        plt.plot(range(301), listvalues(f2, range(301)))
        plt.show()
    elif x == 500:
        plt.plot(range(501), listvalues(f1, range(501)))
        plt.plot(range(501), listvalues(f2, range(501)))
        plt.show()
    elif x == 1000:
        plt.plot(range(1001), listvalues(f1, range(1001)))
        plt.plot(range(1001), listvalues(f2, range(1001)))
        plt.show()
    elif x == 10000:
        plt.plot(range(10001), listvalues(f1, range(10001)))
        plt.plot(range(10001), listvalues(f2, range(10001)))
        plt.show()
    elif x == 100000:
        plt.plot(range(100001), listvalues(f1, range(100001)))
        plt.plot(range(100001), listvalues(f2, range(100001)))
        plt.show()
  • Exercício 2
In [16]:
def binary_search(v, K):
    n = len(v)
    L = 0
    R = n - 1
    while L <= R:
        mid = math.floor((L + R) / 2)
        if v[mid] < K:
            R = mid - 1
        elif v[mid] > K:
            L = mid + 1
        else:
            return mid
    return -1


def pesq_linear(n, k):
    for i in n:
        if i == k:
            return True
    return False


def estar_em(v, K):
    return K in v
In [17]:
# Fazer uma tabela
def table():
    print(f"{'Tamanho sequencia':<20}{'Pesquisa':<20}{'Tmedio 2.a':<20}{'Tmedio 2.b':<20}")


tablee = {10000:7777,20000:15554,30000:23331,40000:31108,50000:38885,60000:46662,70000:54439,80000:62216,90000:69993,
          100000:77770}


def average_timeit(function, sequence, element, repeat=100):
    assert element in sequence
    import timeit
    total_time = 0
    for n in range(0,repeat):
        time_start = timeit.default_timer()
        assert function(sequence,element)
        total_time += timeit.default_timer()-time_start
    return total_time/repeat
In [18]:
av = []
av1 = []
av2 = []
print(f"{'Tamanho sequencia':<20}{'Pesquisa':<20}{'Tmedio 2.a':<30}{'Tmedio 2.b':<30}{'Tmedio in':<30}")
# Para cada valor de cada chave no dicionario tablee ver o tempo medio recorrendo a pesquisa linear, a pesquisa binaria
# e a pesquisa in
for key in tablee:
    value = tablee[key]
    seq = [i for i in range(key, -1,-1)]
    average_linear = average_timeit(pesq_linear, seq, value)
    average_binary = average_timeit(binary_search, seq, value)
    average_in = average_timeit(estar_em,seq,value)
    print(f"{key:<20}{value:<20}{average_linear:<30}{average_binary:<30}{average_in:<30}")
    av.append(average_linear)
    av1.append(average_binary)
    av2.append(average_in)

Tamanho sequencia   Pesquisa            Tmedio 2.a                    Tmedio 2.b                    Tmedio in                     
10000               7777                7.172700000069199e-05         3.38700000213521e-06          2.249800000072355e-05         
20000               15554               0.0001749760000001288         6.971999995926126e-06         9.011999999700038e-05         
30000               23331               0.0001773460000003979         4.0039999987584455e-06        7.142899999962538e-05         
40000               31108               0.00022525799999698393        3.924000003507899e-06         9.272800000132974e-05         
50000               38885               0.000302351999999928          4.141999999660584e-06         0.00011321200000168119        
60000               46662               0.00034416200000009667        4.5839999978625205e-06        0.0001372249999997166         
70000               54439               0.0004431110000001581         4.187999998066516e-06         0.00015971499999807294        
80000               62216               0.00038383200000168926        3.3479999979135757e-06        0.00016640000000109012        
90000               69993               0.0004224659999994174         3.529999997908817e-06         0.00014698799999962375        
100000              77770               0.00041408099999443946        3.080000003023997e-06         0.00016454899999871487
In [19]:
# Crescimento da average linear graficamente
# Crescimento da average linear graficamente
def p2_graf():
    plt.plot(range(10),av)
    plt.plot(range(10),av1)
    plt.plot(range(10),av2)
    plt.show()


def p2_pontos():
    plt.scatter(range(10), av, label= 'sequencial')
    plt.scatter(range(10), av1, label= 'binaria')
    plt.scatter(range(10), av2, label= 'in')
    plt.legend()
  • Exercício 4
In [20]:
def monte_carlo():
    import random
    cont = 0
    fora = 0
    dentro = 0
    for n in range(100, 10001, 100):
        while cont < 100:
            x = random.random()
            y = random.random()
            z = x**2 + y**2
            if z <= 1:
                dentro += 1
            else:
                fora += 1
            cont += 1
            pisim = 4*(dentro/(dentro+fora))
            print('Valor simulado de pi:', pisim)