## Emacs Characters 3

I never thought I would write three posts about entering characters in Emacs.

Emacs Characters demonstrates the quickest way to insert characters such as è and ä by using the C-x 8 key combination. So, for example:

C-x 8 ' e prints é
C-x 8 e prints è
C-x 8 ^ e prints ê
C-x 8 " u prints ü
C-x 8 / / prints ÷
C-x 8 C prints © copyright

Emacs Characters 2 shows how C-x 8 [return] allows you to type in the description of a character, so C-x 8 [return] LEFT ARROW gives ←

It’s time for another way. This post demonstrates toggle-input-method. Emacs has a number of input methods, used for entering such things as Arabic characters. You can see the full list using

 M-x list-input-methods 

Use C-\ to enable the input method. The first time you do this you’ll be prompted for a method. For the purposes of this post, enter TeX. If you don’t know TeX, this post gives you a flavour.

You can now enter characters using TeX. Here are some examples

\pir^2 → πr²
Z\"urich → Zürich
Caf\'e  → café

I used \rightarrow to get the → used above, by the way.

When you’re done using TeX, use C-\ to disable the current input method

That’s three different methods for entering text. Which one is best? For me, it’s whichever is the most convenient. If I want to type the acute accent in café I’d probably use C-x 8 ‘e. When I was writing my novel Dream Paris I used TeX input for typing in the French dialogue.

As this is the Emacs workout, why not think of the ways you could type the following in Emacs?

Einstein wrote E=mc² on the table whilst eating a rösti in a café in Zürich. As easy as πr², he thought.

If you get stuck

M-x describe-input-method 

will give a list of key sequences.

## Common Lisp Loops

I can’t think why you wouldn’t use the Common Lisp loop macro in Emacs. Don’t forget to (require ‘cl-lib)

### Simple Loops

;; keywords: to, upto, below, downto, above, by
;; keywords: collect, append, nconc, count, sum, maximize, minimize

(cl-loop
do (princ 1))
=> 111111... infinite loop

(cl-loop repeat 5
do (princ 1)
(princ 2))
=> 1212121212

(cl-loop for i from 1 below 10
maximize i)
=> 9

(cl-loop for x from 9 downto 1
collect x)
=> (9 8 7 6 5 4 3 2 1)

(cl-loop for i from 10 above 1 by 2
collect i)
=> (10 8 6 4 2)

### Looping over Sets and Arrays

;; keywords: in, on, across, by
;; Remember in for lists
;; across for vectors

(cl-loop for l in '(1 2 3 4 5)
do (princ l))
=> 12345

(cl-loop for l in '(1 2 3 4 5) by #'cddr
collect l)
=> (1 3 5)

(cl-loop for l on '(1 2 3 4 5)
collect l)
=> ((1 2 3 4 5) (2 3 4 5) (3 4 5) (4 5) (5))

(cl-loop for l on '(1 2 3 4 5) by #'cddr
collect l)
=> ((1 2 3 4 5) (3 4 5) (5))

;; Remember that a string is an array in lisp, so...
;; Add up the digits in 90125
(cl-loop for d across "90125"
sum (- d 48))
=> 17

### Destructuring

(cl-loop for (a nil) in '((1 2) (2 3) (3 4))
collect a)
=> (1 2 3)

(cl-loop for (a b) in '((1 2) (2 3) (3 4))
collect (* a b))
=> (2 6 12)

(cl-loop for (a b) on '(1 2 3 4 5) while b
collect (+ a b))
=> (3 5 7 9)

(cl-loop for (a b) on '(1 2 3 4 5) by #'cddr while b
collect (+ a b))
=> (3 7)

### Hashtables

(cl-loop for key being the hash-keys of myhashtable
using (hash-value value)
do (princ value))

### Parallel fors

(cl-loop for i from 1 to 5
for l in '(a b c d)
collect (list i l))
=> ((1 a) (2 b) (3 c) (4 d))

(cl-loop for i from 1 to 5
for j from 2 to 10 by 2
collect (* i j))
=> (2 8 18 32 50)

### Nested fors

(cl-loop for i from 1 to 5
collect (cl-loop for j from 1 to 5
collect (* i j)))
=> ((1 2 3 4 5) (2 4 6 8 10) (3 6 9 12 15) (4 8 12 16 20) (5 10 15 20 25))

(cl-loop for i from 1 to 5
append (cl-loop for j from 1 to 5
collect (* i j)))
=> (1 2 3 4 5 2 4 6 8 10 3 6 ...)

