eXclusiveMinds

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++];
    }
}

You have got 3 sorted arrays A1 A2 and A3 having m n and p elements respectively. A gap of 3 is defined to be max distance between 3 numbers if they are put on a number line say u pick three 2 12 and 7 then the gap is 10. Now u have to find an efficient way of choosing 3 numbers from these 3 separate arrays(A1,A2,A3) such that their gap is minimum. Of course if a num say 2 occurs in all 3 then gap is 0

eXclusiveMinds — Thu, 04 Mar 2010 19:02:21 +0000

Method 1) Basic Method

Let
array1={10,40}
array2={40,50}
array3={10,50}
first second the 0th element from all the 3 arrays and calculate the span and assume that to be minimum span…
for the above case current three values are 10,40,10 from 1st, 2nd and 3rd array respectively and the span is 30.
now increase the index of the array which contains the minimum value and now since we have a tie between 1st array and 3rd array in the given scenario that is both have their current value as 10 we can increase either of them….
Let us assume we increased the index for 1st array and now again calculate the span…
So now the 3 current values are 40, 40, 10 and the span is again 30.
Continue increasing the current minimum value holder array’s index and recalculate the span…
so now since 3rd array contain the minimum value that is 10 increase its index…
so the next 3 values are 40,40,50 and the span is 10. Since this span is less than the previously stored span value replace the previously store span value with the current one.
Now continue doing this unless any of the index is out of bound…such that index is getting increased beyond the last value.

Method 2) Optimized

O(n*m)
n == number of rows
m == number of columns (if number of elements in rows are not same , take the max value)

Merge all rows into a single array, say A (keep track of original row numbers for each of the elements)

may be something like
struct {
int element;
int rowno;
}A[n*m];
3, 7, 16, 48
5, 9, 21, 27, 49, 58
1, 4, 8, 17, 47, 50
{ {1,3} {3,1} {4,3} {5,2} {7,1} {8,3} {9,2} {16,1} {17,3} {21,2} {27,2} {47,3} {48,1} {49,2}, {50,3} {58,2}}

start from A[0], i.e; index=firstP=0; A[index]
Increment Index till u get to c one element from each row.once u get to c all elements from each row , save a pointer to the array at that point , say secondP;

may be something lime
bool Seen[n]={0};
while ( All elements in Seen[n] != 1 )
{
index++;
}
secondP=Index;
This is our first span . (to print the span you can make one more pass over the array from firstP to secondP , and can print elements from different rows)
Find the Span of this Snippet say BestSpan=A[SecondP]-A[firstP];
*Now move firstP to next number , firstP++; , check if the elements between A[firstP] to A[SecondP] contains elements from all rows . if so find the span and update it with the max span (if span < BestSpan)
*If it doesn’t contain all elements from all rows Increment secondP++;
check if the elements between A[firstP] to A[SecondP] contains elements from all rows. If so find the span and update it with the max span (if span < BestSpan)
*Repeat the same till you are done with scanning all elements from the array

While ( Scan all elements != Done )
{
         firstP++
         if ( contains elements from all rows )
         {
           if ( span < BestSpan)
           {
             update BestSpan
           }

           continue;
         }
         secondP++
         if ( contains elements from all rows)
         {
           if ( span < BestSpan)
           {
             update BestSpan
           }
         }
}

{{1,3} {3,1} {4,3} {5,2} {7,1} {8,3} {9,2} {16,1} {17,3} {21,2} {27,2} {47,3} {48,1} {49,2}, {50,3} {58,2}}
FirstP = 1
SecondP = 4
Span = 4
BestSpan = 4
{{1,3} {3,1} {4,3} {5,2} {7,1} {8,3} {9,2} {16,1} {17,3} {21,2} {27,2} {47,3} {48,1} {49,2}, {50,3} {58,2}}
FirstP = 2
SecondP = 4
Span = 2
BestSpan = 2

{{1,3} {3,1} {4,3} {5,2} {7,1} {8,3} {9,2} {16,1} {17,3} {21,2} {27,2} {47,3} {48,1} {49,2}, {50,3} {58,2}}

{{1,3} {3,1} {4,3} {5,2} {7,1} {8,3} {9,2} {16,1} {17,3} {21,2} {27,2} {47,3} {48,1} {49,2}, {50,3} {58,2}}
FirstP = 3
SecondP = 5
Span = 3
BestSpan = 2

{{1,3} {3,1} {4,3} {5,2} {7,1} {8,3} {9,2} {16,1} {17,3} {21,2} {27,2} {47,3} {48,1} {49,2}, {50,3} {58,2}}

