RESOLUCION EXAMEN

Problema.- Leído un número, entero y positivo en el intervalo [999,9999999],

que representa un importe de dinero a pagar por un banco a un determinado
cliente del mismo, se pide traducir este importe a su respectivo literal y
luego aplicar el algoritmo del cambio optimo (cajero automático) para
determinar los cortes de billetes y monedas con los que el cajero va a pagar dicho
importe. Los cortes de billetes con los que se paga son de 200, 100, 50, 20 y 10
Bs. respectivamente, mientras que las monedas son de 5, 2 y 1 Bs.

SOLUCION.-
Un numero como por ejemplo el 741, se descompone en 3 dígitos y donde cada
digito corresponde a una categoría. Así entonces tenemos: centenas (el 7),
decenas (el 4) y unidades (el 1). Luego el literal correspondiente es setecientos
cuarenta y uno, que es la base de nuestro trabajo y a partir de lo cual el
problema se puede subdividir.

// Para las unidades

Funcion Unidades(int d)
INICIO
Caso d hacer
0 : Mostrar “”
1 : Mostrar “y Uno”
2 : Mostrar “y Dos”
3 : Mostrar “y Tres”
4 : Mostrar “y Cuatro”
5 : Mostrar “y Cinco”
6 : Mostrar “y Seis”
7 : Mostrar “y Siete”
8 : Mostrar “y Ocho”
9 : Mostrar “y Nueve”
FinCaso
FIN

// Para las decenas

Funcion Decenas(int d)
INICIO
Caso d hacer
0 : Mostrar “”
1 : Mostrar “Diez”
2 : Mostrar “Veinte”
3 : Mostrar “Treinta”
4 : Mostrar “Cuarenta”

1
 5 : Mostrar “Cincuenta”
6 : Mostrar “Sesenta”
7 : Mostrar “Setenta”
8 : Mostrar “Ochenta”
9 : Mostrar “Noventa”
FinCaso
FIN

// Para las centenas

Funcion Centenas(int d)
INICIO
Caso d hacer
0 : Mostrar “”
1 : Mostrar “Ciento”
2 : Mostrar “Doscientos”
3 : Mostrar “Trescientos”
4 : Mostrar “Cuatrocientos”
5 : Mostrar “Quinientos”
6 : Mostrar “Seiscientos”
7 : Mostrar “Setecientos”
8 : Mostrar “Ochocientos”
9 : Mostrar “Novecientos”
FinCaso
FIN

// los numeros del 11 al 15, tienen un literal especial que corresponde a ambos
dígitos.
Funcion OnceAQuince(int d)
INICIO
Caso d hacer
11 : Mostrar “Once ”
12 : Mostrar “Doce”
13 : Mostrar “Trece”
14 : Mostrar “Catorce”
15 : Mostrar “Quince”
FinCaso
FIN

// para un numero de hasta 3 dígitos, descomponemos en sus 3 dígitos; d3,d2,d1

// Para números del 1 al 999, por ejemplo 741
Funcion Cientos(int m)
INICIO
d1  m MOD 10 // el primer digito menos significativo, me da el 1
d2  m MOD 100 // los 2 digitos menos significativos, me da el 41

2
 d3  INT (m/100) // el primer digito mas significativo, me da el 7
Si d2 >= 11 Y d2 <= 15
Entonces Centenas(d3) : OnceAQuince(d2)
SiNo
d2  (d2 – d1) DIV 10 // sólo el segundo dígito
Centenas(d3) : Decenas(d2) : Unidades(d1)
FinSi
FIN

// Para números de hasta 6 dígitos, descomponemos en 2 grupos de 3 y

procesamos por
// separado. Serán números del 1 al 999999, por ejemplo 741741
Funcion Miles(int m)
INICIO
g1  m MOD 1000 // para el ejemplo, me da el 741 de la derecha
g2  (m – g1)/1000 // para el ejemplo, me da el 741 de la izquierda
(741000)
Si g2 > 0
Entonces Cientos(g2) : Mostrar “ Mil ” // primero el grupo de la
izquierda
FinSi
Si g1 > 0
Entonces Cientos(g1) // luego el grupo de la derecha
FinSi
FIN

// Si tenemos millones, entonces hay 7 o más dígitos, luego tenemos 3 grupos

// Para números del 1 al 999999999, por ejemplo 999741741
Funcion Millones(int m)
INICIO
g1  m MOD 1000000 // para el ejemplo, me da el 741741 (los miles)
g2  (m – g1)/1000000 // para el ejemplo, me da el 999 (los millones)
Si g2 > 0
Entonces Cientos(g2) : Mostrar “ Millones ” // el primer grupo de
la izquierda
FinSi
Si g1 > 0
Entonces Miles(g1) // los restantes 6 de la derecha nos dan Miles
FinSi
FIN

Programa Principal()
Int num
INICIO

3
 Num  LeerEntero()
Millones(num)
CambioOptimo(num)
FIN

Procedimiento CambioOptimo(int Mon)

INICIO
Mostrar “Billetes: ”
mon  Billetes(mon, 200)
mon  Billetes(mon,100)
mon  Billetes(mon, 50)
mon  Billetes(mon, 20)
mon  Billetes(mon, 10)
Mostrar “Monedas: ”
mon  Monedas(mon, 5)
mon  Monedas(mon, 2)
mon  Monedas(mon, 1)
FIN

Funcion Billetes(int cant, int corte)

Int cc
INICIO
cc  0
Mientras (cant > corte)
cant ← cant - corte
cc ← cc + 1 // contamos cuantos de este corte (billete)
finMientras
Si cc > 0 // si hay algo para este corte
Entonces Mostrar cc, “ de ”, corte
FinSi
Devolver cant
FIN

Funcion Monedas(int cant, int moneda)

Int cc
INICIO
cc  0
Mientras (cant > moneda)
cant ← cant - moneda
cc ← cc + 1 // contamos cuantos de este corte (billete)
finMientras
Si cc > 0 // si hay algo para esta moneda
Entonces Mostrar cc, “ de ”, moneda
FinSi

4
 Devolver cant
FIN