In this post, we are going to do a – Solve and Learn strategy ; You will be given a question and I will show you how to apply  the concepts on them.

TYPE 1 :: The Simplest :

If a post mentions recurrences, then it has to mention Fibonacci (Gosh, if only I had a penny for every mention of Fibo in tutorials. )

The recurrence is of type : F(n) = F(n-1) + F(n-2).

I am pretty sure you know to code the linear version of it which runs in O(N) but can you do it in O(log N) ? If you throw google to good use, you will come up with a solution which says there is a Matrix M which when raised to power N, will give you the N-th fibonacci number. And since you can always exponentiate in logN time, you have your answer. But to those, who wondered if this Matrix is magical- read on!

Firstly the answer- No; Its not magical. How. Lets do a little Algebra (yumm… My favourite! )

Obviously enough, the value of N-th term, depends on two previous terms (or states). This implies that all values depend on just the first two states in the sequence. As you can see here -

Hence in General, we may write ::

I hope that has helped you in understanding how to frame such equations and solving it with a matrix.

TYPE 2 : Simplest ++

Now that we have a basic understanding. Try the following recurrence :

F(n) = F(n-1) + F(n-2) + F(n-3).

It is the same as the previous recurrence but with an additional state. I won’t go on explaining the hows (again!). I am going to share the solution.

TYPE 3: Simplest << 1

Consider the following scenario ::

This one is a lot trickier. First thing to notice is that we will need 4 states in a matrix to fully define the next state. The reason for using 4 and not 3 is that H(n) depends on 2 states and thus we need 2 states (and not just 1) to represent it.

If you carefully write down the LHS matrix and the RHS matrix, then we can frame the solution as . . .

TYPE 4 : Ohhh !

The final hurdle can come in the name of a constant. If we add a constant C to the above recurrence we get -

But to tell you the truth, its not that difficult if your concepts are clean. Now there is another additional state to hold the information about C. The solution will look like -

I hope this post lived up to your expectations and I hope it was worth the wait . Please feel free to post comments/corrections/improvements to this post to make it really useful.

Tree is a heirarchial arrangement of nodes. From the literal meaning of Tree we know that it has root, branches, fruits and leaves. Well, in Algorithms also, we have a root – which is the origin of the tree. We have branches which connect to smaller trees and we have leaves, which do not have outgoing branches. And as far as the fruits are concern – depending on the complexity of operations that can be perform, we may label the fruits as sweet and sour !

The simplest tree would be a node which branches to exactly one other node, or in other words – a singly Link List. If every node branches to its child and also to its parent, we have a doubly link list. But in this post, we are not going to discuss these.

The next level of trees would be – where a single node may branch out to a maximum of two other nodes. Such a tree is call a binary tree. Binary trees are some of the most widely us datastructures in computers and we are going to discuss them in a series of posts. So lets begin.

One of the most important things to do is : Create a tree.
So what is it that we ne to create one. We will ne to represent the nodes and the links between nodes. And since we ne to connect to a maximum of two nodes, we will have two branches. We shall call these branches – left and right. Also, it will store some data in it. Our tree will be us to just store integers.

We will use the following structure to create it. FYI, everything here is in C++ and not C.

struct NODE {
    int data;
    NODE *left;
    NODE *right;
};

The obvious advantage of such a strategy is that we can search for elements in the tree in O(h) time, where h is the height of the tree. Do note that, in general, h does not equal logN. If we could actually have a tree where the height is inde logN, we would call such trees as Balanc Binary Search Trees.

Alright then, lets get our hands dirty with a code that will create the tree for us. The function insert takes as input the root of the tree and the value to be insert and returns the node which contains the data.

NODE * insert(NODE *root, int data) {
    if(root==NULL) {
        root=(NODE*)malloc(sizeof(NODE));
        root->left=root->right=NULL;
        root->data=data;
        return root;
    }
    else {
        while(root!=NULL) {
            if(root->data>data) {
                if(root->left!=NULL) root=root->left;
                else break;
            }
            else {
                if(root->right!=NULL) root=root->right;
                else break;   
            }
        }
        NODE *new_node=new NODE;
        new_node->data=data;
        new_node->left=new_node->right=NULL;
        if(root->data > data) {
            root->left=new_node;
        }
        else root->right=new_node;
        return new_node;
    }
}

Another very useful and important property when using the above strategy is, that the INORDER traversal is sort!

