Since I needed this JSON Parser badly in my project, I started to searched and found a very clean solution for it (thanks to Shawn Weisfeld for sharing it). The idea is, we can use Dynamic data type in order to deal with JSON strings, so you can use almost the same code that you have used in your JavaScript source, on the server side. The drawback is, you will lose intelliSense, and of course you have to use .Net 4.0. So if you are planing to use it in older versions, then you came to the wrong place.

Using JSON Parser

You can simply view the source code on github or download it.

Using it is so simple. I have added an extension to string class that will do the trick. If you are not familiar with Extension Methods, I have an article for you.

string jsonStr; // it can be like { a:{b:1}, c:[] }
dynamic parsedStr = jsonStr.ParseJSON(); // you need to add "Using Cheraq.Extensions;"
// to access b, you can use
int b = (int)parsedStr.a.b; // this can lead to error if a is null
int? safeB = parsedStr.a != null? (int?)parsedStr.a.b : (int?)null;

Hope you will find it useful.

What is the Variable Scope in Javascript?

Well, it might look strange, but it seems everything in Javascript has some sort of relationship with functions. The scope of Variables in Javascript is the function that the variable has been defined in it. If it is not inside any function, then it is global. Also functions have same scope as variables.

For a long time, I was assuming  that the variable scope is somehow same as C++ or C# (on code block level which will be indicated by curly braces ({}) or based on indentation in Python), and this is because I didn’t spend enough time to check the basic concepts (it is really boring to read those lengthy books/documents) and it seems I am not alone and lots of web developers are on the same page.

A Common Example: Infamous JavaScript Loop Variable

This is very common case and there are plenty of discussions and solutions for this problem. Let’s say you have a look that generates some links and keep adding them to the document, and the functionality of the link is somehow dependent to the order link being added.

function addLinks () {
    for (var i=0, link; i<5; i++) {
        link = document.createElement("a");
        link.innerHTML = "Link " + i;
        link.onclick = function () {
                alert(i);
        };
        document.body.appendChild(link);
    }
}
addLinks();

If you run above code you will see 5 links, but if you click on any of them, it will alert 5 rather than the proper index. The reason is, sine the anonymous function for onclick didn’t run yet, it will keep a reference to the variable i, that it’s value is 5 after the loop. For better understanding, you can simply move the “var i” to the first line of the function as below:

function addLinks () {
    var i, link;
    for (i=0; i<5; i++) {
        link = document.createElement("a");
        link.innerHTML = "Link " + i;
        link.onclick = function () {
                alert(i);
        };
        document.body.appendChild(link);
    }
}
addLinks();

Now you can see why the final result is always 5. There are different ways to solve this, one way is to make a new scope inside the loop, so rather than reference to the i, its value will be used. Below you can find the updated code.

function addLinks () {
    var i, link;
    for (i=0; i<5; i++) {
        link = document.createElement("a");
        link.innerHTML = "Link " + i;
        link.onclick = function(linkIndex){
            return function () {
                alert(linkIndex);
            };
        }(i);
        document.body.appendChild(link);
    }
}
addLinks();

Here what we’ve done is, we defined new anonymous function which returns our on click handler, but notice we have called this anonymous function. Since during the loop, the function has been called, the value of the loop variable will be stored rather than its reference. This method called Function Closure. If you are using JS frameworks, such, as jQuery, then you might saw this before (on creating new plug-in).

Using closure is fine, but you have to consider efficiency as well and at least for this sample code, it is over kill. Another way to deal with this issue is using DOM to store the value for us. So we can update the above code to something like below:

function linkHandler(){
    alert(thisgetAttribute("data-i"));
}
 
function addLinks () {
    var i, link;
    for (i=0; i<5; i++) {
        link = document.createElement("a");
        link.innerHTML = "Link " + i;
        link.setAttribute("data-i" , i);
        link.onclick = linkHandler;
        document.body.appendChild(link);
    }
}
addLinks();

Here we are simply storing the value in DOM object, and on the handler we will just use that value. This is easier and also debugging it is easier because you can see the value on the generated item as well.

This is what I’ve faced so many times from the time I have started using JS, but recently I dig into it. Hope you will find it useful as well.

Problem A: Centauri Prime

