Escreva um módulo no qual existam três funções: permutação, arranjo e combinação. Cada função deve apresentar seus argumentos específicos para seu devido funcionamento. Em um módulo separado, teste cada uma das funções. Desenvolva suas próprias funções com estrutura def.
Passo 1
Beleza, vamos por partes! O exercício pede pra gente criar um módulo em Python com três funções: permutação, arranjo e combinação. Cada função vai ter seus próprios argumentos pra funcionar direitinho. Além disso, precisamos criar outro módulo separado para testar cada uma dessas funções. Pra isso, vamos usar a estrutura
def
do Python pra definir nossas funções.Passo 2
Primeiro, vamos entender o que é cada uma dessas funções:
-
Permutação: É quando a gente arranja todos os elementos de um conjunto, e a ordem importa. Por exemplo, as permutações de [A, B, C] são ABC, ACB, BAC, BCA, CAB, CBA.
-
Arranjo: É quando a gente seleciona e arranja apenas uma parte dos elementos do conjunto. A ordem também importa aqui. Por exemplo, os arranjos de 2 elementos de [A, B, C] são AB, AC, BA, BC, CA, CB.
-
Combinação: É quando a gente seleciona um subconjunto dos elementos, mas a ordem não importa. Por exemplo, as combinações de 2 elementos de [A, B, C] são AB, AC, BC.
Passo 3
Vamos começar a codificar o módulo com as três funções. Vamos chamar esse módulo de
combinacoes.py
. Cada função vai receber os parâmetros necessários para calcular sua respectiva operação.# combinacoes.py
import math
def permutacao(n):
"""
Calcula a permutação de n elementos.
Permutação é o número de maneiras de arranjar todos os elementos.
"""
return math.factorial(n)
def arranjo(n, p):
"""
Calcula o arranjo de p elementos dentre n.
Arranjo é o número de maneiras de selecionar e arranjar p elementos.
"""
return math.factorial(n) / math.factorial(n - p)
def combinacao(n, p):
"""
Calcula a combinação de p elementos dentre n.
Combinação é o número de maneiras de selecionar p elementos sem se preocupar com a ordem.
"""
return math.factorial(n) / (math.factorial(p) * math.factorial(n - p))
Explicação das funções:
-
permutacao(n)
: Usa a funçãofactorial
da bibliotecamath
pra calcularn!
, que representa o número de permutações de n elementos. -
arranjo(n, p)
: Calculan! / (n - p)!
, que é a fórmula para arranjos de p elementos escolhidos dentre n. -
combinacao(n, p)
: Calculan! / (p! * (n - p)!)
, que é a fórmula para combinações de p elementos escolhidos dentre n.
Passo 4
Agora, vamos criar um outro módulo para testar essas funções. Vamos chamar esse módulo de
test_combinacoes.py
.# test_combinacoes.py
import combinacoes
def testar_permutacao():
n = 5
print(f"Permutação de {n} elementos: {combinacoes.permutacao(n)}")
def testar_arranjo():
n = 5
p = 3
print(f"Arranjo de {p} elementos dentre {n}: {combinacoes.arranjo(n, p)}")
def testar_combinacao():
n = 5
p = 3
print(f"Combinação de {p} elementos dentre {n}: {combinacoes.combinacao(n, p)}")
if __name__ == "__main__":
testar_permutacao()
testar_arranjo()
testar_combinacao()
Explicação dos testes:
-
testar_permutacao()
: Testa a função de permutação com 5 elementos. -
testar_arranjo()
: Testa a função de arranjo escolhendo 3 elementos dentre 5. -
testar_combinacao()
: Testa a função de combinação escolhendo 3 elementos dentre 5.
No final, usamos o bloco
if __name__ == "__main__":
pra garantir que os testes rodem apenas se o script for executado diretamente.Resposta
Abaixo estão os dois módulos com as funções e os testes:
import math
def permutacao(n):
"""
Calcula a permutação de n elementos.
Permutação é o número de maneiras de arranjar todos os elementos.
"""
return math.factorial(n)
def arranjo(n, p):
"""
Calcula o arranjo de p elementos dentre n.
Arranjo é o número de maneiras de selecionar e arranjar p elementos.
"""
return math.factorial(n) / math.factorial(n - p)
def combinacao(n, p):
"""
Calcula a combinação de p elementos dentre n.
Combinação é o número de maneiras de selecionar p elementos sem se preocupar com a ordem.
"""
return math.factorial(n) / (math.factorial(p) * math.factorial(n - p))
test_combinacoes.py
import combinacoes
def testar_permutacao():
n = 5
print(f"Permutação de {n} elementos: {combinacoes.permutacao(n)}")
def testar_arranjo():
n = 5
p = 3
print(f"Arranjo de {p} elementos dentre {n}: {combinacoes.arranjo(n, p)}")
def testar_combinacao():
n = 5
p = 3
print(f"Combinação de {p} elementos dentre {n}: {combinacoes.combinacao(n, p)}")
if __name__ == "__main__":
testar_permutacao()
testar_arranjo()
testar_combinacao()
Pronto! Agora é só rodar o arquivo
test_combinacoes.py
pra ver os resultados das funções.