Lista-04

Kenelly Menezes

Q01:

# Função para converter Fahrenheit para Celsius

def fahrenheit_para_celsius(fahrenheit):
celsius = (fahrenheit - 32) * 5/9
return celsius

# Imprime o cabeçalho da tabela

print("Fahrenheit\tCelsius")
print("-----------------------")

# Loop para gerar a tabela

for fahrenheit in range(50, 151, 5):
celsius = fahrenheit_para_celsius(fahrenheit)
print(f"{fahrenheit}\t\t{celsius:.2f}")

Q02:

# Solicita ao usuário para inserir os dois primeiros termos

termo1 = int(input("Digite o primeiro termo: "))
termo2 = int(input("Digite o segundo termo: "))

# Imprime os dois primeiros termos

print(f"{termo1}\n{termo2}")

# Loop para gerar os próximos 8 termos

for _ in range(8):
termo_novo = termo1 + termo2 # ou termo1 - termo2, dependendo da regra
print(termo_novo)

# Atualiza os dois termos anteriores para os próximos cálculos

termo1, termo2 = termo2, termo_novo
Q03:

import math

# Solicita ao usuário para inserir o valor de x

x = float(input("Digite o valor de x: "))

# Inicializa a variável para armazenar a soma dos termos

resultado = 1.0

# Loop para calcular os termos da série

for n in range(1, 11):
termo_n = x**n / math.factorial(n)
resultado += termo_n

# Imprime o resultado
print(f"O valor de e^{x} é aproximadamente: {resultado:.6f}")

Q04:

# Função para calcular o valor aproximado de π com base na série

def calcular_pi_com_serie(n):
soma = 0.0
sinal = 1.0

for i in range(n):
termo = sinal / (2*i + 1)
soma += termo
sinal *= -1 # Alterna o sinal a cada termo

pi_aproximado = (soma * 4)**(1/3)

return pi_aproximado

# Define o número de termos (n) na série

n_termos = 51

# Calcula o valor aproximado de π com 51 termos

pi_aproximado = calcular_pi_com_serie(n_termos)

# Imprime o resultado
print(f"O valor aproximado de π com 51 termos é: {pi_aproximado:.10f}")
Q05:

# Solicita ao usuário para inserir o número inteiro

numero = int(input("Digite um número inteiro para calcular a raiz quadrada: "))

# Inicializa variáveis
subtrahendo = 1
raiz_quadrada = 0

# Loop para realizar as subtrações

while numero > 0:
numero -= subtrahendo
subtrahendo += 2
raiz_quadrada += 1

# Imprime o resultado
print(f"A raiz quadrada é: {raiz_quadrada}")

Q06:

# Função para verificar se um número é primo

def eh_primo(numero):
if numero <= 1:
return False
for i in range(2, int(numero**0.5) + 1):
if numero % i == 0:
return False
return True

# Solicita ao usuário para inserir um número inteiro

numero = int(input("Digite um número inteiro para verificar se é primo: "))

# Verifica se o número é primo e imprime o resultado

if eh_primo(numero):
print(f"{numero} é um número primo.")
else:
print(f"{numero} não é um número primo.")
Q07:

# Função para calcular a perda de carga (Hazen-Williams)

def calcular_perda_de_carga(vazao, diametro, rugosidade):
coeficiente_k = 10.643
perda_carga = (coeficiente_k * (vazao / (diametro**0.63)) * rugosidade**(0.54)) / (1.0 * 1000.0)
return perda_carga

# Solicita ao usuário para inserir o diâmetro do tubo e o coeficiente de rugosidade

diametro_tubo = float(input("Digite o diâmetro do tubo (em metros): "))
coeficiente_rugosidade = float(input("Digite o coeficiente de rugosidade: "))

# Inicializa a vazão mínima e máxima

vazao_minima = 0.1
vazao_maxima = 10.0

# Incremento da vazão
incremento_vazao = 0.1

# Imprime o cabeçalho da tabela

print("Vazão (l/s)\tPerda de Carga (m)")

# Loop para construir a tabela

vazao = vazao_minima
while vazao <= vazao_maxima:
# Calcula a perda de carga
perda_carga = calcular_perda_de_carga(vazao, diametro_tubo, coeficiente_rugosidade)

# Imprime a linha da tabela

print(f"{vazao:.1f}\t\t{perda_carga:.6f}")

# Atualiza a vazão
vazao += incremento_vazao
Q08:

import math

# Função para calcular o tempo necessário para igualar os níveis dos reservatórios
def calcular_tempo_igualdade_niveis(altura_inicial1, taxa1, altura_inicial2, taxa2):
tempo = 0
while altura_inicial1 < altura_inicial2:
altura_inicial1 += taxa1 / 100 # Convertendo a taxa para metros por minuto
altura_inicial2 += taxa2 / 100 # Convertendo a taxa para metros por minuto
tempo += 1
return tempo

# Dados dos reservatórios

raio_reservatorio = 1.0 # metros
altura_inicial_reservatorio1 = 1.45 # metros
taxa_enchimento_reservatorio1 = 1.55 # cm/min
altura_inicial_reservatorio2 = 1.87 # metros
taxa_enchimento_reservatorio2 = 0.65 # cm/min

# Calcula o tempo necessário para igualar os níveis

tempo_niveis_iguais = calcular_tempo_igualdade_niveis(
altura_inicial_reservatorio1, taxa_enchimento_reservatorio1,
altura_inicial_reservatorio2, taxa_enchimento_reservatorio2
)

# Imprime o resultado
print(f"O tempo necessário para que os reservatórios tenham o mesmo nível é de
{tempo_niveis_iguais} minutos.")

Q09:

# Função para calcular a operação a^b

def calcular_potencia(a, b):
resultado = 1
for _ in range(b):
resultado *= a
return resultado

# Solicita ao usuário para inserir os números a e b

a = float(input("Digite o valor de a: "))
b = int(input("Digite o valor de b (deve ser um número inteiro): "))

# Calcula a^b utilizando a função

resultado_potencia = calcular_potencia(a, b)

# Imprime o resultado
print(f"{a} elevado a {b} é igual a: {resultado_potencia}")
Q10:

# Solicita ao usuário para inserir o número N e os limites do intervalo [a, b]

N = int(input("Digite o número N: "))
a = int(input("Digite o valor de a: "))
b = int(input("Digite o valor de b: "))

# Inicializa uma variável para verificar se há múltiplos

tem_multiplos = False

# Imprime os múltiplos de N no intervalo [a, b]

print(f"Múltiplos de {N} no intervalo [{a}, {b}]:")
for i in range(a, b + 1):
if i % N == 0:
print(i)
tem_multiplos = True

# Se não houver nenhum múltiplo, imprime a mensagem correspondente

if not tem_multiplos:
print("Nenhum múltiplo no intervalo.")