This problem has 7 points for small data set and 8 points for large data set, which can result to 15 points total into your account . Well the points shows that it is an easy problem. You can read the original problem statement here, But here we are going to keep it as simple as possible. Below you can find the problem in brief.

You are going to receive a list which contains name of kingdoms in a planet. For each kingdom name, you have to check it as per below conditions to find out the ruler of that kingdom:

• If the name ends with letter “y”, then nobody rules that kingdom.
• If the name ends with any of following letters (“a”,”e”,”i”,”o”,”u”), then kingdom is ruled by a queen.
• In any other cases, kingdom is rules by a king.

I think the answer is also written in problem statement and you should just implement it. So what you are going to do? For small data set, nothing, but for large data set, you need to read the constraints properly. Then problem statement for large data set says each kingdom name can be at most 100 characters long, which means it can be an string with length “1″. This is important because the problem statement says the name of the kingdom starts with a capital letter, so you need to consider if the kingdom name is just one character, then you need to change the case to lowercase. Below you can find the code to return the ruler.

def findRuler(country):
    lastChar = country.lower()[-1]
    if lastChar == 'y':
        return 'nobody'
    elif lastChar in 'aieou':
        return 'a queen'
    else:
        return 'a king'

Here you can find the complete code and sample input and output files could be found here on GitHub.

Problem B: Music Collection

This is an interesting problem with 20 points (8 for small data set, and 12 for large data set). Here you can read the original problem statement, but if you don’t want to spend time to read the whole story, here you can find the problem in brief.

Lets say you have lots of music files and they got different names (no duplicates). Your music player has a search option which is case insensitive and given any keyword, if the search result contains only one music, it will play it. Your job is, for each entry in the music list, try to find shortest keyword which returns only that item.

The key to solve this problem is, using some sort of indexing table. What we are going to do is, if there are only one item in the list, we will return empty string (this is an edge case, but we have to consider it). If there are more than one item, for each item first we will extract all the substrings (except empty string, can you guess why?). So if the input string is “abc”, we have to generate {“a”, “ab”, “abc”, “b”, “bc”, “c”}. We also need an empty hash table (dictionary). For each substring, we will check the hash table, if we don’t have this item in the hash table, then we will add this item as key and we will use the music name index as value (For music 1, we will add substring “ab” as {“ab”->1}). But if the substring already exists in the hash table, means this substring can return more than one music entry (we don’t need to know how many it will return), so we simply turn the value for that substring in the hash table to some value (like for substring “ab”, we will change the value to {“ab” -> “1000″}). Below code snippet will do this.

subsets = {}
for n in xrange(noEntries):
    entry = inputFile.readline().strip().upper()
    entryLength = len(entry)
    for startIndex in xrange(entryLength):
        for subLength in xrange(entryLength-startIndex):
            subString = entry[startIndex:startIndex+subLength+1]
            if subString in subsets:
                if subsets[subString] != n:
                    subsets[subString] = 1000
            else:
                subsets[subString] = n

Once we prepared the subsets hash table, then we can simple select items that their value is less than 1000 (as per the limit definition, we will not have more than 100 entries, so 1000 is a safe value. You could also change it to any negative value, it doesn’t matter). Since the question is to find shortest string, then for each entry, we need to prepare list of strings which will uniquely identify them, and then sort them as per the problem statement.

result = {}
for s in subsets:
    entryIndex = subsets[s]
    if entryIndex < 1000:
        if entryIndex not in result:
            result[entryIndex] = []
        result[entryIndex].append(s)

Now that we have the result set, we can simply generate result. If you noticed, when we were indexing items (first step) we turned all of them to upper case, the reason is, as per problem statement, the upper case items should appear before lower case items, so we simply can ignore the lower case items. So what we need to do is, simply sort the items first based on the length, and then alphabetically. below code will do this and generates result.

for i in xrange(noEntries):
    if i in result:
        vals = result[i]
        vals = sorted(vals,key=(lambda x: (len(x),x)))
        outputFile.write('"%s"\n'% (vals[0]))
    else:
        outputFile.write(':(\n')

Here you can find the complete code and sample input and output files could be found here on GitHub.

Problem C: Irregular Expression

This is one of those magic games that usually you will see in Google Code Jam contests. This problem has 25 points (10 for small data set, 15 for large data set) and you can find the complete problem statement here. The problem is about 2011 World Witch and Warlock tournament. If we ignore the story line, then problem in brief is as following: You will get a string from input, if you could find below pattern in it, then you will say this string contains some SPELL (be careful, the spell might turn you into frog!). The pattern is as below:

• A sentence which consists of 3 words
• Each word consists of one or more syllables
• Each syllable consists of any number of letters, including exactly one vowel (‘a’, ‘e’, ‘i’, ‘o’, ‘u’)
• First and third words are same and consists of exactly two syllables
• The string might start and end with gibberish characters and also there is no space to separate words

Well, what do you think? If you are thinking about regular expressions, then it is better to look at the problem form different point of view. This is an irregular expression problem, so you cannot use regular expression (the name is somehow magical as well and invites people to use regular expressions or think about it, but NO! Don’t do that!!). Lets say the input string is “kajabbamajabbajab”. This string contains a spell. We can find three words as “jabba”, “ma” and “jabba” in it which satisfies the given pattern. “jabba” contains two syllables: “jab” and “ba” or even you can say “ja” and “bba”. But we can also find another pattern in input string like “abba”, “maj” and “abba” which still it is true. So there are more than one answer (Number of answers doesn’t matter! You should just be able to find one). Google guys are smart enough to not suggest the second answer, otherwise you could simple find the solution, because finding a pattern using the second answer is quiet simple.

In order to solve it, first we will extract the position of each vowel in the string (doesn’t matter which vowel it is). Below code simply does this.

def checkSpell(entry):
    positions = []
    for i,l in enumerate(entry):
        if l in 'aoeiu':
            positions.append(i)

This code for the given example string will generate a list like [1,3,6,8,10,13,15]. Now we start from 0, at each step (i), we get a substring that starts at position[i] and ends at position[i+1]. This will be our search term. Then we will check if we can find this string after position[i+2] or not. If we could find it, then we are done. Otherwise, we will advance i and check the next item, till we reach to n-2. What we are doing is, we are using vowels at position i and i+1 to form a two syllables word, and then we are searching for the same two syllables word from position i+2 to make sure we have enough space for the second word. If we could find the first word again anywhere in the string, then we can make sure the string is matching the given pattern and contains a spell. Below you can find code snippet which does the same.

for i in xrange(len(positions)-2):
    startIndex = positions[i]
    endIndex = positions[i+1]+1
    startWord = entry[startIndex:endIndex]
    searchIndex = positions[i+2]+1
    try:
        spell = entry.index(startWord,searchIndex)
        return 'Spell!'
    except ValueError:
        continue

Here you can find the complete code and sample input and output files could be found here on GitHub.

Problem D: Twibet

This problem has 40 points (15 for small data set and 25 for large data set) and believe it or not, it is super easy question. Here you can find the problem statement, and as usual, below you can find it brief. Let’s say we have some people’s twitter account Id and we know who follows who. Accounts are stored in a list. At day i, ith person (Pi) will tweet something, an all his/her followers will re-tweet it (if they didn’t already). Your task it to find at day i, how many times that message will be tweeted (or re-tweeted). As you can see, this problem could be solved easily using an stack. By considering the limits, you can even solve the problem without any optimization. At day i, you will add the followers of Pi to the top of the stack, then for each item in the stack, you will add the followers of it to the stack (if it is not already there), once you have checked all the items, then you have the result. Below you can find code snippet which does the same.

N = int(inputFile.readline().strip())
fks = inputFile.readline().split()
monks = {}
for n in xrange(N):
    fk = int(fks[n]) - 1
    if fk not in monks:
        monks[fk] = []
    monks[fk].append(n)
outputFile.write('Case #%d:\n' % (t+1))
for d in xrange(N):
    stack = []
    visited = []
    visited.append(d)
    if d in monks:
        stack = monks[d][:]
        while len(stack)>0:
            m = stack.pop(0)
            if m not in visited:
                if m in monks:
                    stack += monks[m][:]
                visited.append(m)
    outputFile.write('%d\n' % (len(visited)))

Here you can find the complete code and sample input and output files could be found here on GitHub.

This concludes the EuroPython2011 contest. As you can see, most of the questions doesn’t need any specific algorithm and they could be solved directly (usually what you expect to see in Google Code Jam contest is lots of Dynamic Programming questions).

CREATE TABLE [dbo].[Test](
[Id] [INT] IDENTITY(1,1) NOT NULL,
[NDate] [datetime] NOT NULL,
CONSTRAINT [PK_Test] PRIMARY KEY CLUSTERED
(
[Id] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
SET IDENTITY_INSERT [dbo].[Test] ON
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (1, '2011-08-24 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (2, '2011-08-24 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (3, '2011-08-24 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (4, '2011-08-24 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (5, '2011-08-21 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (6, '2011-08-21 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (7, '2011-08-21 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (8, '2011-08-21 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (9, '2011-08-21 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (10, '2011-08-21 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (11, '2011-08-21 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (12, '2011-08-21 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (13, '2011-08-21 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (14, '2011-08-21 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (15, '2011-08-21 00:00:00.000')
INSERT [dbo].[Test] ([Id], [NDate]) VALUES (16, '2011-08-21 00:00:00.000')
SET IDENTITY_INSERT [dbo].[Test] OFF

Now if you want to run below LINQ operation for pagination, you will be surprised:

using(var db = new TestDataContext())
{
	var page_1_items = db.Test.OrderByDescending(i=> i.NDate).Take(10).ToList();
	var page_2_items = db.Test.OrderByDescending(i=> i.NDate).Skip(10).Take(10).ToList();
}

The page_1_items will be as following:

Id  NDate
4   2011-08-24 00:00:00.000
3   2011-08-24 00:00:00.000
2   2011-08-24 00:00:00.000
1   2011-08-24 00:00:00.000
11  2011-08-21 00:00:00.000
10  2011-08-21 00:00:00.000
9   2011-08-21 00:00:00.000
8   2011-08-21 00:00:00.000
7   2011-08-21 00:00:00.000
6   2011-08-21 00:00:00.000

And page_2_items will be:

Id  NDate
11  2011-08-21 00:00:00.000
12  2011-08-21 00:00:00.000
13  2011-08-21 00:00:00.000
14  2011-08-21 00:00:00.000
15  2011-08-21 00:00:00.000
16  2011-08-21 00:00:00.000

Did you noticed that some items are missing (item with ID 5)? and also item with ID equals to 11 will be repeated two times! Well, this was surprising me as well. The reason behind this is, generated query to load first page uses TOP X, but for other pages uses ROW_NUMBER(). This is for improving the performance, but this can make trouble for you as well. Below you can find generated queries:

/* For first page */
SELECT TOP 10 [Id],[NDate] FROM [Test] ORDER BY NDate DESC
 
/* For second page */
SELECT [Id[,[NDate] FROM (
  SELECT ROW_NUMBER() OVER (ORDER BY NDate DESC) AS RNumber, Id,NDate
  FROM [Test]) AS t
WHERE RNumber BETWEEN 11 AND 20
 
/* Supposed to return same result as TOP 10, but it is different!! */
SELECT [Id[,[NDate] FROM (
  SELECT ROW_NUMBER() OVER (ORDER BY NDate DESC) AS RNumber, Id,NDate
  FROM [Test]) AS t
WHERE RNumber BETWEEN 1 AND 10

To solve the issue, you need to add secondary ordering statement to ORDER BY statement (in this case we need to add Id as well). So whenever you are sorting your items and performing pagination, consider secondary ordering as well. This is not a perfect solution, because there are lots of cases where you want to allow user to choose ordering column (like when listing items in grid view, etc.). If you are wondering why LINQ is behaving like this, there might be some performance considerations in doing like this, since using TOP X does not require any other operation and it is more likely to be used (usually you want to show most viewed or commented or recent items, which can be addressed by TOP X easily).

Divide & Conquer (D&C) is an important algorithm design paradigm based on multi-branched recursion [Wikipedia]. In simple words, D&C solves the problem by dividing it into smaller sub-problems. Usually this sub-problems are much more smaller than the original problems (like dividing it into half). If the sub-problem still is complicated, D&C divides that sub-problem into smaller sub-problems and continues this until the sub-problem is simple enough to be solved directly. At this stage, you can solve problem easily and usually in constant time (i.e. O(c)). Then the result of this sub-problem will be sent upwards and merged with other sub-problems result and forms the final result.

Below image shows how a D&C based algorithm works. At this example we want to sort a list of numbers. What we will do is, start to split the list into smaller sub-lists  until we have only one item in the list. Well a list with one item in it is already sorted!! So there is nothing special till here, but the key is how you will merge the result. That’s why this algorithm called Merge Sort. Check it out below. We will discuss it later.

Figure 1: Merge Sort - A D&C based algorithm example

Key Steps

When you want to solve a problem using D&C, the first step is, finding a good diving procedure. You have to decide how you are going to divide your problem into sub-problems. Diving should be done in a way that it will simplify the problem and reduce the problem size to half or close to half.

Also you should decide when you will stop division and start to solve, which is desired problem size. Choosing a good stop point is crucial, because D&C usually leads to recursive procedures, and so many recursive calls can increase time/space complexity exponentially. It is possible to remove the recursion by using stack, but then again you will face a new problem which is determining proper stack size.

Another option you can consider when you are solving problems is: Parallel Programming. Since D&C divides problem into distinct sub-problems, those problems could be easily solved in parallel, either using multi-processor machines or cloud computing. For example, if you want to search for specific term in a database with size of Google database, it might take ages to find items and sort them, but using cloud (like Google App Engine environment), you can get result in less than one second. Next you will see some powerful algorithms based on D&C.

Binary Search

Binary Search is a fast searching algorithm that can find index of a value in a sorted array. For simplicity, lets say you have a sorted array that contains values in range [0..10] (see Figure 2). Now lets say we are searching for a number, (e.g. 2) in this list. What we can do is we can start from first number and check each and every number until we either find 2 or reach to the end of the list.  But like this if we want to search in a big list, it will take too much time. What we can do is, we can check the middle item (in this example, it is 5) with the value we are looking for (which is 2). if the value is smaller than middle value (2<5), then we can consider the lower sub-array to middle item for our next step of the search and we can ignore the other part. As you can see, because our array is sorted, we can do this kind of prediction. At this step we have reduced our problem size to half and now we need to search to half of the array for the desired number. If we continue this process, at last step we will have this two conditions:

• Array size reduced to 1, and we can solve problem directly by checking the remaining number with sought value
• Middle item is equals with number we were looking for (which is the answer)

Figure 2: Binary Search in a sorted array of numbers

Below you can find python code for binary search. Most of the programming languages have built-in implementation for binary search and you usually don’t need to implement it again.

def binary_search(seq, t):
    min = 0; max = len(seq) - 1
    while 1:
        if max < min:
            return -1
        m = (min + max) / 2
        if seq[m] < t:
            min = m + 1
        elif seq[m] > t:
            max = m - 1
        else:
            return m

As you can see in the code above, at each step, the list will be divided to half and then one half will be used for the next step, so your algorithm at worse case will be O(log2 n) or for simplicity O(log n). This means if you have a list which contains 1 billion items (1,000,000,000), using binary search at worse case you need to examine 30 items to find the result, but if you do normal search, you might need 1 billion examinations and at end you will find out it is not in the list.

There are some argue about Binary Search and some people are saying Binary Search is not a complete D&C based algorithm because it is dividing the problem into two sub-problems, but it is only considering one of them for next step; and based on this, they are offering different name for it such as decrease and conquer, etc. No matter what we call it, Binary Search is a ROCK STAR.  If you check Wikipedia for binary search, you will find out that implementing Binary Search seems easy initially, but is tricky. I hope the code I’ve published above is correct

Although the basic idea of binary search is comparatively straightforward, the details can be surprisingly tricky… — Professor Donald Knuth

Merge Sort

Merge sort is another D&C based algorithm that we will have a look at it in this post. We have already discussed about this algorithm at the beginning of this post (see Figure 1), but below you can find the general idea behind it.

Let’s say we have a list (L) with size n and we want to sort it. Like any other D&C algorithm, first step is to divide the problem into smaller sub-problems. In Merge Sort, at each step, we should divide the list into to sub-lists with size almost equal to n/2. We will do this until we reach to a list with size equal to 1. At this point, we will stop dividing and start solving the problem. Before we start next step, let’s see what we have right now, we have n lists with size 1. Now we start to conquer the sub-problems and form final result. At each step we will merge two sorted lists, this can be done in O(n). At the worst case, the time complexity of merge sort will be O(n log2 n).

Another issue that should be considered about Merge Sort is it’s space complexity. An iterative but non-recursive version of merge sort requires 2n space, which means if you have a list with size 1GB, then you need 2GB space in order to perform merge sort. This is because of the fact that merging two lists with size n/2 requires n/2 + n/2 + n = 2n space (two lists with size n/2 and one list with size n to save merged result). There are also some implementations which requires only n/2 extra space to perform the search, but for huge arrays where space is a key factor, other algorithms such as heap sort might be better option.

Conclusion

D&C can be used to solve complicated problems in acceptable time/space complexity. This technique is the basis of efficient algorithms for all kinds of problems, such as searching, sorting,  multiplying large number, syntactic analysis and so on. Main idea behind D&C is to reduce the problem into smaller sub-problems that could be solved independently and their result could form the main problem’s result. Since D&C creates independent sub-problems, it can benefit from Parallel Programming and Cloud Computing more than other methodologies and that’s why D&C is the new Black!

What is an algorithm?

An algorithm in simple language is a finite set of instructions for calculating a function. For example we are looking for a file in a folder, what we might do is, we start from beginning of the list, check each and every file until we find the file we want or reaching to the end of the list. This is an algorithm.

Why we should learn them?

Algorithms are actually ways to solve problems; but they are not the solution. By learning algorithms you will find methods that help you in solving problems. It is like Data Structure. If we consider data structure as a tool, algorithms will be manual that helps us to learn how to use those tools to do desired task.

When shall I use specific algorithm?

The solution and algorithm you choose for any given problem, depends to:

• The way you are looking at the problem and visualizing it
• Run Time/Space limits
• Input Size

These are only key factors. There are lots of other factors that might play a key role in selecting an algorithm, such as data structure, etc. Maybe the last two factors are obvious, but let’s see how the first factor might play a key role. Consider the classic 8-Queen problem. In this problem we want to place 8 queens in a 8×8 chessboard in a way that none of them could attack others.

Let’s say we are going to solve it by placing one queen at a time in a way that it will not be able to attack previous queens we have placed. Once we reached to a place that we cannot find a place for this queen, we will return back and move the previous queen to another cell and then continue, until we reach to a result. In this way we are using backtracking to solve the issue.

But there is another way to look at the problem. Let’s say we will place 8 queens in 8 rows randomly. Then we start to move queens in a way to minimize the number of queens that can attach each other. Now we have turned the problem into optimization problem. So as you can see, they way you are understanding and visualizing a problem will play a key role in solving it and finding algorithm.

How we can compare two algorithms?

Well, if there are different algorithms to solve a problem, then there should be some ways to compare them (I’m genius). We usually compare two algorithms based on their time and space complexity. Time and space complexity are not displaying the exact amount of time/space are required to solve a problem; instead they indicate how the time/space requirements will grow when the problem size grows. Since we want to study how the time/space requirements will grow, then we don’t need to consider the exact equation of time/space complexity; We can just consider the biggest factor. Let’s see this in below simple example.

Finding an item in an ordered list

Let’s say we have an ordered list of numbers with size n and we want to see if this list contains number x or not. We can use below ways to search for x:

Algorithm 1: We will start from first item and compare it with x: if it is equal, then list contains this number, otherwise, we will go to next item until we reach end of the list or find x in the list.

Algorithm 2 (Binary Search): We compare x with the middle item of the list. If x is larger than middle item, then we should be able to find it in the second half of the list and we can ignore the first one and vice versa. Once we find out on which part of the list we have to search for x, then we repeat the same step, compare x with the middle item of this new list (first/second half). We continue this until we find x or reaching to a list with size 1.

As you can see, we usually using second algorithm to find items in ordered list. Now let’s see how we can compare the time complexity of these two algorithms. When we want to estimate time complexity, we count how many times a key action or block of actions will be repeated. Like in our example, how many times we should perform comparison to find out given list contains x or not. In order to eliminate role of x in our estimation, we consider the worth-case scenario such as list does not contain x.

In the algorithm 1, we need to do comparison n times in the worth-case (which is obvious). But what about algorithm 2? The answer is log n (when we are using log, we usually mean log in base 2). If you check the algorithm, you will see at each step we will divide list into half, so the list size will change like: n, n/2, n/4, n/8, n/16, … . So in the worth-case we will continue up to log n. When we want to denote the time/space complexity, we usually use big O, and we will show it as O(n) or O(log n). This mean we are just considering the most significant factor and we are neglecting the others. For example if you algorithms time complexity is polynomial like (n²+n), then we can say the time complexity is equal to O(n²).

 Conclusion

Finding proper algorithm for a given problem could be challenging. Learning more algorithms will give us better vision and understanding, and we will be able to analyze problem from different aspects and find different algorithms to solve the problem. Time/space complexity enables us to compare algorithms and choose the best algorithm based on input size and other limitations.

This was an introduction about algorithms. In next articles we will see different type of algorithms and their pros and cons.  Also we will learn how to calculate time/space complexity and combine different algorithms with some heuristic functions in order to reduce complexity.

HttpRuntime.AppDomainAppVirtualPath

And in order to resolve the URL to absolute path, you can simply replace “~” with the value of HttpRuntime.AppDomainAppVirtualPath and you have your absolute path. Below you can find an extension class to HttpServerUtility that adds ResolveUrl method, and you can use ResolveUrl and MapPath of the HttpContext.Current.Server.

public static class HttpServerUtilityExtensions
{
    public static string ResolveUrl(
        this HttpServerUtility server,
        string virtualPath
        )
    {
        if (virtualPath.StartsWith("~/"))
        {
            return string.Format("{0}/{1}",
                HttpRuntime.AppDomainAppVirtualPath,
                virtualPath.Substring(2));
        }
        return virtualPath;
    }
}

Post p = Post.LoadPost();
ltPostBody.Text = HttpUtility.HtmlEncode(p.PostTitle);

But if we have a method in string class that does this for us, then life will be easier and we could use something like below:

ltPostBody.Text = p.PostTitle.HtmlEncode();

Once way to do this is to modify the Post class and change the type of PostTitle to a derived type that has HtmlEncode method. But this is not a solution. What if you couldn’t modify the Post class? Or what if you couldn’t create new derived type because it is sealed by author. Or lots of other scenarios.

The simple solution is, using extension methods. What is it? MSDN says:

Extension methods enable you to “add” methods to existing types without creating a new derived type, recompiling, or otherwise modifying the original type.

The advantage of extension methods are, they will be available on all objects derived from that type. So if you add an extension method to string class, then it will be available on all string objects. Let’s see how we will implement extension methods. Again MSDN says:

Extension methods are defined as static methods but are called by using instance method syntax. Their first parameter specifies which type the method operates on, and the parameter is preceded by the this modifier. Extension methods are only in scope when you explicitly import the namespace into your source code with a using directive.

Let write our own extension method. First we will add new class as below:

namespace Cheraq.Extensions
{
    public static class StringExtensions
    {
        // our methods will be defined here
    }
}

Now we will define our extension method:

public static string HTMLEncode(this string phrase)
{
    return HttpUtility.HtmlEncode(phrase);
}

First of all, our method should be static. Also if you see the parameter, it is so strange. The first parameter should be defined as below:

this type-that-you-want-to-add-extension-method-to-it parameter-name

After that we will define our implementation of the function. When we want to use the function, we need to add using directive to import the namespace. When you import the namespace, the extension method will be available for all object derived from that type. Below image shows our extension method on the auto-complete window. You can see the icon of the extension method is different.

HTMLEncode is an extension method, so it got a different icon.

The usage of extension method is same as normal method of that type. You can even add extension method to sealed class. But this will not violate the principal of encapsulation, because extended methods cannot access private variable and methods in the type they are extending. Below you can find summary of some facts about extension methods:

1. Extension methods can only access private variable and methods in the type they are extending!
2. You cannot use them to override methods of a class or interface
3. They have lower priority than instance methods defined in the type itself. In other words, compiler first looks into the instance methods; if did not find any method with same signature, then it will search in extension methods.
4. Extension methods are brought into scope at the namespace level.
5. If you do not have access to the code of the type that you are extending, then it is better to keep in mind that changes in that type might break the extension method.
6. Do not make everything as extension method. Use it wisely.

Bellow you can find a sample project that demonstrates the usage of extension methods.