print all the amounts that can be paid using only n coins - c

Question

I have a homework problem where the user inputs a number of coins N. The program is supposed to find all the amounts you can make if those coins could be made up of any combination of pennies, nickles, dimes, and quarters.
I had read other posts where they recommend so much to us dynamic programming, so I used DP in my program for the solution below:
#include <stdio.h>
#include <stdlib.h>
// q(quater), d (dime), n(nickle), p(penny).
int find_coin(int *q, int *d, int *n, int *p, int k)
{
int count = 0;
*q = k / 25;
count += *q;
k = k % 25;
*d = k / 10;
count += *d;
k = k % 10;
*n = k / 5;
count += *n;
k = k % 5;
*p = k;
count += *p;
return count;
}
int main() {
int q,d,n,p;
int k = 0;
int i = 0;
int counts = 0;
puts("\nEnter a number of coins: ");
scanf("%d", &k);
find_coin(&q, &d, &n, &p, k);
printf("%3d cents:\t", k);
printf("total of pennies: %d ",p);
printf("total of nickles: %d ",n);
printf("total of Dimes: %d ",d);
printf("total of quaters: %d \n",q);
getchar();
}
My output is:
Enter a number of coins:
5
5 cents: total of pennies: 0 total of nickles: 1 total of Dimes: 0 total of quaters: 0
But my professor now asks me for this output:
Enter the number of coins
2
2 cents: 0 quarters 0 dimes 0 nickels 2 pennies
6 cents: 0 quarters 0 dimes 1 nickels 1 pennies
11 cents: 0 quarters 1 dimes 0 nickels 1 pennies
15 cents: 0 quarters 1 dimes 1 nickels 0 pennies
20 cents: 0 quarters 2 dimes 0 nickels 0 pennies
26 cents: 1 quarters 0 dimes 0 nickels 1 pennies
30 cents: 1 quarters 0 dimes 1 nickels 0 pennies
35 cents: 1 quarters 1 dimes 0 nickels 0 pennies
50 cents: 2 quarters 0 dimes 0 nickels 0 pennies
I tried my solution using a loop, but my loop is incorrect. I did something wrong in the code where the loop is just overloading:
for(i = 1; i > counts; i++) {
printf("%3d cents:\t", k);
printf("total of pennies: %d ",p);
printf("total of nickles: %d ",n);
printf("total of Dimes: %d ",d);
printf("total of quaters: %d \n",q);
k++;
}

Answer 1

You've gotten this backwards, and probably became confused by reading solutions to problems whose only similarity was dealing with coins. Look at what this does:
int find_coin(int *q, int *d, int *n, int *p, int k)
That routine takes in an amount k which is value in cents, and gives back a breakdown of the fewest number of coins that could achieve that amount. Then it returns the count of coins. So if you gave it 26 cents as k it would poke 1 into *q, leave *d and *n at zero, and give you *p as 1. One penny and one quarter makes 26 cents--with a return value indicating two total coins. It wouldn't give you *p as 26 to make 26 cents.
(I'll point out that this has nothing to do with the concept whose somewhat-misleading name is "dynamic programming".)
So if the goal of the program was to take in a total currency value and then print out the fewest coins that make it up, your program would be correct. Imagine if the prompt said:
Enter a number of cents:
Then if you input 5 as with your case, the "optimal" answer is a single coin of one nickel. That's what you got. A correct answer to a problem you weren't assigned.
The real problem is about combinations. If I could have two coins and they could be any from the set...I'd want those to be two quarters for a maximum of 50 cents. But the question is what are all the possibilities, without counting possibilities twice. So you only need to mention two pennies once to make 2 cents.
Look at what your prompt actually says:
Enter a number of coins:
A good lesson here is that you should line up your variable names with things in the problem statement. Both the problem statement (and your question title) talk about "n" coins. So why not call your variable either n or coins? When you name things meaningfully mistakes will jump off the page, as in the mismatch that would have been here between cents and coins:
printf("%3d cents:\t", coins);
Adding some haphazard loops onto this isn't going to get you to the right answer. So it's time to go back to the drawing board. You'll be needing essentially the opposite of find_coin...something that takes a number of quarters, dimes, nickels, and pennies and gives you back the amount of money that represents. And some loops and some research on how to produce combinations.
(Note: When I mention that haphazard loops won't get you the answer, I mean it really can't. One might think that if you were asked to do 5 coins you could say the maximum amount of money in cents would be 5 times 25 for five quarters...with the minimum as 5 times 1 for five pennies. Then count from 5 to 125 and print out all the cent tallies where find_coins returned five coins. But can you see why that can't work? find_coins won't find the five pennies case because it is "inefficient", it can only see that as one nickel. But you're asked to find all combinations of the 5 coins, so that's a combination that needs to be found and output.)