eXclusiveMinds » Tutorials

Quick Sort Implementation in C#

eXclusiveMinds — Fri, 12 Mar 2010 21:23:30 +0000

/* QuickSort.cs */
 
class QuickSort
{
    static void Main(string[] args)
    {
        a = new[] { 1, 6, 7, 2, 3, 8, 9, 4, 5 };
        Quicksort(a, 0, a.Length - 1);
    }
 
    static void Quicksort(int[] array, int lo, int hi)
    {
        //  lo is the lower index, hi is the upper index
        //  of the region of array array that is to be sorted
        int i = lo, j = hi;
        int pivot = array[(lo + hi) / 2];
 
        //  partition
        do
        {
            while (array[i] < pivot)
                i++;
            while (array[j] > pivot)
                j--;
            if (i <= j)
            {
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
                i++;
                j--;
            }
        } while (i <= j);
 
        //  recursion
        if (lo < j)
            Quicksort(array, lo, j);
        if (i < hi)
            Quicksort(array, i, hi);
    }    
}

Merge Sort Implementation in C#

eXclusiveMinds — Fri, 12 Mar 2010 21:21:41 +0000

/* MergeSort.cs */ 
 
class MergeSort
{
    private static int[] a, b;
 
    static void Main(string[] args)
    {
        a = new[] { 1, 6, 7, 2, 3, 8, 9, 4, 5 };
        b = new int[a.Length];
        Sort(0, a.Length - 1);
    }
 
    private static void Sort(int left, int right)
    {
        if (left < right)
        {
            int mid = (left + right) / 2;
            Sort(left, mid);
            Sort(mid + 1, right);
            Merge(left, mid, right);
        }
    }
 
    static void Merge(int left, int mid, int right)
    {
        int i = 0;
        int j = left;
 
        // copy first half of array a to auxiliary array b
        while (j <= mid)
            b[i++] = a[j++];
 
        i = 0;
        int k = left;
 
        // copy back next-greatest element at each time
        while (k < j && j <= right)
            if (b[i] <= a[j])
                a[k++] = b[i++];
            else
                a[k++] = a[j++];
 
        // copy back remaining elements of first half (if any)
        while (k < j)
            a[k++] = b[i++];
    }
}

Example showing Extension Methods in C#

Ujwal Manandhar — Sat, 02 Jan 2010 21:00:55 +0000

Extension Method is really a cool stuff. We can simply add the additional method to any object without knowing anything about that object.Let’s say we want a method for string object which will reverse the string then you can choose extension method to do the thing.

Start writing Extension method:

static class Extension
    {
        public static string Reverse(this String input)
        {
            char[] inputchar = input.ToCharArray();
            for (int i = 0; i < input.Length / 2; i++)
            {
                inputchar[i] ^= inputchar[input.Length - 1 - i];
                 inputchar[input.Length - 1 - i]^=inputchar[i] ;
                 inputchar[i] ^= inputchar[input.Length - 1 - i];
            }
            return new string(inputchar);
        }
    }

Note:
class should be static, Method should be public static and the object on which the method to be added should be passed as parameter preceding by keyword this.

Now you can start to use this method as

class Program
    {
        static void Main(string[] args)
        {
            string s = "ujwal";
            Console.WriteLine(s.Reverse());
        }
    }

I have done extensive use of Extension method while going through Asp.Net MVC project.

Binary Tree Implementation in C#

eXclusiveMinds — Fri, 11 Dec 2009 19:29:12 +0000

This is simple implementation of Binary Tree in C#. It includes all common methods for binary tree.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
 
namespace Interview
{
public class BinaryTree
{
	public TreeNode root;
 
	public BinaryTree()
	{
		root = null;
	}
 
	public void print()
	{
		if (root == null)
			Console.WriteLine("Empty Tree");
		else
			printTree(root);
		Console.WriteLine();
	}
	private void printTree(TreeNode n)
	{
		if (n != null)
		{
			printTree(n.left);
			Console.Write(n.data + " ");
			printTree(n.right);
		}
	}
 
