Thread: C program to Calculate Change

Originally Posted by tabstop

You should search (using whatever search mechanism you like) for either "mod" or "modulus" or "% in C" or something similar.

I have done some googling on the topic but nothing I feel is helping. I found this earlier, see what I put after and let me know if I am o the right track, I believe that is C++ so I will change some of it to make it what I know to be C

Code:

#include <iostream>


int main()
{
    int num;
    cin >> num;
    // num % 2 computes the remainder when num is divided by 2
    if ( num % 2 == 0 )
    {
        cout << num << " is even ";
    }

    return 0;
}

Here is kind of what I am thinking, trustme I am new and at work so I don't have my compiler in front of me or the projects we have done to reference.

Code:

#include <stdio.h>
#include <stdlib.h>


int main()
{
    float amtDue = 0;
    float amtGiven = 0;
    float balAmount =0;

    float twenty = 20.00
    float ten = 10.00;
    float five = 5.00;
    float one = 1.00;
    float quarter = .25;
    float dime = .10;
    float nickel = .05;
    float penny = .01;

    printf ("Enter the Amount Due: ");
    scanf ("%f", &amtDue);

    printf ("Enter the Amount Given: ");
    scanf ("%f", &amtGiven);

    balAmount = amtDue - amtGiven;

    printf ("Change Due: $ %f", balAmount);
    // This is where I really don't know the code but put what my best idea is something like
    
   
    float modTwenty = amtbalance % twenty;
    float modTen = modTwenty % ten;
    // and so on down the line, I can figure out the float or int once I am behind my compiler
    // I am using float because I am using MOD and want the result to be true, then using %d to printf the int so it doesn't say something like 2.3 twenties which is impossible

    printf ("Twenties: %d \nTens: %d", modTwenty, modTen);
 
system ("pause"); 
return 0;
}

Am I getting on the right path???

i would expect the out put at the end to say something like

Twenties: 2
Tens: 1
and so on...

Thanks

I'll add the thing I always add to discussions of the "making change" homework assignment. DON'T USE FLOATS!

Money is not a floating point number. Money is a fixed precision number. Here's a little demonstration of the problem:

Code:

#include <stdio.h>

int main() {
        float i;
        for (i=0.0f; i<20; i+=0.1f) {
                printf("%f\n",i);
        }
        return 0;
}

Here's a little sample of the unexpected output:

2.500000
2.600000
2.700000
2.799999
2.899999
2.999999
3.099999


This just compounds. Floats can only accurately represent fractions produced by dividing 1 by 2: 1/2, 1/4/, 1/8, 1/16, 1/32 and so on. Notice 1/10 ("0.1") is not on the list. You may think you can get out of this with rounding, but you probably won't.

When dealing with change, use an int to represent cents:

Code:

#include <stdio.h>
#include <string.h>

int main() {
	int cents = 537;
	printf("$%d.%02d", cents/100, cents%100);

	return 0;
}

If you aren't sure how mod works, you can do it this way:

x = 12345
y = x / 10 (or 1234 )
z = y * 10 (or 12340)
x - z = 5

That's basically how mod works. It just wraps it all up in a single operation.


Quzah.

Remember that "slick arithmetic method", way that I mentioned before? Well that POST you linked to was going that way.

I don't advise that, because it's not intuitive, at all. 99% of us think like this while loop, when we give change back on a sale:

Code:

/* first, multiply all amounts by 100, to make everything an integer, then */

while(balAmt > 0) {               //while there is an amount due back to the customer
   if(balAmt > 2000) {            //try the largest bill first -- does he get one of those?
      //code to handle it          //if so, subtract $20 (2000 pennies) from the amount 
   }                                 //we still owe.
   else if(balAmt > 1000) {     //and repeat this for the $10 denomination on the next loop
     //code to handle that
   }
    //etc.
}                             
//until the

My advice? Read no more posts on it. Think about the code I've posted here. Isn't that how you actually think when you give back change?

Item cost $15.82. Customer gave you $20.00.

amtDue = 2000 - 1582
amtDue = 418 cents

Start loop: {

Do I owe customer >= 2000 ? No too much
else Do I owe customer >= 1000 ? No too much
else Do I owe customer >= 500 ? No too much
else Do I owe customer >=100 ? Yes. { //1st,2nd,3rd & 4th time thru loop
Give 100 (one dollar)
Subtract 100 from amtDue
}
else Do I owe customer >25 ?
else Do I owe customer >10 ? { //5th time thru the loop, yes
give 10 (one dime)
subtract 10 from amtDue
}
else Do I owe customer >5 ? { //6th time thru the loop, yes
give 5 (one nickel)
subtract 5 from amtDue
}
else Do I owe customer > 1 ? { //7th, 8th, 9th time thru the loop, yes
give 1 cent to customer
subtract 1 from amtDue
}
}
END of Loop
amtDue will equal 0 after 9 loops.

You have to use logic from greater denominations to lesser, so you don't wind up giving the customer nothing but pennies.

Now, on to the way your teacher wants you to do this, using % (mod).

Consider the number line. Since our money system is decimalized (yes, that's a word), it fits beautifully into the base 10 number system:

These amounts are all in pennies (you've done the money X 100, already)

Code:

100's | 10's | 1's, |
==================
  4      1     8

That is amtDue of 418 cents. This time, we work from right to left, and go from smallest denominations, on up.

Start loop: {

right most digit = amtDue % 10:
8 == 418 % 10 //we owe 8 pennies
if(pennies >= 5)
give 1 nickel, and subtract 5 from pennies due

divide 418 by 10, using integer division (standard with integers in C). 418 becomes 41. The 8 remainder is dropped (but we want that, since it's already been handled).
}
End of Loop

Showing 2nd time through the above loop:
1 == 41 % 10 //now we're up to the 10's place (dimes), and we owe 1 dime

amtDue = amtDue / 10 (shorthand C is: amtDue /= 10)

Showing 3rd time through the above loop:
4 == now we're up to 100's place, so we owe 4 1 dollar bills

amtDue /= 10

amtDue is now zero. No more change to make.

See how % 10 gets the right most digit, and how dividing by 10 truncates it away, digit by digit? It's like you were peeling off the digits, from the right hand side of the amtDue.