Lets backup a bit. What are Traversals. It is like visiting many homes using the roads which connect them. Only that, the homes here are the NODEs and the roads are the links between each node.

There are many traversals but the three us very often are – PreOrder, InOrder and PostOrder.

In PreOrder, you print the current node and then visit its left and then its right children, recursively.
In InOrder, you first visit the left child, once you have return, you print the current value and then visit the right child.
In PostOrder, you visit both your children and then print the current value.

Here is the code snippet for the InOrder traversal (recursive version).

void inorder(NODE *root) {
    if(root!=NULL) {
        inorder(root->left);
        printf("%d ",root->data);
        inorder(root->right);
    }
}

However, there exists a really beautiful iterative version which does not use a stack. It assumes that two pointers can be check for equality. It is bas on thread trees and it was first written in 1979 by Morris and hence the name!

How does it work.

The only reason we ne a stack is so that we can do the “RETURN” from child nodes to parent nodes. This return is ne only from one node really. Consider a 5 node tree.

                                      20
                                    /     \
                                   /       \
                                 10        30
                                /   \     
                               /     \
                             5       15

If I write a non-resursive and non-stack version, my greatest headache would be to go to 20 from 15 (statements 7-8). So we need to link 15 and 20 so that we can go to 20 without problems. But that would mean that we are modifying the tree. Well, we could do it in two steps. First we link the two and in the next step once we have printed 20, we can destroy that link.

                                        20
                                      / | \
                                     /  |  \
                                   9    |   30
                                  /   \ |   
                                 /     \|
                               5       15

1. SET current as root.
2. if current is not null do -
2.a. if current has no left child, print current , set current as right child and REPEAT 2.
2.b. else goto the rightmost child of current’s left child.
2.b.a. If this is NULL, then link it to current and set current as left child of current and REPEAT 2.
2.b.b. else set the right child to NULL. Print Current. Set current as Current’s right child . REPEAT 2.

As a pseudocode we may write it as -

Morris-InOrder ( root )
current = root
while current != NULL do
	if LEFT(current) == NULL then
	   print current
	   current=RIGHT(current)
	else do
	   // set pre to left child of current
	   pre=LEFT(current)
	   // find rightmost child of the left child of current
	   while (RIGHT(pre) != NULL  and RIGHT(pre) != current) do
	       pre=RIGHT(pre)
	    //if thus is null, link it to current and set current's left as current
	    if RIGHT(pre) == NULL then
	       RIGHT(pre)=current
	       current=LEFT(current)
	    // else unlink it, print current and set right child of current as current
	    else do
	       RIGHT(pre)=NULL
	       print current
	       current=RIGHT(current)

void MorrisInorder(NODE *root) {
    NODE* current,*pre;
    current=root;
    while(current!=NULL) {
        if(current->left==NULL) {
            printf("%d ",current->data);
            current=current->right;
        }
        else {
            pre=current->left;
            while(pre->right != NULL && pre->right !=current) 
                pre=pre->right;
            if(pre->right==NULL) {
                pre->right=current;
                current=current->left;
            }
            else {
                pre->right=NULL;
                printf("%d ",current->data);
                current=current->right;
            }
        }
    }
}

Now, lets talk about the fruits!

Insert happens in O(h) time. Each of the traversals (recursive and iterative versions using stack) are in O(N) time and O(N) space (system stack or normal stack).

Morris Inorder runs in O(NlogN) time and O(1) space. One could say that it is slower which is true, but the fact that it does not use additional space can be a huge boost in situations where you are low on system memory!

The entire code is available on :PASTEBIN
I hope you gathered all that info well! I will post a Tree 102, in which I shall discuss the delete operation and talk more about balanced trees!

Firstly, we will need to learn a bit about CPU registers. We will concentrate on the x86 architecture. If you have ever written code in x86 Assembly, then you would have heard about them. But let me just walk you through the functions of these registers.

CPU registers are just memory that the CPU can use to store data. But, it is the fastest accessible memory for the CPU. Ideally you would like to keep everything in it. Unfortunately, it is damn expensive and so a trade-off is done on the pricing and performance. Though there are 32 registers, the most commonly used ones(9 to be precise) for the purpose of executing instuctions are –

