Armed with a plethora of features, Unsurrogater sports a clean user interface that builds on a Job Category based navigation. The duplicate search process itself is very intuitive to start as the wizards guide you to setting up the job.

Search Result

Results are viewed hierarchically in a Tree Table display.

Auto Marking

Files can be marked manually or using the Auto Mark feature that takes hints from the user & automatically selects files across the entire result.

Actions

After marking the files, users can choose to perform operations such as copy, move, delete, archive, replace by hard links, etc.

Reports

Results can be stored historically for viewing later or exported as an HTML/XML Report.

Result Combination

A key feature of Unsurrogater is the ability to combine the search results of multiple jobs & discover new duplicates. This saves a lot of time as you don’t have to run the job again for the files already scanned.

The command was:-

(svn stat) -match '^\?.*\.cs$'

The following command gave a much cleaner output (just the full path of the files)

(svn stat "--no-ignore") -match '^\?.*\.cs$' -replace '^.\s+',''

The next command deleted those files from the PC.

(svn stat "--no-ignore") -match '^\?.*\.cs$' -replace '^.\s+','' | rm

I did not pay attention to what the command does and executed it. Net result was that my precious source codes were gone. I looked for the files in the recycle bin. But, being a command line program, it does not seem to use the recycle bin. Then I tried NTFS undelete which is able to restore files that were deleted ‘permanently’ too. What happens is that when you delete a file (SHIFT + DELETE, skipping the recycle bin), windows merely marks the space the file occupied in the disk as free. This is done for performance reasons (a delete operation would take time that is comparable to writing to a file, otherwise).

However, to my dismay, NTFS undelete was unable to find the file. Perhaps it was because of Windows 7 and it’s ways of handling different versions of a file.

It seemed like I would have to re-create the files again. But, then it occurred to me that reflector could come in handy. I had compiled the project previously. So, the debug directory had the compiled assemblies. I used reflector to get the source files back. Although not the exact as the original, the decompiled code was good enough for me to re-create the custom user-control.

I tried deleting the cached passwords from %AppData%\Subversion\Auth\svn.simple. The next time I got the dialog asking for the account information. I typed the username & password in but still got the error.

While at work, I tried doing the commit and it worked. So, it seemed like an IP address ban. But, then again I don’t have a static IP address. Also, the Update, Revert, Check Out commands worked without a hitch.

Then it occurred that it could be a ban by domain name. I use No-IP to map my dynamic IP address to a domain. So, I changed the domain but the results were the same.

I finally tracked it down to being a case-sensitivity issue in the username. A Check Out, Revert, Update was being allowed from a username User but Commit was not. The actual username being user.

It has been difficult to do all this, while still pursuing my degrees. Support from the users has been a great encouragement. Last month (25th of May, to be precise), I started working at Global IDs as a Trainee Software Developer using Java technologies. Global IDs specializes in Data Integration on a large scale. Maxotek takes a step back in terms of my priority.

Chances of new softwares being released is very little. But, we will continue to provide technical support to our valued customers. One day, Maxotek will be back as my main goal. But, until then, there is a lot I must learn, especially the software process models and the business aspects of running a company.

1. Start Firefox in Safe Mode (from Start menu)
2. Reset all the addons
3. Restart firefox

A few days ago, I received an email from a company providing me an opportunity to obtain maxotek.com at a “premium price” before anyone else could, because I am the owner of maxotek.net. It didn’t seem right to me and so I checked the net for others’ experiencing the same. From what I read, it was clear that it was a scam, so I played the waiting game and boy wasn’t I rewarded.

What’s next?

Maybe I’ll use both the domains for different activities. .COM for business and .NET for blogging and other internet services. Only time shall tell.

The taskbar is smart enough to detect an ongoing operation and shows a small progress bar behind the icon. Say you are downloading a file using Internet Explorer in the background and working on a Word document. You don’t even need to switch to the download dialog window to see how much of the file has been downloaded. Just move your eye to the taskbar icon, handy eh?

The taskbar also shows multiple thumbnails of grouped items; all of which can be previewed full screen without even having to switch to the windows (also no clicks or keypresses required).

Another improvement is the desktop preview feature which can be activated by moving the mouse inside the vertical rectangle at the extreme right of the taskbar. Again, no clicks required. To get back to the current screen, just move your mouse away.

Coming back to the taskbar icons, I noticed that unopen taskbar items which are pinned to the taskbar have a whitish glow below the icons. For open windows the background is a gradient based on the color which forms the majority of the icon (looks really cool, I must say).

Speaking of looks, the bootscreen of Windows 7 is what should have been done to Windows Vista.

I guess they rushed Vista’s release and left a lot of things uncompleted. Windows 7 will most certainly address these issues and be what Windows Vista should have been after such a long development period. The naming of Windows 7 seems more of a marketing nature, than technical. If you look at the versioning of Windows, you’ll find the major version has been updated only when there has been a substantial change in the Operating System core. Windows 9X systems (95, 98, ME) where all version 4, 2000 & XP where v 5. So should have been Vista & Vienna as version 6. But, as I read in an article somewhere, Vista is a tainted brand and so Microsoft decided to get the V out. Say bye to Vista/Vienna & hello to Windows 7.

Tutorial Map

1. Introduction
2. Sorting Data
3. Selecting a Sorting Algorithm
4. Sorting Data by Using Bubble Sort
5. Implementing Bubble Sort Algorithm
6. Determining the Efficiency of Bubble Sort Algorithm
7. Sorting Data by Using Selection Sort
8. Implementing Selection Sort Algorithm
9. Determining the Efficiency of Selection Sort Algorithm
10. Sorting Data by Using Insertion Sort
11. Implementing Insertion Sort Algorithm
12. Determining the Efficiency of Insertion Sort Algorithm
13. Sorting Data by Using Shell Sort Algorithm
14. Efficiency of Shell Sort

Introduction

Retrieving data quickly is one of the major tasks of an efficient data management system. Sorting helps in retrieving data faster by storing data in a particular order. There are various sorting algorithms that can be used to arrange data in a specific order.

This tutorial discusses various sorting algorithms and their implementation. In addition, it compares the efficiency of various sorting algorithms.

Sorting Data

Consider that you need to retrieve the telephone number of a person named Steve in a telephone directory, where the names in the telephone directory are stored in a random order.

To retrieve the desired record, you need to sequentially traverse the list of names one by one because the names are not sorted, which is a tedious and time consuming activity. When you have to retrieve a record from a huge volume of data, this activity becomes even more difficult.

A simple solution to save time, and search data efficiently is sorting. Sorting is the process of arranging data in some pre-defined order or sequence. The order can be either ascending or descending.