(cl-loop for i from 1 to 5
collect (cl-loop for j from 1 to 5
sum (* i j)))
=> (15 30 45 60 75)

(cl-loop for i from 1 to 5
sum (cl-loop for j from 1 to 5
sum (* i j)))
=> 225

### Selection

;; if, when, unless

(cl-loop for i from 1 to 20
unless (cl-evenp i) collect i)
=> (1 3 5 7 9 11 13 15 17 19)

(cl-loop for i from 1 to 20
when (= (% i 3) 0) collect i into fizz
when (= (% i 5) 0) collect i into buzz
finally return (list fizz buzz))
=> ((3 6 9 12 15 18) (5 10 15 20))

(cl-loop for i from 1 to 20
if (and (= (% i 3) 0) (= (% i 5) 0)) collect i into fizzbuzz
else if (= (% i 3) 0) collect i into fizz
else if (= (% i 5) 0) collect i into buzz
finally return (list fizz buzz fizzbuzz))
=> ((3 6 9 12 18) (5 10 20) (15))

(cl-loop for i from 1 to 10
if (cl-evenp i)
collect i into evens
and sum i into evensum
else
collect i into odds
and sum i into oddsum
finally return (list evens evensum odds oddsum))
=> ((2 4 6 8 10) 30 (1 3 5 7 9) 25)

Find c from comp where diff is never a member of squares
(cl-loop for c in comp
if  (cl-loop for p in pri
for diff = (/ (- c p) 2)
never (member diff squares))
collect c)

### Then Iteration

(cl-loop for i from 1 to 5
for square = (* i i)
collect square)

;; Though you'd be better with
(cl-loop for i from 1 to 5
collect (* i i))

;; However, this leads to Triangle Numbers
(cl-loop for n from 1 to 10
for triangle = 1 then (+ triangle n)
collect triangle)
=> (1 3 6 10 15 21 28 36 45 55)

(cl-loop for x = 0 then y
for y = 1 then (+ x y)
while (< y 30)
collect y)
=> (1 2 4 8 16)

;; Fibonacci Sequence (note the and)
(cl-loop for x = 0 then y
and y = 1 then (+ x y)
while (< y 30)
collect y)
=> (1 1 2 3 5 8 13 21)

### Termination

;; while, until, always, never, and thereis

while and until are straightforward

(cl-loop for n from 1
for tri = 1 then (+ tri n)
until (> (divs tri) 500)
finally return tri)

never, thereis and always are shorthand for a combination of when-return

(defun isprime(n)
(cond
((< n 2) nil)
((= n 2) t)
((cl-evenp n) nil)
(t
(cl-loop for i from 3 to (sqrt n) by 2
never (= (% n i) 0)))))

## Adventure Game 8: Making a Playable Game

Now we have a working game engine, we need to make the game more interesting.

We can do this in a number of ways.

1. Think of an interesting setting: in a castle, on a spaceship, in a school for witches and wizards…
2. What quest are we setting the player? To find the gold? Escape from the space station before it explodes? To find the spy?
4. What sort of objects could we use? Magic wands, rayguns, teleporters?
5. What sort of puzzles and riddles could we add?

## Exercise

1. Think of the setting for your game. What does the player have to do (what’s their quest?)
2. Draw a map for your game (see lesson 1 for an example) Don’t add too many locations – 16 is more then enough.
3. Think of the objects the player will have to use and add them to the map.
4. Make a note of the game play. What will the player have to do to complete the game.
5. Now modify the code of the game engine to write your own game.
6. Get your partner to play the game and feedback.
7. Make any improvements to the game.

## Adventure Game 7: Robust Code

We now have a working game, however the code isn’t very robust. Robust code continues to function when errors occur.

Here’s an example of the start of a game:

A clearing in a forest
spanner
lockpick
What now?use spoon
Traceback (most recent call last):
Main()
if (objects[noun]==99): # check holding object
KeyError: 'spoon'

Process finished with exit code 1

There are two problems here, one minor, one major.

The minor problem occurs when the user types use spade. Nothing happens as the user isn’t holding a spade, but the program doesn’t alert the user to that fact.

The major problem occurs when the user tries to use spoon. At that point the program throws an exception and terminates.

An exception is an error that occurs when the program is running and causes the program to terminate. In this case, the program is trying to look up an object that doesn’t exist. We need to handle this exception.

The following code deals with both the above problems.

