## 5 Methods for Problem Solving

When developing new software algorithms, a systematic approach helps. When confronted with a software problem use the five methods below to come up with an algorithm to solve the problem.

#### Examplify

Write out specific examples of the problem and see if you can derive a general rule from
there.

#### Pattern Matching

Consider what problems the algorithm is similar to and try to modify the solution to the
related problem to develop an algorithm for this problem.

#### Simplify and Generalize

This has a multi-step approach. First, we change a constraint such as the data type or
amount of data. Doing this helps simplify the problem. Then we solve this new simplified
version.

#### Base Case and Build

We solve the problem first for the base case: n=1. This usually just means recording the
correct result. Then we try to solve the problem for n=2, assuming you have the answer for
n=1. Next try for n=3 and then for n=4. Eventually we can build a solution that can solve the
result for N if we know the correct result for N-1. This often leads to a naturally recursive
algorithm.

#### Data Structure and Brainstorm

This is a hacky approach but often works. We can simply run through a list of data
structures and try to apply each one. This approach is useful because solving a problem
may be trivial once it occurs to us to use, say, a binary search tree.
2

#### Algorithm Implementation Notes

Implement primitive data structures first such as Node or Record, then the data
structures that use them, such as List or HashTable. Implement the insert function first, then search, remove, size, print, etc. For recursive functions, implement a shell insert function that then calls a private
recursive helper function: “def insert” (public) then “def __insert” (private). The basic template for recursive functions is to do a basic “null” check on input data
and then call a recursive helper function. When implementing if/elif/else statements, handle the simplest case first: node is
None, then edge cases. Be consistent in how you develop a solution. Write unit tests as you implement each function, that way you catch bugs as you are
developing and not all at the end.