A Programming Job Interview Challenge #12 – Managed and Unmanaged

The twelfth post of the series of programming job interview challenge is out, 31 readers provided answers to job interview challenge #11. I have to admit that I probably failed explaining what I was looking for in challenge #11, because I asked you to provide the best algorithm in both manners: performance and memory. What I really meant is that performance is most important but don’t neglect the memory issue. Due to my little “embarrassing failure”, there are two groups of correct answers – the performance oriented and the memory oriented.

The correct answer which I was looking for (best at performance) as Alex, the first one to provide a detailed solution (its two times in a row), wrote:

The most time-efficient way would be to utilize a hashtable. (Or, simply a set if your language supports it)

Let’s take the example of searching for a sum 14
in the list 2,6,4,9,1,12,7.
Iterate through the list. For each value x in the list, add it to the hashtable, then check if 14-x exists in the hashtable. If not, go to the next item. if it does, return true (you found your pair). That “add to hashtable before checking” thing is necessary in order to prevent a 14-7=7 situation.

If you reach the end of the list without finding a matching pair, return false.

This algorithm is O(n) time, but also O(n) space.

Those are the other readers who provided such a solution: Kimmen, Dejan Dimitrovski, Alessio Spadaro AS, Guido Domenici, Michael and lucas.

The first one to provide the best solution when it comes to memory consumption was Morgan Cheng:

Here is a time O(n*log(n)) and space O(1) solution:

The first step: sort the N-element list which takes O(n*log(n)) time complexity.

The second step: search two elements whose sum is M. Since the list is already sorted(smaller to the left and larger to the right), we find one number from left to right, while the other number from right to left. The index of left number is indexed by i, and the index of right number is indexed by j. For each step, we calculate delta = M – Array[i] and compare it to Array[j]. If delta equals Array[j], we can return true; if delta Array[j], we increment i and continue. When i >= j, we break and return false.

Those are the other readers who provided such a solution: Mark R, Maneesh, Christof Jans, Dan Sydner, Alessio Spadaro AS, Michael Mrozek and Michael Dikman.

Please check the bloggers algorithms:

1. http://90kts.com/blog/2008/job-interview-question-11-summing-numbers/ by Tim.
2. http://roadrunner74.wordpress.com/2008/07/08/dev-102-interview-challenge-11/ by Heiko Hatzfeld.
3. http://honestillusion.com/blogs/blog_0/archive/2008/07/08/dev102-s-challenge-11-summing-numbers.aspx by James Curran.
4. http://www.xerxesb.com/2008/a-programming-job-interview-challenge-11-summing-numbers/ by Xerxes.
5. http://happyworldnoodle.com/blog1/2008/07/14/summing-numbers-challenge/ by Stephen Goldbaum.

Some readers provided code solutions with no explanation and complexity, I am really sorry but I didn’t have time to understand the complexity of your solutions. next time please explain what you did:

1. I am not familiar with each and every programming language.
2. I don’t have the time to investigate what is the complexity of a solution written in Linq (I think that it is O(n^2)), for example.

This Week Question:

Take a look at the following managed C++ code:

__gc class ManagedClass 
{
   public:
   int i; 
   ManagedClass () { i = 0; };
};

class UnmanagedClass
{
   public:
   void incr(int * i) 
   {   
      (*i)++;
      std::cout << *i << std::endl;
   };
};

int main() {
   ManagedClass* pMngdClass = new ManagedClass;
   UnmanagedClass* pUnmngd = new UnmanagedClass;
   pUnmngd->incr(&(pMngdClass->i));
}

What is wrong with this code and how would you fix it? There are no dirty tricks here, don’t try to catch me on a typo or something like that, you can assume that this code compiles. The correct answer is about an important issue which was neglected in the above sample code. Don’t catch me on the fact that I directly expose a member variable i, for intance. This is just a little sample code where a basic concept is violated.

Get updates by RSS to catch up with the next posts in this series and to get the correct answer for today’s question. As always you may post the solution in your blog or comment. Comments with answers will be approved only next week.