	public void insert(int x)
	{
		root = insert(root, x);
	}
	private TreeNode insert(TreeNode TreeNode, int data)
	{
		if (TreeNode == null)
		{
			TreeNode = new TreeNode();
			TreeNode.data = data;
		}
		else
		{
			if (data <= TreeNode.data)
			{
				TreeNode.left = insert(TreeNode.left, data);
			}
			else
			{
				TreeNode.right = insert(TreeNode.right, data);
			}
		}
		return (TreeNode);
	}
 
	public int Size()
	{
		return (Size(root));
	}
	private int Size(TreeNode TreeNode)
	{
		if (TreeNode == null) return 0;
		else
		{
			return Size(TreeNode.left) + 1 + Size(TreeNode.right);
		}
	}
 
	public int MaxDepth()
	{
		return MaxDepth(root);
	}
	private int MaxDepth(TreeNode TreeNode)
	{
		if (TreeNode == null) return 0;
		int lDepth = MaxDepth(TreeNode.left);
		int rDepth = MaxDepth(TreeNode.right);
 
		return Math.Max(lDepth, rDepth) + 1;
	}
 
	public int MinValue()
	{
		return MinValue(root);
	}
	private int MinValue(TreeNode TreeNode)
	{
		if (TreeNode.left == null) return TreeNode.data;
		else return MinValue(TreeNode.left);
	}
 
	public bool HasPathSum(int sum)
	{
		return HasPathSum(root, sum);
	}
	private bool HasPathSum(TreeNode TreeNode, int sum)
	{
		if (TreeNode == null)
		{
			return (sum == 0);
		}
		else
		{
			int temp = sum - TreeNode.data;
			return HasPathSum(TreeNode.left, temp) || HasPathSum(TreeNode.right, temp);
		}
	}
 
	public void PrintPaths()
	{
		int[] path = new int[1000];
		PrintPaths(root, path, 0);
	}
	private void PrintPaths(TreeNode TreeNode, int[] path, int pathLen)
	{
		if (TreeNode == null) return;
		path[pathLen] = TreeNode.data;
		pathLen++;
		if (TreeNode.left == null && TreeNode.right == null)
		{
			PrintPaths(path, pathLen);
		}
		else
		{
			PrintPaths(TreeNode.left, path, pathLen);
			PrintPaths(TreeNode.right, path, pathLen);
		}
	}
	private void PrintPaths(int[] ints, int len)
	{
		for (int i = 0; i < len; i++)
		{
			Console.Write(ints[i] + " ");
		}
		Console.WriteLine();
	}
 
	public void mirror()
	{
		mirror(root);
	}
	private void mirror(TreeNode TreeNode)
	{
		if (TreeNode != null)
		{
			mirror(TreeNode.left);
			mirror(TreeNode.right);
 
			TreeNode temp = TreeNode.left;
			TreeNode.left = TreeNode.right;
			TreeNode.right = temp;
		}
	}
 
	public void DoubleTree()
	{
		DoubleTree(root);
	}
	public void DoubleTree(TreeNode TreeNode)
	{
		if (TreeNode == null) return;
		DoubleTree(TreeNode.left);
		DoubleTree(TreeNode.right);
 
		TreeNode temp = TreeNode.left;
		TreeNode newNode = new TreeNode();
		newNode.data = TreeNode.data;
		TreeNode.left = newNode;
		TreeNode.left.left = temp;
	}
 
	public bool IsSameTree(BinaryTree tree)
	{
		return IsSameTree(root, tree.root);
	}
	private bool IsSameTree(TreeNode t1, TreeNode t2)
	{
		if (t1 == null && t2 == null) return (true);
		else if (t1 != null && t2 != null)
		{
			return (
				t1.data == t2.data &&
				IsSameTree(t1.left, t2.left) &&
				IsSameTree(t1.right, t2.right)
				);
		}
		else return (false);
	}
 
	public void PrintTreeLevelByLevel()
	{
		PrintTreeLevelByLevel(root);
	}
	private void PrintTreeLevelByLevel(TreeNode root)
	{
		if (root == null) return;
		Queue q = new Queue();
		q.Enqueue(root);
		while (q.Count > 0)
		{
			TreeNode b = (TreeNode)q.Dequeue();
			Console.Write(b.data + " ");
			if (b.left != null)
				q.Enqueue(b.left);
			if (b.right != null)
				q.Enqueue(b.right);
		}
	}
 
	public bool IsBST()
	{
		return (IsBST(root, Int32.MinValue, Int32.MinValue));
	}
	private bool IsBST(TreeNode TreeNode, int min, int max)
	{
		if (TreeNode == null)
		{
			return (true);
		}
		else
		{
			bool leftOk = IsBST(TreeNode.left, min, TreeNode.data);
			if (!leftOk) return (false);
			bool rightOk = IsBST(TreeNode.right, TreeNode.data + 1, max);
			return (rightOk);
		}
	}
}
 
public class TreeNode
{
	private int _data;
	private TreeNode _left;
	private TreeNode _right;
 
	public int data
	{
		get
		{
			return this._data;
		}
		set
		{
			this._data = value;
		}
	}
	public TreeNode left
	{
		get
		{
			return this._left;
		}
		set
		{
			this._left = value;
		}
	}
	public TreeNode right
	{
		get
		{
			return this._right;
		}
		set
		{
			this._right = value;
		}
	}
}
 
}

Finding Fullness quotient of a number

eXclusiveMinds — Fri, 11 Dec 2009 18:54:59 +0000

Define the fullness quotient of an integer n> 0 to be the number of representations of n in bases 2 through 9 that have no zeroes after the most significant digit, For example, to see why the fullness quotient of 94 is 6 examine the following table which shows the representations of 94 in bases 2 through 9.

base: 2 representation of 94: 1011110(2 ^ 6 + 2 ^ 4 + 2 ^ 3 + 2 ^ 2 + 2 ^ 1 = 94)
base: 3 representation of 94: 10111(3 ^ 4 + 3 ^ 2 + 3 ^ 1 + 3 ^ 0 = 94) 
base: 4 representation of 94: 1132(4 ^ 3 + 4 ^ 2 + 3 * 4 ^ 1 + 2 * 4 ^ 0 = 94 )
base: 5 representation of 94: 334(3 * 5 ^ 2 + 3 * 5 ^ 1 + 4 * 4 ^ 0 = 94) 
base: 6 representation of 94: 234(2 * 6 ^ 2 + 3 * 6 ^ 1 + 4 * 6 ^ 0 = 94) 
base: 7 representation of 94: 163(1 * 7 ^ 2 + 6 * 7 ^ 1 + 3 * 7 ^ 0 = 94) 
base: 8 representation of 94: 136(1 * 8 ^ 2 + 3 * 8 ^ 1 + 6 * 8 ^ 0 = 94) 
base: 9 representation of 94: 114(1 * 9 ^ 2 + 1 * 9 ^ 1 + 4 * 9 ^ 0 = 94)

Notice that the representations of 94 in base 2 and 3 both have 0s after the most significant digit, but the representations in bases 4,5, 6, 7, 8, 9 do not. Since there are 6 such representations, the fullness quotient of 94 is 6

Write a method named fullnessQuotient that returns the fullness quotient of its argument. If the argument is less than 1 return -1. Its signature is
int fullnessQuotient (int n)
Hint: use modulo and integer arithmetic to convert n to its various representations

Example:

if n is: 1 return: 8, because: Because all of its representations do not have a 0 after the most significant digit: 2:1,3:1,4:1,5:1,6 : 1,7:1,8:1,9:1 
if n is: 9 return: 5, because: Because 5 of the representations (4, 5, 6, 7, 8) do not have a 0 after the most significant digit: 2:1001,3: 100,4:21,5:14,6:13,7:12,8:11,9:10 
if n is: 360 return: 0, because: All its representations have a 0 after the most significant digit: 2:101101000,3:111100,4:11220,5:2420,6:1400,7 : 1023,8:550,9:440 
if n is: -4 return: -1, because: The argument must be> 0

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Fullness Quotient: "+fullnessQuotient(9));
    }
 
    static int fullnessQuotient(int n)
             {
                     if (n <1)
                             return -1;
                     int count = 0;
 
                     for (int i = 2; i <10; i++)
                     {
                             if (isFullQuotient (n, i))
                                     count++;
                     }
 
                     return count;
             }
 
    private static bool isFullQuotient(int n, int b)
             {
                     int number = n;
                     do
                     {
                             if (number% b == 0)
                                     return false;
                     }while ((number /=b)!= 0);
                     return true;
             }
}

