simplificar este código

[AGmzT]

Hola gente! escribi este código y quisiera saber como simplificarlo muchas gracias!!

float costo, desc0, desc1, desc2, desc3, desc4, desc5, desc6, desc7, desc8, desc9, costoDesc;

public float getCostoDesc() {
float[] desctos = {(100-desc0), (100-desc1), (100- desc2), (100- desc3), (100- desc4),
(100- desc5), (100- desc6), (100- desc7), (100- desc8), (100- desc9)};

if(desctos[9]!=0){
costoDesc = esctos[9]*desctos[8]*desctos[7]*desctos[6]*desctos[5]*desctos[4]*desctos[3]*desctos[2]*desctos[1]*desctos[0]*costo;

}else if (desctos[8]!=0){
costoDesc = desctos[8]*desctos[7]*desctos[6]*desctos[5]*desctos[4]*desctos[3]*desctos[2]*desctos[1]*desctos[0]*costo;

}else if (desctos[7]!=0){
costoDesc = desctos[7]*desctos[6]*desctos[5]*desctos[4]*desctos[3]*desctos[2]*desctos[1]*desctos[0]*costo;

}else if (desctos[6]!=0){
costoDesc = desctos[6]*desctos[5]*desctos[4]*desctos[3]*desctos[2]*desctos[1]*desctos[0]*costo;

}else if (desctos[5]!=0){
costoDesc = desctos[5]*desctos[4]*desctos[3]*desctos[2]*desctos[1]*desctos[0]*costo;

}else if (desctos[4]!=0){
costoDesc = desctos[4]*desctos[3]*desctos[2]*desctos[1]*desctos[0]*costo;

}else if (desctos[3]!=0){
costoDesc = desctos[3]*desctos[2]*desctos[1]*desctos[0]*costo;

}else if (desctos[2]!=0){
costoDesc = desctos[2]*desctos[1]*desctos[0]*costo;

}else if (desctos[1]!=0){
costoDesc = desctos[1]*desctos[0]*costo;

}else if (desctos[0]!=0){
costoDesc = desctos[0]*costo;

}else costoDesc = costo;
return costoDesc;
}

[Profesor_Falken]

Código Java:

int numDescs = desctos.length;
 
