**acc[curr[0]] = curr[1];** // What exactly happening in this line? As far as i understoon curr[1] is sum of the one denominations so why do we acc[curr[0]] be equal to this?

JavaScript
1

Tell us what’s happening:

Your code so far


// Create an array of objects which hold the denominations and their values
var denom = [
{ name: "ONE HUNDRED", val: 100.0 },
{ name: "TWENTY", val: 20.0 },
{ name: "TEN", val: 10.0 },
{ name: "FIVE", val: 5.0 },
{ name: "ONE", val: 1.0 },
{ name: "QUARTER", val: 0.25 },
{ name: "DIME", val: 0.1 },
{ name: "NICKEL", val: 0.05 },
{ name: "PENNY", val: 0.01 }
];

function checkCashRegister(price, cash, cid) {
var output = { status: null, change: [] };
var change = cash - price;

// Transform CID array into drawer object
var register = cid.reduce(
  function(acc, curr) {
    acc.total += curr[1];
    **acc[curr[0]] = curr[1];** // What exactly happening in this line? As far as i understoon curr[1] is sum of the one denominations so why do we acc[curr[0]] be equal to this?
    return acc;
  },
  { total: 0 }
);
console.log(register);

// Handle exact change
if (register.total === change) {
  output.status = "CLOSED";
  output.change = cid;
  return output;
}

// Handle obvious insufficient funds
if (register.total < change) {
  output.status = "INSUFFICIENT_FUNDS";
  return output;
}

// Loop through the denomination array
var change_arr = denom.reduce(function(acc, curr) {
  var value = 0;
  // While there is still money of this type in the drawer
  // And while the denomination is larger than the change remaining
  while (register[curr.name] > 0 && change >= curr.val) {
    change -= curr.val;
    register[curr.name] -= curr.val;
    value += curr.val;

    // Round change to the nearest hundreth deals with precision errors
    change = Math.round(change * 100) / 100;
  }
  // Add this denomination to the output only if any was used.
  if (value > 0) {
    acc.push([curr.name, value]);
  }
  return acc; // Return the current change_arr
}, []); // Initial value of empty array for reduce

// If there are no elements in change_arr or we have leftover change, return
// the string "Insufficient Funds"
if (change_arr.length < 1 || change > 0) {
  output.status = "INSUFFICIENT_FUNDS";
  return output;
}

// Here is your change, ma'am.
output.status = "OPEN";
output.change = change_arr;
return output;
console.log("register is", register);
console.log(register);
}

Your browser information:

User Agent is: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.163 Safari/537.36.

Challenge: Cash Register

Link to the challenge:

2

Looking at the excercise, here cid array is a 2D array containing name values pairs for currencies. The reducer is reducing this to an object so that object contains total, which is the sum of all the currencies in cid array. Also it contains the values of each individual currency.

Above line is adding all the values in array and represent it as total property.

This line is responsible for adding the amount of each currency to the object with creating new properties name as the currency.
Ex. If curr[0] = “PENNY” and curr[1] = 1.25, then above line creating new property called PENNY inside the acc object and assigning the value 1.25 to it.
Later in the code we see register[curr.name] which is possible because of that. You can try printing register object and get a clear picture of what is happening inside the reducer.

3

Thanks for the explanation