{{1,3} {3,1} {4,3} {5,2} {7,1} {8,3} {9,2} {16,1} {17,3} {21,2} {27,2} {47,3} {48,1} {49,2}, {50,3} {58,2}}
FirstP = 4
SecondP = 6
Span = 3
BestSpan = 2

How will you find the MSB and LSB of a number

eXclusiveMinds — Thu, 04 Mar 2010 19:02:21 +0000

1111: MSB=4, LSB=4
1101100: MSB=7, LSB=3
To find MSB: Right shift the operator till the number become zero. The number of time that you have right shifted is the MSB
To find LSB: Right shift the number(take out the last number 0 or 1) and then left shift( put a 0 back)
Now if the number before the operation is equal 0 after the operation then
count++;
rightshift the number
goto start
int msb(int *num)
{

if(*num >> 1 == 0)

{

return msbCount;
}

else

{

*num >>= 1;

msbCount++;

return msb(num);

}
}

int lsb(int *num)
{
         if((*num>>1)<<1 != *num)
           return lsbCount;
         else
         {
           *num >>= 1;
           lsbCount++;
           return lsb(num);
         }
}

How can you get a tree back if traversal of tree output is given

eXclusiveMinds — Thu, 04 Mar 2010 19:02:21 +0000

BST can be constructed if
preorder/postorder+inorder is given
Not possible if preorder+postorder is given
Also refer this link for more algorithm/code regarding this problem

2D array search

eXclusiveMinds — Thu, 04 Mar 2010 19:02:21 +0000

There exits 2D array. We need or find out whether a given string (”microsoft”) exits in the given matrix. The string can be vertical or horizontal or in snake form but not in diagonal.
mi..
…c.o..oft
…..r.s
For every element, check its entire neighbor element to get the match
Please refer this link

How will you write your own sizeof operator

eXclusiveMinds — Thu, 04 Mar 2010 19:02:21 +0000

#define MySizeof(x) (char*)((x*)NULL+1)-(char*)((x*)NULL)

You are given a very large number N of points (x,y,z) in 3D space. You have to find out the k points which are closest to the origin i.e. (0, 0, 0). You have to do it in the most efficient way. (Sorting takes O(nlgn) and apparently there is a much better solution). Distance of P=(x,y,z) from origin is D=sqrt(xx + yy + z*z)

eXclusiveMinds — Thu, 04 Mar 2010 19:02:21 +0000

1. Given a Point P(x,y,z) in the space. The Point is said to be inside the sphere of radius(r) and Origin(0,0,0) if dist(P)=(x^2+y+2+z+2)<=r.
2. We are also assuming the Range and the desity of the points are not known.
3. Pick the First Point (p1) and calculate the hamming distance w.r.t origin and let it be R. This is also your boundary i.e. RH=RL=R
4. Create a sphere with radius R.
4. Find all points within this sphere and let it be N.
5. If N < K then some points are outside the sphere. Double R i.e. R=R*2. RH=R

6. If N > K then some excess points are inside the sphere. Half R i.e. R = R / 2. RL=R
7. If N = K then you are done with your search.
8. Now you have got two reference [RL,RH]. You have also got the no of points within the sphere RL i.e. NL. So no of Points within the cavity [Rl,RH] that needs to be picked is K-NL
9. Define a fn. BinarySearch(lowLimit,upperLimit) whose comparision function would be hamming distance from origin i.e. if Rmid is (RL+RH)/2 then we need to determine all points such that they are between [RL,Rmid] and if is less than K – NL then RL=Rmid else RH=Rmid else id its equal you have found the points.

How will you prove that there is no limit of prime number

eXclusiveMinds — Thu, 04 Mar 2010 19:02:21 +0000

Consider N as the upper limit of prime number
So consider N!+1 which is not divisible by 1-N.
So now N!+1 is also prime number, so gain considering N!+1 as upper limit we can take it forward like first line in the explanation
Hence there is no limit for prime number

How will you remove duplicate from an unsorted array

eXclusiveMinds — Thu, 04 Mar 2010 19:02:21 +0000

Method 1) Using extra space

Bucket sort if range is known
Declare an array of known range and initialize the value of each element as zero
On visiting each input number increment the corresponding array by 1(e.g. if 2 is found then make a[2]+=1)
At the last visit all the elements in the array and display the element if the array value is non-zero. This way the repeated number will be removed

Method 2) without extra space

Sort the elements
Keep info about the first element that is visited and the first array that has been filled
Once the info element is not equal to next element (means non-duplicate), put that next to the array that has been filled up
the problem to find duplicate and remove duplicate character to get code/algorithm