Algorithm to get as close to zero as possible by subtracting only allowed numbers from a starting point

function getCombinations(array, rest) {
  function test(state, col) {
    let best = state;
    const value = array[col];

    // what's the most I can subtract with this value?
    const max = Math.floor(state.rest / value);
    // if this is the last column to check (0), subtracting 4*value, 3*, 2*, ...
    // will not yield a better result that subtracting 5*value
    // so check only the max value.
    const min = col ? 0 : max;

    for (let i = max; i >= min; --i) {
      const tmp = i ? {
        ...state,
        [value]: i,
        rest: state.rest - value * i
      } : state;
      
      const item = col ? test(tmp, col - 1) : tmp;

      // no need to check any further
      if (item.rest === 0) return item;

      if (item.rest < best.rest) best = item;
    }

    // log checked state; since this function is recursive, 
    // avoid logging the same `best` for each `col`
    col || console.log("checked", best);

    return best;
  }

  // copy and sort ASC
  array = [...array].sort((a, b) => a - b);

  const state = { rest };
  array.forEach(value => state[value] = 0); // optional

  // going from right to left (hi to lo) so that I don't have to 
  // check `col < array.length-1` all the time. 
  // this way I can check for `col !== 0` or simply `col?`
  return test(state, array.length - 1);
}

// get 3 random values
const set = new Set();
while (set.size < 3) set.add(Math.floor(Math.random() * 999 + 1));

console.log("values", ...set);

console.log(getCombinations(set, 2250));