Computación Ayuda programando con Java

Gente, alguien sabe como puedo hacer para sumar varios numeros hasta q me de un resultado especifico?

Ejemplo, en un cajero (q de hecho es lo q estoy haciendo), yo quiero sacar 65 rojos, y tengo un arreglo de billetes de 20000, uno de 10000, uno de 5000, uno de 2000 y uno de 1000, como hago para que el me busque entre los arrays los billetes necesarios para hacer la suma? empezando de los mas altos, en este caso 3 de 20 y uno de 5.

Aqui esta el codigo que llevo(el de ese metodo y de esa clase), es el primer cuatri q estoy llevando progra entonces estoy medio mamando, les agradezco la ayuda, pura vida.

public int dispensarDinero (int dineroADispensar) {

int resultado = 0;
for (int x = 0; x < getGabetaParaBillete().length; x++) {
if (getGabetaParaBillete()[x] != null && getGabetaParaBillete()[x].getValorDeBillete() == dineroADispensar) {
resultado += dineroADispensar;
getGabetaParaBillete()[x].retirarBillete();
break;
}
else if (getGabetaParaBillete()[x] != null && dineroADispensar > getGabetaParaBillete()[x].getValorDeBillete()) {
//AQUI ES DONDE ESTOY MAMANDO, puedo hacer q me de billetes de si son cerrados a los billetes del array nada mas//
}
}
return resultado;
}
 
Cargando...

Yo no he programado en Java, pero si tengo alguna experiencia en programación.
Yo resolvería el problema ayudandome con las funciones division y residuo (DIV y MOD) , que no se si en Java se llamen así.
Haría una serie de bucles IF , para ir comparando el monto de dinero a sacar con la denominacion de cada billete, y actualizaria el monto a sacar con el residuo de la division con cada billete. Por ejemplo, si el monto a sacar es 65000, primero lo comparo con los billetes de 20 000
65000/ 20 000 = 3 (aqui ordeno que el cajero tire 3 billetes de 20000)
y el residuo de la division es 5000 . Luego comparo los 5000 con la denominacion inferior, en este caso 10000 . 5000 / 10 000 = 0 . el residuo sigue siendo 5000 .
Luego 5 000 / 5000 = 1 . El residuo de la division es 0, esta seria la condicion de parada del programa.


Para hacer un codigo en forma rapida en Pascal seria algo así como:

int monto_sacar (seria la variable donde se indica el monto que se quiere sacar)
int numbilletes20 (cantidad de billetes de 20 000 que el cajero va a dispensar)
int numbilletes10 , numbilletes5, numbilletes2, numbilletes1


IF monto_sacar <> 0
numbilletes20 = monto_sacar DIV 20 000

monto_sacar = monto_sacar MOD 20 000 (actualiza el monto al residuo de la division)

IF monto_sacar <> 0 THEN
numbilletes10 = monto_sacar DIV 10000

monto_sacar = monto_sacar MOD 10 000

IF monto_sacar <> 0 THEN
numbilletes5 = monto_sacar DIV 5000

monto_sacar =monto_sacar MOD 5000

IF monto_sacar <> 0 THEN
numbilletes2 = monto_sacar DIV 2000

monto_sacar = monto_sacar MOD 2000

IF monto_sacar <> 0 THEN
numbilletesmil = monto_sacar DIV 1000

monto_sacar= monto_sacar MOD 1000

TirarBilletes(numbilletes20,numbilletes10,numbilletes5,numbilletes2, numbilletesmil) (Funcion que tira los billetes al cajero automatico)


Ya que el codigo es repetitivo, tambien se puede hacer un ciclo WHILE , teniendo un array con las denominaciones de los billetes, y otro array con la cantidad de billetes de cada denominacion que se va a tirar

denominaciones = ARRAY [1..5] OF integer (son 5 denominaciones)
cantbilletes = ARRAY [1..5] Of integer

Y el codigo seria mucho mas corto

se ocuparia una variable que va recorriendo los arrays
int i
se inicializa i en 1
i = 1
se inicializa el array denominaciones
denominaciones[1]:= 20 000 , denominaciones[2]:=10 000, denominaciones[3]:=5 000
denominaciones[4]:= 2000, denominaciones[5]:=1000
inicializar tambien cantbilletes en 0 para evitar basura en caso de no actualizar el valor de alguna casilla
cantbilletes[1]:=0 , cantbilletes[2]:=0, cantbilletes[3]:=0, cantbilletes[4]:=0, cantbilletes[5]:=0

