Brute force way is to generate each number in the series check if it is an even number or not. If it is an even number then add it up in some variable which will give the sum in the end.

A close observation of the series reveals that for every 2 odd numbers there is an even number. No wonder as
even + odd = odd
odd + odd = even

Further more an even number in the series is 4 times the previous even number added with previous to previous even number.
Even Number in Fibonacci Series = 4 * Previous even number in the series + Previous to previous even number in the series

ie 8 = 4 * 2 + 0
34 = 4 * 8 + 2
144 = 4 * 34 + 8
610 = 4 * 144 + 34
2584 = 4 * 610 + 144

Thus instead of generating every number in the series, we can directly generate the even numbers in the fibonacci series reducing the iterations of a loop that generates these numbers by a factor of 3
Happy Coding

k = 0;
for i1 = 1 to n
for i2 = 1  to i1
for i3 = 1 to i2
….
…..
….
for im = 1 to im-1
k = k + 1

If you don’t remember or know Big-Oh notation, alternately what is the value of k?

Can you write a function which accepts n and m and outputs k?

Happy to have qualified for the online round now.

My (bad) code can be found at

http://code.google.com/codejam/contest/scoreboard?c=975485#vf=1&sp=5301

The problems can be found at

http://code.google.com/codejam/contest/dashboard?c=975485#

Most elegant and small solutions are coded by top performers in C++

Happy coding !

We all know bubble sort, insertion sort, selection sort, merge sort, quick sort etc etc.

These algorithms have time complexities ranging from O(n^2) to O(n lg n). If n is range bound you can also sort the numbers in O(n) by indexing the numbers in an another array.

However once I was asked for a worst algorithm to sort the numbers.

Worst algorithm to sort the numbers has exponential time complexity. The algorithm is to find all the permutations of the given n numbers.  Assuming n numbers to be { a1, a2,…an) there would be a permutation of these numbers such that

a1<a2<a3…<an

Following program outputs 10

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;

namespace ConsoleApplication1
{
class Program
{
public readonly int myNumber = 5;

public Program()
{
myNumber = 10;
}

static void Main(string[] args)
{
Program p = new Program();
Console.WriteLine(p.myNumber);

}
}

}

Here is the release mode optimized IL code which confirms the same.  I was surprised to see the compiler has not optimized the code to have only one assignment of 10. Instead you can find IL code for both assignments of 5 and 10

.method public hidebysig specialname rtspecialname
instance void  .ctor() cil managed
{
// Code size       25 (0×19)
.maxstack  8
IL_0000:  ldarg.0
IL_0001:  ldc.i4.5
IL_0002:  stfld      int32 ConsoleApplication1.Program::myNumber
IL_0007:  ldarg.0
IL_0008:  call       instance void [mscorlib]System.Object::.ctor()
IL_000d:  nop
IL_000e:  nop
IL_000f:  ldarg.0
IL_0010:  ldc.i4.s   10
IL_0012:  stfld      int32 ConsoleApplication1.Program::myNumber
IL_0017:  nop
IL_0018:  ret
} // end of method Program::.ctor

However CLR can not stop a readonly field being modified using reflection. Using reflection a readonly field can be modified.

An Example

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;

namespace ConsoleApplication1
{
class Program
{
public readonly int myNumber;

public Program()
{
myNumber = 10;
}

static void Main(string[] args)
{
Program p = new Program();
Console.WriteLine(p.myNumber);  // Writes 10
FieldInfo field = p.GetType().GetFields()[0];
field.SetValue(p, 12);
Console.WriteLine(p.myNumber); // Writes 12
}
}

}

In C++, code decides where the allocation happens.

TypeA a = new TypeA(); always comes from Heap in C++ and

TypeA a; always comes from thread’s stack in C++

However in C#

TypeA a = new TypeA(); can come from Managed Heap or Thread’s stack based on if  TypeA is a value type or is a reference type.

So in C# one always needs to know if a type is defined as a value type or as a reference type because the treatment of the two by the CLR differs and can result in unexpected behaviors.

I use a reference argument for the copy constructor because I must.

It took a while for me to understand the must in the above line ( dumb me !)

In case you are also wondering about the must, then it is a must because

The copy constructor defines what copying means – including what copying an argument means.

If it is still not clear, then lets take an example

Class A

{

public :

A() { }

A(const A& a) { } // why reference & const ?

}

Imagine what happens when I write code

A objA;

A newObjA(objA);

In the first line an object of type A called objA gets created using the constructor A().

In the second line, I want a newObjA of type A to be created from an existing object objA of the same type.

A copy of objA will be created and will be pushed on the executing thread’s stack as constructor call is ultimately a function call.  But how can a copy of objA be created ? By calling the copy constructor.

Let’s say I call the copy which needs to be pushed on the stack as copyOfObjAToPushOnStack.

The code for it will look like

A copyOfObjAToPushOnStack = new A(objA);

Aaah ! And we return to the same case as A newObjA(objA); only difference being instead of newObjA it is copyOfObjAToPushOnStack

So unless we pass a reference of objA, it is going to result in an infinite recursion.

This is the reason why a reference is a must in copy constructor.

The const part is to ensure at compile time that during the object construction, the object from which new object constructed does not get modified.

Same reasoning also applies to copy assignment.

It is illegal to define a type in which a reference type and a value type overlap.

I was curious how this illegality was addressed. I thought it would have been at compile time. But to my surprise it is at run time !

An example

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
MyStruct myStruct;
}
}

[StructLayout(LayoutKind.Explicit)]
struct MyStruct
{
[FieldOffset(0)]
public int a;

[FieldOffset(0)]
public MyClass c;
}

class MyClass
{        }
}

If you compile above program, it compiles without any error.

If you run it you will get an exception as

I wonder why this was not a compile time error, when compiler knew that the field c was of a reference type which overlapped with a value type field.

If anyone knows do let me know !

Lets take a look at an example.

Here is an aspx page.

Here is the code behind.

 In Mozilla both the check boxes chk2 & chk3 get enabled / disabled using the javascript.

However in IE, check box, chk3 does not respond to javascript.

The reason for it is the way the tags are rendered

 <input id=”chk1″ type=”checkbox” name=”chk1″ onclick=”javascript:Toggle(this);” />
       
<input id=”chk2″ type=”checkbox” name=”chk2″ disabled=”disabled” />
       
<span disabled=”disabled”><input id=”chk3″ type=”checkbox” name=”chk3″ disabled=”disabled” /></span>

The asp.net check box disabled on the server gets rendered as

<span disabled=”disabled”>….

   So even when the check box is enabled using javascript, it does not get enabled in IE. However Mozila deals with it fine and enables the check box.

The source code for the example can be found here