If the data is sorted, you can directly go to the section that stores the names starting with ‘S’, thereby reducing the number of records to be traversed.

There are different types of sorting algorithms that can help you sort data in a particular order. Even when two algorithms have the same efficiency, there can be situations when one works better than the other.

Selecting a Sorting Algorithm

There are various sorting algorithms that are used to sort data. Some of them are:-

• Bubble Sort
• Selection Sort
• Insertion Sort
• Shell Sort
• Merge Sort
• Quick Sort
• Heap Sort

Because there are a number of sorting algorithms, it becomes important to understand which sorting algorithm to use in a particular situation. To select an appropriate algorithm, you need to consider the following criteria in the suggested order:-

• Execution time
• Storage space
• Programming effort

Consider a situation where the data that needs to be sorted is small in quantity. To sort this data, all the sorting algorithms will use a reasonable amount of storage space. In addition, the sorting algorithms will be executed in a reasonable amount of time.

Therefore, in this situation, the criteria for selecting the sorting algorithm would be the programming effort involved. An algorithm that requires less programming effort would be preferred over an algorithm that requires more programming effort.

Consider another situation where the data that needs to be sorted is large in size. In such a situation, the time taken by different algorithms may differ drastically because of the difference in their orders of growth. For example, when there are a large number of elements, an algorithm with a logarithmic order of growth will execute much faster than an algorithm with a quadratic order of growth.

In addition, with increase in data, the space requirement of different algorithms may also differ drastically. Therefore, when the data is large, you need to select a sorting algorithm that makes most efficient use of time or memory, depending upon the requirement.

Sorting Data by Using Bubble Sort

Bubble sort is one of the simplest sorting algorithms. This algorithm has a quadratic order of growth and is therefore suitable for sorting small lists only. The algorithm works by repeatedly scanning through the list, comparing adjacent elements, and swapping them if they are in the wrong order. The algorithm gets its name from the way smaller elements “bubble’ to the top of the list after being swapped with the greater elements.

Implementing Bubble Sort Algorithm

To understand the implementation of bubble sort algorithm, consider an unsorted list of numbers stored in an array. Suppose there are n elements in the array.

To implement bubble sort algorithm, you need to traverse the list multiple times. The process of traversing the entire list once is called a pass. It can be said that sorting is performed in multiple passes.

Pass 1

In Pass 1, you compare the first two elements and interchange their values, if the first number is greater than the second number. Then, you compare the second and the third elements, and interchange their values if they are not in the correct order. You repeat this process till (n – 1) ^th element is compared with the n^th element. The total number of comparisons in Pass 1 is therefore, n – 1.

By the end of Pass 1, the largest element is placed at the n^th position in the array. The
number of comparisons is one less than the total number of elements in the list.

Pass 2

In Pass 2, you repeat the same process as in Pass 1, but stop the comparison after comparing the element at the (n – 2)^th position with the element at the (n – 1)^th position. This time the number of comparisons required will be one less than in Pass 1. The total number of comparisons in Pass 1 is therefore, n – 2.

By the end of Pass 2, the second largest number will be placed at the (n – 1)^th position in
the array.

Pass 3

In Pass 3, you repeat the same process as in Pass 2, and this time there will be n – 3 comparisons. This means that the comparison will stop after comparing the element at the (n
- 3)^th position with the element at the (n – 2)^th position.

Pass n – 1

Continuing the same process in all subsequent passes, in the (n – 1)^th pass you will have to perform only one comparison. After the completion of this pass, the list will be sorted in the ascending order.

Note: To sort a list with n elements by using bubble sort, n - 1 passes are required

Consider an example. You have an unsorted list containing the ranks of students based on the results of an exam. You need to sort these ranks in the ascending order. The list of ranks is stored in an array, as shown in the following figure:-

There are five elements in the list, therefore four passes would be required to sort the list.

In Pass 1, you need to perform the following steps:-

1. Compare arr[0] with arr[1]. In the given list, arr[0] > arr[1], therefore, you need to interchange the two values. The resultant list is shown in the following figure.

   

2. Compare arr[1] with arr[2]. Here, arr[1] < arr[2], therefore, the values remain unchanged.
3. Compare arr[2] with arr[3]. Here, arr[2] < arr[3], therefore, the values remain unchanged.
4. Compare arr[3] with arr[4]. Here arr[3] > arr[4], therefore, you need to interchange the two values, as shown in the following figure.

   

At the end of Pass 1, the largest element is placed at the last index position. The preceding process will be repeated in all the subsequent passes. However, the value at index 4 will not be compared in any of the subsequent passes because it has already been placed at its correct position.

In Pass 2, you need to perform the following steps:-

1. Compare arr[0] with arr[1]. In the given list, arr[0] < arr[1], therefore, the values remain unchanged.
2. Compare
   arr[1] with arr[2]. Here, arr[1] < arr[2], therefore, the values remain unchanged.
3. Compare arr[2] with arr[3]. Here, arr[2] > arr[3], therefore, you need to interchange the two values, as shown in the following figure.

   

At the end of this pass, the second largest element is placed at its correct position in the list. You will repeat the same process in the subsequent passes. However, the values at Index 3 and 4 will not be compared in the subsequent passes, because they are already placed at their correct position.

The result after Pass 3 would be as follows:-

Similarly, the result after Pass 4 would be as follows.

After Pass 4, the list is completely sorted.

The algorithm to sort the list by using the bubble sort algorithm is as follows:-

Note: If in the preceding example, instead of checking that the element at index j is greater than the element at index j + 1, you check that the element at index j is less than the element at index j+ 1, then the list will be sorted in the descending order.

Determining the Efficiency of Bubble Sort Algorithm

The efficiency for a sorting algorithm is measured in terms of the number of comparisons. The number of comparisons in bubble sort can be easily computed. In bubble sort, there are n – 1 comparisons in Pass 1, n – 2 comparisons in Pass 2, and so on. Therefore, the total number of comparisons will be: (n – 1) + (n – 2) + (n – 3) + … + 3 + 2 + El,which is an arithmetic progression.

The formula for determining the sum of an arithmetic progression is:-

Sum = n/2 [2a + (n - 1)d]

Where,

n is the total number of elements in the arithmetic progression.

a is the first element in the arithmetic progression.

d is the step value, that is, the difference in successive terms of an arithmetic progression.

For the preceding arithmetic progression,

n = n – 1

a = 1

d = 1

Therefore,

Sum = (n -1)/2 [2 x 1 + (n - 1 - el) x el]
Sum = (n – 1)/2 [2 + (n - 2)]

Sum = (n -1)/2 (n)
Sum = n(n – 1)/2

n(n – 1)/2 is of O(n²) order. Therefore, the bubble sort algorithm is of the order O(n²). This means that the time taken to execute the algorithm increases quadratically with the increase in the size of the array.

Suppose it takes 100 ns to execute the algorithm on a list of 10 elements. Now, if the number of elements is doubled, that is, the number of elements is increased to 20, the execution time will increase to 400 ns, which is four times the time taken to execute the algorithm on 10 elements.

Given below is a function that takes an unsorted integer array and sorts it using the Bubble Sort Algorithm.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public int[] BubbleSortArray(int[] a)
{
	for (int i = 1; i < a.Length; i++) // For n - 1 passes
	{
		// In pass i, compare the first n - i elements with their next elements
		for (int j = 0; j < a.Length - 1; j++)
		{
			if (a[j] > a[j + 1])
			{
				int temp;
				temp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = temp;
			}
		}
	}
	return a;
}

Sorting Data by Using Selection Sort

Like bubble sort, selection sort is another simple sorting algorithm. Selection sort also has a quadratic order of growth, and is therefore used for sorting small lists only.

Selection sort scans through the list iteratively, selecting one item in each scan, and moving the item to its correct position in the list. In contrast to bubble sort, where you need to perform n – r swaps in the r^th pass, selection sort performs a maximum of one swap per pass.

Implementing Selection Sort Algorithm

Similar to bubble sort, selection sort also involves multiple passes through the list of elements. In Pass 1, you locate the smallest element from the list, and swap it with the element at the first position in the list. At the end of Pass 1, the smallest value will be placed at its correct position in the list.

In Pass 2, you locate the next smallest value, and swap it with the element placed at the second position in the list. Similarly, you repeat the steps until all the values are placed at the correct positions in the list. If there are n elements in the list, the list will be sorted in n – 1 passes.

Suppose, you need to sort the following list of elements stored in an array by using the
selection sort algorithm.

To sort this list by using the selection sort algorithm, you need to perform the following
steps:-

1. Locate the smallest element in the list. In the given list, arr[2] is the smallest element.
2. Swap the smallest element with the element at index 0 in the array. The resultant array is shown in the following figure.

   

3. Locate the next smallest element in the list. Here, arr[4] is the next smallest element.
4. Swap the smallest element with the element at index 1 in the array, as shown in the following figure:-

   

5. Locate the next smallest
   element in the list. here, arr[2] is the next smallest element, as shown in the following figure:-

   

   The smallest element needs to be swapped with the element at index 2. However, the smallest element is already at index 2. Therefore, you do not need to swap its position with another element.

6. Locate the next smallest element in the list. Here, arr[4] is the next smallest element.
7. Swap the smallest element with the element at index 3 in the array, as shown in the following figure:-

   

The list is now completely sorted.

The algorithm to sort the list by using the selection sort algorithm is as follows:-

1. Repeat steps 2 and 3 varying j from 0 to n – 2 // Repeat for n – 1 passes
2. Find the index of the minimum value in arr[j] to arr[n - 1]
   1. Set min_index = j
   2. Repeat step c varying i from j + 1 to n – 1
   3. If arr[i] < arr[min_index]:
      1. min_index = i
3. Swap arr[j] with arr[min_index]

Determining the Efficiency of Selection Sort Algorithm

To determine the efficiency of selection sort, you need to determine the number of comparisons in selection sort. There are n – 1 comparisons during Pass 1 to find the smallest element. There are n – 2 comparisons during Pass 2 to find the second smallest
element, and so on.

Therefore, the total number of comparisons will be: –

(n – 1) + (n – 2) + (n – 3) + … + 3 + 2 + 1

This is the same as bubble sort. Therefore, the selection sort algorithm is of the order O(n²). This means that the time taken to execute the algorithm increases quadratically with the increase in the size of the array.

Given below is a C# implementation of the above algorithm:-

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public int[] SelectionSortArray(int[] a)
{
	for (int j = 0; j < a.Length - 1; j++)
	{
		int MinIndex = j;
		for (int i = j + 1; i < a.Length; i++)
		{
			if (a[i] < a[MinIndex])
			{
				MinIndex = i;
			}
		}
		int Temp = a[MinIndex];
		a[MinIndex] = a[j];
		a[j] = Temp;
	}
	return a;
}

Sorting Data by Using Insertion Sort

Similar to bubble and selection sort that have a quadratic order of growth, insertion sort also has a quadratic order of growth, and is therefore used for sorting small lists only.

However, insertion sort is much more efficient than bubble sort and selection sort, if the list that needs to be sorted is nearly sorted. This is because bubble sort and selection sort always perform the same number of comparisons, no matter what is the initial ordering of elements.

In contrast, insertion sort performs different number of comparisons depending on the initial ordering of elements. When the elements are already in the sorted order, insertion sort needs to make very few comparisons.

Implementing Insertion Sort Algorithm

The insertion sort algorithm divides the list into two parts, sorted and unsorted. Initially, the sorted part contains only one element. In each pass, one element from the unsorted list is inserted at its correct position in the sorted list. As a result, the sorted list grows by one element and the unsorted list shrinks by one element in each pass.

Consider an unsorted list stored in an array that needs to be sorted by using the insertion
sort algorithm.

To sort this list by using the insertion sort algorithm, you need to divide the list into two sublists, sorted and unsorted. Initially, the sorted list contains only the first element and the unsorted list contains the remaining four elements, as shown in the following figure:-

Note: The list is not physically divided into two separate arrays. The division is only logical where the element at index 0’s considered to be in the sorted list and the elements at indexes I to 4 are considered to be in the unsorted list.

Now, to further sort the unsorted list, you need to perform a number of passes:

1. In Pass 1, take the first element (80) from the unsorted list, and store it at its correct position in the sorted list. Here, 80 is greater than 70, therefore, it remains at array index 1. However, the array index 1 is now considered to be a part of the sorted list. This is shown in the following figure:-

   

   The sorted list has two elements now and the unsorted list has three elements.

2. In Pass 2, take the first element (30) from the unsorted list, and store it at its correct position in the sorted list. Here, 30 is less than 70 and 80, therefore, it needs to be stored at array index 0. To store 30 at array index 0, 80 needs to be shifted to array index 2, and 70 needs to be shifted to array index I. This is shown in the following figure.

   

   The sorted list has three elements now and the unsorted list has two elements.

3. In Pass 3, take the first element (10) from the unsorted list, and store it at its correct
   position in the sorted list.

   Here, 10 is smaller than the three elements in the sorted list, therefore, it needs to be stored at index position 0, as shown in the following figure.

   

   The sorted list has four elements now and the unsorted list has one element.

4. In Pass 4, take the first element (20) from the unsorted list, and store it at its correct position in the sorted list. Here, 20 is greater than 10 and smaller than the other three elements in the sorted list. Therefore, it needs to be stored at index position 1, as shown in the following figure:-

   

   The unsorted list is now empty and the sorted list contains all the elements. This
   means that the list is now completely sorted.

The algorithm to sort the list by using the insertion sort algorithm is as follows:-

1. Repeat steps 2, 3, 4, and 5 varying i from 1 to n -1
2. Set temp = arr[i]
3. Set j = i – i
4. Repeat until j becomes less than 0 or arr[j] becomes less than or equal to temp:
   1. Shift the value at index j to index j + 1
   2. Decrement j by i
5. Store temp at index j + 1

Determining the Efficiency of Insertion Sort Algorithm

Consider an unsorted list of numbers with n elements. To sort this unsorted fist by using insertion sorting, you need to perform (n – 1I) passes. In insertion sort, if the list is already sorted, you will have to make only one comparison in each pass.

In n -1 passes, you will need to make n – 1 comparisons. This is the best case for insertion sort. Therefore, the best case efficiency of insertion sort is of the order O(n).

Now, consider a situation where initially, the list is stored in the reverse order. In this case, you need to make one comparison in the first pass, two comparisons in the second pass, three comparisons in Pass 3, and n – 1 comparisons in the (n – 1)^th pass.

The total number of comparisons in this case is:-

Sum = 1 + 2 + … + (n – 1)

This is the same as bubble sort and selection sort. Therefore, the worst case efficiency of
insertion sort is of the order O(n²).

Given below is a C# implementation of the Insertion sort algorithm:-

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public int[] InsertionSortArray(int[] a)
{
	for (int i = 1; i < a.Length; i++)
	{
		int Temp = a[i];
		int j = i - 1;
 
		while (j >= 0 && a[j] > Temp)
		{
			a[j + 1] = a[j];
			j--;
		}
		a[j + 1] = Temp;
	}
	return a;
}

Sorting Data by Using Shell Sort Algorithm

Insertion sort is an efficient algorithm only if the list is already partially sorted and results in an inefficient solution in an average case. To overcome this limitation, a computer scientist, DL. Shell proposed an improvement over the insertion sort algorithm. The new algorithm was called shell sort after the name of its proposer.

The shell sort algorithm improves the insertion sort algorithm by grouping the elements separated by a distance of several positions to form multiple sublists. Once the list is divided into sublists, you apply insertion sort on each sublist to move the elements towards their correct positions. This helps an element to take a bigger step towards its correct position, thereby reducing the number of comparisons.

To understand the implementation of shell sort algorithm, consider an array a [0...n - 1]. To apply shell sort on this array, you need to select the distance by which the elements in
a group will be separated.

Suppose, initially you group the elements separated by a distance of four elements to create the following sublists:-

• a[0], a[4], a[8] …
• a[1], a[5], a[9] …
• a[2], a[6], a[10] …
• a[3], a[7], a[11] …

You can say that the sublists are created with an increment value of four. Each of the preceding sublists will be sorted by using insertion sort. In the next pass, the increment value will be reduced to three, and the elements will again be grouped to create the following sublists.

• a[0], a[3], a[6] …
• a[1], a[4], a[7] …
• a[2], a[5], a[8]
  …

Each of the preceding sublists will again be sorted by using insertion sort. In the next pass, the increment value will be reduced to two, and the elements will again be grouped to create the following sublists:-

• a[0], a[2], a[4] …
• a[1], a[3], a[5]
  …

Each of the preceding lists Will again be sorted by using insertion sort. In the next pass, the increment value will be reduced to one. In this case, there will be only one list that will be almost sorted. Insertion sort will be applied on the list to sort it completely.

Consider an example of an unsorted list of 11 elements, as shown in the following figure.

To sort the given list by using the shell sort algorithm, you need to perform a number of passes. The number of passes would depend on the initial increment value. Suppose the initial increment value is three, then the list will be sorted in three passes of the complete
list.

Pass 1

In Pass 1, you group the elements with a distance of three to form three sublists, as shown in the following figure:-

After the list is divided into sublists, you sort the sublists by using the insertion sort algorithm on each sublist individually. Once the sublists are sorted, you combine them to form one single list.

The following figure depicts the result of Pass 1:-

Pass 2

In Pass 2, you group the elements separated by a distance of two to form two sublists, as shown in the following figure:-

After the list is divided into sublists, you sort the sublists by using the insertion sort algorithm. Once the sublists are sorted, you combine them to form a single list.
The following figure displays the result of Pass 2.

Pass 3

In Pass 3, you group the elements separated by a distance of one, as shown in the
following figure:-

In this case, there is only a single list. The list is more or less sorted. You can sort the list completely by applying the insertion sort algorithm. The following figure displays the
result of Pass 3.

The list is now sorted. The algorithm to sort the list by using the shell sort algorithm is as
follows:-

1. Repeat step 2 varying incr from 3 to 1 // Repeat for each pass.
2. Repeat steps 3 and 4, varying L from 0 to incr – 1 // Repeat for each sublist in a pass
3. Apply insertion sort on the L^th sublist:
   1. Set i = L + incr // i is set to the index of the second element in the L^th sublist
   2. Repeat until i becomes greater than or equal to n:
      1. Set temp = arr[i]
      2. Set j = i – incr
      3. Repeat steps iv and v until j becomes less than 0 or arr[j] becomes less than or equal to temp
      4. Shift the value at index j to index j + incr
      5. Decrement j by the value contained in incr
      6. Store temp at index j + incr
      7. Increment i by the value contained in incr

Efficiency of Shell Sort

The efficiency of shell sorting can be determined with the help of mathematical analysis.
Although it is easy to develop an intuitive sense of how this algorithm works, it is very difficult to analyze its execution time. However, estimates range from O(n log₂n) to O(n^1.5) depending on the initial size of the increment value.

Note: The efficiency of this sorting algorithm is based on the size of the increments. It is recommended to use prime numbers as increment values because if the increment values are powers of 2 then the same elements are compared again in the next passes.

Given below is a C# implementation of the Shell sort algorithm:-

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public int[] ShellSortArray(int[] a)
{
	for (int incr = 3; incr > 0; incr--)
	{
		for (int L = 0; L < incr; L++)
		{
			for (int i = L + incr; i < a.Length; i += incr)
			{
				int temp = a[i];
				int j = i - incr;
				while (j >= 0 && a[j] > temp)
				{
					a[j + incr] = a[j];
					j -= incr;
				}
				a[j + incr] = temp;
			}
		}
	}
	return a;
}

You will learn about other sorting techniques, such as quick sort, merge sort, and heap
sort in subsequent tutorials

Tutorial Map

1. Introduction
2. Role of Algorithms and Data Structures in Problem Solving
3. Role of Algorithms
4. Role of Data Structures
5. Types of Data Structures
6. Designing Algorithms and measuring their efficiency
7. Identifying Techniques for Designing Algorithms
   1. Divide and Conquer Approach
   2. Greedy Approach
8. Designing Algorithms using Recursion
   1. Tower of Hanoi
9. Determining the Efficiency of an Algorithm
   1. Time/Space Tradeoff
   2. Method for determining Efficiency
   3. Selecting an Efficient Algorithm
   4. Best, Worst, and Average Case Efficiency

Introduction

Computer science is a field of study that deals with solving a variety of problems by using computers. The problem to be solved could be as simple as performing the addition of two numbers, or as complex as designing a robot capable of making decisions in a real-time environment. To solve a given problem by using computer, you need to design an algorithm for it. The nature of an algorithm often depends closely on the nature of the data on which the algorithm works. Therefore, the study of algorithms also involves the study of the data structures that algorithms work on.

This tutorial discusses the role of algorithms and data structures in problem solving through computers. It also discusses some standard techniques that can be used to design algorithms. In addition, it discusses the effect of the selected algorithm on the efficiency of the solution.

Role of Algorithms and Data Structures in Problem Solving

Problem solving is an essential part of every scientific discipline. In today’s world, computers are widely used to solve problems pertaining to various domains, such as banking, commerce, medicine, manufacturing, and transport.

To solve a given problem by using a computer, you need to write a program for it. A program consists of two components, algorithm and data structure.

Many different algorithms can be used to solve the same problem. Similarly, various types of data structures can be used to represent a problem in a computer.

To solve the problem in an efficient manner,you need to select a combination of algorithms and data structures that provide maximum efficiency.

Role of Algorithms

The word algorithm is derived from the name of the persian mathematician Al Khwarizmi.

An algorithms can be defined as a step-by-step procedure for solving a problem. It helps the user arrive at the correct result in a finite number of steps. Consider the following step-by-step procedure to display the first 10 natural numbers:-

1. Set the value of counter to 1
2. Display counter
3. Increment counter by 1
4. If counter <=10, go to step 2

The preceding step-by-step procedure is an algorithm because it produces the correct result in a finite number of steps.

An algorithm has five important properties:-

• Finiteness: An algorithm terminates after a finite number of steps.
• Definiteness: Each step in an algorithm is unambiguous. This means that the action specified by the step cannot be interpreted in multiple ways and can be performed without any confusion.
• Input: An algorithm accepts zero or more inputs.
• Output: An algorithm produces at least one output.
• Effectiveness: An algorithm consists of basic instructions that are realizable. This means that the instructions can be performed by using the given inputs in a finite amount of time.

A problem can be solved by using a computer only if an algorithm can be written for it. In addition, the use of algorithm provides many other benefits:-

• While writing an algorithm, you identify the step-by-step procedure, the major decision points, and the variables necessary to solve the problem. This helps you in the development of the corresponding program.
• Identification of the procedure and the decision points reduces the problem into a series of smaller problems of more manageable size. Therefore, problems that would be difficult or impossible to solve as a whole can be approached as a series of small solvable sub problems.
• With the use of an algorithm, decision making becomes a more rational process. This is because algorithms comprise of sub tasks, where each sub task is atomic in nature and is supported by facts.
• With the use of an algorithm, the same specified steps are used for performing the tasks. This makes the process more consistent and reliable.

Role of Data Structures

Multiple algorithms can be designed to solve a particular problem. However, the algorithm may differ in how efficiently they can solve the problem. In such a situation, an algorithm that provides the maximum efficiency should be used for solving the problem. Efficiency here means that the algorithm should work in minimal time and use minimal memory.

One of the basic techniques for improving the efficiency of algorithms is to structure the data that they operate on in such a way that the resulting operations can be efficiently performed.

The way in which the various data elements are organized in memory with respect to each other is called a data structure.

Data can be organized in many different ways; therefore, you can create as many data structures as you want. However, there are some standard data structures that have proved useful over the years. These include arrays, linked lists, stacks, queues, trees and graphs. We will learn more about these data structures in the subsequent tutorials.

All these data structures are designed to hold a collection of data items. However, the differences lies in the way the data items are arranged with respect to each other and the operations that they allow. Because of the different ways in which the data items are arranged with respect to each other, some data structures prove to be more efficient that others to solve a given problem.

Suppose you have to write an algorithm that enables printer to service the requests of multiple users on a first-come-first-served (FCFS) basis. In this case, using a data structure that stores and retrieves the requests in the order of their arrival would be much more efficient than a data structure that stores and retrieves the requests in a random order.

In addition to improving the efficiency of an algorithm, the use of appropriate data structures also allows you to overcome some other programming challenges, such as:-

• Simplifying complex problems
• Creating standard, reusable code components

• Creating programs that are easy to understand and maintain

Consider an example where you have to find the maximum value in a set of 50 numbers, In this scenario, you can either use 50 variables or a data structure, such as an array of size 50, to store the numbers. When 50 different variables are used to store the numbers, the algorithm to determine the maximum value among the numbers can be written as:

1. Accept 50 numbers and store them in num1, num2, num3, .. num50
2. Set max = num1
3. If num2 > max then: max = num2
4. If num3 > max then: max = num3:
   .
   .
5. If num50 > max then max = num50
6. Display max

On the other hand, when an array of size 50 is used, the algorithm can be written as:-

1. Set max = num[0]
2. Repeat step3 varying i from 1 to 49
3. If num[i] > max then: max = num[i]
4. Display max

From the preceding two algorithms, it can be seen that the algorithm using an array manipulates memory much more efficiently than the algorithm using 50 variables. Also, the algorithm using an array involves few steps and is therefore, easier to understand and implement as compared to the algorithm that uses 50 variables.

Data structures also enable the creation of reusable code components. Suppose you have created a class to implement a data structure that stores and retrieves requests in the order of their arrival. Once the class is created, the same class can be used in several different applications that need to service the requests of multiple users on a FCFS basis.

This means that a data structure once implemented can be used as a standard component to provide a standard solution to a specific set of problems. The use of standard components helps simplify the maintenance process. This is because the standard components are time tested and therefore, do not need much maintenance.

Types of Data Structures

Data structures can be classified under the following two categories:

• Static: These are data structures whose size is fixed at compile time, and does not grow or shrink at runtime. An example of a static structure is an array. Suppose you declare an array of size 50, but store only 5 elements in it; the memory space allocated for the remaining 45 elements will be wasted. Similarly, if you have declared an array of size 50 but later want to store 20 more elements, you will not be able to store these extra required elements because of the fixed size of an array.
• Dynamic: These are data structures whose size is not fixed at compile time and that can grow and shrink at run time to make efficient use of memory. An example of a dynamic data structure would be a list of items for which memory is not allocated in advance. As and when items are added to the lists, memory is allocated for those elements. Similarly, when items are removed from the list, memory allocated to those elements is de-allocated. Such a list is called a linked list.

Note: Arrays and linked lists are basic data structures that are used to implement other data structures such as stacks, queues, trees and graphs.

An array is always a static data structure, and a linked list is always a dynamic data structure. However, the other data structures can be static or dynamic depending on whether they are implemented using an array or a linked list.

Designing Algorithms and measuring their efficiency

Designing an algorithm for a given problem is a difficult intellectual exercise. This is because there is no systematic method for designing an algorithm. Moreover, there may exist more than one algorithm to solve a problem, Writing an effective algorithm for a new problem or writing a better algorithm for an already existing one is an art as well as science because it requires both creativity and insight.

Identifying Techniques for Designing Algorithms

Although there is no systematic method for designing an algorithm, there are some well-known techniques that have probed to be quite useful in designing algorithms. Two commonly used techniques for designing algorithms are:-

Divide and Conquer Approach

The divide an conquer approach is an algorithm design technique that involves breaking down the problem recursively into sub problems until the sub problems become so small that they can directly be solved. The solutions to the sub problems are then combined to give a solution to the original problem.

Divide and conquer is a powerful approach for solving conceptually difficult problems. It simply requires you to find a way of:-

1. Breaking the problem into sub problems
2. Solving the trivial cases.
3. Combining the solutions of the sub problems to solve the original problem.

Divide and conquer often provides a natural way to design efficient algorithms.

Consider an example where you have to find the minimum value in a list of numbers. The lists is as shown in the figure:-

To find the minimum value, you can divide the list into two halves, as shown in the following figure:-

Again, divide each of the two lists into two halves as shown in the following figure:-

Now, there are only two elements in each list. At this stage, compare the two elements in each lists to find the minimum of the two. The minimum values from each of the four lists is shown in the following figures.

Again, compare the first two minimum values to determine their minimum. Also compare the last two minimum values to determine their minimum. The two minimum values thus obtained are shown in the following figure:-

Again, compare the two final minimum values to obtain the overall minimum value, which is 1 in the preceding example.

Designing Algorithms using Recursion

Recursion refers to the technique of defining a process in terms of itself. It is used to solve complex programming problems that are repetitive in nature.

The basic idea behind recursion is to break a problem into smaller versions of itself, and then build up a solution for the entire problem. This may sound similar to the divide and conquer technique. However, recursions not similar to the divide and conquer technique. Divide and conquer is a theoretical concept that may be implemented in a computer program with the help of recursion.

Recursion is implemented in a program by using a recursive procedure or function. A recursive procedure is a function which invokes itself.

Consider a function f(n), which is the sum of the first n natural numbers. This function can be defined in several different ways.

In mathematics, the function will be defined as:-

f(n) = 1 + 2 + 3 + …. + n

However, the same function can be defined in a recursive manner as:-

f(n) = f(n – 1) + n

Where n >1; and f(1) = 1

In this case, the recursive definition of the function f(n) calls the same function, but with its arguments reduced by one. The recursion will end n = 1, in which case f(1) = 1 has been defined.

To understand this concept, consider a factorial function. A factorial function is defined as:-

n! = 1 x 2 x 3 x 4 x .. x n

This same factorial function can be redefined as:-

n! = (n – 1)! x n

Where n > 1; and 0! = 1

This definition of n! is recursive because it refers to itself when it uses (n – 1)!.
The value of n! is explicitly given where n = 0; and the value of n! for arbitrary n is defined in terms of the smaller value of n, which is closer to the base value 0.

If you have to calculate 3! By using recursion. you first define 3! in terms of 2!:-

3! = (3 x 2!)

Now, you will define 2! in terms of 1!:-

3! = (3 x (2 x 1!))

Now, 1! will be defined in terms of 0!:-

3! = (3 x (2 x (1 x 0!)))

As, 0! is defined as 1, the expression becomes:-

3! = (3 x (2 x (1 x 1)))

3! = (3 x (2 x 1 ))

3! = (3 x 2)

3! = 6

This recursive algorithm for determining the factorial of a number n can be written as:-

Algorithm: Factorial(n)

1. If n = 0, then: //Terminating condition
   1. Return (1)
2. Return (n x Factorial(n – 1))

Please note that every recursive algorithm should have a terminating condition. Otherwise, the algorithm will keep on calling itself infinitely.

The main advantage of recursion is that it is useful in writing clear, short, and simple programs. One of the most common and interesting problems that can be solved using recursion is the Tower of Hanoi problem.

Tower of Hanoi

Tower of Hanoi is a classical problem, which consists on n different sized disks and three pins over which these disks can be mounted. All the disks are placed on the first pin with the largest disk at the bottom and the remaining disks in decreasing order of their size as shown in the following figure:-

The objective of the game is to move all disks from the first pin to the third pin in the least number of moves by using the second pin as an intermediary.

To play this game, you need to follow rules:-

• Only one disk can be moved at a time
• A larger disk cannot be placed over a smaller one

Let n be the number of the discs. If n = 3, it will require seven moves to transfer all discs from pin one to pin three, as shown in the table below.

The moves given in the preceding table ar illustrated in the following figures:-

When n = 2, we should move the top disc from pin 1 to pin 2, ,move the top disc from pin 1 to pin 3, and then move the top disc from pin 2 to pin 3.

The solution for n = 1 will be to move the disc from pin 1 to pin 3.

In general, to move n discs from pin 1 to pin 3 using pin 2 as an intermediary, you first need to move the top n – 1 discs from pin 1 to pin 2 using pin 3 as intermediary.

The following algorithm can be used to move the top n discs from the first pin START to final pin FINISH through the temporary pin TEMP:-

Move (n, START, TEMP, FINISH)

1. When n = 1:
   1. MOVE a disc from START to FINISH
   2. Return
2. Move the top n -1 discs from START to TEMP using FINISH as an intermediary [MOVE (n - 1, START, FINISH, TEMP)]
3. Move the top disc from START to FINISH
4. Move the top n – 1 discs from TEMP to FINISH using START as an intermediary [MOVE (n - 1, TEMP, START, FINISH)]

In general, this solution requires 2ⁿ-1 moves for n discs.

Determining the Efficiency of an Algorithm

The greatest difficulty in solving programming problems is not how to solve the problem, but how to solve the problem efficiently. Factors that affect the efficiency of a program include the speed of the machine, the compiler. the operating system, the programming language, and the size of the input. However, in addition to these factors, the way data of a program is organized, and the algorithm used to solve the problem also has a significant impact on the efficiency of a program.

