def contar_unos(cadena):
return [Link]('1')
def diferentes_en_un_bit(a, b):
diferencia = 0
indice = -1
for i in range(len(a)):
if a[i] != b[i]:
diferencia += 1
indice = i
if diferencia > 1:
return False, None
return diferencia == 1, indice
def convertir_a_binario(n, longitud):
return format(n, f'0{longitud}b')
def generar_grupos(numeros, num_variables):
grupos = {}
print("\n▶ Grupos iniciales por número de 1's:")
for numero in numeros:
binario = convertir_a_binario(numero, num_variables)
cantidad_unos = contar_unos(binario)
[Link](cantidad_unos, []).append(binario)
for clave in sorted([Link]()):
print(f"Grupo {clave}: {grupos[clave]}")
return grupos
def combinar_grupos(grupos):
nuevos_grupos = {}
usados = set()
implicantes_primos = set()
todas_claves = sorted([Link]())
print("\n▶ Combinaciones entre grupos:")
for i in range(len(todas_claves) - 1):
grupo_actual = grupos[todas_claves[i]]
grupo_siguiente = grupos[todas_claves[i + 1]]
for a in grupo_actual:
for b in grupo_siguiente:
res, indice = diferentes_en_un_bit(a, b)
if res:
nuevo = a[:indice] + '-' + a[indice + 1:]
nuevos_grupos.setdefault(contar_unos([Link]('-', '')),
[]).append(nuevo)
[Link](a)
[Link](b)
print(f"✔ {a} combinado con {b} → {nuevo}")
for grupo in [Link]():
for termino in grupo:
if termino not in usados:
implicantes_primos.add(termino)
return nuevos_grupos, implicantes_primos
def obtener_implicantes_primos(numeros, num_variables):
grupos = generar_grupos(numeros, num_variables)
implicantes_primos = set()
iteracion = 1
while grupos:
print(f"\n▶ Iteración de combinación #{iteracion}")
grupos, nuevos = combinar_grupos(grupos)
implicantes_primos.update(nuevos)
iteracion += 1
if not grupos:
print("\n▶ No hay más combinaciones posibles.")
print("\n▶ Implicantes primos encontrados:")
print(implicantes_primos)
return implicantes_primos
def cubrir_minterminos(implicantes, minterminos, num_variables):
tabla = {}
for m in minterminos:
bin_m = convertir_a_binario(m, num_variables)
tabla[m] = []
for imp in implicantes:
coincide = all(imp[i] == bin_m[i] or imp[i] == '-' for i
in range(len(imp)))
if coincide:
tabla[m].append(imp)
print("\n▶ Tabla de cobertura (mintermino → implicantes que lo
cubren):")
for k, v in [Link]():
print(f"{k} ({convertir_a_binario(k, num_variables)}): {v}")
return tabla
def encontrar_esenciales(tabla):
esenciales = set()
print("\n▶ Implicantes esenciales:")
for minterm, implicantes in [Link]():
if len(implicantes) == 1:
esencial = implicantes[0]
if esencial not in esenciales:
print(f"Mintermino {minterm} está cubierto **solo**
por {esencial}")
[Link](esencial)
return esenciales
def imprimir_expresion(solucion, num_variables):
variables = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[:num_variables]
partes = []
for termino in solucion:
expresion = ''
for i, c in enumerate(termino):
if c == '1':
expresion += variables[i]
elif c == '0':
expresion += variables[i] + "'"
[Link](expresion)
return ' + '.join(partes)
# Programa principal
try:
num_variables = int(input("🔢 Ingresa el número de variables:
"))
max_valor = 2 ** num_variables - 1
minterminos = list(map(int, input("📥 Ingresa los minterminos
separados por espacio: ").strip().split()))
no_importa_input = input("📥 Ingresa los términos 'don't care'
separados por espacio (o deja vacío): ").strip()
no_importa = list(map(int, no_importa_input.split())) if
no_importa_input else []
todos = set(minterminos + no_importa)
if any(n > max_valor for n in todos):
print(f"❌ Error: Los valores no deben superar {max_valor}
para {num_variables} variables.")
else:
implicantes_primos = obtener_implicantes_primos(todos,
num_variables)
tabla = cubrir_minterminos(implicantes_primos, minterminos,
num_variables)
esenciales = encontrar_esenciales(tabla)
print("\n✅ Expresión booleana simplificada final (solo con
implicantes esenciales):")
print("F =", imprimir_expresion(esenciales, num_variables))
except Exception as e:
print("⚠️ Ocurrió un error:", e)