if (numDescs == 0) {
    costoDesc = costo;
else {
    for (int i = numDescs; i>=0; i--) {
        costoDesc *= desctos[i-1];
    }
    costoDesc *= costo;
}
 

Un saludo

[HackmanC]

Hola,

Iniciado por AGmzT

Hola gente! escribi este código y quisiera saber como simplificarlo muchas gracias!! ...

Posiblemente podrías obtener exactamente el mismo resultado pero con un código mas simplificado de esta forma:

Código Java:

int i = desctos.length - 1;
while (i >= 0 && desctos[i] == 0.0f) {
  i--;
}
costoDesc = costo;
while (i >= 0) {
  costoDesc *= desctos[i--];
}
return costoDesc;
 

La pregunta ahora sería ... ¿estás seguro que eso es lo que quieres obtener?

Evidentemente hay problemas que se notan a simple vista, como el hecho que si dos valores dentro del vector 'desctos' son iguales a 0 entonces el resultado siempre va a ser 0.

Adicionalmente que si los valores son, por ejemplo, 50 tendrías (50^10), 50 elevado a la potencia 10 es un número muy grande. Evidentemente no son porcentajes.

Iniciado por Profesor_Falken

Código:

int numDescs = desctos.length;

if (numDescs == 0) {
    costoDesc = costo;
else {
    for (int i = numDescs; i>=0; i--) {
        costoDesc *= desctos[i-1];
    }
    costoDesc *= costo;
}

Hay un error de lógica con un ArrayOutOfBounds Exception. Si cualquier valor es 0 el resultado siempre va a ser 0, en su caso solo multiplica los valores iniciando desde el primero que sea diferente a 0 descendentemente; eso para realizar exactamente la misma funcionalidad del código inicial, que estoy casi seguro que no realiza la funcionalidad que le solicitaron.

Igual el problema ha de ser otro,
Saludos,

[Profesor_Falken]

Buenas HackmanC,

Muchas gracias por el apunte. Efectivamente en lugar de i>=0 debí dejar i>0. Lo escribí directamente en el post con prisas y es lo que pasa...

También lo puse basándome en un for, que considero una estructura básica e intuitiva para alguien que no conoce los bucles, pero tu aproximación con while y partiendo de la variable costo me parece más elegante.

Eso si, me parece que tienes un bug cuando compruebas los ceros. Lo único que haces es dejar los últimos índices del array sin leer y no aquellos que contienen el cero.
Por ejemplo, si el array tiene 5 elementos y dectos[0] vale 0, lo único que vas a hacer es descartar dectos[4].

Es sencillo eliminar ese bucle inicial sustituyéndolo por una condición y así de paso mejoramos un poco el rendimiento del algoritmo de 2N a N.

Código Java:

int i = desctos.length - 1;
 
costoDesc = costo;
while (i >= 0) {
  if (desctos[i] != 0.0f) {
    costoDesc *= desctos[i--];
  }
}
 
return costoDesc;
 

Un saludo

[HackmanC]

Hola,

Iniciado por Profesor_Falken

... Eso si, me parece que tienes un bug cuando compruebas los ceros. Lo único que haces es dejar los últimos índices del array sin leer y no aquellos que contienen el cero.
Por ejemplo, si el array tiene 5 elementos y dectos[0] vale 0, lo único que vas a hacer es descartar dectos[4]. ...

Tienes toda la razón, es decir, si el Arreglo tiene 5 elementos busca descendentemente el primero que sea diferente a 0, de allí en adelante usa los restantes para la multiplicación; sin importar que exista otro número 0, en consecuencia generando un resultado de 0 por la operación de que cualquier número multiplicado por 0 dá 0.

Pero no lo considero un bug, es decir, para lograr exactamente la misma funcionalidad del código que 'AGmzT' escribió, así tiene que ser. Es decir, si el código original no realiza la funcionalidad esperada exactamente no es inconveniente de mi propuesta.

Lo que hice fue reproducir exactamente la misma funcionalidad original con menos líneas de código utilizando bucles 'while'. No me malinterpretes en muchos casos me equivoco, lo único que quiero en este caso es demostrar el punto de reproducir la misma funcionalidad original. Aunque originalmente posiblemente no sea correcta.

Saludos,

[Profesor_Falken]

Pero no lo considero un bug, es decir, para lograr exactamente la misma funcionalidad del código que 'AGmzT' escribió, así tiene que ser. Es decir, si el código original no realiza la funcionalidad esperada exactamente no es inconveniente de mi propuesta

Tienes toda la razón. Si es un bug, lo es en el código original.


Un saludo

[AGmzT]

Hola,

Gracias a todos por su ayuda,

Les comento que las variables desc.. no siempre van a ser instanciadas por el usuario, y dado que los

miembros del arreglo son el resto de 100- desc.. siempre van a tener valor mayor a 0, de hecho en

el constructor (si no son instanciadas por el usuario) toman un valor fijo que no afecta el producto.

[HackmanC]

Hola,

Posiblemente,

Iniciado por AGmzT

Hola gente! escribi este código y quisiera saber como simplificarlo muchas gracias!! ...

Código Java:

float costo, desc0, desc1, desc2, desc3, desc4, desc5, desc6, desc7, desc8, desc9, costoDesc;
 
public float getCostoDesc() {
  float[] desctos = {(100-desc0), (100-desc1), (100- desc2), (100- desc3), (100-desc4),
                    (100- desc5), (100- desc6), (100- desc7), (100- desc8), (100- desc9)};
  int i = desctos.length - 1;
  while (i >= 0 && desctos[i] == 0.0f) {
    i--;
  }
  costoDesc = costo;
  while (i >= 0) {
    costoDesc *= desctos[i--];
  }
  return costoDesc;
}
 

Técnicamente hace exactamente lo mismo que el código inicial pero de una forma diferente. No puedo decir simplificado realmente, sino mas corto. Mas simple que el código inicial creo que no es posible.

Iniciado por AGmzT

... Les comento que las variables desc.. no siempre van a ser instanciadas por el usuario, y dado que los

miembros del arreglo son el resto de 100- desc.. siempre van a tener valor mayor a 0, de hecho en

el constructor (si no son instanciadas por el usuario) toman un valor fijo que no afecta el producto.

Técnicamente que sean 100-desc no implica que siempre van a tener un valor mayor a 0, 100 - 100 es igual a 0. Pero bueno, si ese es el objetivo real de tu aplicación entonces todo está bien.

Simplemente a mi me pareció extraña la operación y pensé que posiblemente querías porcentajes (por el 100) y no es el caso. También si la lógica de tu aplicación se encarga de inicializar los valores correctamente pues todo sigue bien.

Saludos,