Faça uma função chamada Polinomial que recebe dois parâmetros: uma lista de coeficientes e um valor x. Essa função deve retornar o resultado do cálculo:

$$a0 + a1 . x + a2 . x^2 + … + an . x^n$$

A lista contém os valores dos coeficientes na seguinte ordem:

[a0, a1, a2,...,an]



In [1]:

    
def Polinomial(coefs,x):
    i=0
    res = 0
    for a in coefs:
        res = res + a*(x**i)
        i = i+1
    return res

def Polinomial2(coefs, x):
    res = 0
    for i,a in enumerate(coefs):
        res = res + a*(x**i)
    return res

def Polinomial3(coefs, x):
    return sum([a*(x**i) for i,a in enumerate(coefs)])

print Polinomial([1,2,3,4],10), Polinomial2([1,2,3,4],10), Polinomial3([1,2,3,4],10), 1+20+300+4000









    



4321 4321 4321 4321

Faça uma função chamada OndaSeno que recebe dois parâmetros: uma lista de coeficientes e um valor x. Essa função deve retornar o resultado do cálculo:

$$a0 + a1 . seno(x) + a2 . cos(2x) + a3 . seno(3x) + ... + an . cos/seno (n.x)$$

A lista contém os valores dos coeficientes na seguinte ordem:

[a0, a1, a2,...,an]



In [5]:

    
from math import sin, cos

def OndaSeno(coefs, x):
    res = 0
    i = 0
    for a in coefs:
        if i%2 == 0:
            res = res + a*cos(i*x)
        else:
            res = res + a*sin(i*x)
        i=i+1
    return res

def OndaSeno2(coefs, x):
    res = 0
    for i,a in enumerate(coefs):
        if i%2 == 0:
            res = res + a*cos(i*x)
        else:
            res = res + a*sin(i*x)
    return res

def OndaSeno3(coefs, x):
    # posso colocar if-else dentro de um list comprehension
    return sum( [a*cos(i*x) if i%2==0 else a*sin(i*x) for i,a in enumerate(coefs)] )

print OndaSeno([1,2,3,4,5],3.14), OndaSeno2([1,2,3,4,5],3.14), OndaSeno3([1,2,3,4,5],3.14), 1*cos(0*3.14)+2*sin(1*3.14)+3*cos(2*3.14)+4*sin(3*3.14)+5*cos(4*3.14)









    



9.02218039546 9.02218039546 9.02218039546 9.02218039546

Crie uma função EncontraPalavras que recebe uma string frase e uma string palavra como parâmetros. Ela deve transformar a frase em uma lista de palavras e retornar uma lista de posições dessa lista que contém a palavra.



In [6]:

    
def EncontraPalavras(frase, palavra):
    i=0
    indices = []
    for p in frase.split():
        if p==palavra:
            indices.append(i)
        i = i+1
    return indices

def EncontraPalavras2(frase, palavra):
    return [i for i,p in enumerate(frase.split()) if p==palavra]    

print EncontraPalavras("o gato mia quando o gato tem fome ou outro gato esta perto","gato"), EncontraPalavras2("o gato mia quando o gato tem fome ou outro gato esta perto","gato")









    



[1, 5, 10] [1, 5, 10]

Crie uma função InvertePalavras que recebe uma string frase e retorna a string com as palavras na ordem inversa.



In [8]:

    
def InvertePalavras(frase):
    inverso=''
    for p in frase.split():
        inverso = p + ' ' + inverso
    return inverso

def InvertePalavras2(frase):
    palavras = frase.split()    
    return palavras[::-1] # posso usar indices de lista para inverte-la

print InvertePalavras("o gato mia quando o gato tem fome ou outro gato esta perto")
print InvertePalavras2("o gato mia quando o gato tem fome ou outro gato esta perto")









    



perto esta gato outro ou fome tem gato o quando mia gato o 
['perto', 'esta', 'gato', 'outro', 'ou', 'fome', 'tem', 'gato', 'o', 'quando', 'mia', 'gato', 'o']

A Persistência aditiva de um número é quantas vezes precisamos somar os dígitos de um número até que ele se torne um número de um dígito. Crie uma função que receba um número x e retorne sua persistência multiplicativa. DICA: crie funções auxiliares.



In [14]:

    
def Digitos(x):
    digs = []
    while x>0:
        digs.append(x%10)
        x = x/10
    return digs

def Mult(lista):
    res = 1
    for x in lista:
        res = res*x
    return res

def Persistencia(x):
    conta = 0
    while x >= 10:
        x = Mult(Digitos(x))
        conta = conta+1
    return conta

print Persistencia(39)



In [13]:

    
#alternativa

def Digitos(x):    
    prod = 1 
    while x>0:
        prod = prod * (x%10)
        x = x/10
    return prod

def Persistencia(x):
    conta = 0
    while x >= 10:
        x = Digitos(x)
        conta = conta+1
    return conta

print Persistencia(39)



In [18]:

    
#alternativa
from operator import mul # <-- operação de multiplicação, equivalente ao *

def Digitos(x):    
    x = str(x)
    return reduce(mul, [int(d) for d in x], 1)
# equivalente a:
# res = 1
# for d in x:
#    res = res*d

def Persistencia(x):
    conta = 0
    while x >= 10:
        x = Digitos(x)
        conta = conta+1
    return conta

print Persistencia(39)

Para qualquer número natural se repetirmos o procedimento de somar o quadrado dos dígitos, eventualmente sempre chegaremos no número $1$ ou $89$. Faça um algoritmo que retorne se um número $x$ chega em $1$ ou $89$. DICA: crie funções auxiliares.



In [36]:

    
def Digitos(x):
    digs = []
    while x>0:
        digs.append(x%10)
        x = x/10
    return digs

def SomaQuad(lista):
    res = 0
    for x in lista:
        res = res + x*x
    return res

def QuadDigito(x):
    while x != 1 and x!=89:
        x = SomaQuad(Digitos(x))        
    return x

print QuadDigito(15), QuadDigito(7)



In [15]:

    
#Alternativa
def Digitos(x):
    soma = 0
    while x>0:
        soma = soma + (x%10)**2
        x = x/10
    return soma

def QuadDigito(x):
    while x != 1 and x!=89:
        x = Digitos(x)    
    return x

print QuadDigito(15), QuadDigito(7)



In [16]:

    
#Alternativa
def Digitos(x):
    x = str(x)
    return sum( [int(d)**2 for d in x] )

def QuadDigito(x):
    while x != 1 and x!=89:
        x = Digitos(x)    
    return x

print QuadDigito(15), QuadDigito(7)



In [ ]: