lunchtime algorithms

Session One, 19 April 2016

what's an algorithm?

A list of steps for a computer to solve a given problem

There are many kinds of algorithms

Take the following problem:

Given a list of numbers, find the pair of numbers that, when multiplied together, return the largest product

the naïve algorithm

Text

numbers = [2, 5, 1, 10, 12]

result = 0

for i in range(0, n):
    for j in range(i+1, n):
        if a[i]*a[j] > result:
            result = a[i]*a[j]


# 2*5 > 0   => result = 10
# 2*1 > 10  => result = 10
# 2*10 > 10 => result = 20
# and so on...

drawbacks

extremely slow! Why?
- for an array of size 5, involves 25 calculations
- won't scale
- very memory-intensive
- duplication of effort: 5 * 2 and 2 * 5
- redundant -- continues crunching even when the largest number has been found
most modern computers can execute 10^9 basic operations per second

Can we be smarter about this?

a basic optimisation

Insight: Recognise that the greatest product is also the product of the two greatest numbers in the list

def fastPairwiseProduct(a):
    n = len(a)

    ultimate_index = -1
    for i in range(0, n):
        if ultimate_index == -1 or a[i] > a[ultimate_index]:
            ultimate_index = i

    penultimate_index = -1
    for j in range(0, n):
        if (j != ultimate_index) and (penultimate_index == -1 or a[j] > a[penultimate_index]):
            penultimate_index = j

    return a[ultimate_index] * a[penultimate_index]

Standard optimisation techniques generally find and eliminate duplication of effort and cut down on memory usage

But, naïve algorithms are still useful!

Stress testing

Generate large, random datasets
Naïve algorithm as the base case
Compare output of base case to proposed optimisation
If solutions differ, there is a problem with the optimised case, or the base case, or both 😱

# a scrappy example of stress-testing

while(True):
    numbers = []
    random_length = randint(2,100)
    for num in range(random_length):
        numbers.append(randint(0,10000000))

    outcome1 = slowPairwiseProduct(numbers)
    outcome2 = fastPairwiseProduct(numbers)

    if outcome1 != outcome2:
        print("Error: solutions don't match!")
        print(outcome1)
        print(outcome2)
        break;
    else:
        print("OK ---- " + str(outcome1))

Verifying algorithms

Limited manual testing
Try to generate different answers
- Smallest/largest possible outputs
- Null/undefined/divide by 0 errors
Understand time/memory consumption with increasing dataset size
Corner cases -- "degenerate cases", i.e. wrong datatypes as inputs

some things I learnt

To appreciate algorithms built into modern languages, you have to start writing very imperative code -- no more high-level functions like sort, reduce, filter, etc. 😭
Maths is amazingly useful but you don't need a deep understanding to start writing algorithms. You will spend more time learning the standard optimisation tools
Python is not the worst language ever (C is)