EAX : Accumulator : used to store. Used during add/sub/multiplication. Mult/Div cannot be done elsewehere except in EAX. Also used to store return values.
EDX : storage register Used in conjuction to EAX. It is like a side-kick.
ECX: count register: Used in looping. However, there is an interesting thing about it. It always counts downwards and not upwards.
for ex:
int a=100;
int b=0;
while(b<a)b++;

Then ECX will begin from 100 and not 0 and move to 99,98 … !
ESI : source index for data operations and holds location of input stream.(READING)
EDI : points to location where the result is stored of a data operation destination index. (WRITING)
ESP : Stack pointer
EBP: Base pointer
EBX: not designed for anything specific . can be used for extra storage.
EIP : Current instruction being executed.

Now that we understand this, lets see how a debugger works!
Depending on the type of breakpoint, one of the following happens :

Soft Breakpoint :
Let us assume we need to execute this instruction :
mov %eax,%ebx

And this is at location 0×44332211, and the 2 byte opcode for this is 0x8BC3. Hence what we will see is :
0×44332211 0x8BC3 mov %eax,%ebx

Now when we create a soft breakpoint at this instruction what the debugger does is – it takes the first byte (8B in this case) and replaces it with 0xCC.
So now, the opcode actually looks like – 0xCCC3. This is the opcode for INT 3 interrupt. INT 3 is used to halt the execution. Now when the CPU is happily executing everything till this one and suddenly sees the 0xCC it knows it has to stop(it may not really like it but – Rules are rules ). It then raises the INT 3 interrupt which the debugger will trap. It then checks the EIP register and sees if this intruction is actually in its list of breakpoints (just in case the program itself has a INT 3 inside it). If it is present, it will replace the first byte with the correct value (8B in this case) and then program execution can continue.

There are two kinds of soft breakpoint: One shot – Where the breakpoint occurs only once and after that the debugger removes the instruction from its list; and Persistent – where it keeps recurring. The debugger would replace the first byte with the correct byte but when execution is resumed, it will once again replace it with 0xCC and not remove it from its list.

Soft breakpoints have one caveat though.When we make a soft breakpoint it changes the software/program’s CRC (cyclic redundancy check) check sum. A CRC is a type of function which tells whether there has been any change or not. It is like a hash function and can be applied to memory/files etc.,. It compares against a known value and if the checksum fails, the CRC fails. This can be used to prevent Soft breakpoints like in malwares where if the CRC fails, the malware kills itself. To get around this we use Hardware breakpoints!

Hardware Breakpoints –
Though hardware breakpoints cannot be applied at everything, it is still very useful. Recall, the I said there are 32 registers. I introduced 9 in the previous section, let me add another 8 to that list. These eight – DR0 to DR7 are debug registers. DR0 – DR3 store the address of the breakpoints and thus we can have only 4 hardware breakpoints (Ouch!). DR4 and DR5 are reserved. DR6 is the status register which determines the type of debugging event once it is hit and DR7 is ON/OFF switch for hardware breakpoints and also stores different conditions like -
1. Break when an instruction is executed at a particular address.
2. Break when data is written to an address.
3. Break on reads or writes to an address but not execution.

As you can guess, you can only break 4 bytes of memory with hardware breakpoints but nonetheless they are very useful tools for reverse engineers. For creating hardware breakpoints, you can use hbreak command inside gdb.( More info ).

Memory breakpoints.
These arent really breakpoints. It is more like setting permissions on a section of memory or on an entire page, something similar to file permissions. When we set a particular permission, if any instruction tries to do something outside of these permissions on that memory, then a break occurs. The permissions available are – Page Execution (enables exec but throws access violation on read/write) , Page Read ( allows only read), Page Write (only write), and Guard Page (one time exception after which the page returns to its original status). Like in files, we can use combination of these to set permissions. In gdb, to break on write use watch, rwatch will break on read and awatch will break on read/write.

I hope you now have a better understanding of how debuggers work. You may feel this as being unnecessary info, but trust me it helps to know how things work for better usage.

I would like to thank all Source of knowledge – the World Wide Web. Please free to send me corrections/suggestions/criticism.
Adios!

The cheapest, fastest and most reliable components of a computer system are those that aren’t there.
                                                                                                                                                  -Gordon Bell

I am back with a new post. And this time its about one of my favourite algorithms (Yes, as a geek I am allowed to have fav algos ) – Quick Sort ! Whats so special about it – It is amazingly simple and very clearly complex. Quick sort can be implemented as horribly as follows -