elif verb == "use":
try:
if (objects[noun]==99): # check holding object
use_object(noun)
else:
print("I don't have a", noun)
except:
print("I don't know what a", noun, "is")

You will see try except in many pieces of python code. It’s the professional way to write robust code

Here’s the complete code. Copy and paste it into your IDE

places = ["A clearing in a forest", "An old wooden cabin", "A dark cave", "The top of a Hill", "Deep in the Forest", "An Underground Lake", "Caught in the Brambles"]
moves = [{"n": 1, "s": 2, "e":4},     {"s": 0, "e":3},       {"n": 0} ,     {"w": 1, "s":4},    {"n":3,"w":1, "e":6}, {"w": 2},             {"w": 4}]
location = 0

def print_objects():
for key, val in objects.items():
if val == location:
print(key)

def items():
print("You are carrying: ")
for key, val in objects.items():
if val == 99:
print(key)

def take_object(noun):
for key, val in objects.items():
if key == noun and val == location:
print("Got it!")
objects[noun] = 99

def drop_object(noun):
for key, val in objects.items():
if key ==noun and val == 99:
print("Dropped ", noun)
objects[noun] = location

def use_object(noun):
if noun == "spade" and location == 0:
objects["gold"] = 0 # create the gold
print("You dug up some gold!")
if noun == "spade" and location == 2:
moves[2] = {"n": 0, "e":5}
print("You've opened up a tunnel, leading east...")

def Main():
ans = ""
global location
print(places[0])
print_objects()

while ans != "bye":
ans = input("What now?")
words = ans.split()

# Check if it's a move
if len(words) == 1:
if ans == "items":
items()
elif ans == "look":
print(places[location])
print_objects()

elif ans in moves[location]:
location = moves[location].get(ans)
print(places[location])
print_objects()
else:
print("I can't move that way")
else:
verb = words[0] # e.g. Take or Drop
noun = words[1] # e.g. hammer or spanner

if verb == "take":
take_object(noun)

elif verb == "drop":
drop_object(noun)

elif verb == "use":
try:
if (objects[noun]==99): # check holding object
use_object(noun)
else:
print("I don't have a", noun)
except:
print("I don't know what a", noun, "is")

else:
print("I don't understand what you mean")

Main()

## Exercise

1. Copy the above code into your IDE and test it.
2. Run the code. What happens if you try to take the spade in the clearing in the forest?
3. Is the behaviour of the code here an error or an exception?
4. Fix the code.
5. What errors can occur when a user tries to drop an object? Fix those errors.
6. What other errors can you find in the code?
7. Are there any other exceptions you can find in the code?

## Adventure Game 6: Using Objects

We’ve set up the basics of the game, but it’s not much fun. All you can do is wander round picking up and dropping objects. We need to allow the user to use the objects. We’re going to add two ways of using objects.

• If the player uses the spade in the clearing in the forest they will dig up gold.
• If the player uses the spade in the cave they will open a path to an underground lake.

Note that I’ve added new locations to the map, the same ones we added in Exercise 1

places = ["A clearing in a forest", "An old wooden cabin", "A dark cave", "The top of a Hill", "Deep in the Forest", "An Underground Lake", "Caught in the Brambles"]
moves = [{"n": 1, "s": 2, "e":4},     {"s": 0, "e":3},       {"n": 0} ,     {"w": 1, "s":4},    {"n":3,"w":1, "e":6}, {"w": 2},             {"w": 4}]
location = 0

def print_objects():
for key, val in objects.items():
if val == location:
print(key)

def items():
print("You are carrying: ")
for key, val in objects.items():
if val == 99:
print(key)

def take_object(noun):
for key, val in objects.items():
if key == noun and val == location:
print("Got it!")
objects[noun] = 99

def drop_object(noun):
for key, val in objects.items():
if key ==noun and val == 99:
print("Dropped ", noun)
objects[noun] = location

def use_object(noun):
if noun == "spade" and location == 0:
objects["gold"] = 0 # create the gold
print("You dug up some gold!")
if noun == "spade" and location == 2:
moves[2] = {"n": 0, "e":5}
print("You've opened up a tunnel, leading east...")

def Main():
ans = ""
global location
print(places[0])
print_objects()

while ans != "bye":
ans = input("What now?")
words = ans.split()

# Check if it's a move
if len(words) == 1:
if ans == "items":
items()
elif ans == "look":
print(places[location])
print_objects()

