Question

This morning, I was reading Steve Yegge’s: When Polymorphism Fails, when I came across a question that a co-worker of his used to ask potential employees when they came for their interview at Amazon.

As an example of polymorphism in action, let’s look at the classic ‘eval’ interview question, which (as far as I know) was brought to Amazon by Ron Braunstein. The question is quite a rich one, as it manages to probe a wide variety of important skills: OOP design, recursion, binary trees, polymorphism and runtime typing, general coding skills, and (if you want to make it extra hard) parsing theory.

At some point, the candidate hopefully realizes that you can represent an arithmetic expression as a binary tree, assuming you’re only using binary operators such as ‘+’, ‘-‘, ‘*’, ‘/’. The leaf nodes are all numbers, and the internal nodes are all operators. Evaluating the expression means walking the tree. If the candidate doesn’t realize this, you can gently lead them to it, or if necessary, just tell them.

Even if you tell them, it’s still an interesting problem.

The first half of the question, which some people (whose names I will protect to my dying breath, but their initials are Willie Lewis) feel is a Job Requirement If You Want To Call Yourself A Developer And Work At Amazon, is actually kinda hard. The question is: how do you go from an arithmetic expression (e.g. in a string) such as ‘2 + (2)’ to an expression tree. We may have an ADJ challenge on this question at some point.

The second half is: let’s say this is a 2-person project, and your partner, who we’ll call ‘Willie’, is responsible for transforming the string expression into a tree. You get the easy part: you need to decide what classes Willie is to construct the tree with. You can do it in any language, but make sure you pick one, or Willie will hand you assembly language. If he’s feeling ornery, it will be for a processor that is no longer manufactured in production.

You’d be amazed at how many candidates boff this one.

I won’t give away the answer, but a Standard Bad Solution involves the use of a switch or case statment (or just good old-fashioned cascaded-ifs). A Slightly Better Solution involves using a table of function pointers, and the Probably Best Solution involves using polymorphism. I encourage you to work through it sometime. Fun stuff!

So, let’s try to tackle the problem all three ways. How do you go from an arithmetic expression (e.g. in a string) such as ‘2 + (2)’ to an expression tree using cascaded-if’s, a table of function pointers, and/or polymorphism?

Feel free to tackle one, two, or all three.

[update: title modified to better match what most of the answers have been.]

Answer 1

Polymorphic Tree Walking, Python version

#!/usr/bin/python  class Node:     '''base class, you should not process one of these'''     def process(self):         raise('you should not be processing a node')  class BinaryNode(Node):     '''base class for binary nodes'''     def __init__(self, _left, _right):         self.left = _left         self.right = _right     def process(self):         raise('you should not be processing a binarynode')  class Plus(BinaryNode):     def process(self):         return self.left.process() + self.right.process()  class Minus(BinaryNode):     def process(self):         return self.left.process() - self.right.process()  class Mul(BinaryNode):     def process(self):         return self.left.process() * self.right.process()  class Div(BinaryNode):     def process(self):         return self.left.process() / self.right.process()  class Num(Node):     def __init__(self, _value):         self.value = _value     def process(self):         return self.value  def demo(n):     print n.process()  demo(Num(2))                                       # 2 demo(Plus(Num(2),Num(5)))                          # 2 + 3 demo(Plus(Mul(Num(2),Num(3)),Div(Num(10),Num(5)))) # (2 * 3) + (10 / 2) 

The tests are just building up the binary trees by using constructors.

program structure:

abstract base class: Node

• all Nodes inherit from this class

abstract base class: BinaryNode

• all binary operators inherit from this class
• process method does the work of evaluting the expression and returning the result

binary operator classes: Plus,Minus,Mul,Div

• two child nodes, one each for left side and right side subexpressions

number class: Num

• holds a leaf-node numeric value, e.g. 17 or 42