# My take on Cash register problem

Firstly, I would like to admit that Cash register is one of the most interesting and complex problem. It took me few days to get my mind around this problem and come up with a solution.

I hope Quincy accepts it as a pass for Cash register problem and I can proudly put the JavaScript Algorithms and Data Structures certification on my desk…

I would love to get some feedback from seniors on my solution, wondering if they consider it as a pass or fail.

# How I divided the problem

I divided the problem into three simple scenarios:

• find out if the due is an integer number or floating point number
• if it is an integer number, simply generate the possible combinations of currencies that totals up to due
• if it is a floating point number, divide the due at the point into upper class value and lower class value, and then find possible combinations of currencies that totals up to each extreme values

When you try to find possible matches for either floating point number or integer number, try to take into consideration, how Number literal, fixedTo() method, Remainder operator behaves in JavaScript.

# Extra homework

I spent way too much time figuring out a solution to this problem. My test cases are performing better than what I expected. One major case where due is 96.74, my solution gives a change of following data structure:

``````[
[
"TWENTY",
80
],
[
"TEN",
10
],
[
"FIVE",
5
],
[
"ONE",
1
],
[
"QUARTER",
0.5
],
[
"DIME",
0.2
],
[
"PENNY",
0.04
]
]
``````

Unfortunately, my logic will only work when Cash register has only 3 bills of \$20. In such case, you will see expected output as needed to pass the problem.

I wanted to write logic in a way to support all edge cases. Because, as we are humans, I cannot possibly test all cases that a machine can do. But, whatever loopholes I found when working at the problem, I tried to address it. Following are some cases that passes with this logic:

``````// ADDITIONAL TEST CASES
// checkCashRegister(19, 20, [
//   ["PENNY", 1.01],
//   ["NICKEL", 2.05],
//   ["DIME", 3.1],
//   ["QUARTER", 4.25],
//   ["ONE", 90],
//   ["FIVE", 55],
//   ["TEN", 20],
//   ["TWENTY", 60],
//   ["ONE HUNDRED", 1]
// ])
// checkCashRegister(19, 200, [
//   ["PENNY", 1.01],
//   ["NICKEL", 2.05],
//   ["DIME", 3.1],
//   ["QUARTER", 4.25],
//   ["ONE", 90],
//   ["FIVE", 55],
//   ["TEN", 20],
//   ["TWENTY", 60],
//   ["ONE HUNDRED", 1]
// ])
// checkCashRegister(18.5, 20, [
//   ["PENNY", 1.01],
//   ["NICKEL", 2.05],
//   ["DIME", 3.1],
//   ["QUARTER", 4.25],
//   ["ONE", 90],
//   ["FIVE", 55],
//   ["TEN", 20],
//   ["TWENTY", 60],
//   ["ONE HUNDRED", 1]
// ])
// checkCashRegister(18.2, 20, [
//   ["PENNY", 0],
//   ["NICKEL", 0.8],
//   ["DIME", 0],
//   ["QUARTER", 0],
//   ["ONE", 1],
//   ["FIVE", 2],
//   ["TEN", 2],
//   ["TWENTY", 2],
//   ["ONE HUNDRED", 2]
// ])
``````

# Learning Outcome

I feel proud to have accomplished a working solution on my own. It may be ugly, long, unreadable, messy, sloppy or anything bad you can think of. At the end of the day, positive takeaway for me was to able to see through a logic that meets minimum possible requirements to solve the problem. It may be tough for most people but I advice people to keep at it and reward will be much satisfactory once you see the working solution of your own.

remember that the second number is the value in dollars you have of that denomination, you can’t have 2\$ in 20\$ bills

I’ve copied your code and run it in the challenge, you are missing a test, so you have not finished yet

I agree that my code does not pass one test case. Can you provide feedback on my output on that particular test case (one with 3.26 and 100 as inputs)? Is it not possible that program can give this output? I am confused here.

Most confusing part is why output ask strictly for following change:

`change: [["TWENTY", 60], ["TEN", 20], ["FIVE", 15], ["ONE", 1], ["QUARTER", 0.5], ["DIME", 0.2], ["PENNY", 0.04]]`

when CID has following values:

`[["PENNY", 1.01], ["NICKEL", 2.05], ["DIME", 3.1], ["QUARTER", 4.25], ["ONE", 90], ["FIVE", 55], ["TEN", 20], ["TWENTY", 60], ["ONE HUNDRED", 100]]`

Above data states that there are following bills in CID:

`[ 101, 41, 31, 17, 90, 55, 20, 20, 100 ]`

with following worth starting from smallest value:

`[ 1.01, 2.05, 3.1, 4.25, 90, 275, 200, 400, 10000 ]`

The way, I wrote logic was program itself makes a decision which bill it needs to take out and match it against the total return value customer expects. My output is as following:

`change: [[ 'TWENTY', 80 ], [ 'TEN', 10 ], [ 'FIVE', 5 ], [ 'ONE', 1 ], [ 'QUARTER', 0.5 ], [ 'DIME', 0.2 ], [ 'PENNY', 0.04 ]]`

In case CID only has 3 twenty dollar bills and 1 ten dollar bill, I think you will get the expected output that passes the solution.

`change: [["TWENTY", 3], ["TEN", 1], ["FIVE", 15], ["ONE", 1], ["QUARTER", 0.5], ["DIME", 0.2], ["PENNY", 0.04]]`

``````if (paidAmount > hasPrice || (unitPricesHigh[i] === 20 && paidAmount > 60) || (unitPricesHigh[i] === 10 && paidAmount > 20))