elif ans in moves[location]:
location = moves[location].get(ans)
print(places[location])
print_objects()
else:
print("I can't move that way")
else:
verb = words[0] # e.g. Take or Drop
noun = words[1] # e.g. hammer or spanner

if verb == "take":
take_object(noun)

elif verb == "drop":
drop_object(noun)

elif verb == "use":
if (objects[noun]==99): # check holding object
use_object(noun)

else:
print("I don't understand what you mean")

Main()

## Exercise

1. Copy the code into your IDE. Move around the map to see the new locations
2. Find the spade and use it to dig up gold in the forest
3. Now dig in the cave and check to see the path to the lake opens up.
4. Look at the function use_object(noun). What’s the purpose of the statement objects["gold"] = 0
5. Look at the moves list (line 2). What has been added to the first dictionary in the list?
6. Look at moves[2] (remember, this is the third item in the list). At the moment this is {“n”: 0}. What does that mean?
7. Look at the function use_object(noun). What is the purpose of the line moves[2] = {"n": 0, "e":5} (hint, this is only called if the noun is a spade)
8. Add the following objects to the map: telescope in the wooden cabin, cutters deep in the forest.
9. Add code so if the user uses the telescope on top of the hill they see a message written on a sign saying “There is treasure in the forest”
10. Add code so if the user uses the cutters when caught in the brambles, treasure appears.

We’re going to add two new commands, Look and Items

• Look will show your current location and objects
• Items will show the items you’re currently carrying
places = ["A clearing in a forest", "An old wooden cabin", "A dark cave"]
moves = [{"n": 1, "s": 2},           {"s": 0},              {"n": 0}]
location = 0

def print_objects():
for key, val in objects.items():
if val == location:
print(key)

def items():
print("You are carrying: ")
for key, val in objects.items():
if val == 99:
print(key)

def take_object(noun):
for key, val in objects.items():
if key == noun and val == location:
print("Got it!")
objects[noun] = 99

def drop_object(noun):
for key, val in objects.items():
if key ==noun and val == 99:
print("Dropped ", noun)
objects[noun] = location

def Main():
ans = ""
global location
print(places[0])
print_objects()

while ans != "bye":
ans = input("What now?")
words = ans.split()

# Check if it's a one word input
if len(words) == 1:
if ans == "items":
items()
elif ans == "look":
print(places[location])
print_objects()
elif ans in moves[location]:
location = moves[location].get(ans)
print(places[location])
print_objects()
else:
print("I can't move that way")
else:
verb = words[0] # e.g. Take or Drop
noun = words[1] # e.g. hammer or spanner

if verb == "take":
take_object(noun)

elif verb == "drop":
drop_object(noun)

else:
print("I don't understand what you mean")

Main()

## Exercise

1. Look at the Main() function. Why is location a global variable?
2. List the one word commands that are permitted in this program
3. What does the printobjects() function do?
4. Look at the items() function. Why does it only print items where val =99?

You’re going to add a help function. If the user enters “help” the program will print the following instructions: “Type n,s,e,w to move north, south, east and west.”

1. Add an elif statment under the elif ans == “look”: statement to check if the user has entered “help”
2. Add code to print the help instructions

## Adventure Game 4: Structured Programming

The program is becoming very complicated. We need to apply structured programming techniques to make it easier to follow. According to the specification this means:

“Using modularised programming, clear, well documented interfaces (local variables, parameters) and return values.”

Copy the following code into your IDE

places = ["A clearing in a forest", "An old wooden cabin", "A dark cave"]
moves = [{"n": 1, "s": 2},           {"s": 0},              {"n": 0}]
location = 0

def print_objects():
for key, val in objects.items():
if val == location:
print(key)

def take_object(noun):
for key, val in objects.items():
if key == noun and val == location:
print("Got it!")
objects[noun] = 99

def drop_object(noun):
for key, val in objects.items():
if key ==noun and val == 99:
print("Dropped ", noun)
objects[noun] = location

def Main():
ans = ""
global location
print(places[0])
print_objects()

while ans != "bye":
ans = input("What now?")
words = ans.split()

# Check if it's a move
if len(words) == 1:
if ans in moves[location]:
location = moves[location].get(ans)
print(places[location])
print_objects()
else:
print("I can't move that way")
else:
verb = words[0] # e.g. Take or Drop
noun = words[1] # e.g. hammer or spanner

if verb == "take":
take_object(noun)

elif verb == "drop":
drop_object(noun)

else:
print("I don't understand what you mean")