OUTPUT:

Fullness Quotient: 5

KMP String Searching Algorithm in C#

eXclusiveMinds — Tue, 08 Dec 2009 23:08:20 +0000

We’ve C# example of KMP (Knuth–Morris–Pratt) string serching algorithm.

/// 
/// C# Implementation of KMP Algorithm
/// 
/// Search String
/// Main String
/// 
public int SearchKMP(char[] w, char[] s)
{
	int m = 0;
	int i = 0;
	int[] t = new int[w.Length];
 
	while (((m + i) < s.Length) && (i < w.Length))
	{
		if (s[m + i] == w[i]) i++;
		else
		{
			m += i - t[i];
			if (i > 0) i = t[i];
			i++;
		}
	}
	if (i == w.Length) return m;
	else return -1;
}

Testing it:

static void Main(string[] args)
{
	int foundPosition=SearchKMP("eXclusiveMinds".ToCharArray() ,"01eXclusiveMinds".ToCharArray() );
	Console.WriteLine(foundPosition);
}

OUTPUT:

String Found at index: 2

Program to reverse sentence word by word using C#

eXclusiveMinds — Tue, 08 Dec 2009 18:40:21 +0000

This example shows how can we reverse a sentence word by word. For example; If we have string “This is an eXclusiveMinds article” output should be “article eXclusiveMinds an is This”. For this we have two methods ReverseWordByWord and Reverse (this is helper method to reverse string character by character).
This is also one of the most frequently asked interview question in Microsoft, Google and Amazon for position of Software Design/Development Engineer (or Test).

/// 
/// Function to reverse sentence word by word
/// 
/// string (sentence)
/// reversed string by word
public string ReverseWordByWord(string sentence)
{
	char[] str = sentence.ToCharArray();
 
	str = Reverse(str, 0, str.Length - 1);
 
	int start = 0, end = 0;
	for (int i = 0; i < str.Length; i++)
	{
		if (str[i] == ' ')
		{
			end = i - 1;
			str = Reverse(str, start, end);
			start = i + 1;
		}
	}
 
	//For Last word
	end = str.Length - 1;
	str = Reverse(str, start, end);
 
	return new string(str);
}

This method is helper function which will reverse a string character by character.

/// 
/// Helper method to reverse string character by character.
/// 
/// string to be reversed
/// start index
/// end index
/// reversed string
public char[] Reverse(char[] str, int start, int end)
{
	while (end > start)
	{
		str[start] ^= str[end];
		str[end] ^= str[start];
		str[start] ^= str[end];
		end--;
		start++;
	}
	return str;
}

Testing This Method:

string output=ReverseWordByWord("This is an eXclusiveMinds article");
Console.WriteLine(output);

OUTPUT:

//input: This is an eXclusiveMinds article
article eXclusiveMinds an is This

Remove Duplicate from Array with C#

eXclusiveMinds — Mon, 07 Dec 2009 22:13:37 +0000

This is one of the most frequently asked interview question. This question usually asked for interview of Software Engineer/Test Engineer in Microsoft, Google, Amazon.
We’ve 3 simple solution for this question.

/// 
/// This method removes duplicate from integer array
/// 
/// input array
/// integer array with no duplicate
public int[] RemoveUsingHash(int[] a)
{
	Hashtable ht = new Hashtable();
	for (int i = 0; i < a.Length; i++)
	{
		if (!ht.ContainsKey(a[i]))
		{
			ht.Add(a[i], a[i]);
		}
	}
	int[] output = new int[ht.Count];
	int j = 0;
	foreach (int item in ht.Keys)
	{
		output[j++] = item;
	}
	return output;
}

/// 
/// This method uses array (bucket) of integer
/// 
/// input integer array
/// array of integers without duplicate content on it.
public int[] BucketRemove(int[] a)
{
	int[] bucket = new int[256];
	int count = 0;
	for (int i = 0; i < a.Length; i++)
	{
		if (bucket[a[i]] != 1)
		{
			bucket[a[i]] = 1;
			count++;
		}
	}
	int[] output = new int[count];
	int j = 0;
	for (int i = 0; i < bucket.Length; i++)
	{
		if (bucket[i] == 1)
		{
			output[j++] = i;
		}
	}
	return output;
}

