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ção factorial da biblioteca math pra calcular n!, que representa o número de permutações de n elementos.
  • arranjo(n, p): Calcula n! / (n - p)!, que é a fórmula para arranjos de p elementos escolhidos dentre n.
  • combinacao(n, p): Calcula n! / (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.

Exercícios relacionados