OneCompiler

Atividade P2

46

=========================================================

CALCULADORA DE MATEMÁTICA DISCRETA

=========================================================

=========================================================

OPERAÇÕES COM CONJUNTOS

=========================================================

Esta função organiza os elementos do conjunto.

Ela:

1 - separa números e palavras

2 - remove repetidos

3 - ordena os elementos

def ordenar_conjunto(lista):

# Lista dos números
numeros = []

# Lista das palavras
palavras = []

# Percorre todos os elementos da lista
for item in lista:

    # Tenta transformar em inteiro
    try:
        numeros.append(int(item))

    # Se não conseguir, salva como texto
    except ValueError:
        palavras.append(str(item))

# Remove elementos repetidos
numeros = list(set(numeros))
palavras = list(set(palavras))

# Ordena os valores
numeros.sort()
palavras.sort()

# Junta as duas listas
return numeros + palavras

=========================================================

UNIÃO

=========================================================

Junta dois conjuntos sem repetir elementos

def juntar_conjuntos(conjunto1, conjunto2):

resultado = []

# Adiciona todos os elementos do primeiro conjunto
for valor in conjunto1:
    resultado.append(valor)

# Adiciona os elementos do segundo conjunto
# apenas se eles ainda não existirem
for valor in conjunto2:

    if valor not in resultado:
        resultado.append(valor)

# Retorna organizado
return ordenar_conjunto(resultado)

=========================================================

INTERSEÇÃO

=========================================================

Mostra os elementos que pertencem aos dois conjuntos

def elementos_comuns(conjunto1, conjunto2):

resultado = []

# Percorre o primeiro conjunto
for valor in conjunto1:

    # Verifica se o elemento também existe no segundo
    if valor in conjunto2:
        resultado.append(valor)

return ordenar_conjunto(resultado)

=========================================================

DIFERENÇA

=========================================================

Mostra os elementos do primeiro conjunto

que não pertencem ao segundo

def diferenca_entre_conjuntos(conjunto1, conjunto2):

resultado = []

for valor in conjunto1:

    # Adiciona somente se não estiver no segundo conjunto
    if valor not in conjunto2:
        resultado.append(valor)

return ordenar_conjunto(resultado)

=========================================================

PRODUTO CARTESIANO

=========================================================

Cria todos os pares ordenados possíveis

def pares_ordenados(conjunto1, conjunto2):

resultado = []

# Percorre os elementos do primeiro conjunto
for x in conjunto1:

    # Percorre os elementos do segundo conjunto
    for y in conjunto2:

        # Cria o par ordenado
        resultado.append((x, y))

return resultado

=========================================================

SUBCONJUNTO

=========================================================

Verifica se um conjunto está contido no outro

def verificar_subconjunto(conjunto1, conjunto2):

# Percorre todos os elementos
for valor in conjunto1:

    # Se encontrar um elemento fora do conjunto,
    # então não é subconjunto
    if valor not in conjunto2:
        return False

# Se todos pertencem, retorna verdadeiro
return True

=========================================================

CARDINALIDADE

=========================================================

Conta quantos elementos existem no conjunto

def quantidade_elementos(conjunto):

contador = 0

# Soma +1 para cada elemento
for item in conjunto:
    contador += 1

return contador

=========================================================

DIVISÃO, MDC E MMC

=========================================================

=========================================================

DIVISÃO EUCLIDIANA

=========================================================

Calcula quociente e resto

def calcular_divisao(numero1, numero2):

# Verifica divisão por zero
if numero2 == 0:

    print("Não existe divisão por zero")

    return None

# Calcula o quociente
quociente = numero1 // numero2

# Calcula o resto
resto = numero1 % numero2

# Retorna os resultados
return {
    "quociente": quociente,
    "resto": resto
}

=========================================================

MDC

=========================================================

Calcula o MDC usando o algoritmo de Euclides

def calcular_mdc(valor1, valor2):

