[INF1025] Exercícios Gerais

Prévia do material em texto

INF1025: Introdução à Programação 
Monitor: André Vicente Pessanha 
Lista de exercícios​: 
 
*************************************************************************************************** 
 
OBS: ​Esse PDF contém exercícios de todos os tópicos de Python (P1, P2 e P3) 
Então pra facilitar, use o atalho ​CTRL + F ​e digite >> ​Exercícios de​ << e é só apertar enter 
até chegar no tópico desejado. :) 
 
*************************************************************************************************** 
 
Exercícios de Variáveis​: 
 
EX1: Calcule o perímetro de um círculo de raio 5. (Dica: Use a fórmula p = 2*Pi*r) 
 
import math 
 
r = 5 
p = 2 * math.pi * r 
print("Perímetro: %.2f" % p) 
 
 
EX2: Os raios dos anéis do casco de um caracol do centro até a borda crescem 
exponencialmente de acordo com a expressão: (3 + r)^n sendo r, o raio e n o número 
do anel. Qual o diâmetro do 5º anel em cm, sabendo que o raio é 2.1cm? 
 
r = 2.1 
n = 5 
total = (3 + r) ** n 
print(total) 
 
 
EX3: Uma torneira despeja 75 litros de água por hora. Quanto tempo, em horas, levará 
para encher uma caixa de 3150 litros? Q = V/ t 
 
Regra de três:​ ​75 - 1h 
 3150 - x 
 
print(3150 / 75) 
 
 
EX4: Uma indústria produziu 188 peças e quer colocá-las em 12 caixas, de modo que 
todas as caixas tenham o mesmo número de peças. Quantas peças serão colocadas 
em cada caixa? 
 
print(188 //12 ) 
 
OBS: ​Aqui temos que usar o operador de divisão inteira! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
Exercícios de String​: 
 
 
EX1: Guarde seu nome numa variável e exiba-o precedido e sucedido pela string 
formada por '*' com metade do comprimento de seu nome 
Exemplo: Nome: ​Mia​ Resultado na tela: ​*Mia* 
 
nome = input("Digite seu nome:") 
print('*' + nome + '*') 
 
 
EX2: Guarde o dia, mês e ano de seu nascimento em variáveis: 
 
a) Exiba a data de nascimento no formato 'dd/mm/aaaa' 
b) Exiba a frase: 'Não se esqueça do meu aniversário: dd/mm!!!" 
 
dia, mes, ano = input("Data de Nascimento: ").split(' ') 
print(dia + '/' + mes + '/' + ano) 
print("Não se esqueça do meu aniversário:" + str(dia) + '/' + str(mes)) 
 
EX3: Uma encomenda pesa 34250g e sua embalagem pesa 178g. Exiba o peso da 
encomenda com a embalagem no formato '...Kg e ...g' 
 
 
tot = 34250 + 178 
print("%.2f Kg e %.2f g\n" % (tot/1000, tot)) 
 
 
EX4: Sabendo que a função str() converte um número para string. Mostre quantos 
algarismos tem o número 3 elevado a 1000. 
 
num = 3 ** 1000 
print(len(str(num))) # Exibe 478 
 
OBS:​ Como len é uma função somente para >> strings << logo é necessário converter 
primeiro! 
 
 
EX5: Guarde sua data de nascimento em uma variável no formato 'dd/mm/aaaa'. 
Exemplo dt = '01/01/1984' 
a)​ Exiba apenas o ano ('1984') 
b) ​Exiba o ano invertido ('4891') 
c)​ Exiba toda a data invertida. ('4891/10/10') 
d) ​Exiba a data no formato dd-mm-aaaa 
 
data = input("Digite data nascimento:") 
print("Ano:", data[6:]) 
print("Ano Invertido:", data[-1:-5:-1]) 
print("Data Invertida:", data[-1::-1]) 
novaData = data[:2] + '-' + data[3:5] + '-' + data[6:] 
print("Novo formato:", novaData) 
 
 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
Exercícios de Módulo Externo​: 
 
