Velocity Reviews > C++ > C++ help

# C++ help

davy.zou@brentwood.bc.ca
Guest
Posts: n/a

 03-04-2007
On Mar 3, 9:39 pm, "untitled" <(E-Mail Removed)> wrote:
> then its an easy one,
>
> x is the requested number
>
> int sevens=x/7 //without the fractures
> remainder=x - (sevens*7)
> int twos= remainder/2 //without the fractures
> if (remainder - (twos*2)) =1 then twos++
> if sevens != 0 && sevens<twos then twos=twos-sevens, nines= sevens,
> sevens=0
> if twos != 0 && twos<sevens then sevens=sevens-twos, nines= twos, twos
> =0
>
> just put it in c code

1 1int sevens=x/7 //without the
fractures
2 remainder=x - (sevens*7)
3 int twos= remainder/2 //without the fractures
4 if (remainder - (twos*2)) =1 then twos++
5 if sevens != 0 && sevens<twos then twos=twos-sevens, nines= sevens,
sevens=0
6 if twos != 0 && twos<sevens then sevens=sevens-twos, nines= twos,
twos=0

I don't get it. Several things in fact.

First, I can't see what your program does. Since it doesn't have an
output statement. But I will go on a tangent and guess that it is for
comparing which ever way is the most effective way to distribute the
stamps.

Second, why not just use x%7 for line 2?

Third, since you assigned that twos be reminder/2, then the act of
mutiplying twos by 2 would result in the remainder from line2.
Therefore, in line4, having remainder-remainder would result in 0.

Fourth, in line4, what do you mean by twos++?

Five, line 5 and 6 doesn't make much sense either.

Six, what is if final out put?

I really appreciate you trying to help, and I know that with the above
list I sound like an ungrateful little brat. But I am grateful. I just

Davy

davy.zou@brentwood.bc.ca
Guest
Posts: n/a

 03-04-2007
On Mar 3, 9:39 pm, "untitled" <(E-Mail Removed)> wrote:
> then its an easy one,
>
> x is the requested number
>
> int sevens=x/7 //without the fractures
> remainder=x - (sevens*7)
> int twos= remainder/2 //without the fractures
> if (remainder - (twos*2)) =1 then twos++
> if sevens != 0 && sevens<twos then twos=twos-sevens, nines= sevens,
> sevens=0
> if twos != 0 && twos<sevens then sevens=sevens-twos, nines= twos, twos
> =0
>
> just put it in c code

1 1int sevens=x/7 //without the
fractures
2 remainder=x - (sevens*7)
3 int twos= remainder/2 //without the fractures
4 if (remainder - (twos*2)) =1 then twos++
5 if sevens != 0 && sevens<twos then twos=twos-sevens, nines= sevens,
sevens=0
6 if twos != 0 && twos<sevens then sevens=sevens-twos, nines= twos,
twos=0

I don't get it. Several things in fact.

First, I can't see what your program does. Since it doesn't have an
output statement. But I will go on a tangent and guess that it is for
comparing which ever way is the most effective way to distribute the
stamps.

Second, why not just use x%7 for line 2?

Third, since you assigned that twos be reminder/2, then the act of
mutiplying twos by 2 would result in the remainder from line2.
Therefore, in line4, having remainder-remainder would result in 0.

Fourth, in line4, what do you mean by twos++?

Five, line 5 and 6 doesn't make much sense either.

Six, what is if final out put?

I really appreciate you trying to help, and I know that with the above
list I sound like an ungrateful little brat. But I am grateful. I just

Davy

Alan Johnson
Guest
Posts: n/a

 03-04-2007
http://www.velocityreviews.com/forums/(E-Mail Removed) wrote:
> But you have peaked my interest, would D1 through Dk be inputed by
> user? If it is inputed by user, then it shouldn't be too difficult to
> add the lines of codes to the program that will assign the user input
> to D1 through Dk.
>
> Davy
>

You can expand the recurrence I posted earlier in this thread to any
number of denominations. So if I had an array of denominations d.

C(n) = 0 if n = 0
C(n) = minimum value over all i such that d[i] < n of 1 + C(n - d[i])

If we were to translate this to pseudocode it might look something like:

// n is the number for which we are finding a solution.
// d is an array of denominations.
// k is the number of denominations
// S is an array of index denominations.
Solve(n, d, k)

Allocate arrays C and S of size n

// Base condition of recurrence C(0)
C[0] = 0

