Like any dysfunctional family the Fark.com members are sufficiently evil to each other; but, when the chips are down, they come together and take care of their own. This is the case with Farker joe8122, who’s son has been diagnosed with neurocutaneous melanosis, i.e. a rare form of brain cancer. Long story short (longer story here), his son can undergo some experimental but promising treatment, but needs $100,000 to do so. Insurance won’t cover it, and the hospital won’t treat him without payment.

To try and raise money to get his son treatment, Joe turned to his online family at Fark and asked for help. Within a week the total donated has breached $33,000, and the story has spread to Digg, Reddit, and news website local to Alabama, where Joe and his family live. Several emails have been written to the Governor of Alabama asking for his help, and Fark members continue to put the story in front of media outlets, hoping to spread the news and raise the rest of the money Joe needs. Joe has a website set up to accept donations towards his son’s treatment.

This leaves me feeling very proud of the Fark community, and impressed with the potential power of social websites to directly impact the life of a reader. The power of the internet is in the voices of the people, who can make their story known in forums, comment threads, and their own websites. This power isn’t just limited to opinion and commentary; in the case of Joe8122 and his son, the power of the internet can bring hope for treatment of a terrible affliction.

These interwebs are so cool.

Bookmark to:
Del.icio.us digg FURL reddit Technorati Ma.gnolia Stumble Upon Bloglines

Because so many people have enjoyed retellings of the car’s woes, I decided to finally write down all the problems and share the list here. Enjoy.

1. The tint on the windows has melted, so you can’t really see out the windows, especially the back window.
2. The side-view mirror on the driver’s side shakes enough that you have to steady it with your hand to get a clear view.
3. The air conditioner hasn’t worked in a couple years.
4. The washer-fluid reservoir has a hole, at the bottom, so you can’t ever wash the windows while driving. I tried to fix this once, but you have to pretty much tear the hood apart to get to it.
5. The tachometer (tells you your RPMs) only works reliably when the “Check Engine” light is on. No, I don’t know how these could be related, but the behavior is consistent.
6. The passenger-front power window moves veeerrryyyy ssllllooowwwlllyyyy if any other non-essential electricity is being used (e.g., rolling up another window at the same time).
7. The plate covering the cas cap is jammed in a bit, so you have to use your key to pry it out whenever you want to fill the tank.
8. The fuel guage is unreliable between 1/4 full and Empty. Turn the car off at 1/4 full, start it again to see just above empty, turn it off and restart to see somewhere in between.
9. Here’s a big one - the transmission (automatic) frequently decides it doesn’t like to be in gear. The first gear shift of the trip is a gift, usually Reverse, to get out of a spot; after that, no drive. You can force the car into gear by revving the engine a good bit; I’ve sort of perfected the art of revving for just the right amount of time so that the car engages at the end of the rev, and I’m not lurched about too much. Once you get going the transmission mostly behaves, unless you make sharp turns, or you rapidly decelerate. On occasion, however, the car will decide that it really really likes 2nd gear, and no other gear, and you can only change it’s mind by turning the car off and then on again.
10. Sometimes at a stop light the car will idle very low and shake a bit like it’s about to stall - but, it never actually stalls.
11. After driving a bit the car will make horrible sounds when, at low speed, you turn the wheel slightly left or right of center.
12. The trunk release button up by the driver’s seat doesn’t work. This is relatively easy to fix, but it fails frequently enough that I no longer bother.
13. Checking the codes for the frequent check engine light always returns 12 and 21 - one is a power failure notice (i.e. the battery was disconnected in the past 15 starts) that should have long ago expired, and the other tells me I have a problem with an oxygen sensor.

That’s quite a list, and I’m not actually sure it’s complete. That said, the car still gets me from A to B, and despite its flaws, I love it.

If you’re familiar with my ride and notice that I’ve missed anything, let me know. If you’re impressed that I’m still alive after driving this, and frightened that I still drive in traffic in Texas, let me know that, too.

Bookmark to:
Del.icio.us digg FURL reddit Technorati Ma.gnolia Stumble Upon Bloglines

Surprisingly there are only three numbers that can be written as the sum of fourth powers of their digits:

1634 = 1⁴ + 6⁴ + 3⁴ + 4⁴
8208 = 8⁴ + 2⁴ + 0⁴ + 8⁴
9474 = 9⁴ + 4⁴ + 7⁴ + 4⁴

As 1 = 1⁴ is not a sum it is not included.

The sum of these numbers is 1634 + 8208 + 9474 = 19316.

