Ejercicio Simplificado: Simulador de Cajero Automático Básico

 Ejercicio Simplificado: Simulador de Cajero Automático Básico

Has sido contratado por un banco para crear un programa muy simple que simule un cajero automático. Tu tarea es desarrollar un algoritmo que permita retirar dinero, pero solo con dos tipos de billetes: de 50 y de 100.

Condiciones:

  • El cajero solo tiene billetes de 50 y 100.

  • El usuario solo puede retirar cantidades que sean múltiplos de 50 (por ejemplo: 50, 100, 150, 200, etc.). Si pide una cantidad que no es múltiplo de 50, debe mostrar un mensaje de error.

  • El objetivo es calcular cuántos billetes de cada denominación se deben entregar, usando la menor cantidad de billetes posible (siempre priorizando los billetes de mayor valor).

Cómo debe funcionar:

  1. Pregunta al usuario cuánto dinero quiere retirar.

  2. Si la cantidad no es múltiplo de 50, muestra: "Error: Solo puedes retirar cantidades múltiplos de 50".

  3. Si es válida, calcula:

    • Cuántos billetes de 100 se pueden dar (división entera entre la cantidad y 100).

    • El resto se debe cubrir con billetes de 50 (división entera del resto entre 50).

  4. Muestra el resultado.

Ejemplo:

  • Si el usuario quiere retirar 250:

    • Billetes de 100: 2 (200)

    • Billetes de 50: 1 (50)

    • Total: 200 + 50 = 250

Requisito adicional:

  • Asegúrate de que el programa funcione correctamente para cualquier cantidad múltiplo de 50.

Esqueleto del código (opcional, si quieres usarlo):

python
# Pide al usuario la cantidad a retirar
cantidad = int(input("¿Cuánto dinero quieres retirar? "))

# Verifica si es múltiplo de 50
if cantidad % 50 != 0:
    print("Error: Solo puedes retirar cantidades múltiplos de 50")
else:
    # Calcula billetes de 100
    billetes_100 = cantidad // 100
    resto = cantidad % 100
    
    # Calcula billetes de 50 con el resto
    billetes_50 = resto // 50
    
    # Muestra el resultado
    print(f"Billetes de 100: {billetes_100}")
    print(f"Billetes de 50: {billetes_50}")

Posible prueba:

  • Entrada: 150

  • Salida:

    text
    Billetes de 100: 1
Billetes de 50: 1

Esta versión es más sencilla porque:

  1. Solo tiene dos denominaciones (50 y 100).

  2. No necesita manejar saldos de cuenta ni autenticación.

  3. Solo se enfoca en la lógica básica de distribución de billetes.

  4. Las matemáticas son simples (divisiones enteras y resto)


¿Por qué NO se necesita un ciclo?

Porque con solo dos tipos de billetes y priorizando los de mayor valor (100), la lógica es muy directa:

  1. Primero sacamos todos los billetes de 100 posibles: cantidad // 100

  2. Luego el resto lo cubrimos con billetes de 50: (cantidad % 100) // 50

Ejemplo con 250:

  • Billetes de 100: 250 // 100 = 2 (sobran 50)

  • Billetes de 50: 50 // 50 = 1

  • Total: 2*100 + 1*50 = 250

¿Cuándo SÍ se necesitaría un ciclo?

Si tuviéramos más denominaciones (por ejemplo: 500, 200, 100, 50, 20, 10) y quisiéramos priorizar siempre los billetes más grandes, entonces sí necesitaríamos un ciclo para ir recorriendo todas las denominaciones.

Versión con ciclo (por si quieres practicar):

python
cantidad = int(input("¿Cuánto dinero quieres retirar? "))

if cantidad % 50 != 0:
    print("Error: Solo puedes retirar cantidades múltiplos de 50")
else:
    denominaciones = [100, 50]  # De mayor a menor
    billetes = {}
    
    for denom in denominaciones:
        if cantidad >= denom:
            billetes[denom] = cantidad // denom
            cantidad = cantidad % denom
    
    print("Billetes a entregar:")
    for denom, cantidad_billetes in billetes.items():
        print(f"Billetes de {denom}: {cantidad_billetes}")

Pero para este ejercicio específico, con solo dos denominaciones, la solución sin ciclo es más simple y directa. ¡Tu intuición de usar ciclo muestra que estabas pensando en una solución más general! 



 • Las denominaciones disponibles son: 50, 100, 200, 500 y 1000.


 • Si el inventario no cuenta con una combinación de billetes suficientes para satisfacer el importe solicitado, no dispensará ningún billete.


