Anyhow, there are a number of excellent learning resources for Python, but I seem to learn best by doing. So, after tackling a number of levels in the Python challenge I decided to make my own challenge; Rack up a high score in Scramble and Scramble2, which is a “Boggle”-type game for Facebook and the iTouch/iPhone respectively.

photo credit: therichbrooks

The game is played on a 4×4 or 5×5 grid of letters.  The object is to attain a high score.  You score by connecting adjacent letters into a word.  Longer words result in disproportionally higher scores.  The minimum word length is 3.  You cannot use a letter-space more than once in the same word.

I created a Python program which compared all possible paths to a dictionary of known words and then printed them out in order from longest to shortest.  The program is admittedly lacking in a user-interface.  You have to re-run it to change the board size and it’s not super-optimized for either speed or memory.  However, it does work quite well and is fast enough to use.  It takes about 20-30 seconds to do the initial load of all the paths and then takes between 1-5 seconds to compute possible words once you type in the values from the game.

Below are the results from my Python program (left) and showing my “high score” of 369 (right).

With a better dictionary you could improve the score.  In the example above, my dictionary has 3 of the 5 seven-letter words but misses the eight-letter word in the puzzle.

You can download the Scramble Solver.py – Python source code.  I used a list of words separated by carriage returns from a spell-checking “dictionary”.  You are on your own for finding a word list.  I’m providing the source code so that you can see it, not so you can beat the game :)

Below is a complete listing of the source code:

class wordlist:
    """
    Create a clean list of words from the base dictionary
    """
    def __init__(self, max_length):
        # Constants
        self._rawpath = 'en_us.dic'
        self._maxlength = max_length

    def load(self):
        """
        Returns a clean list of words
        """
        print 'Creating list of words...'
        raw_dictionary = open(self._rawpath, 'r')
        goodwords = set()

        for line in raw_dictionary:
            # Make sure we have a word of the correct size and not starting with a number and with no apostrophes
            if (2 < len(line) < self._maxlength + 1
                and line[0] not in ['0','1','2','3','4','5','6','7','8','9']
                and "'" not in line):
                # Strip off trailing \n and convert to lowercase
                goodwords.add(line[:-1].lower())
        raw_dictionary.close()

        print 'Created list of words.'

        return goodwords

class pathlist:
    """
    Creates a path list which contains all possible paths through the grid.
    """

    def __init__(self, board_size, max_length):
        # Constants
        self._boardsize = board_size
        self._maxlength = max_length

        # Properties
        self.paths = []

    def _traversepath(self, startindex, previouspath):
        """
        Finds all the paths for a given starting point,
        used recursively to explore adjacent segments
        """
        # Immediately exit if we are trying to create a circular path
        # or if the path length gets too long
        if startindex in previouspath or len(previouspath) >= self._maxlength:
            return

        # Copy the path and then add the next segment
        nextpath = previouspath[:]
        nextpath.append(startindex)

        # Only store paths of at least three letters
        if len(nextpath) > 2:
            self.paths.append(nextpath)

        # Grab the row and column for the given startindex
        row = startindex // self._boardsize
        col = startindex % self._boardsize

        # Traverse adjacent paths
        # Up to 8 adjacent paths possible

        # Row above: row - 1
        if row - 1 >= 0 and col - 1 >= 0: self._traversepath(startindex - self._boardsize - 1, nextpath)
        if row - 1 >= 0: self._traversepath(startindex - self._boardsize, nextpath)
        if row - 1 >= 0 and col + 1 <= 3: self._traversepath(startindex - self._boardsize + 1, nextpath)

        # Same row: row - 0
        if col - 1 >= 0: self._traversepath(startindex - 1, nextpath)
        if col + 1 <= 3: self._traversepath(startindex + 1, nextpath)

        # Row below: row + 1
        if row + 1 <= 3 and col - 1 >= 0: self._traversepath(startindex + self._boardsize - 1, nextpath)
        if row + 1 <= 3: self._traversepath(startindex + self._boardsize, nextpath)
        if row + 1 <= 3 and col + 1 <= 3: self._traversepath(startindex + self._boardsize + 1, nextpath)

    def load(self):
        """
        Returns a list of possible paths
        """
        self.paths = []
        print 'Creating the path list...'
        # Generate self.paths by going through all positions
        for i in range(0, self._boardsize ** 2):
            self._traversepath(i, [])

        print 'Created the path list.'

        return self.paths

