Algunos asuntos:

• Aunque el array devuelto por la llamada recursiva está capturado en la variable c , esa variable no se usa más adelante, por lo que ha sido inútil.

• results se inicializa como [] , pero luego nunca se modifica/extiende, por lo que se garantiza que el return result final devuelto devolverá esa lista vacía.

• Los dos problemas anteriores deben resolverse iterando las soluciones presentes en c : agregue el valor actual a esas soluciones (ya que restamos ese valor para obtener esas soluciones) y agregue esas soluciones extendidas a la matriz de results actual.

• Cuando remaining es igual a 0, no tiene sentido hacer más llamadas recursivas. Este es en realidad un caso base de la recursividad. (Prefiero hacer esta verificación un nivel más profundo en la recursividad, al comienzo de la función: si la suma es 0, deberíamos devolver una solución vacía que luego puede extenderse por los valores seleccionados a medida que salimos de la recursividad) .

• Sin relación, pero es una mejor práctica separar sus declaraciones con punto y coma. No sería el primero en caer en una de las trampas de la inserción automática de punto y coma . Mejor toma el control.

Aquí hay una versión corregida:

 function theseAddToSum(steps = [], sum) { // Base cases: if (sum < 0) return []; // No solutions if (sum == 0) return [[]]; // A solution let results = []; if (steps.length < 1) return 'error'; for (let i = 0; i < steps.length; i++) { let cur = steps[i]; let remaining = sum - cur; let c = theseAddToSum(steps, remaining) // Use the solutions we got back from recursion for (let solution of c) { solution.push(cur); // ... then extend them results.push(solution); // ... and collect them } } return results; } console.log(theseAddToSum([1, 2, 3], 4));

Esta es una oportunidad perfecta para usar backtracking . La idea de retroceder es que nos propusimos probar todas las combinaciones posibles, pero cuando nuestra combinación actual falla y no podemos continuar construyendo sobre ella, entonces regresamos e intentamos otra cosa.

La forma en que abordamos un problema de retroceso es la siguiente:

1. Averiguar cómo podemos dividir nuestra respuesta en partes o pasos
   • Entonces, para este problema, como ya lo hizo, dividimos la solución en una matriz.
   • Consideraremos cada valor en la matriz como un paso en la construcción de nuestra solución.
2. Encontrar una manera de encontrar todas las soluciones posibles en cada paso
   • Para esta pregunta, las posibles soluciones son los valores en la matriz de entrada [1,2,3]
3. Configura un ciclo que probará todas las soluciones
   • La razón por la que dije configurar es porque aunque comenzaremos la primera iteración, la idea no es iterar directamente todas las soluciones en nuestro paso actual.
   • Intentaremos construir nuestra solución con nuestro paso actual como parte de esa solución.
4. Comience en el primer paso de solución posible:
   • Agréguelo a su matriz de solution
   • Compruebe si es posible continuar construyendo la solución.
     • En esta pregunta, si la suma de nuestros pasos es mayor que 4, no podemos seguir construyendo.
   • Si es posible, recurra, con nuestra solución actual como punto de partida.
     • Repita los pasos 3 - 4
   • Si no es posible seguir construyendo, elimine el paso actual de la solución y ahora podemos iterar el bucle para probar la siguiente solución posible en el paso actual.
5. Cada vez que recurrimos, verificamos si nuestra solución resuelve nuestra entrada principal y, si lo hace, la agregamos a una matriz.

Son muchas palabras, resolvamos la pregunta:

 const getSum = (arr) => arr.reduce((acc, num) => num + acc, 0); function theseAddToSum(steps, sum) { const solutions = []; function recurse(steps, sum, currentSol) { if (getSum(currentSol) === sum) { solutions.push([...currentSol]); return } for (let i = 0; i < steps.length; i++) { currentSol.push(steps[i]); if (getSum(currentSol) <= sum) { recurse(steps, sum, currentSol); } currentSol.pop(); } } recurse(steps, sum, []) return solutions; } console.log(theseAddToSum([1, 2, 3], 4));