Find the sum of all the numbers that can be written as the sum of fifth powers of their digits.

Let’s break it down

Here’s what we need:

• A function to break an input number into its digits and find the sum of those digits each raised to a given power
• A loop to go through a reasonable set of numbers and test each one (reasonable in that we don’t expect numbers higher than the end of our limit will exhibit the features we’re testing for)
• A means to compare a number against the sum of its digits (trivial)

Digitize and Powerify

Here’s our function taking a number and power as inputs; passing in the power that we’re raising digits to lets us solve the question with 6th powers, 10th powers, etc.

    private int FindSumOfPowers(double inputNumber, double power)
    {
        int returnValue = 0;
        int tempValue = 0;
        foreach (char c in inputNumber.ToString())
        {
            tempValue = (int)Math.Pow(Convert.ToDouble(c.ToString()), power);
            returnValue += tempValue;

        }
        return returnValue;
    }

Feeding our function

Yep, that’s all there is to it; let’s put pieces together and pull out numbers matching our criteria into a collection:

    protected void Page_Load(object sender, EventArgs e)
    {
        double power = 5;
        var results = from p in Enumerable.Range(2, 10000000)
                      let sumofPowers = FindSumOfPowers(p, power)
                      where p == sumofPowers
                      select new { p, sumofPowers };

        foreach (var result in results)
        {
            Response.Write(result.p.ToString() + "<br/>");
        }
        Response.Write("===========================<br/>");
        Response.Write(results.Sum(result => { return result.p;}));
    }

I chose to run this code until the number 10,000,000, at which I felt confident I had run through all the possible numbers. We skip 1 because as the problem stated that number doesn’t count. We’re using some simple LINQ to loop through the numbers in our range and pull out the values that are equal to the return value of FindSumOfPowers(…). The anonymous variable results will be an Inumerable<> holding our matching numbers (technicalliy, the number and the calculated sum, which by the where clause are the same). Finally, we’ll use the Sum() extension method with a lambda expression telling it to use the “p” property when summing the collection.

Your turn

This certainly can’t be the most efficient or elegant solution; anyone have some pointers on speeding this up or making it better? Does your language run circles around C# on this problem?

Bookmark to:
Del.icio.us digg FURL reddit Technorati Ma.gnolia Stumble Upon Bloglines

“If you’re not failing all the time, you’re not putting yourself in a situation to get super lucky.” - Ira Glass

I saw this on 43 Folders today, and felt it a good thing to share. Ira Glass is the host and producer of This American Life and is a fixture in television and radio. In the video below he talks about not giving up when what you produce doesn’t come close to what you know is good, specifically if you’re in the creative fields and working with stories, drawings, comics, etc.. Per Ira, the trick is to just keep producing, and eventually you’ll close the cap between where you are and where you want to be. Watch the whole clip (5 minutes), it’s worth it.

This clip is part of a series on storytelling; take a look at the others are YouTube for some more good stuff, like the quote at the top of the page.

Bookmark to:
Del.icio.us digg FURL reddit Technorati Ma.gnolia Stumble Upon Bloglines

static private string NumberEnding(int number)
    {
        string numberAsString = number.ToString();

        //handle everything ending in 11, 12, and 13
        if ((numberAsString.EndsWith("11")) ||
           (numberAsString.EndsWith("12")) ||
           (numberAsString.EndsWith("13")))
        {
            return "th";
        }
        else
        {
            switch (number % 10)
            {
                case 1: return "st";
                case 2: return "nd";
                case 3: return "rd";
                default: return "th";
            }
        }
    }

Bookmark to:
Del.icio.us digg FURL reddit Technorati Ma.gnolia Stumble Upon Bloglines

First off is Problem #8:

Find the greatest product of five consecutive digits in the 1000-digit number.

The huge number is:

7316717653133062491922511967442657474235534919434969835203127745063262395783180169848018694788
5184858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522
7443043557668966489504452445231617318564030987111217223831136222989342338030813533627661428280
6444486645238749303589072962904915604407723907138105158593079608667017242712188399879790879227
4921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360
4839586446706324415722155397536978179778461740649551492908625693219784686224828397224137565705
6057490261407972968652414535100474821663704844031998900088952434506585412275886668811642717147
9924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421
9022671055626321111109370544217506941658960408071984038509624554443629812309878799272442849091
8884580156166097919133875499200524063689912560717606058861164671094050775410022569831552000559
3572972571636269561882670428252483600823257530420752963450

