Estoy trabajando en una función que desglosa la entrada dada en denominaciones usando una llamada recursiva.
En cada paso se repite en dos variantes:
Además de imprimir la combinación de denominaciones capturadas en la lista cuando quedan == 0, tengo la intención de capturar el valor de esa lista y devolverlo de la función.
Aquí está el código:
static final int[] DENOMINATIONS = {9,5,3};
private static void change(int remaining, List<Integer> coins, int pos)
if (remaining == 0) {
// This correctly prints the desired output.
// I want to return that exact value from the function.
System.out.println(coins);
} else {
if (remaining >= DENOMINATIONS[pos]) {
coins.add(DENOMINATIONS[pos]);
another.addAll(coins);
change(remaining - DENOMINATIONS[pos], coins, pos);
coins.remove(coins.size() - 1);
}
if (pos + 1 < DENOMINATIONS.length) {
change(remaining, coins, pos + 1);
}
}
}
public static List<Integer> denominations(int amount) {
List<Integer> result = new ArrayList<Integer>();
List<Integer> another = new ArrayList<Integer>();
change(amount, result, another ,0);
System.out.println(another.size());
return another;
}
public static void main(String[] args) {
List<Integer> list = denominations(13);
System.out.println(list);
}
Salida: [5, 5, 3]
Parece suponer que Java se pasa por referencia, lo que no es cierto. Los métodos Java se pasan por valor.
He actualizado tu código:
método de cambio:
private static List<Integer> change(int remaining, List<Integer> coins, int pos) { // Updated method return type;
if (pos < 0 || pos >= DENOMINATIONS.length) { // check if position is invalid
return new ArrayList<>(); // return an empty list
}
if (remaining == DENOMINATIONS[pos]) { // check if remaining is equal to denominations[pos]
coins.add(DENOMINATIONS[pos]); // add the denominations to the coins result
return coins; // return the result
} else if (remaining > DENOMINATIONS[pos]) { // check if remaining is greater than denominations[pos]
coins.add(DENOMINATIONS[pos]);// add the possible denominations to the coins result
remaining = remaining - DENOMINATIONS[pos]; // calculate the new remaining
if (remaining >= DENOMINATIONS[pos]) { // check if remaining is greater than or equal to denominations[pos]
return change(remaining, coins, pos); // stick to this position
} else {
return change(remaining, coins, pos + 1); // increment pos to go to the lower denominations
}
} else if (remaining < DENOMINATIONS[pos]) { // check if remaining is lesser than denominations[pos]
if (coins.isEmpty()) { // if coins is empty then go to the next denomination
return change(remaining, coins, pos + 1);
} else {
coins.remove(coins.size() - 1); // remove the previous denomination
return change(remaining + DENOMINATIONS[pos - 1], coins, pos); // go back to the previous remaining and // try this DENOMINATIONS[pos]
}
}
return coins;
}
método de denominaciones:
public static List<Integer> denominations(int amount) {
return change(amount, new ArrayList<Integer>(), 0);
}
ENTRADA : 13
SALIDA :[5, 5, 3]
Tendría que agregar return coins;
en el change
método y, pero puede mantenerlo como lo tiene. Devolver y cambiar una matriz es un olor a código, ya que el método opera en el objeto (lo modifica) y devuelve un resultado.
Para que funcione, puede definir su denomination
método de la siguiente manera:
public static List<Integer> denominations(int amount) {
List<Integer> result = new ArrayList<Integer>();
change(amount, result, 0);
return result;
}
Editar:
La lista está vacía porque el único lugar donde ha cambiado es aquí:
coins.add(DENOMINATIONS[pos]);
change(remaining - DENOMINATIONS[pos], coins, pos);
coins.remove(coins.size() - 1);
Donde se agrega y elimina un elemento. Es lo que has escrito lo que lo hace vacío :)
Edit2:
Sugeriría pasar un segundo objeto, que sería una copia de la lista que le gustaría devolver y no se modifica.
La documentación de GAE para JPA 2.0 establece que el objetivo mejorar_guerra para el archivo hormiga debería ser este: <target name = "datanucleusenhance" depende = "compilar" description = "Realiza mejoras en ...
Si tengo la interfaz: public interface Val {public NilVal NIL; } Y una clase singleton que lo implementa: la clase pública NilVal implementa Val {private static NilVal nil = null; ...
Tengo este método que arroja una excepción pública String Pipeit () arroja TransformerException, TransformerConfigurationException, SAXException, IOException intenté llamar a este método desde una GUI ...
Tengo una tarea de hormiga gradle que inicia una base de datos H2. El script de compilación se ve así: aplique el complemento: repositorios 'java' {mavenCentral ()} dependencias {runtime 'com.h2database: h2: 1.3.168' ...