Estoy escribiendo una función y esta es la última pieza del rompecabezas, que pensé que sería fácil de resolver, pero después de algunos intentos fallidos con los bucles for y while, intenté buscarlo en línea y todavía no pude encontrar un responder. Encontré algunas soluciones oscuras y complejas, pero creo que debería haber una forma más sencilla de resolver esto. Por ejemplo, si tengo una matriz
[1, 2, 3, 5, 7, 9]Y el argumento es 10, la función debería devolver 6 (1 + 2 + 3), porque la suma de los valores debería ser <= 10 (o el número que se pase). Si el argumento es 4, la función debería devolver 3 (1 + 2) y así sucesivamente.
Puedes usar un bucle for :
const arg = 10 const arr = [1, 2, 3, 5, 7, 9] let res = 0; const calc = (arr, limit) => { for (num of arr) { if (num + res > limit) { break; } res += num; } return res; } console.log(calc(arr, arg)).reduce() cada valor actual ( cur ) agregado al acumulador ( acc ) y verificado contra el límite ( max ). Si acc + cur es menor que el límite, devuelva acc+ cur , de lo contrario, devuelva acc . Se agregó .sort() si la matriz está fuera de servicio, según el comentario de Spectric.
const array = [1,2,3,5,6,8]; const mixed = [0,7,3,8,2,1]; const A = 10; const B = 15; const closest = (arr, max) => { return arr.sort((a, b) => a - b).reduce((acc, cur) => (acc + cur) > max ? acc : (acc + cur)); } console.log(closest(array, A)); console.log(closest(array, B)); console.log(closest(mixed, B));Un enfoque interesante es darnos cuenta de que queremos hacer un pliegue (algo así como Array.prototype.reduce ) pero uno del que podamos escapar temprano. La respuesta de zer00ne hace esto eligiendo verificar la condición en cada iteración, y simplemente devolviendo continuamente el acumulador cada vez que no se cumple la condición. Eso está bien para muchos casos de uso, pero sería bueno hacerlo más explícito.
Conozco dos maneras de hacer esto. Una es tener algún valor de señal que devolveríamos, probablemente un símbolo, para decir: "Terminamos, solo devuelva el acumulador". La desventaja es que esta función ahora depende del valor de esa señal externa. No es terrible y, a menudo, podría ser la solución correcta. No es difícil de escribir, y lo dejaré como ejercicio.
La otra técnica es requerir que la devolución de llamada elija explícitamente si continuar la iteración o detenerse proporcionándole las funciones next y done . Si queremos continuar, llamamos a next con el siguiente valor del acumulador. Si hemos terminado, simplemente llamamos done . Aquí hay una versión de eso:
const fold = (fn) => (a) => ([x, ...xs]) => x == undefined ? a : fn (a, x, (r) => fold (fn) (r) (xs), () => a) const sumUpTo = (n) => fold ((a, x, next, done) => a + x > n ? done () : next (a + x)) (0) console .log (sumUpTo (10) ([1, 2, 3, 5, 7, 9])) //=> 6 console .log (sumUpTo (4) ([1, 2, 3, 5, 7, 9])) //=> 3 console .log (sumUpTo (10) ([1, 2, 3, 4, 5, 6])) //=> 10 sumUpTo toma nuestro valor total y devuelve una función que toma una lista de números. Lo hace llamando a fold usando una función de devolución de llamada, el valor inicial ( 0 para una suma) y finalmente pasando nuestra lista de números. Esa devolución de llamada hace el trabajo que nos importa. Luego, fold lo llama repetidamente hasta que se queda sin valores o se llama done .
Podemos desglosar la versión de una línea anterior para centrarnos específicamente en la devolución de llamada, si lo deja más claro:
const callback = (n) => (a, x, next, done) => a + x > n ? done () : next (a + x) const sumUpTo = (n) => fold (callback (n)) (0)Es un patrón muy elegante, en mi opinión.