I think the cleanest way to handle this is to get a collection of all X-digit sequences and the product of their digits, and then sort the collection according to what you want. We’re going to need a few helper functions, so let’s get started.

Finding the product of an X-digit sequence

First, let’s make a function that takes a string as input and returns the product of each digit in the string. I’m going to assume the string contains only numeric characters for this example, but in the field you’d of course want to check that. Also this function shouldn’t care how long the sequence is, allowing us to later find 3-digit, 10-digit, or 15-digit sequence products if we choose.

    private double MultiplySequence(string sequence)
    {
        double finalValue = 1; 

        foreach (char c in sequence)
        {
            finalValue *= Convert.ToDouble(c.ToString());
        }
        return finalValue;
    }

The function above simply loops through all the characters in a string, converts the character to a double, and then multiples it against the other digits, with finalValue holding the resulting product of all the digits in the string.

Running through the sequences

We’re going to want to work with a collection of all the sequences, so we need some code to generate them for us.

    private IEnumerable GetSequences(string originalSequence, int subsequenceLength)
    {
        int originalLength = originalSequence.Length;
        int index = 0;

        while (index + subsequenceLength <= originalLength)
        {
            yield return originalSequence.Substring(index, subsequenceLength);
            index++;
        }
    }
}

We’re passing in a string for the original sequence (our 1000-digit number) and an integer specify the length of sequence we want. We simply loop through our input sequence stopping at the last full subsequence (of length subsequenceLength). Note the yield return syntax here; we’re making use of a custom iterator to return the values we want. Using this is the same as creating a IEnumerable collection and then adding the substrings we want to it during each pass of the for loop and returning the collection. There’s a lot of other cool stuff you can do with them that we’ll hopefully cover in later Euler problems.

Fetching our sequences and results

Now that we have our pieces in place, let’s toss in our inputs and use some LINQ to pull out the meaningful data:

    protected void Page_Load(object sender, EventArgs e)
    {
        string hugeNumber = "731671765313306249192251196744....(removed for brevity)...";

        var final = from sequence in GetSequences(hugeNumber, 5)
                    where !sequence.Contains('0')
                    let multipliedResult = MultiplySequence(sequence)
                    orderby multipliedResult descending
                    select new { sequence, multipliedResult };

        Response.Write("Winner: " + final.First().multipliedResult);

        Response.Write("<br/><br/>Full Results:<br/>=========================<br/>");
        foreach (var tempSequence in final)
        {
            Response.Write(tempSequence.sequence + " => " + tempSequence.multipliedResult + "<br/>");
        }
    }

In the code above we’re using LINQ to loop through the IEnumerable returned by the GetSequence function we defined. We ignore any sequences that contain a zero (as the product will be 0). For each sequence we’re defining a variable called multipliedResult and setting it’s valued to the product obtained through out MultiplySequence function. We then order all the results by the multipledResult, and finally fill out final variable with anonymous types containing each sequence and its product. The Response.Writes show the answer we’re looking for, and then show all the ordered results. Because one of our parameters to GetSequences is the length of sequence to use, we can easily run our code to find the greatest product of 10, 15, 31, etc. consequence digits in our huge number.

Final Thoughts

I had a lot of fun with this, and am looking forward to working through other Euler problems. The Project Euler website has a place for you to sign up and submit your own answers; if you enjoyed this, go ahead and give one of the other problems a shot on your own. It’s geeky, but fun.

Bookmark to:
Del.icio.us digg FURL reddit Technorati Ma.gnolia Stumble Upon Bloglines

Todo or Not Todo

You may have noticed that when Visual Studio automatically generates some code for you, there sometimes is a comment in the generated code akin to “//TODO: Implement logic here”. If you go to View -> Task List and select “Comments” from the dropdown, you’ll see that “TODO” comment in the list. Anywhere in your code that you start a comment with “TODO” you’ll find a corresponding entry in the Task List. Cool, huh?

This was handy for me today as I went through a project in the midstream of development and documented all the things I knew I was planning to do but hadn’t finished yet. Weeks, or even months from now, if I were to pick up the project without these comments, I’d need to review each portion of code to see where I had left off. Worse, if another developer new to the project had to pick up the project and run with it, they’d have a longer learning curve getting a feel for what the project was doing. Now of course there is hopefully other documentation in the form of use cases and such to provide some direction, but a little commentary at the implementation level comes in really handy.

As usual, it’s not rocket science, but pretty handy when you need it.

Bookmark to:
Del.icio.us digg FURL reddit Technorati Ma.gnolia Stumble Upon Bloglines

