How to use lists - list

Question

I have never programmed before and I am trying to do an assignment.
I have to construct a change machine, that will give change to 1 euro, given an input, e.g input = 70, change = 30. The machine wants to give as few coins as possible among the coins with values 50, 20, 10, 5, 2 and 1 cent. So if the input is 65, the machine will give: 20 10 5.
The computation is run in a while-Loop, that runs until the remaining change needed is 0. In each loop body, I have to determine the largest coin still fitting in the remaining change needed. All the coins should be added to a list. Finally, the contents of that list should be displayed to the user.
So, I created the button to start the computation and the code should look like and I called my input money.
to compute-change
Create empty list
while [ remaining change > 0] [
Determine largest coin c, such that remaining change - c >= 0
Update the list with the chosen coin
Update the remaining change to be determined
]
end
So, I know how to create an empty list, i.e. [], and I know what the change is gonna be: 100-money; I also think I understood what the while means, however, even by following the skeleton of the report I don't know how to go on.
Can you help me?

Answer 1

Edit: How can I do this in NetLogo?
I downloaded and installed Netlogo and had a look at how the language works. I created a solution that you can use as base for your development (don't worry, I will explain it):
globals [
remaining_change
biggest_coin
possible_coins
returned_coins
]
to compute_change
set remaining_change 57
set returned_coins []
set possible_coins [1 2 5 10 20 50]
while [ remaining_change > 0 ] [
foreach possible_coins
[
if( remaining_change - ? >= 0 )
[
set biggest_coin ?
]
]
;Print next result
print "Return a coin of value: "
print biggest_coin
print "Remaining change: "
print remaining_change
;Append coins to list
set remaining_change remaining_change - biggest_coin
set returned_coins lput biggest_coin returned_coins
]
print returned_coins
end
How does it work?
Let us begin with the first block:
globals [
remaining_change
biggest_coin
possible_coins
returned_coins
]
At this point, I create a few variables I use for data storage:
remaining_change is the amount of change that needs to be returned.
biggest_coin is the value of the coin that will be returned next (the biggest possible value)
possible_coins is a list of all coins-sizes available
returned_coins is a list of all returned coins.
So, with these variables we can now start initializing them:
set remaining_change 57 we use an amount of 57 cents to return as example
set returned_coins [] initialize returned_coins with an empty list (nothing is yet returned)
set possible_coins [1 2 5 10 20 50] this is a list of our types of coins. The ascending order is important as we will see later.
Lets do stuff!
We start of with a while loop around the computation, that will keep returning coins, untilthere is no more change left to return.
while [ remaining_change > 0 ] [
]
After that, we need to determine which coin would be next to return to the user. We doo that by examining every possible coin with a foreach loop.
Basically, what we do next translates to:
"Let us look at this coin. Is it less or equal than what we need to
return? Yes? Then this is currently the biggest coin to give back. But
what about the next biggest coin?
Speaking in code, that looks like this:
foreach possible_coins
[
if( remaining_change - ? >= 0 )
[
set biggest_coin ?
]
]
do not let yourself get confused by the ?. It is just Netlogos way of saying "This is the currently examined item in your foreach loop" - so it is your current coin-value.
Let us tell the user what is going on!
This is not necessary for your computation, but nice for understanding whats going on. Its simply some output of what we calculated for the user to see.
;Print next result
print "Return a coin of value: "
print biggest_coin
print "Remaining change: "
print remaining_change
Finally, return the coin!
It is now time to return the next coin:
set remaining_change remaining_change - biggest_coin first, decrease our left amount of change by the value of our biggest coin.
set returned_coins lput biggest_coin returned_coins after that, append our value to the resulting list.
And there you go!
You have successfully computed a list of coins, that you can simply print returned_coins.
I am by no means an expert on NetLogo, but I tried this code and it works just fine. There are other ways of doing this, some probably simpler, but this code will provide you with a good starting point.
Base answer:
You basically need to understand the following concepts:
conditionals
Example in pseudo code:
if( remainingChange >= 50 )
{
output.append(new FiftyCentCoin());
remainingChange -= 50;
}
else
{
...
}
What happens here?
The if statement (or a slight variation, depending on your language) - also known as conditional - evaluates a boolean expression. Based on the result (true or false) it can execute a block of statements, basically using this algorithm:
if (*this is true*)
*do this*
else
*do that*
The example compares the amount of change to be returned with the value 50 (your biggest coin). If you need to return this amount of money or more, 50 cents will be subtracted from the leftover Change and a new FiftyCentCoin is appended to your output.
looping
Example in pseudo code:
while ( remainingChange > 0 )
{
returnACoin();
}
What happens here?
The while statement is a variation of a conditional, that will evaluate an expression, and repeat a block of code, as long as the expression holds true - using this algorithm:
while(*this is true*)
*do this*
The given example performs the action returnACoin again and again, until the amount of remainingChange is 0.
Using these basic blocks you can create your algorithm:
Be aware, that I have given you just a short introduction, and you should still read through multiple tutorials to get to know your language and its syntax.
In the following you can find some pseudo code (as you did not tell what language you are using) that you can use as rough guideline for your development:
price = 1.33 //1.33€ as example
sumPaid = 2 //amount of money the user paid
changeToReturn = sumPaid - price
changeCoins = []
while( changeToReturn > 0 )
{
if( changeToReturn >= 50 )
{
changeCoins[] = 50
changeToReturn -= 50
}
else if( changeToReturn >= 20 )
{
changeCoins[] = 20
changeToReturn -= 20
}
...
}