// Now compute C(1) through C(n)
for v = 1 to n

// maybe something like std::numeric_limits<unsigned>::max()
min = infinity

// Find the minimum value of 1+C(n-d[i])
for i = 1 to k
if (d[i] <= k)
value = 1 + C[v - d[i]]
if (value < min)
min = value
stamp = i

// Store the results for the next loop.
C[v] = min
S[v] = stamp

return S

The array C holds the minimum count of stamps needed for each value,
which is a necessary piece of information, but not exactly what we want.
The array S keeps up with the index of which denomination stamp we add
at each step. We can use that knowledge to construct the actual set of
stamps with something like:

// n is the number for which we are finding a solution.
// d is an array of denominations.
// S is an array of index denominations.
PrintSet(n, d, S)
while (n > 0)
Print S[n]
n = n - d[S[n]]

This works due to the same logic we used to create the array in the
first place. At each step we are just subtracting the denomination that
we decided was necessary to add to the optimal substructure to get the
solution for n.

--
Alan Johnson

Alan Johnson
Guest
Posts: n/a

 03-04-2007
Alan Johnson wrote:
> (E-Mail Removed) wrote:
>> But you have peaked my interest, would D1 through Dk be inputed by
>> user? If it is inputed by user, then it shouldn't be too difficult to
>> add the lines of codes to the program that will assign the user input
>> to D1 through Dk.
>>
>> Davy
>>

>
> You can expand the recurrence I posted earlier in this thread to any
> number of denominations. So if I had an array of denominations d.
>
> C(n) = 0 if n = 0
> C(n) = minimum value over all i such that d[i] < n of 1 + C(n - d[i])
>
> If we were to translate this to pseudocode it might look something like:
>
> // n is the number for which we are finding a solution.
> // d is an array of denominations.
> // k is the number of denominations
> // S is an array of index denominations.
> Solve(n, d, k)
>
> Allocate arrays C and S of size n
>
> // Base condition of recurrence C(0)
> C[0] = 0
>
> // Now compute C(1) through C(n)
> for v = 1 to n
>
> // maybe something like std::numeric_limits<unsigned>::max()
> min = infinity
>
> // Find the minimum value of 1+C(n-d[i])
> for i = 1 to k
> if (d[i] <= k)
> value = 1 + C[v - d[i]]
> if (value < min)
> min = value
> stamp = i
>
> // Store the results for the next loop.
> C[v] = min
> S[v] = stamp
>
> return S
>
>
> The array C holds the minimum count of stamps needed for each value,
> which is a necessary piece of information, but not exactly what we want.
> The array S keeps up with the index of which denomination stamp we add
> at each step. We can use that knowledge to construct the actual set of
> stamps with something like:
>
> // n is the number for which we are finding a solution.
> // d is an array of denominations.
> // S is an array of index denominations.
> PrintSet(n, d, S)
> while (n > 0)
> Print S[n]
> n = n - d[S[n]]
>

Oops. One small correction. You'd probably like to print the actual
denominations in the set, rather than the indices, so:
Print d[S[n]]

> This works due to the same logic we used to create the array in the
> first place. At each step we are just subtracting the denomination that
> we decided was necessary to add to the optimal substructure to get the
> solution for n.
>

--
Alan Johnson

Alan Johnson
Guest
Posts: n/a

 03-04-2007
Alan Johnson wrote:
> Alan Johnson wrote:
>> (E-Mail Removed) wrote:
>>> But you have peaked my interest, would D1 through Dk be inputed by
>>> user? If it is inputed by user, then it shouldn't be too difficult to
>>> add the lines of codes to the program that will assign the user input
>>> to D1 through Dk.
>>>
>>> Davy
>>>

>>
>> You can expand the recurrence I posted earlier in this thread to any
>> number of denominations. So if I had an array of denominations d.
>>
>> C(n) = 0 if n = 0
>> C(n) = minimum value over all i such that d[i] < n of 1 + C(n - d[i])
>>
>> If we were to translate this to pseudocode it might look something like:
>>
>> // n is the number for which we are finding a solution.
>> // d is an array of denominations.
>> // k is the number of denominations
>> // S is an array of index denominations.
>> Solve(n, d, k)
>>
>> Allocate arrays C and S of size n
>>
>> // Base condition of recurrence C(0)
>> C[0] = 0
>>
>> // Now compute C(1) through C(n)
>> for v = 1 to n
>>
>> // maybe something like std::numeric_limits<unsigned>::max()
>> min = infinity
>>
>> // Find the minimum value of 1+C(n-d[i])
>> for i = 1 to k
>> if (d[i] <= k)