void quicksort(int *x,int l,int u)
{
	int i,j,t;
	if(l>=u)return;
	t=x[l];
	i=l;
	j=u+1;
	for(;;)
	{
		do i++; while(i<=u && x[i]<t);
		do j--;while(x[j]>t );
		if(i>j)break;
		swap(x[i],x[j]);
	}
	swap(x[l],x[j]);
	quicksort(x,l,j-1);
	quicksort(x,j+1,u);
}

or as simple as

void quicksort(int *x,int l,int u)
{	
	int i,j,t;
	if(l>=u)return;
	t=x[l];
	i=l;
	for(j=l+1;j<=u;j++)
	{
		if(x[j]<x[l])
			swap(x[++i],x[j]); 
	}
	swap(x[l],x[i]);
	quicksort(x,l,i-1);
	quicksort(x,i+1,u);	
}

But in this post, we are not going to see its looks but rather we are going to explore its performance (real beauty).
Anyone who attended a class on ‘Algorithms and Data-structures’ or had the pleasure of learning it on your own (like me) knows that Quick Sort runs in O(nlogn) expected average time. Its a known fact that for any given quick-sort (standard implementation) there exists a case which will ensure that it runs in O(n^2) time (even for the purely randomized version. If you don’t know about it, feel free to comment at the bottom and I will let the secret out ) .

But what if I wanted to find the average expected time. I know there exists a mathematical derivation using Expectation and it shows that it is nlogn but what if I wanted to find out the exact number of comparisons made on the average. We are going to make an attempt on that.

Before we do that, we should take a minute to observe that there are two variables on which quicksort’s performance can be measured. One is the Number of SWAPS made and the second is the Number of Comparisons. We must select the variable which has the most impact in reducing its complexity. In this post I am using Comparisons over Swaps, Why? Simple because, the impact of a comparison is more than the impact of a Swap. How to prove it? Simple- Write a piece of CODE! (I will post the code a little later)

We will just add a new counter before the comparison inside the loop and when the sort exits, we will have the exact count of the comparisons made.

void quicksort(int *x,int l,int u)
{	
	int i,j,t;
	if(l>=u)return;
	t=x[l];
	i=l;
	for(j=l+1;j<=u;j++)
	{
            cmp++;
		if(x[j]<x[l])
			swap(x[++i],x[j]); 
	}
	swap(x[l],x[i]);
	quicksort(x,l,i-1);
	quicksort(x,i+1,u);	
}

A very basic optimization would be to add it outside the loop as shown.

void quicksort(int *x,int l,int u)
{	
	int i,j,t;
	if(l>=u)return;
	t=x[l];
	i=l;
    cmp+=u-l;
	for(j=l+1;j<=u;j++)
	{
		if(x[j]<x[l])
			swap(x[++i],x[j]); 
	}
	swap(x[l],x[i]);
	quicksort(x,l,i-1);
	quicksort(x,i+1,u);	
}

It is still slow and I want to speed it up. Is there any way I can get rid of that for loop. Actually, YES. I can remove it clearly. I know you are throwing away your thinking hat saying that -” WHAT WILL YOU SORT ? AND IF YOU AREN’T SORTING ANYTHING WHATS THE POINT ?” Well, you are right. I am not interested in sorting. I am only interested in estimating the time it will take to run on average. To do this, I don’t need to sort any array, I just need to simulate it and to simulate it quicker, I will remove the for loop and everything associated with it.
Now our simulator code looks like this. I have also removed the two variables and replaced it with the length I want to partition.

int quicksort_count(int L)
{
	int m;
	if(n<=1)return 0;
	m=l+(rand()%L);
	return n-1 + quicksort_count(m-1) + quicksort_count(L-m-1);
}

double quicksort_avg(int L)
{
	if(n<=0)return 0;
	double sum=0.0;
	for(int m=1;m<=L;m++)
		sum+=L-1 + quicksort_avg(m-1) + quicksort_avg(L-m);
	return sum/L;
}

We can improve its runtime by using Dynamic Programming. We could use the Top-Down approach where we store the values that were previously computed in an array and look it up or we could do Bottom-Up and compute the values in increasing order.

double quicksort_avg(int L)
{
    double dp[L+5];//5 is just taken for safety !
    dp[0]=0;
	for(int n=1;n<=L;n++)
	{  
        double sum=0.0;
	    for(int m=1;m<=n;m++)
	       	sum+=n-1 + dp[m-1] + dp[n-m];
	     dp[n]=sum/n;  	
    }   
	return dp[L];
}