class solver:
    """
    Class for solving 4x4 and 5x5 grid word puzzles using a dictionary
    """
    def __init__(self, paths = None, dict = None):
        """
        Loads up the dictionary and paths from file
        """
        print 'Loading words...'
        self.dictionary = dict
        print 'Loaded %d words.' % len(self.dictionary)

        print 'Loading paths...'
        self.paths = paths
        print 'Loaded %d paths.' % len(self.paths)

        # initialize grid
        self.grid = []

    def _translate_path_to_letters(self, path, letters):
        """
        Translates a numerical path to letters given a grid.

        Returns a string
        """
        output = ''
        for p in path:
            output += letters[p]
        return output

    def _get_intersecting_words(self):
        """
        Finds the intersection between the dictionary words
        and the (path-based) possible words

        Returns a subset of the possible words
        """
        realwords = {}
        for word in self.dictionary:
            if self.possiblewords.has_key(word):
                realwords[word] = self.possiblewords[word]
        return realwords

    def get_words(self, letters):
        """
        Returns a dictionary with keys of valid words.
        The values of the dictionary are the paths taken to get those valid words.
        For example, in the sample data set (4x4 board):
            Key: genius
            Value: [4, 8, 5, 6, 9, 10]
        """
        output = ''
        self.grid = letters
        self.possiblewords = dict()

        # Translate all paths into letters
        print 'Translating all possible paths into possible words...'
        for path in self.paths:
            self.possiblewords[self._translate_path_to_letters(path, letters)] = path
        print 'Translated paths into %d unique words.' % len(self.possiblewords)

        print 'Finding possible real words...'
        realwords = self._get_intersecting_words()
        print 'Found %d possible real words.' % len(realwords)

        return realwords

MAXLENGTH = 10
BOARDSIZE = 4

pl = pathlist(BOARDSIZE, MAXLENGTH)
wl = wordlist(MAXLENGTH)
s = solver(pl.load(), wl.load())

while True:
    print 'Enter all %d lines in a row, with no spaces between them.  Or, press ENTER to use the default values.  Type "q" by itself to quit.' % BOARDSIZE
    line = raw_input("line:").lower()

    if line == 'q':
        break

    # Check to see if we should use the default values
    if len(line) == 0:
        print 'Using default values.'
        # Assumes BOARDSIZE of 4 or 5 only
        if BOARDSIZE == 4:
            line = 'oiei' + 'gnic' + 'eusn' + 'oliy'
        else:
            line = ''

    # Find all the possible words and their paths
    wordset = [word for word in s.get_words(line).keys()]

    # Print out the words, sorted from longest to shortest, ignoring the paths
    for word in sorted(wordset, None, len, True):
        print word

It turns out the problem was that I had Virtual PC 2007 AND Virtual PC 2007 SP1 installed side-by-side. I uninstalled my original Virtual PC 2007 (not SP1) and then applied the Windows Update and the problem was solved.

I’ve read of this same issue affecting Vista as well. Hope this helps anyone who encounters this problem.

An error occurred during local report processing.

The definition of the report ‘/Main’ is invalid.

An internal error occurred on the report server. See the error log for more details.

This happens only under specific circumstances.  The base list must have a required lookup column/field that is multi-value.  The view must not include this column.

A required, multi-value lookup column is created to demonstrate the problem:

An example of the list data in standard view, showing the “Region” column:

I created a new view without the “Region” column to show the duplicates bug.  Standard view appears normal:

Same view, but when switched to Datasheet view, duplicate records show:

Same view in Export to Spreadsheet shows duplicates:

If the column is not required, everything works fine.  If the column exists in the view, everything is fine.  It is only when the required column is omitted from the view that you see duplicates.

If the column is included from the view, everything is normal during Edit in Datasheet mode:

Duplicates are now gone in Export to Spreadsheet as well:

There seems to be no fix for this problem.  The work-around is, if you have a required multi-value lookup column, to always add the column to views, especially datasheet views.  If a user creates their own view without the column, they may run into this problem.  User education is the only solution in this case.

Although this seems like a rare circumstance, it does appear that multiple SharePoint users are encountering this problem.  This affects both WSS 3.0 and MOSS 2007.

Two of the missing methods are case-insensitive versions of the methods “Contains” and “Replace”. I do not take credit for writing the methods — I found them on Google and have provided references in the code. I did add the comments to make the overloaded methods match the originals. I also tested them to make sure they behaved like the originals when provided with a null or empty string.

I’m not sure why the .NET team did not provide case-insensitive Replace or case-insensitive Contains, they do it with many other string methods like StartsWith and EndsWith. Hopefully these help.

The case-insensitive Contains code is heavily based on a post on this forum. The case-insensitive Replace code is heavily based on a Code Project comment. Learn more about C# extensions on MSDN.

Please note that I had to butcher some of the XML comments because the code formatter was deleting them. It shouldn’t affect compiling, but you may have to fix some if you want the full Intellisense.

using System;
using System.Text;

