Javascript-引导现金支付 function

Question

I'm stuck on a project where we are making financial exercises for children. Each exercise has a specific objective (Screenshot of an exercise where students match a bill to a numeric amount):

One one of the exercises, students add bills to their wallet. Once these bills are added, each user has a wallet array with bills in it as so:

var walletArray = [
  {
    code: aed,
    denomination: 0.5,
    image: "/assets/images/coin50",
    type: "coin",
  },
  { code: aed, denomination: 1, image: "/assets/images/coin1", type: "coin" },
  { code: aed, denomination: 5, image: "/assets/images/bill5", type: "bill" },
  { code: aed, denomination: 5, image: "/assets/images/bill5", type: "bill" },
  { code: aed, denomination: 10, image: "/assets/images/bill10", type: "bill" },
  { code: aed, denomination: 50, image: "/assets/images/bill50", type: "bill" },
];

I want to write a function that takes an integer input from the user (example: 17) and outputs which bills to pay with. So for this example, if the user inputs 17, the function should output the bills with denominations 5, 5, and 10. I will then calculate the change for them. The website tells the users which bills to pay and how much change they can expect.

I have a function that calculates the total of the wallet array and notifies me if the input amount is greater than the total wallet balance:

function calculateTotal(walletArray) {
  total = 0;

  for (var i = 0; i < walletArray.length; i++) {
    total = total + walletArray[i].denomination;
  }

  if (payAmount > total) {
    console.log("ABOVE LIMIT");
  } else {
    return total;
  }
}

However, I cannot figure out how to pick the right bills from the array. I'm running a for loop on the array, and its easy enough if the amount input by the user perfectly matches a bill (20 or 50 for example). I just don't know how to select the different bills that the user needs to pay.

for (var i = 0; i < walletArray.length; i++) {
  if (payAmount == walletArray[i].denomination) {
    console.log(
      "perfect match! pay with " + currency + walletArray[i].denomination
    );
  } else {
    //code to select the bills goes here
  }
}

Any help or even pseudocode to solve this problem would be greatly appreciated. The solution can use vanilla js or any library you like!

Answer 1

Important note : this problem requires a lot of computation (an unsimplified solution implies analyzing 2^wallet.length combinations of wallet coins). Using large wallets for tests might result in large run times or even unresponsive javascript environments . That is not the case for the default example included in the snippet below, which runs typically in just a few hundredth of a second.

There are several optimizations still to be performed, the most obvious one being simplifying the data structures used in code. I decided to stick for this first version to the original format, that results in the need to deep-clone objects that could be avoided.

 // utility functions const cloneSelection = wallet => wallet?.map(o => ({...o})); const cloneSolution = solution => ({selection: cloneSelection(solution.selection), diff: solution.diff}); const generateUniqueId = function(selection, payAmount){ const a = selection.map(o=>o.denomination); let nr = 0, nv = -1, uniqueId = ''; a.forEach( function(ai, i){ if(ai === nv){ nr++; } else{ if(nv > 0){ uniqueId += (uniqueId? '+': '') + nr + 'x' + nv; } nv = ai; nr = 1; } } ); return uniqueId + (uniqueId? '+': '') + nr + 'x' + nv + '=' + payAmount; } const memoizationData = {}; const selectAmount = function(payAmount, wallet){ const uniqueId = generateUniqueId(wallet, payAmount); let solution = memoizationData[uniqueId]; if(solution){ return cloneSolution(solution); } if(wallet.length === 1){ const diff = wallet[0].denomination - payAmount; return diff >= 0? {selection: cloneSelection(wallet), diff}: {selection: null, diff: 1/0}; } const diff = wallet.reduce((s, o) => s + o.denomination, 0) - payAmount; if(diff < 0){ solution = {selection: null, diff: 1/0}; // "non-solution" } else{ solution = {selection: wallet, diff}; for(let iOut = 0; iOut < wallet.length; iOut++){ if(solution.diff < 1e-3){ break; } const wallet1 = cloneSelection(wallet); wallet1.splice(iOut, 1); // extract i-th "coin" from the wallet const solution1 = selectAmount(payAmount, wallet1); if(solution1.diff < solution.diff){ solution = solution1; } } } memoizationData[uniqueId] = cloneSolution(solution); return solution; } const aed = 'aed'; const walletArray = [ { code: aed, denomination: 0.5, image: "/assets/images/coin50", type: "coin" }, { code: aed, denomination: 0.5, image: "/assets/images/coin50", type: "coin" }, { code: aed, denomination: 0.5, image: "/assets/images/coin50", type: "coin" }, { code: aed, denomination: 1, image: "/assets/images/coin1", type: "coin" }, { code: aed, denomination: 1, image: "/assets/images/coin1", type: "coin" }, { code: aed, denomination: 1, image: "/assets/images/coin1", type: "coin" }, { code: aed, denomination: 2, image: "/assets/images/coin2", type: "coin" }, { code: aed, denomination: 5, image: "/assets/images/bill5", type: "bill" }, { code: aed, denomination: 5, image: "/assets/images/bill5", type: "bill" }, { code: aed, denomination: 5, image: "/assets/images/bill5", type: "bill" }, { code: aed, denomination: 10, image: "/assets/images/bill10", type: "bill" }, { code: aed, denomination: 50, image: "/assets/images/bill50", type: "bill" }, ]; // if not sorted walletArray.sort((o1, o2)=>o1.denomination - o2.denomination); const t0 = Date.now(); const ret = selectAmount(16.5, walletArray); const dt = (Date.now() - t0)/1000; console.log('solution = ', ret); console.log(`dt = ${dt.toFixed(2)}s`);

Description of the algorithm

We start with a wallet W , which is a set of n coins C ₁ , C ₂ , ..., C _n , and a pay amount A : problem P( W , A ).

The solution to the problem is a selection of the coins in the wallet, a subset of W . A non-solution (that is there are not enough funds to cover the amount) is denoted by a void selection.

The solution is recursive.

Start solution

The default solution for P( W , A ) is W (the selection is the whole wallet) if the sum of coin values in the wallet is >= A , or ∅ (non-solution) otherwise.

Recursion

For each coin C _i , we build a new wallet W _i = W ∖ { C _i }, that is we extract that coin from the original wallet W and solve the problem P( W _i , A ) ie, we try to find if there's a better selection of coins from the smaller wallet.

The solution of P( W , A ) is the best one from the start solution and the n partial wallet solutions.

Obviously, a selection is better if the sum of its coin values minus A is smaller (but positive).

Bottom of recursion

We can directly solve a problem (that is without dividing it) in three cases:

• the sum of the coin values is smaller than the total amount, in which case we return a non-solution
• the sum of the coin values is equal to the total amount, in which case we found a solution to the final problem
• there is only one coin left: if its value is larger than the amount we return it as the selection, otherwise we return a non-solution.

Memoization

Memoization is essential to reduce the run-time for this type of algorithms. It stores the results of previous evaluations of the main function, in order to avoid recomputing the same cases, very advantageous since the amount of overlaps close to the bottom of recursion is huge. I used memoization is a brute-force alternative to a dynamic programming solution, that would make memoization unnecessary (or implicit).