System.Blog.Martens.Ben : BrainTeaser

Brain Teaser #3 Answer

benmartens — Tue, 13 May 2008 18:06:45 GMT

If you haven't read the question yet, you can read it here.

The answer for this lies in the C# specification. Specifically, read section 8.13. There are two different ways you can use a using statement and in this case we are interested in the second way. The key words from the spec are "in this case ResourceType is implicitly the compile-time type of the expression, and the resource variable is inaccessible in, and invisible to, the embedded statement."

So effectively what the code in our question means is:

Foo x;
using (/*y =*/ x = new Foo())
{
} // this calls y.Dispose();

In this example, y is effectively the copy of x that is made so that x becomes inaccessible and invisible to the embedded statement. If Foo is a reference type, you don't really see the difference because x and y point to the same type. However, if Foo is a value type, it is actually making a copy of the value and you're dealing with a completely different memory location.

Brain Teaser #3

benmartens — Wed, 07 May 2008 17:41:24 GMT

This brain teaser also comes courtesy of Simeon Cran.

What will the following code output? When you think you know, copy the code into Foo.cs and run “csc Foo.cs” and then run “Foo.exe”. Did it output what you expected? The brain teaser is to come up with the correct explanation for why the program outputs what it does.

using System;

struct Foo : IDisposable
{
    bool disposed;
    
    public void Dispose()
    {
        disposed = true;
        Console.WriteLine("Disposed");
    }

    static void Main(string[] args)
    {
        Foo foo;
        using (foo = new Foo())
        {
        }
        Console.WriteLine(foo.disposed);
        using (foo = new Foo())
        {
            foo.Dispose();
        }
        Console.WriteLine(foo.disposed);
    }
}

Brain Teaser #2 Answer

benmartens — Tue, 06 May 2008 19:46:32 GMT

Have read the question yet? Read it here.

The problem is pretty simple if you have 00111 (where all the bits after the first 1 are also 1’s.) You shift right, run the NOT operator, and then AND that result with the original. For example:
```
	ORIGINAL = 00111 
	SHIFT RIGHT = 00011 
	NOT = 11100 
	AND with ORIGINAL = 00100
```
The question now becomes, how can I take a number like 001xxxxxx and make sure all those subsequent values are 1? Well if you take 001xxx, shift right 1 and OR, you’ll have 0011xxx. Then shift right two and OR and you’ll have 001111x. Make sense? Shift by 4, then 8, then 16, 32, 64 and you’re done.

Here's the code:

// Clears all the bits on the given value except 
// the leftmost bit that was set
static ulong KeepHighestSetBit(ulong value)
{
	value |= value>>1;
	value |= value>>2;
	value |= value>>4;

	value |= value>>8;
	value |= value>>16;
	value |= value>>32;
	return value & ~(value>>1);
}

Congrats to Raj Kaimal for figuring this out!

Brain Teaser #2

benmartens — Thu, 01 May 2008 02:27:37 GMT

This brain teaser comes courtesy of a co-worker named Simeon Cran.

Using C# and no branches, and no method calls, no allocations, and no unsafe code, write a method that takes a ulong and clears all the bits in it except the highest bit that was set. Use as few operations as possible.

e.g.:
0 -> 0
1 -> 1
2 -> 2
3 -> 2
4 -> 4
5 -> 4
6 -> 4
7 -> 4
8 -> 8
9 -> 8
10 -> 8
…

Brain Teaser Answer

benmartens — Wed, 12 Mar 2008 02:35:25 GMT

There was a lot of extra information in that brain teaser. All you really needed was these two sentences:

Clearly 41 runs * 1210 feet = 49610 feet. The watch incorrectly said that I had skied 20,100 but had the correct number of runs.

So if I had looked after one run, the watch would have said 1210. After two runs it would have said 2420. After 10 it would have said 12100. Obviously that line of reasoning can’t continue indefinitely because by the time we get to 41 runs, the watch isn’t showing what we expect. So what happened?

The number is stored as a 16 bit signed integer. The maximum 15 bit number is 32,767. After reaching that number, the counter rolled over to 0 and kept increasing. 32,767+20,100 = 52,867. That’s close enough to the expected 49,610 to be reasonable. The difference can be accounted for by slight rises and falls in the run (it’s not perfectly smooth all the way down) and a little barometric pressure variation throughout the day.

That's my theory anyway. Until I check the watch just before 32,767 and then do it again and check just after 32,767, I won't be sure. It seems very reasonable though.

Brain Teaser

benmartens — Tue, 11 Mar 2008 03:36:41 GMT

During a recent Hope on the Slopes 24-hour ACS skiing fundraiser, I used my watch to track vertical feet throughout the day. The watch isn't perfectly calibrated, but it's reasonably accurate. The watch counts a run any time you make a vertical change of at least 100 feet (so when you ride up the lift you are going up at least 100 feet, it counts that as a run.) We started skiing at 9:30am and didn’t look at the watch until 7:30pm. I only skied on one lift and it had a vertical rise of 1210 feet. At that time I was surprised to see that I had skied 20,100 feet and 41 runs.

Clearly 41 runs * 1210 feet = 49610 feet. The watch incorrectly said that I had skied 20,100 but had the correct number of runs. Huh?

I had plenty of time to think this over while I was riding the lifts later that evening. Eventually I realized that the watch was actually tracking all of my vertical feet correctly. Do you know what happened?

I'll make another post in a couple days with the answer. Leave a comment if you know the answer.

These additional facts may or may not help you:

I wore the watch the whole time.
The watch was on the whole time (remember that it correctly counted all 41 runs.)
There was no major weather event that changed the barometric pressure.
It was accurately tracking my vertical feet the entire time.
I didn't stop or restart the watch at any point (again, remember that it showed 41 runs.)
The highest number I have ever seen it record previously is 28,000.
1210 is the vertical rise of the lift. One trip down the ski run would show slightly more than that due to little hills in the middle of the run. None of those hills are higher than 100 feet so they don't make the watch think they are extra runs.