# Calculating the number of coins in money change

I wrote a program that calculates the minimum number of coins required to give a user change.

One concern I have is: When do we initialize the value of a float to be negative or positive? I recently saw

float userInput = -1.0;


float userInput = 1.0;


Are there differences between the two, and when would one be used over the other?

#include <stdio.h>
#include <cs50.h>
#include <math.h>

int main(void)
{
float input = -1;
int z = 0;
int counter = 0;

do
{
printf("The amount of changed owed(in dollars) is ");
input = get_float();
}
while (input < 0);
input = input * 100;
input = round(input);
z = input;

while (z >= 25)
{
z = z - 25;
counter++;
}

while (z >= 10)
{
z = z - 10;
counter++;
}

while (z >= 5)
{
z = z - 5;
counter++;
}

while (z >= 1)
{
z = z-1;
counter++;
}

printf("The number of minimum coins needed is %d\n", counter);
}


• The only missing thing is the #include lines at the top of the file. These are part of "the complete code". According to this site's guidelines, the question title should describe what your code is supposed to do, therefore "Calculating the number of coins in money change" is preferred. – Roland Illig Apr 14 '19 at 6:17
• Oh I see, thank you! Is it okay now? – asimichroma Apr 14 '19 at 6:20
• Thanks for all the edits. The cs50.h header already provides an important clue. :) – Roland Illig Apr 14 '19 at 6:20
• No problem haha, thank you for letting me know :) Yes, I'm a newbie, sorry if my questions aren't worded the best way =p – asimichroma Apr 14 '19 at 6:24
• No worries. It's almost impossible to get your first question perfect on the first try. As it is now, it's in the perfect state to be answered: It contains a compilable self-contained piece of code that can be generally reviewed, and a little bonus question on top of that. – Roland Illig Apr 14 '19 at 6:31

In general we want to initialize a variable directly to the value it needs, rather than to a temporary "invalid" value. This reduces complexity, and helps to prevent the accidental use of the "invalid" value as if it were a real input.

We should also put variable declarations as close to the point of use as practical. (e.g. z could be declared at the point of assignment from input). It's best for variables to only exist in the scope in which they are needed.

Note that the input variable is effectively reassigned 3 times, and used to represent 3 different things in the program. If we split the program into separate stages, this becomes clearer:

int main(void)
{
float input = -1;

// here "input" is invalid - it's just a placeholder.

// get user input (dollars):
{
do
{
printf("The amount of changed owed(in dollars) is ");
input = get_float();
}
while (input < 0);
}

// here "input" is the amount of dollars as a float

// convert input to cents:
{
input = input * 100;
input = round(input);
}

// here "input" is the number of cents, as a float

// calculate number of coins for change:
{
int z = input; // note we actually want the number of cents as an int...
int counter = 0;

...

printf("The number of minimum coins needed is %d\n", counter);
}
}


It's best to avoid reusing variables like this. Any name given to such a variable is inaccurate or very general (e.g. "input"). Also, when changing some part of the program, we have to understand and modify a much larger amount of code than would otherwise be necessary.

Here, we can avoid reusing the variable by splitting the program up using functions, e.g.:

float get_dollar_input()
{
while (true)
{
printf("The amount of change owed (in dollars) is: ");

const float dollars = get_float(); // variable initialized to actual value :)

if (dollars < 0)
{
printf("Input must not be negative.");
continue;
}

return dollars;
}
}

int convert_to_cents(float dollars)
{
return (int)round(dollars * 100);
}

int calculate_minimal_coins(int cents)
{
int counter = 0;

// ...

return counter;
}

int main(void)
{
const float dollars = get_dollar_input();
const int cents = convert_to_cents(dollars);
const int coins = calculate_minimal_coins(cents);

printf("The minimum number of coins needed is %d\n", coins);
}


When calculating the change, we do a lot of subtraction in a loop. For a large input (e.g. \$200,457,298.46), this could take a looooooong time. We can use division to find the count of each coin, and the remainder (modulus) operator to apply the subtraction:

int calculate_minimal_coins(int cents)
{
const int quarters = cents / 25;
cents %= 25;

const int dimes = cents / 10;
cents %= 10;

const int nickels = cents / 5;
cents %= 5;

const int pennies = cents; /* unnecessary, but explanatory */

return quarters + dimes + nickels + pennies;
}


One last thing: We should never use floating point variables to represent exact monetary values. It would be better to ask the user for the number of cents as an integer (or perhaps to ask for two integers: one for dollars, and one for cents).

• taking a floating point input and converting to int right away, as OP has done, is perfectly safe for amounts up to trillions of dollars (as far as floating-point precision is concerned - you can't actually store those amounts in a 32-bit int). Asking a user to enter monetary amounts in cents presents far more possibility of error. – Oh My Goodness Apr 14 '19 at 10:49
• Using double instead of float would make this usage acceptable. The type float only guarantees 6 decimal places. – Roland Illig Apr 14 '19 at 20:32
• 200,457,298.46 converted to int cents overflow and is inaccurate with float anyways. – chux - Reinstate Monica Apr 15 '19 at 22:51
• Instead of int convert_to_cents(float dollars) { return (int)round(dollars * 100); }, consider long long convert_to_cents(double dollars) { return llround(dollars * 100.0); }  – chux - Reinstate Monica Apr 15 '19 at 22:55
• True. Probably the best thing overall would be to make the limitations of the program clear to the user by printing an error if the input is too large. – user673679 Apr 16 '19 at 9:14

When do we initialize the value of a float to be negative or positive?

That's entirely use case dependent!

In your concrete example, initialisation is entirely irrelevant, as you overwrite the initialisation value anyway!

float input;
{
input = get_float();
}


Still initialising the variable might, though, prevent undefined behaviour if you later modify the code in a way the (re-)assignment might get skipped under some circumstances (you might forget to add the then necessary initialisation during modification...).

Back to the use cases: Even with same exponent and magnitude (i. e. with same absolute value) positive and negative are totally different values, consider pow(7.0, 10.12) and pow(7.0, -10.12)` (whatever the values would mean) yielding totally different results (positive both times!), or consider results of sine and cosine.

Perhaps a bit more concrete: negative values in a banking application might mean you have some debts (although for such a scenario, I'd prefer integers with fixed point semantics, where number 1 would mean e. g. 1/100 or 1/1000 of a cent, whichever precision you might need).

If sign of numbers is irrelevant, prefer (well, there's no unsigned float/double...) positive ones, most people would consider them more natural – or would you prefer negative speed limit signs, meaning don't drive slower (i. e. smaller value -> higher absolute value) backwards?