Cajero Automático con Múltiples Denominaciones

python
# Inventario inicial - 10 billetes de cada denominación
billetes_1000 = 10
billetes_500 = 10
billetes_200 = 10
billetes_100 = 10
billetes_50 = 10

# Programa principal
print("=== CAJERO AUTOMÁTICO ===")

# Mostrar inventario actual
print("\n--- Inventario Actual ---")
print(f"Billetes de 1000: {billetes_1000}")
print(f"Billetes de 500: {billetes_500}")
print(f"Billetes de 200: {billetes_200}")
print(f"Billetes de 100: {billetes_100}")
print(f"Billetes de 50: {billetes_50}")
print("--------------------------")

# Pedir la cantidad a retirar
cantidad = int(input("\n¿Cuánto dinero quieres retirar? "))

# Verificar monto mínimo
if cantidad < 50:
    print("Error: El monto mínimo es 50")

# Verificar si es múltiplo de 50
elif cantidad % 50 != 0:
    print("Error: Solo puedes retirar cantidades múltiplos de 50")

else:
    # Calcular cuántos billetes de cada uno necesitamos
    temp_1000 = min(billetes_1000, cantidad // 1000)
    resto = cantidad - (temp_1000 * 1000)
    
    temp_500 = min(billetes_500, resto // 500)
    resto = resto - (temp_500 * 500)
    
    temp_200 = min(billetes_200, resto // 200)
    resto = resto - (temp_200 * 200)
    
    temp_100 = min(billetes_100, resto // 100)
    resto = resto - (temp_100 * 100)
    
    temp_50 = min(billetes_50, resto // 50)
    resto = resto - (temp_50 * 50)
    
    # Verificar si se puede dispensar exactamente la cantidad solicitada
    if resto != 0:
        print("Error: No hay una combinación de billetes disponible para el monto solicitado")
    else:
        # Actualizar el inventario
        billetes_1000 -= temp_1000
        billetes_500 -= temp_500
        billetes_200 -= temp_200
        billetes_100 -= temp_100
        billetes_50 -= temp_50
        
        # Mostrar resultado
        print(f"\nRetirando {cantidad}:")
        if temp_1000 > 0:
            print(f"• {temp_1000} billete(s) de 1000")
        if temp_500 > 0:
            print(f"• {temp_500} billete(s) de 500")
        if temp_200 > 0:
            print(f"• {temp_200} billete(s) de 200")
        if temp_100 > 0:
            print(f"• {temp_100} billete(s) de 100")
        if temp_50 > 0:
            print(f"• {temp_50} billete(s) de 50")
        
        # Mostrar inventario final
        print("\n--- Inventario Final ---")
        print(f"Billetes de 1000: {billetes_1000}")
        print(f"Billetes de 500: {billetes_500}")
        print(f"Billetes de 200: {billetes_200}")
        print(f"Billetes de 100: {billetes_100}")
        print(f"Billetes de 50: {billetes_50}")
        print("------------------------")

print("\n¡Gracias por usar nuestro cajero!")

Este código ahora incluye todas las denominaciones solicitadas (50, 100, 200, 500 y 1000) y verifica que exista una combinación exacta de billetes antes de realizar el retiro. Si no hay una combinación que satisfaga exactamente el monto solicitado, no se dispensará ningún billete.

El algoritmo intenta usar primero los billetes de mayor denominación y luego va bajando progresivamente a los de menor denominación, lo que es la forma estándar de operar en los cajeros automáticos.

Cajero Automático con Múltiples Denominaciones

python
# Inventario inicial - 10 billetes de cada denominación
billetes_1000 = 10
billetes_500 = 10
billetes_200 = 10
billetes_100 = 10
billetes_50 = 10

# Programa principal
print("=== CAJERO AUTOMÁTICO ===")

# Mostrar inventario actual
print("\n--- Inventario Actual ---")
print(f"Billetes de 1000: {billetes_1000}")
print(f"Billetes de 500: {billetes_500}")
print(f"Billetes de 200: {billetes_200}")
print(f"Billetes de 100: {billetes_100}")
print(f"Billetes de 50: {billetes_50}")
print("--------------------------")

# Pedir la cantidad a retirar
cantidad = int(input("\n¿Cuánto dinero quieres retirar? "))

# Verificar monto mínimo
if cantidad < 50:
    print("Error: El monto mínimo es 50")

# Verificar si es múltiplo de 50
elif cantidad % 50 != 0:
    print("Error: Solo puedes retirar cantidades múltiplos de 50")

else:
    # Calcular cuántos billetes de cada uno necesitamos
    temp_1000 = min(billetes_1000, cantidad // 1000)
    resto = cantidad - (temp_1000 * 1000)
    
    temp_500 = min(billetes_500, resto // 500)
    resto = resto - (temp_500 * 500)
    
    temp_200 = min(billetes_200, resto // 200)
    resto = resto - (temp_200 * 200)
    
    temp_100 = min(billetes_100, resto // 100)
    resto = resto - (temp_100 * 100)
    
    temp_50 = min(billetes_50, resto // 50)
    resto = resto - (temp_50 * 50)
    
    # Verificar si se puede dispensar exactamente la cantidad solicitada
    if resto != 0:
        print("Error: No hay una combinación de billetes disponible para el monto solicitado")
    else:
        # Actualizar el inventario
        billetes_1000 -= temp_1000
        billetes_500 -= temp_500
        billetes_200 -= temp_200
        billetes_100 -= temp_100
        billetes_50 -= temp_50
        
        # Mostrar resultado
        print(f"\nRetirando {cantidad}:")
        if temp_1000 > 0:
            print(f"• {temp_1000} billete(s) de 1000")
        if temp_500 > 0:
            print(f"• {temp_500} billete(s) de 500")
        if temp_200 > 0:
            print(f"• {temp_200} billete(s) de 200")
        if temp_100 > 0:
            print(f"• {temp_100} billete(s) de 100")
        if temp_50 > 0:
            print(f"• {temp_50} billete(s) de 50")
        
        # Mostrar inventario final
        print("\n--- Inventario Final ---")
        print(f"Billetes de 1000: {billetes_1000}")
        print(f"Billetes de 500: {billetes_500}")
        print(f"Billetes de 200: {billetes_200}")
        print(f"Billetes de 100: {billetes_100}")
        print(f"Billetes de 50: {billetes_50}")
        print("------------------------")

print("\n¡Gracias por usar nuestro cajero!")

Este código ahora incluye todas las denominaciones solicitadas (50, 100, 200, 500 y 1000) y verifica que exista una combinación exacta de billetes antes de realizar el retiro. Si no hay una combinación que satisfaga exactamente el monto solicitado, no se dispensará ningún billete.

El algoritmo intenta usar primero los billetes de mayor denominación y luego va bajando progresivamente a los de menor denominación, lo que es la forma estándar de operar en los cajeros automáticos.


Cajero Automático con Múltiples Denominaciones

python
# Inventario inicial - 10 billetes de cada denominación
billetes_1000 = 10
billetes_500 = 10
billetes_200 = 10
billetes_100 = 10
billetes_50 = 10

# Programa principal
print("=== CAJERO AUTOMÁTICO ===")

# Mostrar inventario actual
print("\n--- Inventario Actual ---")
print(f"Billetes de 1000: {billetes_1000}")
print(f"Billetes de 500: {billetes_500}")
print(f"Billetes de 200: {billetes_200}")
print(f"Billetes de 100: {billetes_100}")
print(f"Billetes de 50: {billetes_50}")
print("--------------------------")

# Pedir la cantidad a retirar
cantidad = int(input("\n¿Cuánto dinero quieres retirar? "))

# Verificar monto mínimo
if cantidad < 50:
    print("Error: El monto mínimo es 50")

# Verificar si es múltiplo de 50
elif cantidad % 50 != 0:
    print("Error: Solo puedes retirar cantidades múltiplos de 50")

else:
    # Calcular cuántos billetes de cada uno necesitamos
    temp_1000 = min(billetes_1000, cantidad // 1000)
    resto = cantidad - (temp_1000 * 1000)
    
    temp_500 = min(billetes_500, resto // 500)
    resto = resto - (temp_500 * 500)
    
    temp_200 = min(billetes_200, resto // 200)
    resto = resto - (temp_200 * 200)
    
    temp_100 = min(billetes_100, resto // 100)
    resto = resto - (temp_100 * 100)
    
    temp_50 = min(billetes_50, resto // 50)
    resto = resto - (temp_50 * 50)
    
    # Verificar si se puede dispensar exactamente la cantidad solicitada
    if resto != 0:
        print("Error: No hay una combinación de billetes disponible para el monto solicitado")
    else:
        # Actualizar el inventario
        billetes_1000 -= temp_1000
        billetes_500 -= temp_500
        billetes_200 -= temp_200
        billetes_100 -= temp_100
        billetes_50 -= temp_50
        
        # Mostrar resultado
        print(f"\nRetirando {cantidad}:")
        if temp_1000 > 0:
            print(f"• {temp_1000} billete(s) de 1000")
        if temp_500 > 0:
            print(f"• {temp_500} billete(s) de 500")
        if temp_200 > 0:
            print(f"• {temp_200} billete(s) de 200")
        if temp_100 > 0:
            print(f"• {temp_100} billete(s) de 100")
        if temp_50 > 0:
            print(f"• {temp_50} billete(s) de 50")
        
        # Mostrar inventario final
        print("\n--- Inventario Final ---")
        print(f"Billetes de 1000: {billetes_1000}")
        print(f"Billetes de 500: {billetes_500}")
        print(f"Billetes de 200: {billetes_200}")
        print(f"Billetes de 100: {billetes_100}")
        print(f"Billetes de 50: {billetes_50}")
        print("------------------------")

print("\n¡Gracias por usar nuestro cajero!")

Este código ahora incluye todas las denominaciones solicitadas (50, 100, 200, 500 y 1000) y verifica que exista una combinación exacta de billetes antes de realizar el retiro. Si no hay una combinación que satisfaga exactamente el monto solicitado, no se dispensará ningún billete.

El algoritmo intenta usar primero los billetes de mayor denominación y luego va bajando progresivamente a los de menor denominación, lo que es la forma estándar de operar en los cajeros automáticos.

Comentarios

Publicar un comentario

Entradas populares de este blog

¿Qué es un Closure?

CÓDIGO SIMPLIFICADO python def contador_llamadas ( funcion_original ) : contador = 0 def funcion_envoltura ( ) : nonlocal contador contador += 1 print ( f"Llamada número: { contador } " ) return funcion_original ( ) # ← Ejecuta saludar() return funcion_envoltura # Definimos UNA sola función-funcion_original ) def saludar ( ) : return "¡Hola!" # Aplicamos el contador saludar_contador = contador_llamadas ( saludar ) # Usamos la función print ( saludar_contador ( ) ) # Llamada 1 print ( saludar_contador ( ) ) # Llamada 2 print ( saludar_contador ( ) ) # Llamada 3 🎯   SALIDA: text Llamada número: 1 ¡Hola! Llamada número: 2 ¡Hola! Llamada número: 3 ¡Hola! LA CLAVE ESTÁ EN ESTA LÍNEA: python return funcion_envoltura # ← ¡NO lleva paréntesis! 🔍  ¿QUÉ PASA PASO A PASO? PASO 1:  Cuando haces: python saludar_contador = contador_llamadas ( saludar ) contador_llamadas  crea  c...
Leer más

Calculadora de edad

    Calculadora de edad Trabajas en una compañía que ofrece seguros de vida y de gastos médicos. La empresa está desarrollando una herramienta tecnológica, para que los agentes puedan calcular el monto de una póliza. Para dicho cálculo, se consideran varios factores de riesgo, entre los que se encuentra la edad. Por ello, el contratante debe llenar un formulario, incluyendo su fecha de nacimiento. Como primer reto, deberás calcular la edad del cliente al momento de la cotización.     • La captura de la fecha de nacimiento debe ser en una sola cadena de texto con formato DD-MM-AAAA.  • Validar que sea una fecha existente, si supera los 31 días o menor a 1 día de un mes, se deberá marcar como inválido.  • El año de nacimiento debe ser mayor de 1900. • Validar si el cliente ya cumplió años en la fecha de captura o aún no.  • Validar que no se puede dejar información en blanco o campos vacíos.    Análisis del problema Necesitamos: ...
Leer más

Funciones en Python: con y sin paréntesis

  Funciones en Python: con y sin paréntesis Te explico la diferencia fundamental entre usar funciones con y sin paréntesis en Python: 1. Función CON paréntesis:  Ejecución Cuando usas paréntesis después del nombre de una función,  estás ejecutando o llamando  esa función: python def saludar ( ) : return "¡Hola!" # Con paréntesis - EJECUTA la función mensaje = saludar ( ) print ( mensaje ) # Output: ¡Hola! 2. Función SIN paréntesis:  Referencia Cuando usas el nombre sin paréntesis,  estás haciendo referencia  a la función como objeto: python def saludar ( ) : return "¡Hola!" # Sin paréntesis - REFERENCIA a la función mi_funcion = saludar print ( mi_funcion ) # Output: <function saludar at 0x...> # Ahora puedes ejecutarla usando la referencia print ( mi_funcion ( ) ) # Output: ¡Hola! Ejemplos prácticos Ejemplo 1: Funciones como objetos de primera clase python def sumar ( a , b ) : return a + b def multipli...
Leer más