Note: the code below is assumed to be contained in a static class called Utilities, that I’ll call later from the .ASPX page.

Note part deux: please forgive the lack of indentation and carriage returns, Wordpress is not playing nicely, and I don’t have an opportunity right now to trick it in to doing what I want. Will fix soon.

Creating the utility function

Because I want to toggle between numeric, full and abbreviated month values, I first need an Enumeration:

public enum MonthListType : int {
MonthNumbers,
FullMonthNames,
AbbreviatedMonthNames
}

Now for a function that will return the months in the format I want:

public static Dictionary<string, string> GetMonthList(MonthListType type)
{
Dictionary<string, string> monthList = new Dictionary<string, string>()
{
{ "01", "January"},
{ "02", "February"},
{ "03", "March"},
{ "04", "April"},
{ "05", "May"},
{ "06", "Jun"},
{ "07", "July"},
{ "08", "August"},
{ "09", "September"},
{ "10", "October"},
{ "11", "November"},
{ "12", "Dec"}
}
switch (type)
{
case MonthListType.MonthNumbers:
return monthList.ToDictionary(m => m.Key, m => m.Key);
break;
case MonthListType.FullMonthNames:
return monthList.ToDictionary(m => m.Key, m => m.Value);
break;
case MonthListType.AbbreviatedMonthNames:
return monthList.ToDictionary(m => m.Key, m => m.Value.Substring(0, 3));
break;
default:
return monthList;
break;
}
}


Putting our new code to use

Now in a .ASPX page we’ll add a dropdown :

<asp:DropDownList ID="MonthDropdown" runat="server"></asp:DropDownList>

And in the backend wire it up with our months, with the text values being abbreviated month names:

MonthDropdown.DataSource = Utilities.GetMonthList(Utilities.MonthListType.AbbreviatedMonthNames);
MonthDropdown.DataValueField = "key";
MonthDropdown.DataTextField = "value";
MonthDropdown.DataBind();

Bonus - Painless Day and Year Dropdowns

To quickly generate values 1-31 for our day dropdowns and some reasonable values for our year dropdowns, we can use the handy function Enumerable.Range(start, count) which returns an enumerable list of consecutive integers starting at the integer you specify, and continuing until you have the amount of integers you want. This is easy to apply for the dropdowns:

DayDropdown.DataSource = Enumerable.Range(1, 31);
DayDropdown.DataBind();
YearDropdown.DataSource = Enumerable.Range(DateTime.Now.Year, 10);
YearDropdown.DataBind();

Piece of cake! Leave me a note if you find this useful or have any suggestions to improve it.

Bookmark to:
Del.icio.us digg FURL reddit Technorati Ma.gnolia Stumble Upon Bloglines

<label for="ctlFirstName">First Name</label>
<input id="ctlFirstName" type="text" />

Clicking on “First Name” focuses the cursor inside the ctlFirstName <input /> element; Were the <input /> a checkbox, clicking the <label> would mark the box as checked. This improves the accessibility of the form for users browsing with screen readers. Sighted users have more area to click on to achieve a task, e.g. selecting a checkbox; they can click the words instead of the smaller box, a small application of Fitt’s Law.

Unfortunately, this functionality is lost when using a <label> to point to a .NET control, because .NET will rename all the controls at runtime, and the association with the label is lost (e.g. for=”ctlFirstName”, but the input is renamed to “ctl00_ctlFirstName”). To prevent this, you can substitute the <label> element with the .NET Label control. Usually, <asp:label> outputs a <span>; to make it behave instead as a <label>, use the “AssociatedControlID” parameter to specify the associated control:

<asp:label runat="server" id="lblFirstname" associatedcontrolid="ctlFirstName">First Name</asp:label>
<asp:textbox runat="server" id="ctlFirstName"></asp:textbox>

will produce something similar to:

<label for="ctl00_ctlFirstName">First Name</label>
<input id="ctl00_ctlFirstName" type="text" />


And now the <label> and the <input /> stay associated after .NET does its control renaming - woot! All this time and I had never noticed the “AssociatedControlID” attribute. Now I know, and being a markup junkie, it makes me pretty happy.

Bookmark to:
Del.icio.us digg FURL reddit Technorati Ma.gnolia Stumble Upon Bloglines

This is further proof to support my long standing assertion that legos are the greatest toy ever created.

Prints are available on RedBubble - I think I may have to get 1-2 of these.

(via wil wheaton)

Bookmark to:
Del.icio.us digg FURL reddit Technorati Ma.gnolia Stumble Upon Bloglines