1

PROGRAMMING IN HASKELL
Chapter 11 - The Countdown Problem
2
What Is Countdown?
!
A popular quiz programme on British television
that has been running since 1982.
!
Based upon an original French version called
"Des Chiffres et Des Lettres".
!
Includes a numbers game that we shall refer to
as the countdown problem.
3
Example
1 3 7 10 25 50
Using the numbers
and the arithmetic operators
765
+ - ! %
construct an expression whose value is
4
Rules
!
All the numbers, including intermediate results,
must be positive naturals (1,2,3,).
!
Each of the source numbers can be used at
most once when constructing the expression.
!
We abstract from other rules that are adopted
on television for pragmatic reasons.
5
For our example, one possible solution is
!
There are 780 solutions for this example.
!
Changing the target number to gives
an example that has no solutions.
Notes:
831
(25-10) ! (50+1) 765
=
6
Evaluating Expressions
Operators:
data Op = Add | Sub | Mul | Div
Apply an operator:
apply :: Op $ Int $ Int $ Int
apply Add x y = x + y
apply Sub x y = x - y
apply Mul x y = x * y
apply Div x y = x `div` y
7
Decide if the result of applying an operator to two
positive natural numbers is another such:
valid :: Op $ Int $ Int $ Bool
valid Add _ _ = True
valid Sub x y = x > y
valid Mul _ _ = True
valid Div x y = x `mod` y == 0
Expressions:
data Expr = Val Int | App Op Expr Expr
8
eval :: Expr $ [Int]
eval (Val n) = [n | n > 0]
eval (App o l r) = [apply o x y | x # eval l
, y # eval r
, valid o x y]
Return the overall value of an expression, provided
that it is a positive natural number:
Either succeeds and returns a singleton
list, or fails and returns the empty list.
9
Formalising The Problem
Return a list of all possible ways of choosing zero
or more elements from a list:
choices :: [a] $ [[a]]
For example:
> choices [1,2]
[[],[1],[2],[1,2],[2,1]]
10
Return a list of all the values in an expression:
values :: Expr $ [Int]
values (Val n) = [n]
values (App _ l r) = values l ++ values r
Decide if an expression is a solution for a given list
of source numbers and a target number:
solution :: Expr $ [Int] $ Int $ Bool
solution e ns n = elem (values e) (choices ns)
&& eval e == [n]
11
Brute Force Solution
Return a list of all possible ways of splitting a list
into two non-empty parts:
split :: [a] $ [([a],[a])]
For example:
> split [1,2,3,4]
[([1],[2,3,4]),([1,2],[3,4]),([1,2,3],[4])]
12
Return a list of all possible expressions whose values
are precisely a given list of numbers:
exprs :: [Int] $ [Expr]
exprs [] = []
exprs [n] = [Val n]
exprs ns = [e | (ls,rs) # split ns
, l # exprs ls
, r # exprs rs
, e # combine l r]
The key function in this lecture.
13
combine :: Expr $ Expr $ [Expr]
combine l r =
[App o l r | o # [Add,Sub,Mul,Div]]
Combine two expressions using each operator:
solutions :: [Int] $ Int $ [Expr]
solutions ns n = [e | ns' # choices ns
, e # exprs ns'
, eval e == [n]]
Return a list of all possible expressions that solve an
instance of the countdown problem:
14
How Fast Is It?
System:
Compiler:
Example:
One solution:
All solutions:
solutions [1,3,7,10,25,50] 765
1.2GHz Pentium M laptop
GHC version 6.4.1
0.36 seconds
43.98 seconds
15
!
Many of the expressions that are considered
will typically be invalid - fail to evaluate.
!
For our example, only around 5 million of the
33 million possible expressions are valid.
!
Combining generation with evaluation would
allow earlier rejection of invalid expressions.
Can We Do Better?
16
results :: [Int] $ [Result]
results ns = [(e,n) | e # exprs ns
, n # eval e]
type Result = (Expr,Int)
Valid expressions and their values:
We seek to define a function that fuses together
the generation and evaluation of expressions:
Fusing Two Functions
17
results [] = []
results [n] = [(Val n,n) | n > 0]
results ns =
[res | (ls,rs) # split ns
, lx # results ls
, ry # results rs
, res # combine' lx ry]
This behaviour is achieved by defining
combine' :: Result $ Result $ [Result]
where
18
solutions' :: [Int] $ Int $ [Expr]
solutions' ns n =
[e | ns' # choices ns
, (e,m) # results ns'
, m == n]
New function that solves countdown problems:
combine (l,x) (r,y) =
[(App o l r, apply o x y)
| o # [Add,Sub,Mul,Div]
, valid o x y]
Combining results:
19
How Fast Is It Now?
Example:
One solution:
All solutions:
solutions' [1,3,7,10,25,50] 765
0.04 seconds
3.47 seconds
Around 10
times faster in
both cases.
20
!
Many expressions will be essentially the same
using simple arithmetic properties, such as:
!
Exploiting such properties would considerably
reduce the search and solution spaces.
Can We Do Better?
x ! y y ! x
x ! 1 x
=
=
21
Exploiting Properties
Strengthening the valid predicate to take account
of commutativity and identity properties:
valid :: Op $ Int $ Int $ Bool
valid Add x y = True
valid Sub x y = x > y
valid Mul x y = True
valid Div x y = x `mod` y == 0
x "
y
x " y && x &
1
x " y && x & 1 && y &
1
x "
y
&& y &
1
22
How Fast Is It Now?
Example:
Valid:
Solutions:
solutions'' [1,3,7,10,25,50] 765
250,000 expressions
49 expressions
Around 20
times less.
Around 16
times less.
23
One solution:
All solutions:
0.02 seconds
0.44 seconds
Around 2
times faster.
Around 7
times faster.
More generally, our program usually produces a
solution to problems from the television show in
an instant, and all solutions in under a second.