namespace MyNamespace
{
    /// <summary>
    /// Overloads the string object and adds case-insenstive options to certain methods
    /// </summary>
    public static class StringExtensions
    {
        /// <summary>
        /// Returns a value indicating whether the specified System.String object occurs
        /// within this string.
        /// </summary>
        /// <param name="original">The System.String object to be checked.</param>
        /// <param name="value">The System.String object to seek.</param>
        /// <param name="comparisonType">One of the System.StringComparison values that
        /// determines how this string and value are compared.</param>
        /// <returns>true if the value parameter occurs within this string, or
        /// if value is the empty string (""); otherwise, false.</returns>
        /// <exception cref="System.ArgumentNullException">value is null.</exception>
        static public bool Contains(this string original, string value, StringComparison comparisonType)
        {
            if (original == null)
                throw new NullReferenceException("Object reference not set to an instance of an object.");

            if (value == null)
                throw new ArgumentNullException("value");

            if (String.Empty == value)
                return true;

            return (0 < = original.IndexOf(value, comparisonType));
        }

        /// <summary>
        /// Replaces all occurrences of a specified System.String in this instance
        /// with another specified System.String. < / summary>
        /// <param name="original">The System.String object to be searched.</param>
        /// <param name="oldValue">A System.String to be replaced.</param>
        /// <param name="newValue">A System.String to replace all occurrences of oldValue.</param>
        /// <param name="comparisonType">One of the System.StringComparison values that
        /// determines how this string and value are compared.</param>
        /// <returns>A System.String equivalent to this instance but with all
        /// instances of oldValue replaced with newValue.</returns>
        /// <exception cref="System.ArgumentNullException">oldValue is null.</exception>
        /// <exception cref="System.ArgumentException">oldValue is the empty string ("").</exception>
        static public string Replace(this string original, string oldValue, string newValue, StringComparison comparisonType)
        {
            if (original == null)
                throw new NullReferenceException("Object reference not set to an instance of an object.");

            if (oldValue == null)
                throw new ArgumentNullException("oldValue");

            if (String.Empty == oldValue)
                throw new ArgumentException("oldValue");

            int lenPattern = oldValue.Length;
            int idxPattern = -1;
            int idxLast = 0;

            StringBuilder result = new StringBuilder(original.Length);

            while (true)
            {
                idxPattern = original.IndexOf(oldValue, idxPattern + 1, comparisonType);

                if (idxPattern < 0)
                {
                    result.Append(original, idxLast, original.Length - idxLast);
                    break;
                }

                result.Append(original, idxLast, idxPattern - idxLast);
                result.Append(newValue);

                idxLast = idxPattern + lenPattern;
            }

            return result.ToString();
        }
    }
}

For my example, I’m using a parameter named “Time” with choices “Morning”, “Noon”, and “Night”.  The values are M, N, and I respectively.  You can see how I set up the parameter in the following screenshot.

You can accomplish having all the checkboxes selected by default in two ways.  The first way is to pass an object array of values, and the easiest way to do that is to use the Split command to split a string into a string array.  I used =Split(“M,N,I”,”,”) as my default.  I had to provide the second parameter for Split, the delimiter, because the default is space.

The second, and easier method, is to just add a line item for each item you want checked, as demonstrated in this screenshot:

Here is the resulting parameter list, showing all the items selected (same for either method):

Sometimes, you need to display the parameters of your report, perhaps so it could be regenerated later.  You’ll need to print out that object array, so use the opposite of Split, Join.  Below is a textbox with an expression of =Join(Parameters!Time.Label, “, “), which joins the parameter values together with a comma and space separator.

Here is the result of the code, with two parameters selected shown:

If you only put the parameter label in the textbox (i.e. using code =Parameters!Time.Label) then when you display the report, you’ll get the famous Reporting Services #Error message.  You have to use Join in this case.

If, somewhere in the site author tree, you have user accounts that no longer exist, you will encounter the “User not found” error while viewing the report and browsing the list of shared data sources.

I found two good blog articles about this issue as well as a solution here:

• Wherefore Art Thou Author?
• Resetting the Author on a SharePoint site, or Wherefore Art Thou Author Redux

I modified the code a bit to just show the site author without resetting it.  I also changed the code to explicitly dispose of the SharePoint objects.

The utility takes two parameters, the first is the site URL.  If you only pass one parameter, it looks up the site author.  If you pass a second parameter (in the format of DOMAIN\USER), the site author will be reset to the value you supply.

To build, run this from the command-line:

%WINDIR%\Microsoft.NET\Framework\v2.0.50727\csc /target:exe /out:SPResetAuthor.exe SPResetAuthor.cs
/reference:"%COMMONPROGRAMFILES%\Microsoft Shared\web server extensions\12\ISAPI\Microsoft.SharePoint.dll"

Source code of SPResetAuthor.cs:

using System;
using System.Text;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Administration;

