Just a couple of notes: I’ve written in python here not only because I generally enjoy writing in it, but because it does such a fantastic job syntactically getting out of the way of the logic of the code. I firmly believe it’s prioritization of readability that really exposes the purpose of the code makes it a fantastic teaching language. Also, in this post I’m just ignoring memory usage differences, they all should be pretty negligible.

The problem is as follows. Given a class (shown below), complete it such that the add_val(value) function adds a value to some data structure which stores the set of previously entered values, and sums_to(value) checks whether the value supplied is the sum of any two numbers currently stored.


class SumFromList:
  insert_val(value):
    #Add a value to the current set
  
  sums_to(value):
    #Return whether any two numbers in the stored set sum to the given value


The first thing that popped into my head when I saw this was a solution for the adds_to(value) function. If the values were stored in a sorted array, then a quick search function could be implemented by setting pointers to the beginning (the smallest entry) and the end (the largest) of the array. Then set a loop which, if the sum of the two values pointed to sum to a value less than the one supplied, incremented the starting pointer. Alternately, if the value was greater than the one supplied the end pointer would be decremented, and of course if they add to the given value, return true. By this method, it could be accurately checked whether we have a pair which sum to the value in O(n) time.


  sums_to(val):
    head = 0
    tail = len(value_set) - 1
    while(head < tail):
      sum = value_set[head] + value_set[tail]
      if(sum == val):
        return true
      elif(sum > val):
        tail = tail - 1
      else:
        head = head + 1
    return false


Now this is all well and good, but it doesn’t consider the insert_val(value) function performance at all, nor have we done any requirements gathering beyond the initial specifications.

There are three different usage patterns to consider. Firstly, insertions could be significantly more frequent than checks, in which case our naive search may be good enough, provided that our insertion is especially efficient. We could also have relatively few insertions, and a great deal of calls to sums_to(value), in which case we could justify a pretty ugly insertion function if we can get O(1) or O(log(n)) checking for sum-pairs. Finally, we could have similar amounts of both, in which case we would pick whichever of our two solutions performed better generally.

Addressing the first case, as it ties in nicely to my proposed sum-pair checker, it’s now worth looking at the insert_val(value) function to see what we can do to make this better. Specifically, are there any data types or algorithms that can give us a performance boost.

We were originally working with an array, where finding the insertion index for the value is O(log(n)) and then there’s an additional O(n) for memcpy(), which isn’t great. We could get a bit of a performance boost and maintain compatibility with our sums_to(value) implementation with a doubly linked list, dropping the additional O(log(n)) because while we can’t use the bisection method to find the insertion index any more, moving all following elements is no longer necessary.

What took me a little longer to come to than I’d care to admit, and I’m sure a few of you have arrived at the idea already, is to use a balanced binary tree. Insertion is only O(log(n)), and retrieving values in ascending or descending order, while maybe slightly more complex than with an array or linked list, is pretty simple. This would require a bit of a rewrite of our sums_to(value) function, and maybe a couple of extra functions to handle tree creation and traversal, but would provide by far the most elegant solution.

Should we instead be designing for a system where pair-sum checks are significantly more frequent, then we should look to another data structure, the hash map, for our O(1) performance solution. We will maintain two state variables, one with an unordered list of the values added through insert_val(value) and one with a map where each key is a sum of two of the numbers in the list and each value is simply ’1′ (or anything else you’d like, really). Our insert_val(value) function should now append each new value to the end of our list, which is O(1), and then iterate over the entire list, summing the new value and the current value and the sum as a key to the hash map. This way the sums_to(value) function needs only to check if the key exists, which can be O(1), our desired result.


class SumFromList:
  value_list = []
  sum_dict = {}
  insert_val(value):
    value_list.append(value)
    for i in value_list:
      sum_dict[value + i] = 1
  
  sums_to(value):
    if value in sum_dict:
      return true
    else:
      return false


While this may not be incredibly elegant, it’s certainly fast at checking for sum-pairs. And it could potentially be made more robust by a little further investigation into the requirements. If there’s values are likely to repeat frequently, implementing methods to store never more than two copies of the value would not interfere with results and provide boosts in both speed and memory footprint.

I don’t know if this is a common practice problem or not, it was the first time I had bumped into it, but it struck me as such a fantastic example of how the many data types we as programmers have at our disposal have each their own strengths and weaknesses, and of how there’s often a stand out choice (or two), even if almost any could work.

My main change to evanbrynne.com will be a new potential-employer landing page, linked to from my resume, which will give a bit more of a professional bio and link to my git pages and projects. If anyone ever reads this, particularly a prospective employer, any feedback would definitely be appreciated. Although I’ve done well with co-op placements and research groups at UVic, presenting myself in a professional and flattering manner is still something I’m struggling with, so for the moment I’m going for candid and honest. Finishing university (for now) and going out into the real world scares the pants off me, but it’s also one of the most exciting things I’ve ever done. I really love what I do, and the thought of getting to code, work, and learn every day of the week and really feel like I’m contributing to something sounds incredible. I hope I can put myself out there successfully and end up with a job that really challenges me; nothing would make me happier.

Anyhow, this post took somewhat of a different direction than I intended. I think I’ll try planning out my next posts a little more thoroughly ahead of time and see if that works better. Either way, thanks for reading. From here on in I promise to be a little less self involved. If I’m feeling genuinely ambitious I might even aim for witty. I’m sure that’ll go well.

What follows is the recipe for, what I consider to be, the Ultimate Pancake. Enjoy.

1 1/2 cups all-purpose flour
3 teaspoons baking powder
1 teaspoon salt
2 tablespoons white sugar
2 teaspoons of vanilla extract.
2 Handfulls of frozen mixed berries OR 1 well ripened banana.
1 1/4 cups milk
1 egg
3 tablespoons butter, melted

Mix together the dry ingredients in a bowl while your butter melts. Add either the banana or berries (or both I suppose), though if you’re using a banana, make sure that it’s a little more ripe that how you would eat it. If they’re nice and firm and fresh, just starting to brown, it’ll add an unpleasant green flavour. Next pour in the milk, egg, butter, and vanilla and mix until you’ve got most of the lumps out.

Heat a pan at medium and add a gratuitous amount of butter (trust me on this one). 1/4 or 1/3 cup scoops of batter produce nicely sized pancakes, let them cook on one side until bubble are breaking the top surface, then flip and cook on the other side until it too is lightly browned. Repeat for 6-10 pancakes, replenishing the butter after each set.

Okay, so the butter really isn’t essential, but it makes them damn tasty.