javascript least amount of elements from an integer array that can be used to get to a total value

Question

please can somebody help?

If i have a total or a sum for instance 91

How can I create an array of the least amount of elements needed to get to the total value?

[50, 20, 10 , 5, 3, 2, 1] totaling this array will provide 91.

I know how to perform the opposite function using reduce or like so:

<script>
var numbers = [65, 44, 12, 4];

function getSum(total, num) {
    return total + num;
}
function myFunction(item) {
    document.getElementById("demo").innerHTML = numbers.reduce(getSum);
}
</script>

Answer 1

Greedy algorithm

Here is a solution using greedy algorithm. Note that this solution will work correctly in case when all the smaller numbers are divisors of all the bigger numbers such as in case [50, 10, 5, 1]. (see dynamic algorithm below this one for solution that can handle any input)

50 mod 10 = 0
50 mod 5  = 0
50 mod 1  = 0
10 mod 5  = 0
10 mod 1  = 0
5  mod 1  = 0

const sum = xs => xs.reduce((acc, v) => acc + v, 0);

function pickSubset(options, total, currentPick) {

  if (sum(currentPick) === total) { return currentPick; }
  if (options.length === 0) { return null; }

  const firstVal = options[0];
  let res = null;

  if (sum(currentPick) + firstVal > total) {
    res = pickSubset(options.slice(1), total, currentPick);
  } else {
    let opt1 = pickSubset(options, total, currentPick.concat(options[0]));
    let opt2 = pickSubset(options.slice(1), total, currentPick.concat(options[0]));

    if (opt1 && opt2) {
      opt1.length < opt2.length ? res = opt1 : res = opt2
    } else if (opt1) {
      res = opt1;
    } else {
      res = opt2;
    }
  }

  return res;
}

const total = 73;
const options = [50, 25, 10, 5, 2, 1];

console.log(pickSubset(options, total, []));

To handle unsorted input you can wrap it in another function and sort it prior to passing it to the main function.

const sum = xs => xs.reduce((acc, v) => acc + v, 0);

function pickSubset(options, total, currentPick) {

  const sortedOptions = options.sort((a, b) => b - a);

  function _pickSubset(options, total, currentPick) {

    if (sum(currentPick) === total) { return currentPick; }
    if (options.length === 0) { return null; }

    const firstVal = options[0];
    let res = null;

    if (sum(currentPick) + firstVal > total) {
      res = pickSubset(options.slice(1), total, currentPick);
    } else {
      let opt1 = pickSubset(options, total, currentPick.concat(options[0]));
      let opt2 = pickSubset(options.slice(1), total, currentPick.concat(options[0]));

      if (opt1 && opt2) {
        opt1.length < opt2.length ? res = opt1 : res = opt2
      } else if (opt1) {
        res = opt1;
      } else {
        res = opt2;
      }
    }

    return res;
  }

  return _pickSubset(sortedOptions, total, currentPick);
}



const total = 73;
const options = [50, 25, 10, 5, 2, 1].reverse();

console.log(pickSubset(options, total, []));

Dynamic programming (bottom-up natural ordering approach)

This solution works correctly for any type of input.

function pickSubset(options, total) {

  function _pickSubset(options, change, minNums, numsUsed) {
    for (let i = 0; i < change + 1; i++) {
      let count = i;
      let newNum = 1;
      let arr = options.filter(v => v <= i);

      for (let j of arr) {
        if (minNums[i - j] + 1 < count) {
          count = minNums[i - j] + 1;
          newNum = j;
        }
      }

      minNums[i] = count;
      numsUsed[i] = newNum;
    }

    return minNums[change];
  }

  function printNums(numsUsed, change) {
    const res = [];
    let num = change;
    while (num > 0) {
      let thisNum = numsUsed[num];
      res.push(thisNum);
      num = num - thisNum;
    }
    return res;
  }

  const numsUsed = [];
  const numsCount = [];

  _pickSubset(options, total, numsCount, numsUsed);
  return printNums(numsUsed, total);
}

const options = [50, 10, 5, 2, 1];
console.log(pickSubset(options, 73));

Dynamic programming (top-down memoization approach)

// helper function that generates all the possible solutions
// meaning, all the possible ways in which we can pay the provided amount
// and caches those solutions;
// returns the number of possible solutions but that is not neccessary
// in this case
const _pickSubset = (toPay, options, currentPick, cache) => {
  if (toPay < 0) { return 0; }
  if (toPay === 0) {
    cache.add(currentPick);
    return 1;
  }
  if (options.length === 0) { return 0; }

  return _pickSubset(toPay - options[0], options, currentPick.concat(options[0]), cache)
    + _pickSubset(toPay, options.slice(1), currentPick, cache);
};

// memoize only with respect to the first two arguments - toPay, bills
// the other two are not necessary in this case
const memoizeFirstTwoArgs = fn => {
  const cache = new Map();
  return (...args) => {
    const key = JSON.stringify(args.slice(0, 2));
    if (cache.has(key)) { return cache.get(key); }
    const res = fn(...args);
    cache.set(key, res);
    return res;
  };
};

// uses memoized version of makeChange and provides cache to that function;
// after cache has been populated, by executing memoized version of makeChange,
// find the option with smallest length and return it
const pickSubset = (toPay, options) => {
  const cache = new Set();
  const memoizedPickSubset = memoizeFirstTwoArgs(_pickSubset);
  memoizedPickSubset(toPay, options, [], cache);

  let minLength = Infinity;
  let resValues;

  for (const value of cache) {
    if (value.length < minLength) {
      minLength = value.length;
      resValues = value;
    }
  }

  return resValues;
}

const options = [50, 25, 10, 5, 2, 1];
const toPay = 73;

console.log(pickSubset(toPay, options));