Main()


## Exercise

1. Copy the code into an IDE and run it. Check that it works
2. Give an example of a local variable in the code.
3. Give an example of a global variable.
4. Give an example of a parameter.
5. How many functions have parameters passed to them?
6. What are the advantages of the modular approach?
7. Add a function eat_object(noun). The function will print “I can’t eat” + noun.
8. Add code to the Main method to call the eat_object() function

## Adventure Game 3: Take and Drop Objects

We added objects to the game in the last lesson. Now we’re going to add code to allow the user to take and drop objects

Copy and paste the following code into your IDE

places = ["A clearing in a forest", "An old wooden cabin", "A dark cave"]
moves = [{"n": 1, "s": 2},           {"s": 0},              {"n": 0}]
location = 0

def print_objects():
for key, val in objects.items():
if val == location:
print(key)

def Main():
ans = ""
global location
print(places[0])
print_objects()

while ans != "bye":
ans = input("What now?")
words = ans.split()

# Check if it's a move
if len(words) == 1:
if ans in moves[location]:
location = moves[location].get(ans)
print(places[location])
print_objects()
else:
print("I can't move that way")
else:
verb = words[0] # e.g. Take or Drop
noun = words[1] # e.g. hammer or spanner
if verb == "take":
for key, val in objects.items():
if key == noun and val == location:
print("Got it!")
objects[noun] = 99
if verb == "drop":
for key, val in objects.items():
if key ==noun and val == 99:
print("Dropped ", noun)
objects[noun] = location

Main()

## Exercise

1. Run the game. Take the spanner and drop it in the cave. Check that everything is working correctly.
2. Add a spoon to the list of objects. Place the spoon in the cave. Check that you can Take it and Drop it.
3. What happens if you enter “take elephant?”
4. Look at the line words = ans.split() in the Main() function. What does it do? (try experimenting with the code in IDLE if you’re unsure)
5. Look at the if statement in the Main() function: if len(words) == 1: Why was that code included?
6. Look at the statement if verb == "take": What do key and val mean in the for loop?
7. What is the purpose of the for loop?
8. What is the purpose of the line 'objects[noun] == 99'
9. Look at the if verb = "drop" statement. Why does the for loop check if key = noun and val == 99?

Now we have the locations sorted, we need to add objects to the game. These will be things such as keys and chests. Later on we’ll add code so that the player can use these objects

Note how I’m only using 3 locations while I write this game. It’s always a good idea to keep things simple. Get the mechanics of the game working first, and then expand it.

Copy and paste the code below into your IDE.

places = ["A clearing in a forest", "An old wooden cabin", "A dark cave"]
moves = [{"n": 1, "s": 2},           {"s": 0},              {"n": 0}]
location = 0

def print_objects():
for key, val in objects.items():
if val == location:
print(key)

def Main():
ans = ""
global location
print(places[0])
print_objects()

while ans != "bye":
ans = input("What now?")
if ans in moves[location]:
location = moves[location].get(ans)
print(places[location])
print_objects()
else:
print("I can't move that way")

Main()

## Exercise

1. Look at the objects dictionary objects = {“spanner”:0, “lockpick”:0, “spade”:2}. What do the keys in the dictionary represent? (hint: the key is the part before the colon:)
2. What do the values in the dictionary represent?
3. Add “rope” to the list of objects. Place it in the cave.
4. Add “torch” to the list of objects. Place it in the cabin.
5. Run the code and check the objects are where you think they should be.
6. Look at the print_objects() function. Explain how it works

### Extension

1. Draw your own map for a game. Implement it. Modify the code so that you are using your map.
3. Add code so that if the user types “l” (for look) the game prints out the current location and a list of objects.

## Coin Change Problem

Famously (or at least famously in maths puzzle circles) there are 293 ways to make a US dollar using the following coins:

Penny (1 cent) | Nickel (5 cents) | Dime (10 cents) | Quarter (25 cents) | Half Dollar (50 cents) | Dollar (100 cents)

You could make a dollar with, for example, 4 quarters or 10 dimes.

How many ways are there of making a Brtish pound?

At the time of writing GB currency has the following coins

1p, 2p, 5p, 10p, 20p, 50p and £1 or 100p.

It’s usually a good idea to start problems like this by looking at simpler cases.

If we only have 1p coins, the answer is easy. There’s only 1 way to make any value: 1p = 1, 2p = 1 + 1, 3p = 1 + 1 + 1 etc