There can be cases, where a number of methods and algorithms can be used to solve a problem. In such a situation, it can be difficult to decide which algorithm to use.

When there are several different ways to organize data and devise algorithms, it becomes important to develop criteria to recommend a choice. Therefore, you need to study the behavior of algorithms under various conditions and compare their efficiency.

The efficiency of an algorithm can be computed by determining the amount of resources it consumes. The primary resources that an algorithm consumes are:

• Time: The CPU time required to execute the algorithm
• Space: The amount of memory used by the algorithm for execution

The lesser resources that an algorithm uses, the more efficient it is.

Time/Space Tradeoff

To solve a given programming problem, many different algorithms may be used. Some of these algorithms may be extremely time-efficient and others extremely space-efficient.

Time/space tradeoff refers to a situation where you can reduce the use of memory at the cost of slower program execution, or reduce the running time at the cost of increased memory usage.

An example of a situation where a time/space tradeoff can be applied is that of data storage. If data is stored in a compressed form, the memory usage is less because data compression reduces the amount of space required. However, it is more time consuming because some additional time is required to run the compression algorithm. Similarly, if data is stored in its uncompressed form, the memory usage is more, but the running time is less.

Memory is generally perceived to be extensible because you can increase the memory of your computer. Time, however, is not extensible. Therefore, time considerations generally override memory considerations.

Method for determining Efficiency

Although, the efficiency of an algorithm depends on how efficiently it uses time and memory space, the scope of this course is limited to determining only the time efficiency of an algorithm.

To measure the time efficiency of an algorithm, you can write a program based on the algorithm, execute it, and measure the time it takes to run. The execution time that you measure in this case would depend on a number of factors such as:-

• Speed of the machine
• Compiler
• Operating System
• Programming language
• Input data

However, to determine how efficiently an algorithm solves a given problem, you would like to determine how the execution time is affected by the nature of the algorithm. Therefore, you need to develop fundamental laws that determine the efficiency of a program in terms of the nature of the underlying algorithm.

To understand how the nature of an algorithm affects the execution, consider a simple example. Suppose assignment, comparison, write, and increment statements take a, b, c, and d time units to execute respectively. Now, consider the following code used to display the elements stored in an array:-

1. Set I = 0 // 1 assignment
2. While(I < n): // n comparisons
   1. Display a[I] // n writes
   2. Increment I by 1 // n increments

The execution time required for the preceding algorithm is given by:-

T = a + b x n + c x n + d x n

T = a + n(b + c + d)

Here, T is the total running time of the algorithm expressed as a linear function of the number of elements (n) in the array. From the preceding expression, it is clear that T is directly proportional to n.

In fact, the total running time T is directly proportional to the number of iterations involved in the algorithm. The number of iterations can be determined by counting the number of comparisons involved in the algorithm.

In the preceding code segment, a total of n comparisons are being made. Therefore, the total running time of the algorithm, T is directly proportional to n.

As T is directly proportional to n, an increase in the value of n will result in a proportional increase in the value of T, as shown in the following figure.

Now, consider the following algorithm:-

1. Set I = 0 // 1 assignment
2. While (I < n): // n comparisons
   1. Set J = 0 // n assignments
   2. While (J < n): // n x n comparisons
      1. Display (a[I][J]) // n x n writes
      2. Increment J by 1 // n x n increments
   3. Increment I by 1 // n increments

If you count the number of comparisons in the preceding code segment, they come out to be (n ² + n), which is a quadratic function of n. Therefore, the total running time is directly proportional to n².

Note: Although the number of comparisons is n² + n, the value of n is very small as compared to the value of n² (especially when n is very large). Therefore, the value of n can be ignored for finding the approximate running time.

As the running time is directly proportional to n², an increase in the value of n will result in a quadratic increase in the running time. This means that if the value of n is doubled, the running time will increase four times. The rate of change of T with an increase in the value of n is depicted in the following figure:-

From the preceding discussion, you can conclude that the running time of a program is a function of n, where n is the size of the input data. The rate at which the running time of an algorithm increases as a result of an increase in the volume of input data is called the order of growth of the algorithm.

The order of growth of an algorithm is defined by using the big O notation. The big O notation has been accepted as a fundamental technique for describing the efficiency of an algorithm.

The following table lists some possible orders of growth, and their corresponding big O notations.

If an algorithm has a linear order of growth, the algorithm is said to be of the order O(n). Similarly, if an algorithm has a quadratic order of growth, the algorithm is said to be of the order O(n ²).

Selecting an Efficient Algorithm

Now that you know how the efficiency of a particular algorithm is determined, let us see how this knowledge can be used to select an efficient algorithm.

According to their orders of growth, the big O notations can be arranged in an increasing order as:-

O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(n³) < O (2ⁿ) < O (10ⁿ)

Therefore, if a problem can be solved by using algorithms each of the preceding orders of growth, an algorithm of the order of O(1) will be considered best, and an algorithm of the order O(10ⁿ) will be considered the worst. The goal of algorithm development should be to make algorithms of the smallest possible orders.

The following table depicts the orders of growth for the preceding big O notations.

Big O Notation	Order of growth
O(1)
O(log n)
O(n)
O(n log n)
O(n2)
O(n3)
O(2n)
O(10n)

Now, consider that the assignment, comparisons, write and increment statements take a,b,c and d time units to execute, respectively. Also, suppose all arithmetic operations require e time units to execute. Now, consider the following two algorithms to find the sum of first n natural numbers:-

Algorithm A

1. Set sum = 0 // 1 assignment
2. Set i = 0 // 1 assignment
3. While (i <= n) // n comparisons
   1. Set sum = sum + i // n arithmetic operations, n assignments
   2. Increment i by 1 // n increments
4. Display (sum) // 1 write

Algorithm B

1. Set sum = (n x (n + 1))/2 // 3 arithmetic operations, 1 assignment
2. Display (sum) // 1 write

Both Algorithm A and Algorithm B perform the same task, that is, both determine the sum of the first n natural numbers. Algorithm A adds each number iteratively to a variable sum. However, Algorithm B uses a formula to calculate the sum of the first n natural numbers.

The execution time requires for Algorithm A is given by:-

T = (n + 2) x a + (n x b) + (1 x c) + (n x d) + (n x e)

T = an + 2n + bn + c + dn + en

T = c + n(a + b + d + e + 2)

As T is a linear function of n.

Therefore, the algorithm is of the order O(n).

Now determine the time required to execute algorithm B:-

T = (1 x a) + (1 x c) + (3 x e)

T = a + c + 3e