I am still not happy. It is using O(N^2) time which I obviously do not like. It may seem like its impossible to reduce it but in reality that is not the case. For example, if n=5, then the look ups would be :

0 and 5-1
1 and 5-2
2 and 5-3
3 and 5-4
4 and 5-5.

As you can see, I am looking up the same elements twice !
So, I could remove the two lookups and instead multiply it by 2. Also, I can remove the n-1 added every time in the loop (n times to be accurate) and then I divide it by n, leaving me n-1. With those changes, I can convert it to O(N) time.

double quicksort_avg(int L)
{
    double dp[L+5],sum=0;
    dp[0]=0;
    for(int n=1;n<=L;n++)
    {
        sum+=2*dp[n-1];
        dp[n]=n-1  + sum/n;   
    }
    return dp[L];
}

Even now, I am not happy. ( Its impossible to make me happy, right ?). We can actually improve on the O(N) space, since we are only looking at the previous state. Now, our final piece looks like :

double quicksort_avg(int L)
{
    double dp,sum=0;
    dp=0;
    for(int n=1;n<=L;n++)
    {
        sum+=2*dp;
        dp=n-1 + sum/n;   
    }
    return dp;
}

Beautiful isn’t it. In one for-loop using 2 variables, I can actually find out the average comparions made by quicksort for a given length of numbers.

What I (rather Jon Bentley) is trying to show is that – sometimes and almost always we can add functionality by actually removing code! Though this was a pretty small example (and a beautiful example), it seems to explain the idea pretty well.

Do watch the video.

The original video: Three Beautiful QuickSorts

Here is the Wikilink for it so that you can see the basics of the languange.

In a C version of it, you will need 3 variables – to store the previous value and current value, and one temporary. One more to make sure you only print 5 and not any more , making our count 4 !
Lets look at the code now :

int main()
{
	int prev=1,curr=1,temp,count;
	for(count=0;count<5;count++)
	{
		printf("%d ",curr);
		temp=curr;
		curr=prev+curr;
		prev=temp;

	}
}

So here goes !
We only have 8 instructions, out of which we will use 7 (since we are not reading anything from the stdin).
You have to think through absolutely every single thing before you so even put a ‘.’ (dot) on the code editor (quite literally).
We need to print SPACE, so we need 32(ASCII of SPACE) in the memory somewhere!.
We need to print number (for simplicities sake, ONE digit numbers) so we need to make sure we have the ASCII values of it, in memory (ASCII of 0 is 48, 1 is 49 and so on..).
If you look at the C code, we will need keep count of the number of items we have remaining to print. And then we need two locations to store previous and current values of the sequence. A very important thing to remember is that all memory is initialized to 0 at the start and we are relying on this for it to work. Also, the looping statements compare the memory location currently being referred (where your current pointer is) to against 0 and if it is true it breaks otherwise loops.

Writing a simple pseudocode (in terms of only Brainf*k) :

Initialize a location A to 32
Initialize a location B to 48
Initialize a location C to 5
Initialize a location D and E to 1.
Set current Location to C.
Start a Loop
	Add B to E and F.
	Print E.
	Subtract B from E
	Add D to E and F
	Copy E to D 
	Copy F to E
	Reduce C by 1 and Set it as the current location
End Loop

Also the A,B,C,D,E and F are all contiguous in memory and so I am using a[0],a[1]…a[6] to refer to them in the code !

Here is the final version.

++++++++[>++++>++++++<<-]>>>++++++>+>+<<-[<[>>>+>+<<<<-]>>>.<<<<.>>>>>[<-<<<+>>>>-]<[>+>+<<-]<[>>>+<<<-]>>[<<+>>-]>[<<+>>-]<<<<-]  

To make sense of it I have divided it into parts. Some parts have not been commented and are left as an exercise for you to figure out ( I know I am mean ).

++++++++[>++++>++++++<<-] //32 48
>>>++++++ //6
>+>+<<- //Set first two values to 1 and reduce the number of terms to be printed to 5.
[
	<[>>>+>+<<<<-]
	>>>.//print the number
	<<<<.//print space
	>>>>>[<-<<<+>>>>-]
	<[>+>+<<-]
	<[>>>+<<<-]
	>>[<<+>>-]//copy from a[6] to a[4]
	>[<<+>>-]//copy from a[7] to a[5]
	<<<<-//decrement the value
]  