This method only works for sorted array. You can either return same array (duplicate content will move to last part of array) or last index of array which is length of array without duplicate element.

/// 
/// Removes duplicate in sorted array
/// 
/// array of integers
/// array of integers with no duplicate content (duplicate content moved to last part of array.)
public int[] RemoveDuplicate(int[] a)
{
	int j = 0;
	for (int i = 1; i < a.Length; i++)
	{
		if (a[j] != a[i])
		{
			a[++j] = a[i];
		}
	}
	return a;
}

Testing these methods:

int[] input = new int[] { 1, 2, 3, 4, 4, 5, 5, 6, 7 };
int[] a = BucketRemove(input);
foreach (int i in a)
{
	Console.Write(i + " ");
}
 
Console.WriteLine();
int[] b =RemoveUsingHash(input);
foreach (int i in a)
{
	Console.Write(i + " ");
}
 
Console.WriteLine();
int[] c = RemoveDuplicate(input);
foreach (int i in a)
{
	Console.Write(i + " ");
}

OUTPUT:

1 2 3 4 5 6 7
1 2 3 4 5 6 7
1 2 3 4 5 6 7

Simple array rotation example in C#

eXclusiveMinds — Mon, 07 Dec 2009 21:28:39 +0000

We’ve a solution for following frequently asked interview question. Here’s problem statement “Implement the following function, RotateArray, which takes as its input an array of unique integers that has been sorted in ascending order, then rotated by an unknown amount X where 0 <= X <= (arrayLength - 1). An array rotation by amount X moves every element array[i] to array[(i + X) % arrayLength]. RotateArray discovers and returns X by examining the array. You should be able to do this in less than linear time."

Signature of method would be:

public int[] RotateArray(int[] a, int X);

Here’s implementation:

/// 
/// Rotates sorted array.
/// 
/// integer array
/// rotation index
/// 
public int[] RotateArray(int[] a, int X)
{
	int[] output = new int[a.Length];
	int j;
 
	for (int i = 0; i < a.Length; i++)
	{
		j = (i + X) % a.Length;
		if (j < 0)
		{
			j += a.Length;
		}
		output[j] = a[i];
	}
	return output;
}

Testing this method:

static void Main(string[] args)
{
	int[] a = RotateArray(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }, 3);
	foreach (int i in a)
	{
		Console.Write(i + " ");
	}
}

OUTPUT:

7 8 9 1 2 3 4 5 6 //input: 1 2 3 4 5 6 7 8 9

Program to find longest palindrome in string with C#

eXclusiveMinds — Mon, 07 Dec 2009 21:10:58 +0000

Are you searching for solution for finding longest palindrome in string? If so we’ve something for you. We have following C# example for finding longest palindrome in character array (or string). We’ve two different while loop to find longest palindrome for odd length palindromes and even lenth palindromes.

 /// 
 /// This method finds longest palindrome in a character array.
 /// 
 /// array of characters
public void FindLongestPalindrome(char[] input)
{
	int len;
	int i = 0, j = 0, k = 0, l = 0;
	int lower = 0, upper = 0;
	len = input.Length;
 
	/*Odd length Palindromes*/
	while (i < len && j < len)
	{
		k = i;
		l = j;
		while ((k >= 0 && l < len) && (input[k] == input[l]))
		{
			if ((upper - lower) <= (l - k))
			{
				lower = k;
				upper = l;
			}
			k--;
			l++;
		}
		i++;
		j++;
	}
 
	/*Even length Palindromes*/
	i = 0;
	j = 1;
	while (i < len && j < len)
	{
		k = i;
		l = j;
		while ((k >= 0 && l < len) && (input[k] == input[l]))
		{
			if ((upper - lower) <= (l - k))
			{
				lower = k;
				upper = l;
			}
			k--;
			l++;
		}
		i++;
		j++;
	}
 
	for (i = lower; i <= upper; i++)
	{
		Console.Write(input[i]);
	}
	Console.WriteLine();
}