Unlike Algorithm A, the time taken by Algorithm B is a constant, and does not depend on the value of n. Therefore, the algorithm is of the order O(1).

Because Algorithm A is of the order O(n), the execution time of Algorithm A increases linearly with the value of n. However, Algorithm B is of the order O(1). Therefore, the execution time of Algorithm B is constant. This means that an increase in the value of n does not have any impact on the execution time of the algorithm. Therefore, however large the problem be, Algorithm A solves it in the same amount of time.

Suppose for n = 10, both Algorithm A and B take 10 nanoseconds(ns) to execute. However when n is increased to 100, Algorithm A will take 100 ns to execute, but Algorithm B will take only 10 ns to execute, Similarly, when n is increased to 1000, Algorithm A will take 1000 ns to execute, but Algorithm B will take only 10 ns.

This means that when the problem is very large in size, Algorithm B would prove to be much more efficient than Algorithm A.

Best, Worst, and Average Case Efficiency

Suppose you have a list of names in which you have to search for a particular name. You have designed an algorithm that searches the name in the list of n elements, by comparing the name to be searched with each element in the list sequentially.

The best case in this scenario would be if the first element in the list matches the name to be searched. The efficiency in that case would be expressed as O(1) because only one comparison was made.

Similarly, the worst case in this scenario would be if the complete list is traversed and the element is found at the end of the list or is not found in the list. The efficiency in that case would be expressed as O(n) because n comparisons were made.

Continuing with the same example, the average case efficiency can be obtained by finding the average number of comparisons. Here,

Minimum number of comparisons = 1

Maximum number of comparisons = n

Therefore, average number of comparisons = (n + 1)/2

(n + 1)2 is a linear function of n. Therefore, the average case efficiency will be expressed as O(n).

The worst case efficiency of the preceding search program can be improved by using an alternate search algorithm that provides a better worst case efficiency.

A search algorithm with a better worst case efficiency is binary search that provides an efficiency of O(log n) in the worst case. We will learn more about this algorithm in the subsequent tutorials.

Many courses being taught at the higher levels of education, today, don’t start off at the absolute beginning of Programming. For a person who has no prior experience in programming, knowing the basics is very essential. In these series of tutorials, I will take you on the journey that I did, back at school and learned whatever little of Programming, that I know today. We will begin by using LOGO, the programming language. I believe it will impart good insights into the bare-bones of Programming.

We need to know a few terms before we begin using LOGO. Don’t worry these are no jargons, only the bare minimals.

Instruction

An instruction is a command to the computer which causes a certain action to be performed.

Program

Lines of instruction that are executed or processed by the computer one by one.

We will need the MSWLogo software to go any further. You can get it from here. Once installed, start Microsoft Windows Logo from the start menu. The application is composed of a pair of Windows. The upper one with a white background and a Triangle in the middle is your drawing area.

The lower one titled Commander is where you will write the instructions and feed it to the computer.

LOGO is a programming language that works on turtle graphics. A triangle shaped object (the Turtle) is used to draw lines & curves on the screen. To draw these lines you instruct the turtle to move forward or backward and while doing so, it leaves a line behind. Try typing the instruction given below in the textbox to the right of the Execute button in the Commander window and then press enter or click on Execute.

FORWARD 50

As you can see, the turtle moved upward, or forward in its own orientation, leaving behind the black line. The instruction we provided is composed of two parts: FORWARD – the command to make the turtle go forward and 50 the distance it moved forward by. Now type in the following command and press enter.

BACK 100

The turtle comes back 100 units drawing over the old line and extending it by 50 at the bottom. Unlike in real life, an overwrite on the same line doesn’t make the line thicker. Let us try some more tricks, type in the following instruction and press enter.

RIGHT 90

This makes the turtle turn right (clockwise) by 90 degrees allowing us to draw a horizontal line. The RIGHT command is followed by an angle in degrees. The turtle can turn in any direction with this. But, we have a command to make it turn the other way too – the LEFT command. Now execute the following command.

FD 100

FD command is an alias (another name) for the FORWARD command and it provides the exact same functionality. The Aliases for the commands are given in the table below.

Lets complete our diagram by executing these instructions one by one.

LT 90
FD 100
RT 270
FD 100

There we have it; Mr. Paniter has drawn us our very own Square. The third instruction, RT 270 can be replaced by an equivalent LT 90. You can provide a negative value to the FD and BK commands to make them go the opposite way. You can even give negative angles or angles greater than 360 degrees and make the poor turtle go round and round (apparently, the slow dude turns so fast, we won’t be able to see it spin its head off, or maybe it has some sharp geomerty skills and does only one round).

Drawing dashed lines or discontinous figures

Did I mention how the turtle goes about drawing all those lines? The guy uses a pen! Not your average pen that runs out of ink every second day, though. Just as we raise our pen in between writing two words, you can make the turtle raise its pen and move to some place else. During this movement, it won’t draw a line. We use the PENUP command to raise the pen up. While in this state, moving in no direction will result in a line being drawn. To lower the pen use the PENDOWN command. When the pen has been lowered, lines will again begin to be drawn following an FD OR BK command (unless offcourse if you move it by 0 units).

Note: PENUP & PENDOWN commands are not followed by any numbers. You can also use their aliases PU & PD.

Clear the screen using the CS command and execute the following instruction to draw a dashed line.

FD 30
PU
FD 30
PD
FD 30
PU
FD 30
PD
FD 30

Chaining Instuctions in one line

You can write multiple instuctions in one line. For example, the dashed line can be drawn using the following command.

CS FD 30 PU FD 30 PD FD 30 PU FD 30 PD FD 30

The REPEAT command

The REPEAT command is used to repeat a series of instructions a given number of times. For example, you can use the following code to draw a square.

REPEAT 4 [FD 100 RT 90]

The dashed line can be drawn with the REPEAT command.

CS REPEAT 3 [PD FD 30 PU FD 30]

The REPEAT command is followed by a number specifying how many times to repeat the steps and the set of instructions to be repeated. The instructions to be repeated are enclosed between the square brackets [ and ].

Syntax

Syntax is the grammar of instructions. Every command has a syntax. For example, the FD command is followed by a number, whereas the syntax of PU & PD commands don’t contain any numbers following them. We can express these syntax in general forms:-

Syntax helps us understand the structure of the command, how its written/used. Every Programming language has its own set of commands, statements & their corresponding syntaxes.

Note: Description of statements is not relevant to the LOGO language. We will go through it in a later tutorial.

In this tutorial we have seen what instructions are and how to write them for the LOGO language. The LOGO language offers more than what we have covered here. But, our aim was only to get familiar with instructions. In the next tutorial we will be continuing our journey into the world of Programming.