calc_num_exercicios_00_python_respostas

Prévia do material em texto

INSTITUTO FEDERAL MINAS GERAIS (IFMG) - CAMPUS BAMBUÍ
Cálculo Numérico
Prof. Marcos Roberto Ribeiro
Lista de Exercícios 00
Exercício 1:
Escreva um código que receba um número de segundos e converta este número em horas, minutos e
segundos. Escreva também um programa que faça o contrário.
Solução:
Segundos para horas, minutos e segundos:
segundos = int(input('Informe número de segundos: '))
# Minutos
minutos = segundos // 60
# Segundos restantes
segundos = segundos % 60
# Horas
horas = minutos // 60
# Minutos restantes
minutos = minutos % 60
print(horas, ':', minutos, ':', segundos, sep='')
Horas, minutos e segundos para segundos:
print('Informe os dados solicitados')
horas = int(input('Horas: '))
minutos = int(input('Minutos: '))
segundos = int(input('Segundos: '))
segundos = horas * 60 * 60 + minutos * 60 * segundos
print('\nO total de segundos é', segundos)
1/20
Exercício 2:
Desenvolva um script em Python que calcule a área de um círculo a partir de seu raio (Area = r2 × π).
Solução:
# -*- coding: utf-8 -*-
import numpy as np
print('Informe o valor do raio')
R = float(input())
A = R**2 * np.pi
print('')
print('A área do cículo é {a:.8f}'.format(a=A))
Exercício 3:
Considere a fórmula para cálculo de juros simples:
J =
C × I × T
100
,
onde J , C, I e T correspondem a juros, capital, taxa e tempo, respectivamente. Construa um código
que solicite ao usuário os valores de C, I e T e calcule J .
Solução:
print('Informe os dados')
capital = float(input('Capital: '))
taxa = float(input('Taxa: '))
tempo = float(input('Tempo: '))
juros = (capital * taxa * tempo) / 100
print('\nJuros:', juros)
Exercício 4:
Construa um código que receba três números e informe o maior deles.
Solução:
soma = 0
for cont in range(10):
print('\nAluno ', cont+1)
nota = float(input('Informe a nota: '))
soma = soma + nota
media = soma / 10
print('A média da turma é {m:.2f}'.format(m=media))
2/20
Exercício 5:
Faça um código que receba um número e responda se o mesmo é par ou ímpar.
Solução:
n = int(input('Informe um número: '))
if n % 2 == 0:
print(n, 'é par')
else:
print(n, 'é ímpar')
Exercício 6:
Faça um código capaz de calcular as raízes de uma equação de segundo grau no formato Ax2+Bx+C = 0.
Considere as seguintes observações:
• Se o termo A = 0 então a equação não é uma equação de segundo grau;
• Seja ∆ = B2 − 4×A×C. Se ∆ < 0 então a equação não possui raízes. Se ∆ = 0 então a equação
possui apenas uma raiz.
Solução:
print('Informe os termos da equação')
a = float(input('A: '))
b = float(input('B: '))
c = float(input('C: '))
print()
if a == 0:
print('Não é uma equação de segundo grau')
else:
delta = b**2 - 4 * a * c
if delta < 0:
print('A equação não possui raízes')
else:
x1 = (-b + delta**0.5) / 2 * a
if delta == 0:
print('A única raiz da equação é ', x1)
else:
x2 = (-b - delta**0.5) / 2 * a
print('As raízes da equação são:')
print('x1 = ', x1)
print('x2 = ', x2)
3/20
Exercício 7:
Faça um código para determinar se um ano é ou não bissexto. Um ano N é bissexto se N é múltiplo de
400, ou então se N é múltiplo de quatro, mas não é múltiplo de 100. Por exemplo, 2012 (múltiplo de 4,
mas não múltiplo de 100) é bissexto, 1900 (múltiplo de quatro e de 100) não é bissexto, 2000 (múltiplo
de 400) é bissexto).
Solução:
ano = int(input('Informe o ano: '))
if (ano % 400 == 0) or ((ano % 4 == 0) and not (ano % 100 == 0)):
print('Ano bissexto')
else:
print('Ano não bissexto')
Exercício 8:
Crie um código que receba valores para as variáveis reais A, B e C e calcule a seguinte fórmula
N =
(A+B × C)−
√
A×B × C
2× C +B
.
Solução:
print('Informe os valores solicitados')
A = float(input('A: '))
B = float(input('B: '))
C = float(input('C: '))
N = (A + B * C) - (A * B * C)**0.5
N = N / (2 * C + B)
print('')
print('O valor de N é', N)
Exercício 9:
Considere a função range(início, fim, passo). Utilize essa função algumas vezes com variações nos
parâmetros e faça laços de repetições para imprimir os valores gerados.
Solução:
# Números de 1 a 10
for c in range(1, 11):
print(c)
# Contagem decrescente
for c in range(10, 1, -1):
print(c)
# Múltiplos de 3 entre 20 e 50
for c in range(21, 50, 3):
print(c)
4/20
Exercício 10:
Elabore um código que receba três notas considerando os pesos 0, 3, 0, 3 e 0, 4 para as notas 1, 2 e 3,
respectivamente. A nota final é soma ponderada das três notas (NotaF inal = Nota1 ∗ 0, 3 + Nota2 ∗
0, 3 + Nota4 ∗ 0, 3). O código deve receber estas notas para 10 alunos. É necessário informar se cada
aluno foi aprovado (nota final maior ou igual a 60) ou não. Também deve ser informada a média final
de todas as notas finais.
Solução:
print('Informe as notas dos alunos')
soma = 0 # Soma das notas finais
# Repetição para cada aluno
for cont in range(10):
print('--------------------------')
print('Aluno', cont+1)
# Lê as notas
nota1 = float(input('Nota 1: '))
nota2 = float(input('Nota 2: '))
nota3 = float(input('Nota 3: '))
# Calcula nota final
nota_final = nota1 * 0.3 + nota2 * 0.3 + nota3 * 0.4
print('Nota final:', nota_final)
# Soma nota final
soma = soma + nota_final
# Verifica se o aluno foi aprovado
if nota_final >= 60:
print('Aluno aprovado!')
else:
print('Aluno reprovado!')
# Exibe a média das notas finais
print('Média dos alunos:', soma/10)
5/20
Exercício 11:
Projete um código que leia uma quantidade indeterminada de números. A cada número informado, o
usuário deve informar se deseja continuar ou parar. Ao final, o código deve retornar o maior e o menor
número recebido.
Solução:
# Menor começa em infinito (qualquer número é menor que infinito)
menor = float('Inf')
# Menor começa em menos infinito (análogo ao menor)
maior = float('-Inf')
# Laço infinito porque não sabemos quando o usuário deseja parar
while True:
# Lê o número
n = float(input('Informe um número: '))
# Teste se o número é maior até o momento
if n > maior:
maior = n
# Testa se o número é o menor até o momento
if n < menor:
menor = n
# Verifica se o usuário deseja parar
parar = input('Deseja parar (S/N): ')
if parar.upper() == 'S':
break
# Exibe o maior e menor números digitados
print('Maior número informado:', maior)
print('Menor número informado:', menor)
6/20
Exercício 12:
A fórmula C = 95(F − 32) representa a equivalência de temperaturas entre graus Celsius (C) e graus
Fahrenheit (F ). Construa um código capaz de converter uma temperatura de Celsius para Fahrenheit e
outro que façam o contrário (F = 5×C9 + 32). Junte os dois códigos de conversão em um único código.
Inicialmente deve ser perguntado ao usuário qual a conversão desejada para que em seguida seja usada
a fórmula adequada.
Solução:
Conversão de Fahrenheit para Celsius
f = float(input('Informe a temperatura em Fahrenheit: '))
c = 9/5*(f - 32)
print('Temperatura em Celsius:', c)
Conversão de Celsius para Fahrenheit
c = float(input('Informe a temperatura em Celsius: '))
f = (5 * c)/9 + 32
print('Temperatura em Fahrenheit:', f)
Código com as duas conversões:
print('Informe o tipo de conversão desejada')
print('1 - Fahrenheit para Celsius')
print('2 - Celsius para Fahrenheit')
resposta = input()
if resposta == '1':
f = float(input('Informe a temperatura em Fahrenheit: '))
c = 9/5*(f - 32)
print('Temperatura em Celsius:', c)
else:
c = float(input('Informe a temperatura em Celsius: '))
f = (5 * c)/9 + 32
print('Temperatura em Fahrenheit:', f)
Exercício 13:
Elabore um código que calcule o fatorial de um número recebido. O fatorial de um número n, representado
por n!, é calculado da seguinte maneira n! = n× (n− 1)× ...× 2× 1. Sendo que 1! = 0! = 1.
Solução:
n = int(input('Informe um número inteiro: '))
fat = 1
if n > 1:
for cont in range(2, n+1):
fat = fat * cont
print('O fatorial de', n, 'é', fat)
7/20
Exercício 14:
Implemente o algoritmo de Euclides1 para calcular o máximo divisor comum (MDC) de dois números.
Solução:
print('Informe dois números')
n1 = int(input('N1: '))
n2 = int(input('N2: '))
if n1 < 1 or n2 < 1:
print('\nNúmeros inválidos para MDC')
else:
while True:
resto = n1% n2
if resto == 0:
break
n1 = n2
n2 = resto
print('\nO MDC é ', n2)
Exercício 15:
Crie um código que calcule o mínimo múltiplo comum (MMC) entre dois números. O MMC de dois
números n1 e n2 pode ser calculado como MMC = n1∗n2MDC , onde MDC é o máximo divisor comum entre
n1 e n2.
Solução:
print('Informe dois números')
n1 = int(input('N1: '))
n2 = int(input('N2: '))
n1_copia = n1
n2_copia = n2
if (n1 > 0) and (n2 > 0):
while True:
resto = n1 % n2
if resto == 0:
break
n1 = n2
n2 = resto
mmc = n1_copia * n2_copia // n2
print('\nO MMC é ', mmc)
1https://pt.wikipedia.org/wiki/Algoritmo_de_Euclides
8/20
https://pt.wikipedia.org/wiki/Algoritmo_de_Euclides
Exercício 16:
Elabore um código capaz de simular uma calculadora simples. O código deve solicitar ao usuário a
operação desejada (soma, multiplicação, divisão, subtração ou potência) ou então sair. Quando o usuário
escolhe uma operação, o programa deve solicitar dois números, realizar a operação sobre estes números
e exibir o resultado. O código deve sempre solicitar uma nova operação até que o usuário escolha sair.
Solução:
while True:
print('\n-------------------')
print('Calculadora')
print('-------------------')
print('+: soma')
print('-: subtração')
print('*: multiplicação')
print('/: divisão')
print('**: potência')
print('s: sair')
resposta = input('Informe a opção desejada: ')
if resposta == 's':
break
if resposta not in ['+', '-', '*', '/', '**']:
print('Opção inválida')
else:
print('Inforne dois números:')
n1 = float(input('N1:'))
n2 = float(input('N2:'))
if resposta == '+':
r = n1 + n2
elif resposta == '-':
r = n1 - n2
elif resposta == '*':
r = n1 * n2
elif resposta == '/':
r = n1 / n2
elif resposta == '**':
r = n1 ** n2
print(n1, resposta, n2, '=', r)
9/20
Exercício 17:
Desenvolva um código que, considerando um conjunto de números naturais A = {1, 2, 3, ..., n}, gere
todas as combinações com três elementos contidos em A. Antes de gerar as combinações o programa
deve perguntar o número de elementos de A ao usuário.
Solução:
n = int(input('Informe o número de elementos do conjunto: '))
print('\nPossíveis combinações:')
for cont1 in range(n):
for cont2 in range(n):
for cont3 in range(n):
print('(', cont1+1, ', ', cont2+1,
', ', cont3+1, ')', sep='')
Exercício 18:
Considerando um conjunto A = {1, 2, 3, ..., n} com n informado pelo usuário, crie um código para obter
os subconjuntos de três elementos contidos em A. Lembre-se que um conjunto não possui elementos
repetidos.
Solução:
n = int(input('Informe o número de elementos do conjunto: '))
print('\nSubconjuntos:')
for cont1 in range(n):
for cont2 in range(cont1+1, n):
for cont3 in range(cont2+1, n):
print('{', cont1+1, ', ', cont2+1,
', ', cont3+1, '}', sep='')
10/20
Exercício 19:
Considere a lista X exibida na Figura 1. Considere também as variáveis A = 2 e B = 3, informe o
resultado de cada expressão:
(a) X[A+ 1]
Solução: X[A+ 1] = X[2 + 1] = X[3] = 10
(b) X[A ∗ 2]
Solução: X[A ∗ 2] = X[2 ∗ 2] = X[4] = 104
(c) X[A+B]
Solução: X[A+B] = X[2 + 3] = X[5] = 2
(d) X[A ∗B]
Solução: X[A ∗ b] = X[2 ∗ 3] = X[6] = 23
(e) X[A] +X[B]
Solução: X[A] +X[B] = X[2] +X[3] = 4 + 10 = 14
(f) X[X[A] +B]
Solução: X[X[A] +B] = X[X[2] + 3] = X[4 + 3] = x[7] = 65
(g) X[X[X[A+B]]]
Solução: X[X[X[2 + 3]]] = X[X[X[5]]] = X[X[2]] = X[4] = 104
(h) X[X[A] ∗ 2]
Solução: X[X[A] ∗ 2] = X[X[2] ∗ 2] = X[4 ∗ 2] = x[8] = 78
(i) X[X[A] +X[B]]
Solução: X[X[A] +X[B]] = X[X[2] +X[3]] = X[4 + 10] = X[14] = ERRO
A posição 14 não existe!
40 5 4 10 104 2 23 65 78 974
0 1 2 3 4 5 6 7 8 9
Figura 1: Vetor X
11/20
Exercício 20:
Implemente um código que receba duas listas com 10 números e armazene em um terceira lista a soma
das duas primeiras, considerando as respectivas posições. Ao final, exiba o resultado na tela.
Solução:
# -*- coding: utf-8 -*-
lista1 = []
lista2 = []
lista_soma = []
print('Informe da primeira lista')
for cont in range(10):
mensagem = 'Posição ' + str(cont) + ': '
numero = float(input(mensagem))
lista1.append(numero)
print('Informe da segunda lista')
for cont in range(10):
mensagem = 'Posição ' + str(cont) + ': '
numero = float(input(mensagem))
lista2.append(numero)
# Soma posições
for cont in range(10):
numero = lista1[cont] + lista2[cont]
lista_soma.append(numero)
for cont in range(10):
print('Posição ', cont, ':',
lista1[cont], '+', lista2[cont],
'=', lista_soma[cont])
Exercício 21:
A função shuffle() da biblioteca random permite embaralhar uma lista de elementos. Utilizando essa
função crie um código capaz de sortear elementos de uma lista. O usuário deve informar o número total
de elementos e quantos elementos devem ser sorteados.
Solução:
# -*- coding: utf-8 -*-
from random import shuffle
n_elementos = int(input('Informe o número de elementos: '))
n_sorteio = int(input('Informe a quantidade de elementos sorteados: '))
lista = list(range(1, n_elementos+1))
shuffle(lista)
print('Elementos sorteados:')
for cont in range(n_sorteio):
print(lista[cont])
12/20
Exercício 22:
Projete um código que preencha uma lista de 100 posições com números de 1 a 10 (utilize a função
randint() da biblioteca random). Em seguida, conte o número de vezes que cada número aparece e
armazene em um segunda lista. Por fim, exiba a quantidade de veses que cada número apareceu.
Solução:
# -*- coding: utf-8 -*-
from random import randint
lista = []
for cont in range(100):
num = randint(1, 10)
lista.append(num)
lista_cont = [0]*10
for num in lista:
lista_cont[num-1] += 1
print('Contagem dos números:')
for cont in range(10):
print(cont+1, ':', lista_cont[cont])
13/20
Exercício 23:
Construa um código capaz de calcular a velocidade média de uma viagem a partir das velocidades de
cada trecho. Uma viagem pode possuir de 1 a 50 trechos. O cálculo da velocidade média n trechos é
dado pela fórmula:
distância1 × velocidade1 + ...+ distâncian × velocidaden
distância1 + ...+ distâncian
Após o cálculo da velocidade média, o programa deve exibir quais trechos tiveram velocidade acima da
média.
Solução:
# -*- coding: utf-8 -*-
num_trechos = int(input('Informe o número de trechos: '))
lista_dist = []
lista_vel = []
soma_dist = 0
soma_vel_dist = 0
for cont in range(num_trechos):
print('------------------------------')
print('Trecho ', cont+1)
dist = float(input('Distância: '))
lista_dist.append(dist)
soma_dist += dist
vel = float(input('Velocidade: '))
lista_vel.append(vel)
soma_vel_dist += vel*dist
vel_med = soma_vel_dist/soma_dist
print('Velocidade média:', vel_med)
print('Trechos com velocidade acima da média:')
for cont in range(num_trechos):
if lista_vel[cont] > vel_med:
print('Trecho ', cont+1 , ': diatância =', lista_dist[cont],
', velocidade =', lista_vel[cont])
14/20
Exercício 24:
Implemente um código capaz de ordenar os elementos de uma lista. Inicialmente, o código deve receber
a quantidade de posições e um valor para cada posição. Em seguida, o código deve ordenar os elementos
da lista utilizando o método bolha2:
• Percorra a lista várias vezes ordenando pares de elementos, até que todos os elementos estejam
ordenados;
• Observe o exemplo a seguir:
1. Lista inicial desordenada F,O,R,A,O,R,D,E,M
2. Primeira passagem até a última posição
(a) F,O,R,A,O,R,D,E,M F ≯ O não troca
(b) F,O,R,A,O,R,D,E,M O ≯ R não troca
(c) F,O,R,A,O,R,D,E,M R > A troca
(d) F,O,A,R,O,R,D,E,M R > O troca
(e) F,O,A,O,R,R,D,E,M R ≯ R não troca
(f) F,O,A,O,R,R,D,E,M R > D troca
(g) F,O,A,O,R,D,R,E,M R > E troca
(h) F,O,A,O,R,D,E,R,M R > M troca
(i) F,O,A,O,R,D,E,M,R Fim da primeira passagem
3. Segunda passagem até a penúltima posição
(a) F,O,A,O,R,D,E,M,R F ≯ O não troca
(b) F,O,A,O,R,D,E,M,R O > A troca
(c) F,A,O,O,R,D,E,M,R O ≯ O não troca
(d) F,A,O,O,R,D,E,M,R O ≯ R não troca
(e) F,A,O,O,R,D,E,M,R R > D troca
(f) F,A,O,O,D,R,E,M,R R > E troca
(g) F,A,O,O,D,E,R,M,R R > M troca
(h) F,A,O,O,D,E,M,R,R Fim da segunda passagem
4. Terceira passagem até a antepenúltima posição
(a) F,A,O,O,D,E,M,R,R F > A troca
(b) A,F,O,O,D,E,M,R,R F ≯ O não troca
(c) A,F,O,O,D,E,M,R,RO ≯ O não troca
(d) A,F,O,O,D,E,M,R,R O > D troca
(e) A,F,O,D,O,E,M,R,R O > E troca
(f) A,F,O,D,E,O,M,R,R O > M troca
(g) A,F,O,D,E,M,O,R,R Fim da terceira passagem
5. Quarta passagem até a quarta última posição
(a) A,F,O,D,E,M,O,R,R A ≯ F não troca
(b) A,F,O,D,E,M,O,R,R F ≯ O não troca
(c) A,F,O,D,E,M,O,R,R O > D troca
(d) A,F,D,O,E,M,O,R,R O > E troca
(e) A,F,D,E,O,M,O,R,R O > M troca
(f) A,F,D,E,M,O,O,R,R Fim da quara passagem
6. Quinta passagem até a quinta última posição
(a) A,F,D,E,M,O,O,R,R A ≯ F não troca
(b) A,F,D,E,M,O,O,R,R F > D troca
(c) A,D,F,E,M,O,O,R,R F > E troca
(d) A,D,E,F,M,O,O,R,R F ≯M não troca
(e) A,D,E,F,M,O,O,R,R Fim da quinta passagem
7. Na sexta passagem não ocorre nenhuma troca e o código pode parar
2O método bolha é um método de ordenação bastante simples, existem diversos outros métodos de ordenação mais complexos
e mais eficientes.
15/20
Solução:
# -*- coding: utf-8 -*-
texto = input('Informe os elementos da lista (separados por espaço): ')
lista = texto.split()
num_elementos = len(lista)
print('Lista informada: ', lista)
for cont_passagem in range(num_elementos):
troca = False
for cont in range(num_elementos-cont_passagem-1):
if lista[cont] > lista[cont+1]:
auxiliar = lista[cont]
lista[cont] = lista[cont+1]
lista[cont+1] = auxiliar
troca = True
if not troca:
break
print('Lista ordenada: ', lista)
Exercício 25:
Desenvolva um código que receba uma lista de números inteiros e, sem seguida, crie uma nova lista
contendo os mesmos números sem repetições.
Solução:
# -*- coding: utf-8 -*-
texto = input('Informe os elementos da lista (separados por vírgula): ')
lista = texto.split(',')
lista_sr = []
for elemento in lista:
repete = False
for elemento_sr in lista_sr:
if elemento == elemento_sr:
repete = True
break
if not repete:
lista_sr.append(elemento)
print('Lista original: ', lista)
print('Lista sem prepetições: ', lista_sr)
16/20
Exercício 26:
Crie as funções input_int(mensagem) e input_float(mensagem) semelhantes à função input().
As funções devem receber uma mensagem, exibi-la ao usuário e garantir que o número digitado seja
válido. Enquanto o usuário digitar um número incorreto, as funções devem informar que o número é
inválido e solicitar e digitação novamente. Faça uma chamada a cada função para testá-las. Dica: utilize
a instrução try (tratamento de exceções).
Solução:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def input_int(mensagem):
while True:
try:
return int(input(mensagem))
except:
print('Número inválido! Tente novamente.')
def input_float(mensagem):
while True:
try:
return float(input(mensagem))
except:
print('Número inválido! Tente novamente.')
n = input_int('Informe um número inteiro: ')
print('Número informado:', n)
n = input_float('Informe um número fracionário: ')
print('Número informado:', n)
17/20
Exercício 27:
Implemente o módulo mat.py contendo as seguintes funções:
impar(numero): Retorna True ou False, caso o numero seja impar ou não;
area_circulo(raio): retorna a área de um círculo a partir de seu raio, área = raio2× π (dica, importe
pi da biblioteca math)
Codifique as chamadas a essas funções em outro arquivo.
Solução:
Arquivo mat.py:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from math import pi
def impar(numero):
if numero % 2 != 0:
return True
else:
return False
def area_circulo(raio):
return raio*raio*pi
Arquivo chamadas_mat.py:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from mat import impar, area_circulo
n = int(input('Informe um número inteiro: '))
if impar(n):
print(n, 'é ímpar')
else:
print(n, 'é ímpar')
r = float(input('Informe o raio do círculo: '))
print('A área do círculo é ', area_circulo(r))
18/20
Exercício 28:
Implemente um módulo com as seguintes funções:
ano_bissexto(ano): retorna True se o ano for bissexto e False, em caso negativo;
dias_mes(ano, mes): retorna a quantidade de dias do mês (deve usar a função ano_bissexto);
nome_mes(mes): retorna o nome do mes informado (1 a 12)
Construa um programa que receba uma data do usuário (mês e ano) e mostre o resultado das funções
implementadas sobre essa data.
Solução:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def ano_bissexto(ano):
if (ano % 400 == 0):
return True
elif (ano % 4 == 0) and not (ano % 100 == 0):
return True
else:
return False
def dias_mes(ano, mes):
if mes in [1, 3, 5, 7, 8, 10, 12]:
return 31
elif mes in [4,6,9,11]:
return 30
elif mes == 2:
if ano_bissexto(ano):
return 29
else:
return 28
else:
return -1
def nome_mes(mes):
lista_nomes = ['janeiro', 'fevereiro', 'março',
'abril', 'maio', 'junho', 'julho',
'agosto', 'setembro', 'outubro',
'novembro', 'dezembro']
if 1 <= mes <= 12:
return lista_nomes[mes-1]
else:
return 'Mês inválido'
print('Informe a data')
ano = int(input('Ano: '))
mes = int(input('Mês: '))
print('Ano bissexto:', ano_bissexto(ano))
print('Dias do mês:', dias_mes(ano, mes))
print('Nome do mês:', nome_mes(mes))
19/20
Exercício 29:
Escreva um módulo com funções para calcular o máximo divisor comum (MDC) e o mínimo múltiplo
comum (MMC) de uma lista de números. Dica: comece calculando o MDC dos dois primeiros números e,
depois, para cada número, calcule o MDC desse número com o resultado anterior (o MMC pode ser feito
de fórmula análoga). Implemente também chamadas a essas funções números digitados pelo usuário.
Solução:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def mdc_simples(n1, n2):
while True:
resto = n1 % n2
if resto == 0:
return n2
n1 = n2
n2 = resto
def mdc_lista(lista_numeros):
mdc_atual = lista_numeros[0]
for cont in range(1, len(lista_numeros)):
mdc_atual = mdc_simples(mdc_atual, lista_numeros[cont])
return mdc_atual
def mmc_lista(lista_numeros, mdc):
mmc_atual = lista_numeros[0]
for cont in range(1, len(lista_numeros)):
num = lista_numeros[cont]
mdc = mdc_simples(num, mmc_atual)
mmc_atual = mmc_atual * num // mdc
return mmc_atual
print('Cálculo de MDC e MMC')
lista_str = input('Informe a lista de números inteiros: ')
lista_num = [int(num) for num in lista_str.split()]
mdc = mdc_lista(lista_num)
mmc = mmc_lista(lista_num, mdc)
print('MDC:', mdc)
print('MMC:', mmc)
Exercício 30:
Selecione alguns dos códigos desenvolvidos e os execute passa a passo observando o fluxo de execução e
os valores das variáveis.
20/20