All right. Pretty cool huh! Well as a real mind-boggler you can try making it print N numbers (dont worry about printing it right, just print out the actual value encoded by ascii ).

You could use it to even encrypt messages in a really wierd way. Oh almost forgot. To run your Brainf*k programs use the following website. They have an online interpreter and a debugger of sorts too : www.brainfk.tk

I hope you liked your Christmas Present . Merry Christmas and a Happy New Year… Ho oh ho

If you have a null reference – every bachelor in the world would seem married, polyandrously!
                                                                                                                                                  -Edsger Djikstra

What is a Null Reference : A Null reference is a pointer that points to a NULL (in C++). For example,

#include<stdio.h>
int main()
{
    char *cp=NULL;
    cp=(char*)(malloc(sizeof(char)*12);
    cp="HELLO THERE";
    printf("%s\n"cp);
}

Here, in Line 4 you have a Null Reference. Now you would wonder why that is a bad thing. In the context of this program, it isnt all that bad since it executes smoothly. But if you begin using complex source codes then you will have to be careful that you do no use/pass a NULL REFERENCE in/to a function. As this can lead to potential issues – sometimes almost impossible to detect !

A HISTORY LESSON :
Hoare’s first job was in the 60′s, as a programmer for a British Manufacturer – Elliots. After about 9 months, he was asked to design a new programming language ( Imagine this as your assignment at your first job !) While working on that, he found a book – Report on the International Algorithmic Language – ALGOL-60 (around 23 pages). He mostly wrote the new language around Algol 60 and left out complicated parts like if statements but later added them into it.

In those days, code was written in Machine Language and it was easier to debug in machine language ( I never thought I would ever hear that!) than in high level languages because of now knowing the exact values in the 4096 bytes of memory. The principle involved was that ” One should be able to tell the error by looking at the high level code alone”. And this was a real problem and people were a little nervous about the high level languages. But as the complexity went up, it was accepted eventually.

Now, Lets examine another piece of commonly used code -

#include<stdio.h>
#define N 100
int main()
{
	int arr[N];
	int s=0;
	int k
	/*** SOME CODE TO DO SOME OPERATIONS ON ARRAYS ***/
	/*** SOME CODE THAT MODIFIES k***/
	
	while(s<N)
        {
              printf("%d\n",arr[s]);
              s++;
        }
	if(k>=0 && k<N)printf("K-th value is %d\n",arr[k]);
}

If we look at what we are doing in the code at Line 10 and 11 – We are making sure that the subscript in within bounds. Thus we see that two checks(Upper Bound and Lower bound) are required to make sure this condition is satisfied. But this added to the time to run code (In those days the processors were really slow and things like if-s could take up a large amount of time !) and also to the size of the code.

A Question may come up – Is this a good thing to do? The Answer is YES. Languages like JAVA already implement it!

Hoare later on went on to become part of the team to design the successor of ALGOL – 60. He suggested that an Object/Record could be referenced by a pointer. But pointers in indirect memory can cause absolute havoc, because if you used a float as a pointer you could end up overwriting your own code! Thus, he took it for granted that the programmer must declare what data the pointer points to and it could be checked at compile time. He asked the customers – Whether they would like the Type checking removed once the code was tested ? They said No. The reason being that there are more chances of errors and issues popping up in a Live environment than in a test environment.

At that point, many people also used FORTRAN instead of ALGOL and Elliot wanted to sell it to them also. So they wrote a program which converted FORTRAN to ALGOL. It was a disaster, not because it compromised the speed but because – after converting it, it would come up with an entire essay of subscript errors.

Hoare invented the NULL REFERENCE but his friend Edsger Djikstra thought that it was a bad idea – If you have a null reference – every bachelor in the world would seem married, polyandrously – since every bachelor has the same wife – NULL but is still a bachelor !

Hoare came up with a solution based on Discrimination of Objects belonging to the disjoint Union Class – A union between two sets with nothing in common! For eg, if we have a class Vehicle and subclasses – Cars and Bus. They both have an attribute Capacity but for a bus it refers to the passenger Capacity whereas for a car it refers to boot capacity. Thus it would discriminate based on bus or car and give you the corresponding capacity (by making a discriminating class.) Thus a pointer could point to a vehicle or to NULL.

Also, having NULL made it easy to initialize. If you didn’t do it this way, you could end up doing it in a really complex manner which could require a sub-language of its own. For eg, it is easy to design a data-structure without the NULL but almost impossible to design a circular structure without it! Hoare did not want to deal with that and hence NULL became a possible value for every pointer.

Thus in a way, it also influenced the way C was written. One of the greatest issues was the gets() function in C, which allowed buffer – overflow. If it had not been for it, the World would have been free of malwares !

If you asked me whether it was a Good choice or a bad choice to have a NULL reference – I would say that it was a good choice. Consider the amount of time I have saved thanks to the NULL pointer and the structures also owe some stability to the NULL Pointer. However, one must be very careful around it because it is very dificult to see that the pointer points to a NULL and it can be a cause for many a sleepless night!

See it yourself

Oh yes, I’ve had nightmares about binary search. The worst kind. Now, you would tell me – What kinda geek are you ! I’ll answer – an honest Geek. Many people feel that the Binary Search is the easiest algorithms but in fact it is much more complex than some of the other algorithms.

To give you a brief background, I can write everything from a Quick Sort to Djikstra SSSP in over 4 programming languages without so much as blinking but when it comes to binary search – my heart begins to pound and my head begins to twirl. Why ? Because every line of that algorithm is just too simple that we (or maybe just me !) don’t pay close attention to it. You may not agree and I won’t blame you. Most programmers have used binary search to just do that – search. Not that I use it for something else. But just that the way you can apply binary search to an array of problems is amazing. And its only when you begin to apply it to others areas, you realize that you never really understood Binary Search !

Let me first show you the actual code :

int binary_search(int *arr, int sizeOfArray,int search)
{
	lo=0;
	hi=sizeOfArray-1;
	while(lo<=hi)
	{
			mid= lo + (hi-lo)/2;
			if(arr[mid]==search)
			{
				//ELEMENT FOUND
				return mid;
			}
			if(arr[mid]<search)
				lo=mid+1;
			else hi=mid-1;
	}
	return -1;
}
//ELEMENT NOT FOUND

The algorithm is only ~10 lines, but each line is very important. Lets start with line 5: This is the condition that controls the looping. It is important to realize that if the element exists in the array, then the above condition can be anything that ensures continuous looping because on finding the element, we will break. But, if the item is not present in the array, then this condition is very important.

1. We are very easily tempted to write the value, lo<hi instead of lo <=hi, and I will show you why we shouldn’t give into that temptation.
Consider the case : 1, 3 4, 5, 10 ,12 14 and we are looking for 10. The series of updates to lo,hi and mid are as follows.

lo=0,hi=6,mid=3;
lo=4,hi=6,mid=5;
lo=4,hi=4,mid=4;

Now for the last loop, if we had not used the ‘=’ condition, it would have broken from the loop without even finding.

2. Okay. Does the next line look like magic to you ? It is nothing but a better way of writing (lo+hi)/2. Now, why do I need that ? – To save me from the overflow. You see- (lo+hi) could easily overflow the integer range and result into some non-sensical data. Of course, it won’t happen in most cases as you cannot actually have an array the size of a 32 bit number, but still it is better to avoid it !

3. In most cases, you would write lo=mid, afterall that is what the leading text suggests but then why have I used mid+1 ?
Consider the case : 0 2 5 and search for 3.
lo=0,hi=2,mid=1;
lo=1,hi=2,mid=1;
lo=1,hi=2,mid=1;

and it goes on forever !

For the same reason we use hi=mid-1.
Now to prove why this is NOT wrong. Now, if the condition arr[mid] <search is satisfied, it means that (mid+1)-th element is definitely larger that mid-th element. We have already checked with the mid-th element so we can move the lower bound to the element which is after that. Thus it does not hamper the algorithm in any way!

A very common problem employing binary search is , given a monotonically increasing/decreasing function F(x) find a value of x such that F(x)= VALUE. The domain of x is real numbers. To do this, we need to remember that the domain is really dense and so it is not possible to get a F(x) which is EXACTLY equal to VALUE, so we define a new function SATISFY(x,VALUE) which return true if for a given x, F(x) is within a satisfactory range of VALUE. Also, for this case, the condition to in the while loop is just the precision required on the return value.
Thus,

	double EPS= precision_required;
	double lo=lower_bound, hi=upper_bound;
	while( abs(lo-hi)> EPS)
	{
		mid=lo+(hi-lo)/2.0;
		if(SATISFY(mid,VALUE)==true)
			hi=mid;
		else lo=mid;
	}
	// lo is the answer !!

Lastly, one usage of binary search ( give it a shot) :

Given an array of N numbers (sorted) and given a search term- S, find the largest index i, such that the number at i, is smaller than S but larger than any other number smaller than S.

Eg: case: 1 2 2 2 3 4 5 7 7 8 8 9 . and S= 8. Then the answer is 8, as the 8th number (0-indexed) = 7 is the largest of all numbers smaller than S, and 8 is the largest index which contains 7!

I would like to thank lovro for the tutorial on binary search that has helped me out a lot

This is the first official (read meaningful) post on this blog. And as the title suggests, it is about the recent HDCP key leak.

What is HDCP: High-Bandwidth Digital Content Protection. It is used as an encryption to protect digital formats( video/audio) so that the data being transferred over the wire (usually Digital Visual Interface -DVI , High Definition Multimedia Interface – HDMI) is secure and not copied off the wire.

How Does it work : It uses a very common trick : Identification. But to make sure that unscrupluous people don’t tamper, there is a protocol to identify. When a vendor makes a HDCP compliant device, he procures a license from Digital Content Protection LLC. The license contains two vectors u and v. u is the private key and v is a public key. v is also called the Key Selection vector(KSV) and as per HDCP specs, it must have a hamming weight of 20. Both u and v are 56-bits.

When two devices(transmitter and receiver) wish to communicate they exchange their public keys (v) or KSVs. Then they each compute the dot product of their private key (u) with the other device’s KSV. Then the transmitter sends a nonce(number used once) to the receiver. The receiver performs a non-invertible function h on the dot product it generated and the nonce. It replies back with a 16-bit number and the transmitter does the same. When these two numbers match, it assumes that the other device is HDCP compliant and begins the transfer of digital data (encrypted).

Now, for all this to work, both the dot products calculated must be the same. For that to happen, the private key must be made in a special way. They use a 40 by 40 matrix key generator which generates the private vector. This can be called as a master key. If anyone has this master key, he can open any lock he likes!

The Problem: All this sounds really good. The numbers are 56-bits and to that fact with a hamming weight of 20, it is near impossible to generate a key randomly by any processor in this era. BUT (In Computers, there is always a big BUT, isn’t it ?), what if we had 40 valid keys(private keys)- then would it be possible. YES. This fact has been known for a long time and there is a paper that shows this !

In reality what happens is that there are two private keys :; source and sink. Depending on whether the device is a transmitter or reciever it uses the source or sink keys as the private key.

LETS DO IT !! : Well, I would love to. But I don’t have 40 keys (darn!). However, we could use an example and see if this is infact possible !
Lets consider 4 devices – A, B, C, D. The private keys (source) are

A	9	13	0	4
B	12	1	4	8
C	6	5	9	15
D	15	12	15	5

 
and for sinks :

A	4	11	5	10
B	5	13	8	6
C	8	0	12	12
D	6	13	7	14

The corresponding KSV for the four devices  {1010, 0110, 0011,1001 } (in binary).

Now if A and B wish to communicate and A is source and B is sink. They would first exchange the KSV. Then it applies the other device’s KSV on its private key to get a number. For simplicity, lets assume they just check whether they are equal directly. So A would get = 13+0=13 (adding 2nd and 3rd elements) and B would get = 5+8=13 (adding 1st and 3rd). Since they are equal, they proceed !!

But now, we have a fourth Device E. We know the public key (since its public and all!) but the private key is unknown. We will assume that E is a sink device and its key is (a,b,c,d).
Now, if we pair every known device with E, we will be able to get simultaneous equations (four in number) and anyone who knows linear algebra knows that 4 equations and 4 variables = solvable!!

Thus to replicate a 40 element vector, we would only need 40 valid keys!

Thus we can replicate or rather impersonate any device as HDCP compliant without even being!

I hope you enjoyed reading it. Most of the information posted here has been collected from various blogs around the net, and I thank them all for explaining it in great detail.

I am also posting the links :
Crosby Paper
THE LEAKED KEY !

Anyhow, to the nomad who accidentally ended on this page. I am sorry for you. But since you are here anyway, I’ll tell you what this one is about. Just another GEEK ranting about the things he likes !