How about if we have 1p and 2p coins?

ValuePossibleWays
1p1p1
2p2 x 1p, 2p2
3p3 x 1p, 2p + 1p2
4p4 x 1p, 2p + 2p, 2p + 1p + 1p3
5p5 x 1p, 2 x 2p +1p, 2p + 3 x 1p3

Extend the table and you quickly see a pattern

ValueWays
1p1
2p2
3p2
4p3
5p3
6p4
7p4
8p5
9p5
10p6

We could write the following python code to work out the number of ways of making values with only 1 or 2p coins:

def coin12(n):     if n%2 == 0:         return int(n/2 +1)     else:         return int((n + 1)/2)

What about if we have 1p, 2p and 5p coins?

It turns out we can use our previous function to help us work this out.

For example, we could make 8p entirely of 2s and 1s. But this is just coin12(8) ways using the above function

We could make 8p using a 5p coin and 3p made of 2s and 1s: this is coin12(3) ways

This lets us write out the following table.

ValuePossibleWays
1pcoin12(1)1
2pcoin12(2)2
3pcoin12(3)2
4pcoin12(4)3
5p5p, coin12(5)4
6p5p + 1p, coin12(6)5
7p5p + coin12(2), coin12(7)6
8p5p + coin12(3), coin12(8)7
9p5p + coin12(4), coin12(9)8
10p5p + 5p, 5p + coin12(5), coin12(10)10

We can use this to help us write a new function

def coin125(n):     total =0     while n >= 5:         total += coin12(n)         n -= 5     return total + coin12(n)

When the function is tested, the results match the table above.

for i in range (1,11):     print(i ,": " ,coin125(i))

Now we can look at using the 1p, 2p, 5p and 10p coins. Our coin125 function suggests a way this can be done:

def coin12510(n):     total =0     while n >= 10:         total += coin125(n)         n -= 10     return total + coin125(n)

Similarly we could make functions for coins up to 20p, 50p and 100p

I’ve missed out some of the steps below, but working through all the coins I finished up with the following function:

 def coin125102050100(n):     total =0     while n >= 100:         total += coin125102050(n)         n -= 100     return total + coin125102050(n) print(coin125102050100(100))

Which gave me the correct answer: 4563. In other words, there are 4,563 ways to make £1 using 1p, 2p, 5p, 10p, 20p, 50p and £1 coins.

However.

This isn’t very elegant. Looking at the code we can see we’re doing the same thing over and over again. Also, what if we had a currency that used 100 coins? Or 1000? It would take a lot of copying and pasting to work those problems out.

There has to be a better way.

Let’s look at the functions again. It’s easy to spot a pattern to them. Using pseudocode, they can be written out something like this:

define coinVALUES(n): total =0 while n >= VALUE:     total += coinVALUES-1(n)     n -= VALUE end while return total + coinVALUES-1(n) end define

Here’s a first attempt at writing the above in Python

values = [100, 50, 20, 10, 5, 2, 1] def coin(n, val):     total = 0     while n> values[val]:         total += coin(n, val+1)         n -= values[val]     return total + coin(n, val+1)

You might notice I’ve written a recursive function, but there’s a problem. There’s no escape clause, there’s nothing to stop the function calling itself forever.

That’s quite easy to fix though

All we have to do is realise that coin1(n) = 1. If you want to make 5p using only 1p coins, there’s only one way to do it: 1p + 1p + 1p + 1p + 1p.

We can use that to add a clause to make a proper recursive function.
It also sorts out an irritating niggle: why should coin12 be different to all the other coin functions?

values = [100, 50, 20, 10, 5, 2, 1] def coin(n, val):     if values[val] == 1:         return 1     total = 0     while n>= values[val]:         total += coin(n, val+1)         n -= values[val]     return total + coin(n, val+1) print(coin(100,0))

This works but it’s a little bit messy. I have to call the function with an extra argument, 0, telling it to start at the beginning of the values list.

It would be better to treat coin as a “helper” function and to write another function to call it. This would make the function a lot more user friendly.

I’ve wrapped the coin function in a one called makechange. To show the flexibility of my function, I’ve used makechange to work out how many ways there are to make change from a dollar.

 values = [100, 50, 25, 10, 5, 1] def coin(n, val):     if values[val] == 1:         return 1     total = 0     while n>= values[val]:         total += coin(n, val+1)         n -= values[val]     return total + coin(n, val+1) def makechange(n):     return coin(n,0) print(makechange(100))`