Gah. One more correction. This should have been:
if (d[i] <= v)

>> value = 1 + C[v - d[i]]
>> if (value < min)
>> min = value
>> stamp = i
>>
>> // Store the results for the next loop.
>> C[v] = min
>> S[v] = stamp
>>
>> return S
>>
>>
>> The array C holds the minimum count of stamps needed for each value,
>> which is a necessary piece of information, but not exactly what we
>> want. The array S keeps up with the index of which denomination stamp
>> we add at each step. We can use that knowledge to construct the
>> actual set of stamps with something like:
>>
>> // n is the number for which we are finding a solution.
>> // d is an array of denominations.
>> // S is an array of index denominations.
>> PrintSet(n, d, S)
>> while (n > 0)
>> Print S[n]
>> n = n - d[S[n]]
>>

>
> Oops. One small correction. You'd probably like to print the actual
> denominations in the set, rather than the indices, so:
> Print d[S[n]]
>
>> This works due to the same logic we used to create the array in the
>> first place. At each step we are just subtracting the denomination
>> that we decided was necessary to add to the optimal substructure to
>> get the solution for n.
>>

>
>

--
Alan Johnson

untitled
Guest
Posts: n/a

 03-04-2007
On Mar 4, 5:35 am, (E-Mail Removed) wrote:
> On Mar 3, 9:39 pm, "untitled" <(E-Mail Removed)> wrote:
>
> > then its an easy one,

>
> > x is the requested number

>
> > int sevens=x/7 //without the fractures
> > remainder=x - (sevens*7)
> > int twos= remainder/2 //without the fractures
> > if (remainder - (twos*2)) =1 then twos++
> > if sevens != 0 && sevens<twos then twos=twos-sevens, nines= sevens,
> > sevens=0
> > if twos != 0 && twos<sevens then sevens=sevens-twos, nines= twos, twos
> > =0

>
> > just put it in c code

>
> 1 1int sevens=x/7 //without the
> fractures
> 2 remainder=x - (sevens*7)
> 3 int twos= remainder/2 //without the fractures
> 4 if (remainder - (twos*2)) =1 then twos++
> 5 if sevens != 0 && sevens<twos then twos=twos-sevens, nines= sevens,
> sevens=0
> 6 if twos != 0 && twos<sevens then sevens=sevens-twos, nines= twos,
> twos=0
>
> I don't get it. Several things in fact.
>
> First, I can't see what your program does. Since it doesn't have an
> output statement. But I will go on a tangent and guess that it is for
> comparing which ever way is the most effective way to distribute the
> stamps.
>
> Second, why not just use x%7 for line 2?
>
> Third, since you assigned that twos be reminder/2, then the act of
> mutiplying twos by 2 would result in the remainder from line2.
> Therefore, in line4, having remainder-remainder would result in 0.
>
> Fourth, in line4, what do you mean by twos++?
>
> Five, line 5 and 6 doesn't make much sense either.
>
> Six, what is if final out put?
>
> I really appreciate you trying to help, and I know that with the above
> list I sound like an ungrateful little brat. But I am grateful. I just
>
> Davy

you are right, it wasn't clear,

first i'll explain how the program will think then i'll answer your
questions:

first line will count how many 7cent stamp could be afforded with the
money required, of course there will be some extra cents we will
process it in line 2
line 2 will see how many extra cents you have after we got all the
sevens.
line 3 will check how many 2cent stamps can be afforded for that extra
cents
line 4 if the remainder was less than 2 cents (ie. 1 cent) then of
course we will consider it 2cent that is adding one cent over the
required money as you told me.
in line 5,6 we replace every 7cent and 2cent stamp to one 9cent stamp
so we got the most effective number of stamps.
line 5 if the 7c stamps was less than the 2c stamps, then combine all
the sevens with an equivilant number of 2c stamps and replace them
with 9c stamps. then delete the combined 7 and 2c stamps.
line 6 do the same if the twos was more than sevens.

the out put will be
int sevens
int nines
int twos

i'll write the code in few minutes.

untitled
Guest
Posts: n/a

 03-04-2007
On Mar 4, 1:36 pm, "untitled" <(E-Mail Removed)> wrote:
> On Mar 4, 5:35 am, (E-Mail Removed) wrote:
>
>
>
>
>
> > On Mar 3, 9:39 pm, "untitled" <(E-Mail Removed)> wrote:

>
> > > then its an easy one,

>
> > > x is the requested number

>
> > > int sevens=x/7 //without the fractures
> > > remainder=x - (sevens*7)
> > > int twos= remainder/2 //without the fractures
> > > if (remainder - (twos*2)) =1 then twos++
> > > if sevens != 0 && sevens<twos then twos=twos-sevens, nines= sevens,
> > > sevens=0
> > > if twos != 0 && twos<sevens then sevens=sevens-twos, nines= twos, twos
> > > =0

>
> > > just put it in c code

>
> > 1 1int sevens=x/7 //without the
> > fractures
> > 2 remainder=x - (sevens*7)
> > 3 int twos= remainder/2 //without the fractures
> > 4 if (remainder - (twos*2)) =1 then twos++
> > 5 if sevens != 0 && sevens<twos then twos=twos-sevens, nines= sevens,
> > sevens=0
> > 6 if twos != 0 && twos<sevens then sevens=sevens-twos, nines= twos,
> > twos=0

>
> > I don't get it. Several things in fact.

>
> > First, I can't see what your program does. Since it doesn't have an
> > output statement. But I will go on a tangent and guess that it is for
> > comparing which ever way is the most effective way to distribute the
> > stamps.

>
> > Second, why not just use x%7 for line 2?

>
> > Third, since you assigned that twos be reminder/2, then the act of
> > mutiplying twos by 2 would result in the remainder from line2.
> > Therefore, in line4, having remainder-remainder would result in 0.

>
> > Fourth, in line4, what do you mean by twos++?

>
> > Five, line 5 and 6 doesn't make much sense either.

>
> > Six, what is if final out put?

>
> > I really appreciate you trying to help, and I know that with the above
> > list I sound like an ungrateful little brat. But I am grateful. I just

>
> > Davy

>
> you are right, it wasn't clear,
>
> first i'll explain how the program will think then i'll answer your
> questions:
>
> first line will count how many 7cent stamp could be afforded with the
> money required, of course there will be some extra cents we will
> process it in line 2
> line 2 will see how many extra cents you have after we got all the
> sevens.
> line 3 will check how many 2cent stamps can be afforded for that extra
> cents
> line 4 if the remainder was less than 2 cents (ie. 1 cent) then of
> course we will consider it 2cent that is adding one cent over the
> required money as you told me.
> in line 5,6 we replace every 7cent and 2cent stamp to one 9cent stamp
> so we got the most effective number of stamps.
> line 5 if the 7c stamps was less than the 2c stamps, then combine all
> the sevens with an equivilant number of 2c stamps and replace them
> with 9c stamps. then delete the combined 7 and 2c stamps.
> line 6 do the same if the twos was more than sevens.
>
> the out put will be
> int sevens
> int nines
> int twos
>
> i'll write the code in few minutes.- Hide quoted text -
>
> - Show quoted text -

ok here is the code, tell me if it workes, it works with me by the
way:

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
int twos=0;
int sevens=0;
int nines=0;
int reqMoney=0;
int remainderCents=0;

cout<<"input required money"<<endl;
cin>>reqMoney;

sevens=reqMoney/7; //check how many sevens can be afforded
remainderCents= reqMoney-(sevens*7); //check the extra cents you
can use % but i prefer this i don't know why
twos= remainderCents/2; //check how many twos can be afforded for
the extra cents left
if ( (remainderCents-(twos*2)) ==1) twos++; //add one cent above
the reqmoney if the extra cents=1
if ( (sevens != 0) && (sevens<twos))
{
twos=twos-sevens;
nines=sevens;
sevens=0;
}

if ( (twos != 0) && (sevens>twos))
{
sevens=sevens-twos;
nines=twos;
twos=0;
}
cout<<"twos="<<twos<<endl;
cout<<"sevens="<<sevens<<endl;
cout<<"nines="<<nines<<endl;

system("PAUSE");
return EXIT_SUCCESS;
}

roy axenov
Guest
Posts: n/a

 03-04-2007
On Mar 4, 2:36 pm, "untitled" <(E-Mail Removed)> wrote:
> On Mar 4, 5:35 am, (E-Mail Removed) wrote:
> > On Mar 3, 9:39 pm, "untitled" <(E-Mail Removed)>
> > wrote:
> > > int sevens=x/7
> > > remainder=x - (sevens*7)
> > > int twos= remainder/2
> > > if (remainder - (twos*2)) =1 then twos++
> > > if sevens != 0 && sevens<twos then twos=twos-sevens,
> > > nines= sevens, sevens=0
> > > if twos != 0 && twos<sevens then sevens=sevens-twos,
> > > nines= twos, twos =0