# Repete enquanto o segundo número for diferente de zero
while valor2 != 0:

    # Calcula o resto
    resto = valor1 % valor2

    # Atualiza os valores
    valor1 = valor2
    valor2 = resto

# Quando o resto vira zero,
# o MDC é o último valor diferente de zero
return valor1

=========================================================

MMC

=========================================================

Calcula o MMC usando o MDC

def calcular_mmc(valor1, valor2):

# Primeiro calcula o MDC
valor_mdc = calcular_mdc(valor1, valor2)

# Fórmula do MMC
resultado = (valor1 * valor2) // valor_mdc

return resultado

=========================================================

ARITMÉTICA MODULAR

=========================================================

Valor padrão de Zn

ZN = 7

=========================================================

ALTERA Zn

=========================================================

Define um novo valor para Zn

def alterar_zn(valor):

global ZN

ZN = valor

=========================================================

SOMA MODULAR

=========================================================

Calcula soma modular

def soma_modular(a, b):

return (a + b) % ZN

=========================================================

MULTIPLICAÇÃO MODULAR

=========================================================

Calcula multiplicação modular

def multiplicacao_modular(a, b):

return (a * b) % ZN

=========================================================

CONGRUÊNCIA

=========================================================

Verifica se dois números são congruentes

def conferir_congruencia(a, b):

return (a % ZN) == (b % ZN)

=========================================================

INVERSO MULTIPLICATIVO

=========================================================

Procura o inverso multiplicativo

def encontrar_inverso(numero):

# Testa todos os números até Zn
for candidato in range(1, ZN):

    # Verifica se o resto é igual a 1
    if (numero * candidato) % ZN == 1:
        return candidato

# Caso não exista inverso
return None

=========================================================

PROGRAMA PRINCIPAL

=========================================================

print("===== CONJUNTOS =====")

Valores fixos para evitar erro no OneCompiler

entrada_a = ["1", "2", "3", "a"]
entrada_b = ["2", "4", "a", "c"]

Organiza os conjuntos

conjunto_a = ordenar_conjunto(entrada_a)
conjunto_b = ordenar_conjunto(entrada_b)

Mostra os conjuntos

print("A =", conjunto_a)
print("B =", conjunto_b)

União

print("União =", juntar_conjuntos(conjunto_a, conjunto_b))

Interseção

print("Interseção =", elementos_comuns(conjunto_a, conjunto_b))

Diferença

print("A - B =", diferenca_entre_conjuntos(conjunto_a, conjunto_b))

print("B - A =", diferenca_entre_conjuntos(conjunto_b, conjunto_a))

Produto cartesiano

print("Produto cartesiano =",
pares_ordenados(conjunto_a, conjunto_b))

Subconjunto

print("A está contido em B?",
verificar_subconjunto(conjunto_a, conjunto_b))

Cardinalidade

print("Cardinalidade de A =",
quantidade_elementos(conjunto_a))

print("Cardinalidade de B =",
quantidade_elementos(conjunto_b))

=========================================================

DIVISIBILIDADE

=========================================================

print("\n===== DIVISIBILIDADE =====")

Valores fixos

numero1 = 24
numero2 = 18

Calcula divisão

divisao = calcular_divisao(numero1, numero2)

Mostra quociente e resto

print("Quociente =", divisao["quociente"])

print("Resto =", divisao["resto"])

Calcula e mostra o MDC

print("MDC =", calcular_mdc(numero1, numero2))

Calcula e mostra o MMC

print("MMC =", calcular_mmc(numero1, numero2))

=========================================================

ARITMÉTICA MODULAR

=========================================================

print("\n===== ARITMÉTICA MODULAR =====")

Define o valor de Zn

alterar_zn(7)

Valores utilizados

numero_a = 14
numero_b = 21

Verifica congruência

print("Congruência:",
conferir_congruencia(numero_a, numero_b))

Número para encontrar o inverso

valor_x = 3

Mostra o inverso multiplicativo

print("Inverso multiplicativo:",
encontrar_inverso(valor_x))