Faça um programa que faça operações simples de frações:
  • Crie e leia duas frações p e q, compostas por numerador e denominador.
  • Encontre o máximo divisor comum entre o numerador e o denominador, e simplifique as frações.
  • Apresente a soma, a subtração, o produto e o quociente entre as frações lidas.
Obs.: Cria uma função para cada item.

Passo 1

Resumo do problema: precisamos criar um programa que leia duas frações p e q (cada uma com numerador e denominador), simplifique-as usando o máximo divisor comum e depois apresente a soma, subtração, produto e quociente dessas frações. Cada funcionalidade deve estar em sua própria função.

Passo 2

Criar a função de máximo divisor comum (MDC) usando o algoritmo de Euclides. Essa função recebe dois inteiros a e b e retorna o MDC deles.

Passo 3

Criar a função simplificar que recebe uma fração representada por tupla (numerador, denominador), calcula o MDC dos valores, divide numerador e denominador por esse MDC e retorna a fração simplificada.

Passo 4

Criar funções para as operações entre frações: soma, subtração, produto e quociente. Cada função recebe duas frações e retorna o resultado já simplificado usando a função simplificar.

Passo 5

Implementar o fluxo principal do programa: ler os numeradores e denominadores das frações, chamar simplificar em cada uma, calcular as quatro operações chamando as funções correspondentes e exibir tudo na tela de forma clara.

Resposta

Programa para operações com frações em Python

def mdc(a, b):
# Algoritmo de Euclides para calcular o máximo divisor comum
a, b = abs(a), abs(b)
while b != 0:
a, b = b, a % b
return a
def simplificar(fracao):
# Recebe tupla (num, den) e retorna tupla simplificada
num, den = fracao
if den == 0:
raise ValueError(“Denominador não pode ser zero.”)
sinal = -1 if num * den < 0 else 1
num, den = abs(num), abs(den)
fator = mdc(num, den)
return (sinal * (num // fator), den // fator)
def soma(p, q):
# Soma de frações p=(n1,d1) e q=(n2,d2)
n1, d1 = p
n2, d2 = q
resultado = (n1 * d2 + n2 * d1, d1 * d2)
return simplificar(resultado)
def subtracao(p, q):
# Subtração de p - q
n1, d1 = p
n2, d2 = q
resultado = (n1 * d2 - n2 * d1, d1 * d2)
return simplificar(resultado)
def produto(p, q):
# Produto de frações
n1, d1 = p
n2, d2 = q
resultado = (n1 * n2, d1 * d2)
return simplificar(resultado)
def quociente(p, q):
# Divisão de p / q
n1, d1 = p
n2, d2 = q
if n2 == 0:
raise ValueError(“Não é possível dividir por fração zero.”)
resultado = (n1 * d2, d1 * n2)
return simplificar(resultado)

Fluxo principal

def main():
print(“Digite a fração p:”)
n1 = int(input(" Numerador: “))
d1 = int(input(” Denominador: “))
print(“Digite a fração q:”)
n2 = int(input(” Numerador: “))
d2 = int(input(” Denominador: "))
p = simplificar((n1, d1))
q = simplificar((n2, d2))

print(f"\nFrações simplificadas:")
print(f" p = {p[0]}/{p[1]}")
print(f" q = {q[0]}/{q[1]}")

print("\nResultados das operações:")
s = soma(p, q)
print(f" Soma: {s[0]}/{s[1]}")
sub = subtracao(p, q)
print(f" Subtração: {sub[0]}/{sub[1]}")
prod = produto(p, q)
print(f" Produto: {prod[0]}/{prod[1]}")
div = quociente(p, q)
print(f" Quociente: {div[0]}/{div[1]}")
if name == “main”:
main()

Exercícios relacionados