El ciclo seria asi:
WHILE monto_sacar <> 0
cantbilletes := monto_sacar DIV denominaciones
monto_sacar:= monto_sacar MOD denominaciones
i:= i +1 ( se incrementa i en 1 para que acceda al siguiente billete)
ENDWHILE

TirarBilletes(cantbilletes)

Hagamos un ejemplo: sacar ¢23 000 .
monto_sacar := 23000

Primera pasada del ciclo: cantbilletes[1]:= 23 000 DIV 20 000 (El resultado es 1)
monto_sacar := 23 000 MOD 20 000 (El resultado es 3 000)

Segunda pasada del ciclo:
cantbilletes[2]:= 3 000 DIV 10 000 (El resultado es 0)
monto_sacar := 3 000 MOD 10000 (El resultado sigue siendo 3 000)
Tercera pasada del ciclo
cantbilletes[3]:= 3 000 DIV 5 000 (Resultado 0 )
monto_sacar:= 3 000 MOD 5000 (Resultado sigue siendo 3 000)
Cuarta pasada del ciclo
cantbilletes[4] := 3 000 DIV 2 000 (Resultado 1)
monto_sacar := 3 000 MOD 2000 (Resultado 1 000)
Quinta pasada del ciclo
cantbilletes[5]:= 1 000 DIV 1 000 (Resultado 1)
monto_sacar:= 1 000 MOD 1000 (resultado 0 ya que la division no tiene residuo)
Sexta pasada del ciclo
como monto_sacar es 0 termina la ejecucion del ciclo y finalmente se ejecuta la funcion
TirarBilletes, usando el array cantbilletes que contiene la cantidad de billetes de cada denominacion , en est caso:
1 de 20 000
0 de 10 000
0 de 5 000
1 de 2 000
1 de 1000

Ojo que yo me baso en el viejo lenguaje Pascal, pero la logica es la misma en todos los lenguajes, solo es cuestion de traducir .

Espero que le sirva de ayuda.

 
Pura vida, Java se bretea muy diferente, pero como mencionaste, la logica es la misma, no hice mas q leer lo del MOD q en java es %, me dio la jupa para hacerlo, muchas gracias, mira como quedo el codigo funcional, no use un ciclo while por q necesito q me evalue todas las pociciones del array de uno en uno, entonces use un ciclo for:

public void retirarDinero (int dineroARetirar) {
int c= 0;


for (int i = 4; i >= 0 && i < getGabetaParaBillete().length; i=i-1) {
if (dineroARetirar == getGabetaParaBillete().getValorDeBillete()) {
dineroARetirar= dineroARetirar;
c= getCantidadDeBilletes();
c= dineroARetirar / getGabetaParaBillete().getValorDeBillete();
getGabetaParaBillete().retirarBillete();
System.out.println (c + " billete de " + dineroARetirar);
break;
}
else if (dineroARetirar > getGabetaParaBillete().getValorDeBillete()) {
c= getCantidadDeBilletes();
c= dineroARetirar / getGabetaParaBillete().getValorDeBillete();

System.out.println (c + " billete de " + getGabetaParaBillete().getValorDeBillete());
getGabetaParaBillete().retirarBillete();

dineroARetirar = dineroARetirar % getGabetaParaBillete().getValorDeBillete();


}
}



Pura vida, y otra vez muchas gracias.
 
Unos comentarios sobre el código...

Code:
public void retirarDinero (int dineroARetirar) {
    int c = 0;


    for (int i = getGabetaParaBillete().length - 1; i >= 0; i--) {
        // ESTE IF NO SE LE VA A CUMPLIR CUANDO EL MONTO A RETIRAR ES MAYOR AL BILLETE EVALUADO
        // QUE SERÍA LO QUE LE PUEDA OCURRIR EN LA MAYORÍA DE LOS CASOS
        if (dineroARetirar == getGabetaParaBillete()[i].getValorDeBillete()) {
            dineroARetirar = dineroARetirar; // ESTO ES TOTALMENTE INNECESARIO
            c = getCantidadDeBilletes()[i]; // IRRELEVANTE PORQUE NUNCA USA ESTE VALOR OBTENIDO
            // LA SIGUIENTE ASIGNACION ES INNECESARIA PORQUE SIEMPRE LE DARÍA 1
            // POR QUE? POR EL IF
            c = dineroARetirar / getGabetaParaBillete()[i].getValorDeBillete();
            // QUÉ HACE retirarBillete() y qué pasa si no tiene billetes disponibles?
            getGabetaParaBillete()[i].retirarBillete();
            System.out.println (c + " billete de " + dineroARetirar);
            break;
        }
        else if (dineroARetirar > getGabetaParaBillete()[i].getValorDeBillete()) {
            c = getCantidadDeBilletes()[i]; // IRRELEVANTE PORQUE NUNCA USA ESTE VALOR OBTENIDO
            c = dineroARetirar / getGabetaParaBillete()[i].getValorDeBillete();

            System.out.println (c + " billete de " + getGabetaParaBillete()[i].getValorDeBillete());
            getGabetaParaBillete()[i].retirarBillete();

            dineroARetirar = dineroARetirar % getGabetaParaBillete()[i].getValorDeBillete();
        }
    }
}

Ya le paso una versión más sencilla y efectiva basado en lo que veo de ese código, compa...
 
Compa, échele una ojeada a este código:

Code:
public class Cajero
{
    public static enum Billete {
        CINCUENTA_MIL(50_000),
        VEINTE_MIL(20_000),
        DIEZ_MIL(10_000),
        CINCO_MIL(5_000),
        DOS_MIL(2_000),
        MIL(1_000);
        
        private final int valor;
        
        Billete(int valor)
        {
            this.valor = valor;
        }
        
        public int valor()
        {
            return this.valor;
        }
    }
        
    private int[] billetes = new int[Billete.values().length];
    
    public Cajero()
    {
        for (int i = 0; i < billetes.length; i++)
        {
            billetes[i] = 10;
        }
    }
    
    public void retirar(int monto)
    {
        int remanente = monto;
        int cantidad = 0;
        int[] retiro = new int[Billete.values().length];
        for (int i = 0; i < retiro.length; i++)
        {
            retiro[i] = 0;
        }
        
        // Revisar si se puede dispensar el monto solicitado
        for (Billete billete : Billete.values())
        {
            if (remanente >= billete.valor())
            {
                cantidad = remanente / billete.valor();
                
                // si la cantidad a dispensar es mayor a la disponible, retirar el disponible
                if (cantidad > billetes[billete.ordinal()])
                    cantidad = billetes[billete.ordinal()];
                
                retiro[billete.ordinal()] = cantidad;
                remanente -= (cantidad * billete.valor());
            }
        }
        
        // Imprimir listado de billetes que se retiran
        System.out.println("Retiro de " + monto + " colones...");
        if (remanente == 0)
        {
            for (Billete billete : Billete.values())
            {
                if (retiro[billete.ordinal()] > 0) {
                    billetes[billete.ordinal()] -= retiro[billete.ordinal()];
                    System.out.println(billete.toString() + ": " + retiro[billete.ordinal()]);
                }
            }
        }
        else
        {
            System.out.println("Fondos insuficientes.");
        }
    }
    
    public static void main(String[] args)
    {
        // Crear un cajero con 880000 colones
        Cajero atm = new Cajero();
        
        atm.retirar(500000);
        atm.retirar(381000);
        atm.retirar(320000);
    }
}

Decidí hacer una pequeña clase sólo para el efecto de retirar plata de un cajero y que vea cómo puede aprovechar los enums y hacer el código más sencillo. Espero le sirva.

Saludos.
 

¡Los Foreros están posteando en estos temas!

¿Qué se esta discutiendo en Foro de Costa Rica?


¡Tendencia!

📑 Evite Multas y Sanciones: Ofrecemos servicios de presentación de declaraciones de IVA, alquileres y la anual de renta

TicosLand is now also available on Android and iOS

🚀 FACTURATica.com la #1 sin Mensualidades ni Anualidades. Inscripción gratis en Hacienda.

¡Caliente!

¿Piensa cogerse a alguna amiga de su doña próximamente?

  • No


Los resultados solo son visibles tras votar.
Atrás
Arriba