EX1: Calcule a área da coroa circular (anel) formada por 2 circulos de raios r1 e r2 (r1 
> r2 e pi = 3.14 e área do circulo : pi*r ** 2 
 
 
import math 
 
r1 = 5.0 
r2 = 8.0 
area = math.pi*r1**2 - math.pi*r2 **2 
print("Resultado:", area) 
 
OBS: ​Os valores de r1 e r2 são só para testes! 
 
 
EX2: Calcule as raízes da equação 2x^2 + 6x - 20 = 0. Guarde delta em uma variável. 
 
import math 
a = 2 
b = 6 
c = -20 
delta = (b**2 - 4*a*c)**0.5 
print("Raízes: %.1f e %.1f\n" % ((-b - delta)/(2*a),(-b + delta)/(2*a))) 
 
 
 
EX3: Utilizando as leis do cosseno, mostre a medida do lado a do triângulo de lados 
a, 10 e 16 com theta igual a 60 graus: 
 
Obs: Fórmula Lei dos cossenos: a^2 = b^2 + c^2 - 2*b*c *cos(theta) 
 
import math 
 
b = 10 
c = 16 
a = (b ** 2 + c **2 - 2*b*c* math.cos(math.radians(60))) ** 0.5 
print(a) 
 
 
OBS: Precisamos sempre converter para radianos! 
 
 
 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
Exercícios de Funções​: 
 
EX1: Crie uma função para calcular a área do círculo cujo raio é recebido. Use a 
constante math.pi e coloque uma mensagem de documentação (Doc String) na 
função. 
 
import math 
 
def calcAreaCirc (r): 
 """Função que calcula a área de um círculo""" 
 return math.pi * r**2 
 
raio = float(input("Digite o Raio:\n")) 
print(calcAreaCirc(raio)) 
 
OBS: ​Quando o enunciado menciona que algo é >> Recebido << pela função, está implícito 
que é recebido como parâmetro. 
 
EX2​: ​Crie uma função para calcular a área da coroa circular cujos raios r1 e r2 são 
recebidos. 
 
def calcAreaCoroa (r1, r2): 
 return math.pi*r1**2 - math.pi*r2 **2 
 
 
EX3: Crie as funções lateral(r, h), total (r, h) para calcular a área da lateral e a área 
total de um cilindro reto. (OBS: Use obrigatoriamente a função do item 1) 
 
def lateral(r, h): 
 return 2* math.pi * r * h 
 
def total(r, h): 
 return 2*calcAreaCirc(r) + lateral(r, h) 
 
OBS:​ Sempre que o enunciado cita o nome das funções e dos parâmetros, é obrigatório 
usar >> ​Exatamente ​<< esses nomes no seu programa! 
 
 
EX4:​ ​Crie uma função que recebe a idade, altura e peso de uma pessoa, calcula o IMC 
e exiba uma mensagem de alerta pra quem está abaixo do peso ideal. 
Obs: Considere que uma pessoa com IMC abaixo de 18.5KG ou acima de 24.9KG é 
considerado abaixo do peso ideal. 
Obs: Fórmula de IMC: Peso dividido pela altura ao quadrado. 
 
def alertaAbaixoPeso (idade, altura, peso): 
imc = peso/altura **2 
if(imc < 18.5 or imc > 24.9): 
print("Abaixo do peso ideal!") 
 
 
EX5:​ ​Modifique sua função anterior pra que ela exiba uma mensagem de alerta 
apenas para os menores de idade que estão abaixo do peso ideal. 
 
def exibeAlerta (idade, altura, peso): 
 imc = peso/altura**2 
 if(imc < 18.5 or imc > 24.9 and idade < 18): 
 print("Abaixo do peso ideal e é menor de idade!") 
 
 
 
 
EX6:​ ​Faça um programa que exiba na tela um dos avisos de acordo com o critério da 
tabela: 
 
 
def exibeAlerta (idade, altura, peso): 
 imc = peso/altura**2 
 if(imc < 18.5): 
 print("Abaixo do peso ideal") 
 elif(imc < 24.9): 
 print("peso ideal") 
 elif(imc < 34.9): 
 print("Obesidade de Grau 1") 
 elif(imc < 39.9): 
 print("Obesidade de Grau 2") 
 else: 
 print("Obesidade de Grau 3") 
 
 
idade, altura, peso = input("Digite um valor:").split(' ') 
exibeAlerta(idade, float(altura), float(peso)) 
 
 
EX7:​ ​A sensação térmica é influenciada por vários fatores climáticos, como a 
umidade e densidade do ar, mas principalmente pela velocidade do vento. A seguinte 
fórmula empírica calcula seu valor: 
 
ST = 33 + (10*raiz(v) + 10.45 - v)* ((T-33)/22) 
 
Faça um programa que pergunte a temperatura e a velocidade do vento ocorridas por 
hora de um dia e mostre a sensação térmica equivalente. 
 
 
def calcSensTerm (v, t): 
 return 33 + (10 * v ** 0.5 + 10.45 - v)* ((t-33)/22) 
 
v, t = input("Digite a velocidade e temperatura:").split(' ') 
 
print("Sensação Térmica: %.2f\n" % calcSensTerm(float(v), float(t))) 
 
 
 
EX8: Refaça o item 7 utilizando a função uniform do módulo random na leitura dos 
dados. 
 
import random 
 
def calcSensTerm (v, t): 
 return 33 + (10 * v ** 0.5 + 10.45 - v)* ((t-33)/22) 
 
v = random.uniform(30,100) 
t = random.uniform(30,100) 
print("Velocidade: %.2f\nTemperatura: %.2f\n" %( v ,t)) 
print("Sensação Térmica: %.2f\n" % calcSensTerm(v, t)) 
 
 
 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
Exercícios de Condição: 
 
EX: Faça um programa que lê um número e exibe na tela se ele é par ou ímpar 
 
x = int(input("Digite um valor:")) 
if( x % 2 == 0 ): 
 print("É par!") 
else: 
 print("É ímpar!") 
 
OBS:​ É preciso converter de string para int ou float na leitura! 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
Exercícios de Recursão​: 
 
 
EX​: ​Crie uma função recursiva que retorne a quantidade de algarismos de um 
número. 
 
def calcAlgRec(x): 
if(x < 10): 
 return 1 
return 1 + calcAlgRec(x // 10) 
 
print(calcAlgRec(123456)) # Exibe 6 
 
EX​: ​Crie uma função recursiva que calcule a soma de todos os algarismos de um 
número. 
 
 
def somaAlgRec(x): 
if(x < 10): 
 return x 
return (x % 10) + somaAlgRec(x // 10) 
 
print(somaAlgRec(1234)) # Exibe 10 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
Exercícios de Lista: 
 
EX: Crie uma lista com nomes digitados pelo usuário até que o mesmo digite “fim”. 
 
nomes =[] 
nome = input("Digite o nome:”) 
while (nome != "fim"): 
 nomes += [nome] 
 nome = input("Digite o nome:") 
 
 
EX: Modifique o exercício do item anterior colocando após cada nome uma sequência 
de 5 zeros. 
 
nomes =[] 
nome = input("Digite o nome: ") 
while (nome != "fim"): 
nomes += [nome] 
nomes += [5*['0']] 
nome = input("Nome?") 
 
print(nomes) 
 
 
EX: Crie uma função recursiva que calcula o somatório de um conjunto de valores. 
Recebe como parâmetro uma lista (Conjunto de valores) e a quantidade de 
elementos. 
 
def somatorioRec(v, n): 
if(n == 0): 
 return 0 
return v[0] + somatorioRec(v[1:], n-1) 
 
print(somatorioRec([10, 20, 10], 3)) 
 
 
 
 
 
 
 
EX: Faça uma função recursiva que retorne o maior valor de uma lista com sublistas: 
 
def maior(l): 
 if(not l): 
 return 0 
 if(type(l[0]) == list): 
 if(maior(l[0]) > maior(l[1:])): 
 return maior(l[0]) 
 else: 
 return maior(l[1:]) 
 if(len(l) == 1): 
 return l[0] 
 if(l[0] > maior(l[1:])): 
 return l[0] 
 else: 
 return maior(l[1:]) 
 
 
 
 
EX: Faça uma função que exibe o maior valor de uma lista de preços.​ ​(Sem usar o 
método max) 
 
 
def exibeMaior(vals): 
 maior = -1 
 for x in vals: 
 if(x > maior): 
 maior = x 
 
 return maior 
 
vals = [50.5, 30.7, 25.2, 100, 70] 
print(exibeMaior(vals)) 
 
 
OBS:​ Como preço é sempre um número positivo, é só inicializar a variável maior com 
qualquer número negativo! Dessa forma, obrigatoriamente ele será menor que o primeiro 
valor lido da lista! E com isso, na primeira iteração, o maior valor será o primeiro elemento 
da lista, podendo ser atualizado ou não, dependendo se houver algum elemento com valor 
maior. 
 
 
 
 
 
 
 
 
EX: Faça uma função que implemente a​ ​Interseção entre listas: 
 
def intersect (l1, l2): 
l3 = [] 
for x in l1: 
 if(x in l2): 
 l3 += [x] 
 
return l3 
 
l1 = [1, 5, 2] 
l2 = [10, 3, 5] 
print(l1, l2) 
 
print(intersect(l1,l2)) 
 
 
 
EX: Faça uma função que implemente a​ ​união entre listas: 
 
 
def union (l1, l2): 
l3 = [] 
for x in l1: 
 if(x not in l2): 
 l3 += [x] 
 
for x in l2: 
 if(x not in l1): 
 l3 += [x] 
 
 
return l3 
 
 
EX: Faça uma função que implemente a subtração dos conjuntos ​ ​A - B: 
 
def subsConj (l1, l2): 
l3 = [] 
for x in l1: 
 if(x not in l2): 
 l3 += [x] 
 
return l3 
 
EX: Faça uma função que implemente a​ ​subtração simétrica de conjuntos: (x E União 
e not E interseção) 
 
Subtração simétrica de conjuntos: (x E União e not E interseção) 
 
def subsSimetrica (l1, l2): 
l3 = [] 
t1 = intersect(l1,l2) 
t2 = union(l1,l2) 
for x in l1: 
 if(x in t1 and x not in t2): 
 l3 += [x] 
for x in l2: 
 if(x in t1 and x not in t2): 
 l3 += [x] 
 
 
return l3 
 
 
EX: Faça um programa que contabiliza o total gasto em litros de cada modelo de 
carro e exiba na tela o nome do modelo e a maior quantidade. 
 
Considere a lista dados em que cada elemento possui informação do nome do 
modelo e a quantidade de km/L e a lista lidos que cada elemento possui o nome do 
modelo e a quantidade de km. 
 
dados = [['Up', 18], ['Gol', 10], ['Corsa',11],['Fiat', 12.5], ['Furgão', 13]] 
lidos = [['Up', 100], ['Gol', 200], ['Corsa', 150],['Fiat', 230], ['Furgão', 450], ['Fiat', 300], 
['Gol', 100]] 
 
def busca(nome, dados): 
for x in dados: 
 if(nome == x[0]): 
 return dados.index(x) 
return -1 
 
 
def atualiza(dados, lidos, total): 
for x in lidos: 
 pos = busca(x[0], dados) 
 if(pos != -1): 
 total[pos] += lidos[pos][1] 
 
 
for i in range(len(total)): 
 total[i] /= dados[i][1] 
 
def exibeMaior(dados, total): 
maior = -1 
 
for x in total: 
 if(x > maior): 
 maior = x 
 
pos = total.index(maior) 
print("Maior Quantidade: %.2f Modelo: %s\n" %(total[pos], dados[pos][0])) 
 
dados = [['Up', 18], ['Gol', 10], ['Corsa',11],['Fiat', 12.5], ['Furgão', 13]] 
lidos = [['Up', 100], ['Up', 100], ['Gol', 100], ['Corsa', 150],['Fiat', 230], ['Furgão', 450], ['Fiat', 
300], ['Gol', 100]] 
total = 5*[0] 
atualiza(dados, lidos, total) 
print(total) 
exibeMaior(dados, total)