Tabla conceptual
Carlos A. Hernández
Nicolas D. Burbano
Miller F. Camargo
Iván D. Galindo
Julián A. Burbano
Institución Universitaria Politécnico Grancolombiano
Elementos De Teoría De La Computación- [grupo B02]
Tutor Edward Reyes
08 octubre de 2024
2
Tabla de Contenido
Tabla de Contenido 2
Entrega semana 7 3
Algoritmo relacionado con alguna actividad cotidiana 3
Diagrama de Flujo PSeInt 8
Conclusión 12
3
Entrega semana 7
Algoritmo relacionado con alguna actividad cotidiana
Para este ejercicio hemos decidido elaborar el algoritmo para la preparación de arroz, que
es muy común en el día a día en la alimentación de la mayoría de los colombianos,
Lo hemos pensado hacer directamente en código de programación en el lenguaje Python
ya que es bastante practico, también hemos elaborado el código en PSeInt con el fin de poder
elaborar adecuadamente el diagrama de flujo el cual no ayudará a entender un poco más los
ciclos de repetición o bucles, además de la toma de decisiones y sus condicionales.
print("El siguiente ejercicio lo realizamos a partir de la preparación de
una receta cotidiana para el día a día, el Arroz")
arroz = int(input("¿Cuánta cantidad en gramos de arroz vas a preparar?
"))
while arroz <= 0:
print("Por favor, ingresa una cantidad válida mayor que 0.")
arroz = int(input("¿Cuánta cantidad en gramos de arroz vas a
preparar? "))
agua = arroz * 2
aceite = (arroz * 15) / 500
sal = (arroz * 30) / 500
ajo = (arroz * 1) / 500
ingredientes = {"arroz (gr)": arroz, "agua (ml)": agua,"aceite (ml)":
aceite,"ajo (unidades)": ajo,"sal (gr)": sal}
print("necesitas los siguientes ingredientes" + str(ingredientes))
for ingrediente, cantidad in ingredientes.items():
cantidad_ingresada = float(input(f"Indica la cantidad de
{ingrediente} que tienes para tu preparación: "))
while cantidad_ingresada != cantidad:
4
if cantidad_ingresada < cantidad:
print(f"Faltan {cantidad - cantidad_ingresada:.2f}.")
cantidad_ingresada += float(input(f"Ingrese la cantidad
adicional de {ingrediente}: "))
else:
print(f"Debes retirar {cantidad_ingresada - cantidad:.2f}.")
cantidad_ingresada -= float(input(f"Ingrese la cantidad de
{ingrediente} a retirar: "))
print(f"{ingrediente.capitalize()} Ahora tienes la cantidad
necesaria.")
print("Cuentas con todos los ingredientes correctamente.")
print("como primer paso debes añadir aceite en la olla")
while True:
aceite_añadido = input("Añadiste aceite en la olla? (si/no): ")
if aceite_añadido == "si":
break
else:
print("Por favor, añade el aceite para continuar.")
aceite_ingresado = float(input("¿Cuanta cantidad de Aceite ingresaste a
la olla: "))
while aceite_ingresado != aceite:
print("La cantidad de aceite no es correcta. Por favor, ingresa
exactamente " + str(aceite) + " mililitros.")
aceite_ingresado = float(input("¿Cuánta cantidad de aceite ingresaste
a la olla? (en mililitros): "))
print("Aceite añadido correctamente.")
print("como segundo paso debes añadir el Ajo en la olla")
while True:
ajo_añadido = input("Añadiste el ajo en la olla? (si/no): ")
if ajo_añadido == "si":
break
else:
print("Por favor, añade el ajo para continuar.")
ajo_ingresado = float(input("¿Cuanta cantidad de Ajo ingresaste a la
olla"))
while ajo_ingresado != ajo:
5
print("La cantidad de aceite no es correcta. Por favor, ingresa
exactamente " + str(ajo) + " Unidades.")
ajo_ingresado = float(input("¿Cuanta cantidad de Ajo ingresaste a la
olla"))
print("Ajo añadido correctamente.")
print("Como tercer paso deberas freir el ajo hasta que esté dorado. Por
favor, confirma cuando esté listo.")
while True:
estado_ajo = input("¿El ajo está dorado? (si/no): ")
if estado_ajo == "si":
break
else:
print("Continúa friendo el ajo.")
print("como Cuarto paso debes añadir el Arroz en la olla")
while True:
arroz_añadido = input("Añadiste el arroz en la olla? (si/no): ")
if arroz_añadido == "si":
break
else:
print("Por favor, añade el arroz para continuar.")
arroz_ingresado = float(input("¿Cuánta cantidad de arroz ingresaste a la
olla? "))
while arroz_ingresado != arroz:
if arroz_ingresado < arroz:
print(f"La cantidad de arroz es menor que la necesaria. Te falta
{(arroz - arroz_ingresado):.2f} gramos.")
print("La cantidad de arroz que exactamente debes añadir es " +
str(arroz) + " gramos.")
else:
print(f"La cantidad de arroz es mayor que la necesaria. Y no
tienes esa cantidad Has ingresado {(arroz_ingresado - arroz):.2f} gramos
de más.")
print("La cantidad de arroz que exactamente debes añadir es " +
str(arroz) + " gramos.")
arroz_ingresado = float(input("Por favor, ingresa exactamente la
cantidad correcta de arroz en gramos: "))
print("Arroz añadido correctamente.")
6
print("como quinto paso debes añadir el agua en la olla")
while True:
agua_añadido = input("Añadiste el agua en la olla? (si/no): ")
if agua_añadido == "si":
break
else:
print("Por favor, añade el agua para continuar.")
agua_ingresado = float(input("¿Cuánta cantidad de agua ingresaste a la
olla? "))
while agua_ingresado != agua:
if agua_ingresado < agua:
print(f"La cantidad de agua es menor que la necesaria. Te falta
{(agua - agua_ingresado):.2f} mililitros.")
print("La cantidad de agua que exactamente debes añadir es " +
str(agua) + " gramos.")
else:
print(f"La cantidad de agua es mayor que la necesaria. y no
tienes esa cantidad Has ingresado {(agua_ingresado - agua):.2f}
mililitros de más.")
print("La cantidad de agua que exactamente debes añadir es " +
str(agua) + " gramos.")
agua_ingresado = float(input("Por favor, ingresa exactamente la
cantidad correcta de agua en mililitros: "))
print("Agua añadida correctamente.")
print("como sexto paso debes añadir la sal en la olla")
print(f"añade {sal:.2f} gramos de sal a la olla.")
sal_ingresado = float(input("¿Cuánta cantidad de sal ingresaste a la
olla? "))
while sal_ingresado != sal:
if sal_ingresado < sal:
print(f"La cantidad de sal es menor que la necesaria. Te falta
{(sal - sal_ingresado):.2f} gramos.")
print("La cantidad de arroz que exactamente debes añadir es " +
str(sal) + " gramos.")
else:
print(f"La cantidad de sal es mayor que la necesaria. Has
ingresado {(sal_ingresado - sal):.2f} gramos de más.")
print("La cantidad de arroz que exactamente debes añadir es " +
str(agua) + " gramos.")
7
sal_ingresado = float(input("Por favor, ingresa exactamente la
cantidad correcta de sal en gramos: "))
print("Sal añadida correctamente.")
ingredientes_en_olla = {
"aceite": aceite_ingresado,
"ajo": ajo_ingresado,
"arroz": arroz_ingresado,
"agua": agua_ingresado,
"sal": sal_ingresado
}
print ("ingrediente Añadidos en la olla")
print (ingredientes_en_olla)
ingredientes_requeridos = {
"aceite": aceite,
"ajo": ajo,
"arroz": arroz,
"agua": agua,
"sal": sal
}
print ("ingredientes requeridoa para la preparación")
print (ingredientes_requeridos)
for ingrediente, cantidad_necesaria in ingredientes_requeridos.items():
cantidad_ingresada = ingredientes_en_olla[ingrediente]
if cantidad_ingresada != cantidad_necesaria:
print(f"Error: La cantidad de {ingrediente} no es correcta.
Necesitas {cantidad_necesaria} pero ingresaste {cantidad_ingresada}.")
break
else:
print("Todos los ingredientes han sido añadidos correctamente.")
print("Ahora, deberas revolver todos los ingredientes. valida que todos
los ingredientes estén correctamente revueltos.")
while True:
ingredietes_revueltos = input("¿revolviste los ingredientes
correctamente? (si/no): ")
if ingredietes_revueltos == "si":
print("Ahora, espera a que el arroz se seque. Por favor, confirma
cuando esté seco.")
8
while True:
arroz_seco = input("¿El arroz se ha secado? (si/no): ")
if arroz_seco == "si":
print("Disminuyendo el fuego a mínimo.")
break
else:
print("Continúa esperando hasta que el arroz se seque.")
print("Después de una hora, puedes apagar el fuego y tu arroz
está listo para servir. ¡Buen provecho!")
break
else:
print("revuelve el arroz")
print("El arroz está completamente listo para servir. ¡Disfruta de tu
comida!")
9
Diagrama de Flujo PSeInt
10
11
12
Conclusión
Este ejercicio nos permitió aplicar los conceptos fundamentales de programación de una
manera práctica y sencilla. A través de la preparación de arroz, pudimos poner en práctica y
entender así el uso de bucles para repetir tareas hasta que se cumplieran ciertas condiciones,
condicionales para tomar decisiones en base a las entradas del usuario, y el manejo de variables
para almacenar y operar con los datos.
Aprendimos cómo descomponer una tarea cotidiana en pasos lógicos y organizados, y a
través de Python y PSeInt, entendimos cómo funcionan los flujos de control y las estructuras de
repetición. Además, el uso del diagrama de flujo nos ayudó a visualizar mejor el proceso
completo y cómo las decisiones afectan el resultado final. Este tipo de ejercicios son clave para
dominar los fundamentos de la programación, ya que nos permiten conectar la teoría con
problemas reales de manera práctica.