// Original code from: http://blog.krichie.com/2008/09/12/
//      resetting-the-author-on-a-sharepoint-site-or-wherefore-art-thou-author-redux/

namespace SPResetAuthor
{
  class Program
  {
    static void Main(string[] args)
    {
      if (args.Length < 1)
      {
        StringBuilder sb = new StringBuilder();
        sb.Append("\nSYNTAX: SPResetAuthor.exe (Site URL) [new owner]  \n");
        sb.Append("\nwhere:\n\n");
        sb.Append("\n\t(Site URL) - The web URL for"
            + " the site i.e. http://sharepoint/site/");
        sb.Append("\n\t[new owner] - The login account"
            + " for the new author, i.e. DOMAIN\\USER");
        Console.WriteLine(sb.ToString());
        return;
      }
      // Open the site collection
      Console.WriteLine("Opening site collection for: {0}", args[0]);
      using (SPSite site = new SPSite(args[0]))
      {
        // Open the web via the URL passed in
        Console.WriteLine("Opening site (web)...");

        using (SPWeb web = site.OpenWeb())
        {
          Console.WriteLine("Site (web) title: " + web.Title);
          if (args.Length == 1)
          {
            Console.WriteLine("Attempting to retrieve author for site");
            try
            {
              Console.WriteLine("web.Author: {0}", web.Author.ToString());
            }
            catch (Exception ex)
            {
              Console.WriteLine("Exception occured:\n{0}", ex.ToString());
            }
          }
          if (args.Length == 2)
          {
            Console.WriteLine("Resetting Author to: {0}", args[1]);
            SPUser user = web.EnsureUser(args[1]);
            web.Author = user;
            web.Update();
            Console.WriteLine("Author for site {0}, reset to {1}", args[0], args[1]);
            Console.WriteLine("Author ID: " + web.Author.ID.ToString());
            Console.WriteLine("Author Name: " + web.Author.Name);
          }
        }
      }
    }
  }
}

1. Folder icons have been turned sideways

I understand this was done to give a better visual indicator. But who stores real manila folders on their side? Defeats the metaphor if you ask me.

Folder icons are now sideways

2. Start menu scrolling is a pain

I don’t like having a fixed size start menu.  Why should I have to scroll to see menu items?  I would like to be able to re-size the menu, but this isn’t really possibly. You can make the menu bigger by bumping up the number of recent items, but you’ll still have to scroll. To adjust the Start menu size, right click on Start menu, choose Properties. Select the top Customize… button. In the Start menu size group, select the Number of recent programs to display option.

Start menu scrolling is a pain

3. Start menu icon only appears on mouse over

Not having icons on the Start menu for Document, Computer, Network, etc is just annoying. Icons are there for a visual depiction. Having icons apart from the actual item is distracting.  They should either have an icon or not–don’t stick it in as an afterthought.

Start menu icon only appears on mouse over

4. Confusing verbs in the Network and Sharing Center

The Tasks in the Network and Sharing Center are about as confusing as it gets.  If I want to set my IP address for my wireless adapter, which would I choose: Manage wireless networks, Set up a connection, or Manage network connection?  Like a lot of Microsoft products, there are too many ways to do the same thing.  So many similarly worded choices just add to the confusion.

Confusing verbs in the Network and Sharing Center

5.  In Explorer, column resizer is too small

In Explorer windows, Vista/Server 2008 added the filter drop down.  I love this feature but they managed to make resizing columns much more difficult.  The resizer now has just a few pixels where it’s active.  To top it off, when you click on the arrow for the filter, it pops down.  Click it again, and it stays down.  You can’t get it to go away.  Drag the filter arrow and it takes the whole column, so you can re-order them.  Why not just make the filter arrow part of the column resizer?  It makes more sense than it does to re-order the columns and I bet it happens a lot more often.

In Explorer, column resizer is too small

6. Not having the “up one folder” button in Explorer.

There is a pretty good bread-crumb navigation in Explorer now.  There is a back button.  But, there is no “up one folder” button, like there used to be.  I know, you can click on the actual item, but having to hunt visually is not nearly as effective as clicking a single button that is always there. At least the keyboard shortcut (backspace) is intact.

Missing the "up one folder" button

The old "UP" button - where did you go?

Screenshots of the three scenarios:

The correct query returns the desired results: two columns of information

Accidentally leaving off the comma results in only one column (with the wrong data)

Adding in an explicit "AS" gives the same results as omitting the comma

I’ve been working with SQL for years and never had this issue before. I supposed it is because if I make a mistake like this, I usually omit more than one comma, which causes a parsing error.

The user can interactively sort on a header textbox by just setting the “interactive sort” properties:
http://weblogs.sqlteam.com/joew/archive/2008/08/02/60666.aspx

You can also sort using standard report parameters:
http://www.databasejournal.com/features/mssql/article.php/10894_3492236