> i'll write the code in few minutes.

Unless I'm much mistaken, this doesn't work. Try 81. The
9x7, 2x9.

Here's what seems to be a general solution (the only
problem with it is that its efficiency borders on that of
bogosort):

#include <iostream>
#include <stack>
#include <map>

const int stamp_1 = 2 ;
const int stamp_2 = 7 ;
const int stamp_3 = 9 ;

namespace xyz
{ int f ( std :: map < int , int > x )
{ int result = 0 ;
for
( std :: map < int , int > :: iterator i =
x . begin ( ) ;
i != x . end ( ) ; ++ i )
result += ( * i ) . second ;
return result ; }
int g ( std :: map < int , int > x )
{ int result = 0 ;
for
( std :: map < int , int > :: iterator i =
x . begin ( ) ;
i != x . end ( ) ; ++ i )
result += ( * i ) . first * ( * i ) . second ;
return result ; }
std :: map < int , int > solve
( int s , std :: stack < int > c )
{ std :: map < int , int > result ;
int best = 0 ;
if ( c . size ( ) )
{ result [ 0 ] = 1 ;
int cur_c = c . top ( ) ;
c . pop ( ) ;
int max_c = s / cur_c ;
std :: map < int , int > tmp ;
for ( int i = 0 ; i <= max_c ; ++ i )
{ tmp = solve ( s - cur_c * i , c ) ;
if ( tmp [ 0 ] ) continue ;
tmp [ cur_c ] = i ;
if ( g ( tmp ) != s ) continue ;
int cur_val = f ( tmp ) ;
if ( ! best || cur_val < best )
{ result = tmp ; best = cur_val ; } } }
return result ; } } ;

int main ( )
{ int sum ;
std :: cin >> sum ;
std :: stack < int > stamps ;
stamps . push ( stamp_1 ) ;
stamps . push ( stamp_2 ) ;
stamps . push ( stamp_3 ) ;
std :: map < int , int > solution =
xyz :: solve ( sum , stamps ) ;
for
( std :: map < int , int > :: iterator i =
solution . begin ( ) ;
i != solution . end ( ) ; ++ i )
std :: cout << ( * i ) . first << " " <<
( * i ) . second << std :: endl ; }

--
roy axenov

Kai-Uwe Bux
Guest
Posts: n/a

 03-04-2007
untitled wrote:

> On Mar 4, 1:36 pm, "untitled" <(E-Mail Removed)> wrote:
>> On Mar 4, 5:35 am, (E-Mail Removed) wrote:
>>
>>
>>
>>
>>
>> > On Mar 3, 9:39 pm, "untitled" <(E-Mail Removed)> wrote:

>>
>> > > then its an easy one,

>>
>> > > x is the requested number

>>
>> > > int sevens=x/7 //without the fractures
>> > > remainder=x - (sevens*7)
>> > > int twos= remainder/2 //without the fractures
>> > > if (remainder - (twos*2)) =1 then twos++
>> > > if sevens != 0 && sevens<twos then twos=twos-sevens, nines= sevens,
>> > > sevens=0
>> > > if twos != 0 && twos<sevens then sevens=sevens-twos, nines= twos,
>> > > twos =0

>>
>> > > just put it in c code

>>
>> > 1 1int sevens=x/7 //without the
>> > fractures
>> > 2 remainder=x - (sevens*7)
>> > 3 int twos= remainder/2 //without the fractures
>> > 4 if (remainder - (twos*2)) =1 then twos++
>> > 5 if sevens != 0 && sevens<twos then twos=twos-sevens, nines= sevens,
>> > sevens=0
>> > 6 if twos != 0 && twos<sevens then sevens=sevens-twos, nines= twos,
>> > twos=0

>>
>> > I don't get it. Several things in fact.

>>
>> > First, I can't see what your program does. Since it doesn't have an
>> > output statement. But I will go on a tangent and guess that it is for
>> > comparing which ever way is the most effective way to distribute the
>> > stamps.

>>
>> > Second, why not just use x%7 for line 2?

