Skip to content

Latest commit

 

History

History
156 lines (93 loc) · 4.34 KB

factorial.md

File metadata and controls

156 lines (93 loc) · 4.34 KB
Raw

A simple solution to finding the factorial of a number

Whatever it is that you are trying to do, think of it as a function and give it a sensible name:
factorial

factorial is a pretty sensible name for a function that returns the factorial of a number.

Work out the inputs to the function and give them sensible names:
n

In general, descriptive names are better, but in the case of an integer, certain letters like i, j, k and n are so universally used to denote integers as to be quite descriptive enough. In this case, it should be clear that factorial takes a single whole number.

Write out the first line of the function definition, including the arguments:
def factorial(n):
    pass

The pass operation does nothing, but ensures that your code will run without errors (even if it gives the wrong answer).

Add a test using the most simple argument values that you can think of

print factorial(0) == 1

There are many ways to do testing in Python. This is a good start.

Add a return value for your function using the value that your test is expecting:
def factorial(n):
    return 1

print factorial(0) == 1

Run your test and check that it passes.

True
Think of a sensible name for your return value, add a variable with that name at the top of your function, assign to it your return value and return the variable instead of the value:
def factorial(n):
    total = 1
    return total

print factorial(0) == 1

Assuming that we know that a factorial produces the product of a number and all the positive integers that precede it, then total is not a bad name for the return value. product might be a reasonable choice, too.

Run your test again and check that it passes:
True
Add another test using the next most simple argument values that you can think of:
print factorial(1) == 1

If necessary, extend your function definition, so that both your tests pass.

def factorial(n):
    total = 1
    return total

print factorial(0) == 1
print factorial(1) == 1
In this case, it is not necessary to add any code:
True
True
Add another test using the next most simple argument values that you can think of.
print factorial(2) == 2
Extend your function definition, so that all your tests pass:
def factorial(n):
    total = 1
    if n > 1:
        total = n
    return total

print factorial(1) == 1
print factorial(1) == 1
print factorial(2) == 2

There are other ways to attack this problem, and this is not yet a good general solution, but the tests will pass.

Add yet another test using the next most simple argument values that you can think of:
print factorial(3) == 6
Extend your function definition, so that all your tests pass

This is one possible approach:

def factorial(n):
    total = 1
    if n > 1:
        total = n
    if n > 2:
        total = n * n - 1
    return total

print factorial(1) == 1
print factorial(1) == 1
print factorial(2) == 2
print factorial(3) == 6

But, at this point (and quite possibly earlier) anyone who is familiar enough with while loops will see that this approach is not going to generalise very well and will probably suspect that there is a better way to do it.

Like this:
def factorial(n):
    total = 1
    while n > 1:
        total = total * n
        n = n - 1
    return total

print factorial(1) == 1
print factorial(1) == 1
print factorial(2) == 2
print factorial(3) == 6

This, in fact, is a perfectly reasonable answer. All the tests will pass.

And further tests will confirm that this is a good general solution.

Now, there is no easy way to make the cognitive leap required to recognise that this solution requires a looping structure of the kind illustrated, but the purpose of this slow and deliberate approach is to get to the point where you have a suitable framework in which to think about possible solutions.

At least if you can get to the point where you have the skeleton of a solution and some passing tests, you can concentrate on working out the core of a problem without the baggage of an ill-defined function with misconceived arguments and spurious return values.