es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Álgebra booleana: cómo completar las expresiones faltantes.

28 Jul, 2023 Programación

Por ejemplo, AB + AB’ = A y ABC + ABC’ = AB. Cuando el usuario ingresa AB, ¿cómo puedo encontrar la letra faltante y darle la forma que tenía antes de simplificarse? De hecho, lo que necesitamos hacer es multiplicar la letra faltante y la letra no faltante con la expresión actual. Por ejemplo, A * (B + B’).

Otros ejemplos:

  • ABC + A’C’ (falta la letra B) => (A’C’ * (B + B’)) + ABC
  • ABCD + AD’ (faltan las letras B y C) => ((AD’ * (B+B’)) * (C + C’)) + ABCD

Suponemos que el usuario ingresa las letras en orden. El resultado debe ser acorde. Primero “A”, luego “B”, luego “C”, luego “D” y hasta D como máximo. ¿Cómo podemos resolver este problema con Python?

Tags:  , , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Una posible solución en Python podría ser crear una función que tome la expresión de entrada del usuario (como una cadena de texto) y la letra máxima que podría estar incluida (por ejemplo, ‘D’ en los ejemplos anteriores).

    La función podría iterar a través de cada letra de la cadena, verificando si falta comparándola con la letra actual que se está verificando (por ejemplo, si la entrada es “AB” y estamos verificando la letra ‘C’, sabemos que falta).

    Si se encuentra una letra faltante, la función podría crear el término faltante multiplicándolo por la negación correspondiente (por ejemplo, si falta la ‘B’, podríamos multiplicar ‘A’ por ‘(B + B\’)’ para obtener ‘A(B + B\’)’).

    La función continuaría este proceso para cada letra faltante y armaría la expresión final sumando todos los términos.

    Aquí tienes un código de ejemplo que implementa este enfoque:

    def encontrar_termino_faltante(expresion_entrada, letra_maxima):
    terminos = []
    letras_faltantes = set(letra_maxima) - set(expresion_entrada)
    for letra in letra_maxima:
        if letra in expresion_entrada:
            terminos.append(letra)
        else:
            negacion = letra + '\''
            termino_faltante = letra + '(' + expresion_entrada + '+' + negacion + ')'
            terminos.append(termino_faltante)
    return '+'.join(terminos)

# Ejemplo de uso
expresion_entrada = 'ABC'
letra_maxima = 'D'
resultado = encontrar_termino_faltante(expresion_entrada, letra_maxima)
print(resultado) # Salida: A(BC + B'C') + ABC' + AB'C + A'B'C'

    Ten en cuenta que esta función asume que la expresión de entrada es una expresión booleana válida que sigue las reglas del álgebra booleana (por ejemplo, no hay letras repetidas, paréntesis balanceados, etc.). También asume que la expresión de entrada no contiene ninguna negación (es decir, todas las letras son positivas). Si la entrada no cumple con estas suposiciones, la función debería modificarse adecuadamente.

Comments are closed.