>>
>> > Third, since you assigned that twos be reminder/2, then the act of
>> > mutiplying twos by 2 would result in the remainder from line2.
>> > Therefore, in line4, having remainder-remainder would result in 0.

>>
>> > Fourth, in line4, what do you mean by twos++?

>>
>> > Five, line 5 and 6 doesn't make much sense either.

>>
>> > Six, what is if final out put?

>>
>> > I really appreciate you trying to help, and I know that with the above
>> > list I sound like an ungrateful little brat. But I am grateful. I just

>>
>> > Davy

>>
>> you are right, it wasn't clear,
>>
>> first i'll explain how the program will think then i'll answer your
>> questions:
>>
>> first line will count how many 7cent stamp could be afforded with the
>> money required, of course there will be some extra cents we will
>> process it in line 2
>> line 2 will see how many extra cents you have after we got all the
>> sevens.
>> line 3 will check how many 2cent stamps can be afforded for that extra
>> cents
>> line 4 if the remainder was less than 2 cents (ie. 1 cent) then of
>> course we will consider it 2cent that is adding one cent over the
>> required money as you told me.
>> in line 5,6 we replace every 7cent and 2cent stamp to one 9cent stamp
>> so we got the most effective number of stamps.
>> line 5 if the 7c stamps was less than the 2c stamps, then combine all
>> the sevens with an equivilant number of 2c stamps and replace them
>> with 9c stamps. then delete the combined 7 and 2c stamps.
>> line 6 do the same if the twos was more than sevens.
>>
>> the out put will be
>> int sevens
>> int nines
>> int twos
>>
>> i'll write the code in few minutes.- Hide quoted text -
>>
>> - Show quoted text -

>
> ok here is the code, tell me if it workes, it works with me by the
> way:
>
> #include <cstdlib>
> #include <iostream>
>
> using namespace std;
>
> int main(int argc, char *argv[])
> {
> int twos=0;
> int sevens=0;
> int nines=0;
> int reqMoney=0;
> int remainderCents=0;
>
> cout<<"input required money"<<endl;
> cin>>reqMoney;
>
> sevens=reqMoney/7; //check how many sevens can be afforded
> remainderCents= reqMoney-(sevens*7); //check the extra cents you
> can use % but i prefer this i don't know why
> twos= remainderCents/2; //check how many twos can be afforded for
> the extra cents left
> if ( (remainderCents-(twos*2)) ==1) twos++; //add one cent above
> the reqmoney if the extra cents=1
> if ( (sevens != 0) && (sevens<twos))
> {
> twos=twos-sevens;
> nines=sevens;
> sevens=0;
> }
>
> if ( (twos != 0) && (sevens>twos))
> {
> sevens=sevens-twos;
> nines=twos;
> twos=0;
> }
> cout<<"twos="<<twos<<endl;
> cout<<"sevens="<<sevens<<endl;
> cout<<"nines="<<nines<<endl;
>
>
>
> system("PAUSE");
> return EXIT_SUCCESS;
> }

I just tried it. For 100 it tells me to use

100c = 13 x 7c + 1 x 9c

This is not optimal because

100c = 4 x 7c + 8 x 9c

is better.

Best

Kai-Uwe Bux

el3anchoke@gmail.com
Guest
Posts: n/a

 03-04-2007
This "program" is not written in c++, i'm a Java programmer , but you
will get the idea by just looking at the code.
didnt have time to comment it , the number of function can be
optimized to only one if you forward where you want the function to
start as a second varible

Hope it works for you .

//three function are used to calculate the lest number of stamps
needed

function int dvide_9 (int money)
{
int num = 0;
rest = moeny%9
num=num+(moeny/9)
if (rest = {

num=num+1
rest = 0;
}
rest = rest%7
num = num +(rest/7)
if (rest = 6) {

num=num+1
rest = 0;
}
rest = rest % 2
num = num + (rest/2)
if (rest = 1) {

num=num+1
rest = 0;
}

resturn num;
}

function int dvide_7 (int money)
{
int num = 0;

rest = money%7
num = num +(money/7)
if (rest = 6) {

num=num+1
rest = 0;
}
rest = rest % 2
num = num + (rest/2)
if (rest = 1) {

num=num+1
rest = 0;
}

resturn num;
}

function int dvide_2 (int money)
{
int num = 0;

rest = money % 2
num = num + (money/2)
if (rest = 1) {

num=num+1
rest = 0;
}

resturn num;
}

--------------------------------------------------
main program

choses the function with less number of (num value) which is the
number of stamps used.