# Why does greedy return the wrong output for 0.53 while other inputs work properly?

The change calculating program I wrote seems to be working as intended except when the input is .53 it returns 2 quarters and 2 pennies instead of 2 quarters and 3 pennies. It appears to be working fine for similar input values like 3.53, 0.23 or 0.38.

What could be causing this error?

float c;
double round(double c);

int r=c*100;

First, when you call a function, you don't include its return type and/or its parameter(s) datatype(s). For example, the prototype for round() is

double round(double x);

This means that round() receives a double and returns a double. When we call it though, we call it like that

round(x);

Where x is a double variable. Watch the short on functions for more information!

Second, you should multiply the amount you receive from the user by 100 first, then round it using roundf() or round() because these functions, as their names suggest, round floating-point values to the nearest integer. And if you round the input first, then multiply it by 100 it'll always give you a multiple of 100. For example, if I entered 1.99, do you think your program should

1. round 1.99 first which gives 2
2. then multiply 2 by 100 which gives 200

or

1. multiply 1.99 by 100 first which gives 199.0
2. then round 199.0 which gives 199

Lastly, you're dividing by quarters, dimes, nickles and pennies anyway regardless of q being >, < or = the divisor which is surely wrong since this is integer division and if q is < the divisor, the result will be 0. Probably some conditions will be sufficient to solve this.

Also, no need to use 4 variables for each type of coins. You could have used just one variable adding the number of coins of each type to it like

int total = 0;

// quarters
total += amount / quarters;
amount %= quarters;

// dimes
total += amount / dimes;
amount %= dimes;

and so on.

EDIT: you should only output the total number of coins followed by a newline character.

• So it was still chunking. Confusion is gone now that I know how to read prototype composition, when to round and how to optimize the rest of the code! Thanks sensei Jun 22, 2014 at 9:27
• Could You rephrase why having division result for q = 0 is wrong tho? Program never uses it as divisor later on so it seems alright to me. Even providing r=0 program never devides by 0. Jun 22, 2014 at 10:14
• Consider these two variables, a and b, where a and b are integers and a < b. When dividing a/b (i.e., integer division), the result won't be a fraction or a floating-point value (because you're dividing integers). Instead, it will be just 0 which could lead to some logical errors in your program.
– kzidane
Jun 22, 2014 at 10:25
• My intention was to cover this eventuality with next line a%b. So that even if a/b divison is 0, remaining fraction is carried over under modulo a%b. Jun 22, 2014 at 10:37
• I see. You were still doing one extra unneeded step though! Probably you may make use of that in a future program because this really can lead to some issues :)
– kzidane
Jun 22, 2014 at 10:40

You are running into float imprecision. When you multiply 0.53 * 100 and store it in an int, you will truncate any decimals. 0.53 is actually stored as something like 0.52999999 and multiplying that by 100 will result in an integer of 52.

You want to round the value before storing it as an integer.

int r = round(c*100);

is the correct syntax. That line you have in your code doesn't actually do anything.

Here's a good video on floating point imprecision that I found helpful: http://www.youtube.com/watch?v=PZRI1IfStY0

Brenda.