"I was using the "Find" method on an unsorted TStringlist... which you're not supposed to do. Sometimes it works (my initial test case had the items in my list already sorted, just by coincidence), but usually it doesn't..."

So, Roddy had two options:

{...}


Names.LoadFromFile('names.txt');


Names.Sorted := True;


{...} 

...or...

//Instead of using Names.find, do the following:


Result := Names.IndexOf('Bobby Fisher'); 

Thanks again to Roddy for suggesting this puzzle. If you'd like to submit an idea for a puzzle, email me at jacob(at)twodesk.com.

Roddy (*Names may have been changed to protect the innocent) had code similar to the following:

function FindBobbyFisher: Integer;


var


  Names: TStringList;


  I: Integer;


begin


  Names := TStringList.Create;


  Names.LoadFromFile('names.txt');


  if not Names.Find('Bobby Fisher', I) then


    Result := -1


  else


    Result := I;


  Names.Free;  


end; 

Roddy's code worked at first, but soon Bobby Fisher could not be found. What is Roddy missing?

{$INCLUDE ../includes/dotnet.inc}

The fix?  Use backslashes in the file path, not forward slashes:

{$INCLUDE ..\includes\dotnet.inc}

During testing, everything worked as expected, but after checking in all the files, he got an email from the build machine telling him he broke the build.

What did he do wrong?

Here's the method I used:

1. Create an array containing one string for each song in the songbook
2. Sort the array by the number of occurrences of the digit in question
3. Get the number of occurrences of the digit in the first X strings in the array, where X is the number of songs in the service.

Here's my code:

function CountOccurrences(S: string; AInt: Integer): Integer;


var


  I: Integer;


begin


  Result := 0;


  for I := 1 to Length(S) do


    if S[I] = Chr(AInt + 48) then


      Inc(Result);


end;


 


function GetCount(SongsInBook, SongsInService, Digit: Integer): Integer;


var


  I, J: Integer;


  Numbers: array of string;


  TempStr: string;


begin


  //Make sure the numbers are as expected


  Assert(SongsInService <SongsInBook);


  Assert((Digit <10) and (Digit> -1));


  //First, fill an array with all the numbers in the book


  SetLength(Numbers, SongsInBook);


  for I := 0 to SongsInBook - 1 do


  begin


    Numbers[I] := IntToStr(I + 1);


  end;


  //Sort the array by the number of occurences of the digit in question. We'll


  //just use a simple sort.


  for I := 0 to SongsInBook - 1 do


  begin


    for J := I + 1 to SongsInBook - 1 do


    begin


      if CountOccurrences(Numbers[J], Digit)>=


         CountOccurrences(Numbers[I], Digit) then


      begin


        TempStr := Numbers[I];


        Numbers[I] := Numbers[J];


        Numbers[J] := TempStr;


      end;


    end;


  end;


  //Finally, get the number of digits in the top SongsInService "worst" songs


  TempStr := '';


  for I := 0 to SongsInService - 1 do


    TempStr := TempStr + Numbers[I];


  Result := CountOccurrences(TempStr, Digit);


end;


 


function GetDigitCounts(SongsInBook, SongsInService: Integer): THymnBoard;


{var


  I: Integer;}


begin


  Result.N0 := GetCount(SongsInBook, SongsInService, 0);


  Result.N1 := GetCount(SongsInBook, SongsInService, 1);


  Result.N2 := GetCount(SongsInBook, SongsInService, 2);


  Result.N3 := GetCount(SongsInBook, SongsInService, 3);


  Result.N4 := GetCount(SongsInBook, SongsInService, 4);


  Result.N5 := GetCount(SongsInBook, SongsInService, 5);


  Result.N6 := GetCount(SongsInBook, SongsInService, 6);


  Result.N7 := GetCount(SongsInBook, SongsInService, 7);


  Result.N8 := GetCount(SongsInBook, SongsInService, 8);


  Result.N9 := GetCount(SongsInBook, SongsInService, 9);


 


//The following also works, and is much shorter, but is less readable:


{  for I := 0 to 9 do


    Integer(Pointer(Integer(@Result) + I * sizeof(Integer))^) :=


      GetCount(SongsInBook, SongsInService, I);}


end; 

There are a couple of optimizations that could be done here that I didn't do for the sake of readability. One is that the array doesn't necessarily need to be regenerated each time, but really only needs to be re-sorted for each digit. The array could be generated only once.

Also, a better sorting algorithm than simple sort could obviously be used, but the sorting isn't the point here, so I decided to keep the code as simple as possible.

Your task is to create an algorithm to determine the minimum number of each digit card (the little cards with a single digit, 0-9, on them) to include with each hymn board. You are given the number of songs in the songbook, and the maximum number of songs that can be sung during a service. A song is never repeated during a service.

For example, if there are 10 songs in the book, and two songs can be sung during a service, then you need exactly two 1s, and one of everything else (two 1s in case the two songs are 1 and 10). That one is easy enough to do by hand, but most books will have a few hundred songs, and at least three songs are sung at most services. Your algorithm should be universal.

Here's your skeleton code:

The solution is to check Application.Terminated in the thread loop:

while TransactionsPending and not Application.Terminated do


  //etc...


end; 

With this check in, when the application is closed, the thread will finish processing the transaction it's processing, and then gracefully exit.

procedure TProcessingThread.Execute;


var


  Trans: TAccountTransaction;


begin


  while TransactionsPending do


  begin


    try


      Trans := TAccountTransaction.Create;


      try


        GetNextPendingTransaction(Trans);


        Trans.Settle;


      except


        on E: Exception do


          LogError(Format('Transaction %d failed: %s', [Trans.ID, E.Message]));


      end;


    finally


      Trans.Free;


    end;


  end;


end; 

When Steven, a senior developer looked at the code, he pulled Ray aside and gently explained something very important that Ray had missed. What did Steven tell Ray?

The site is being moved to a new server, and to make sure that we don't lose any comments in the process, there is no puzzle this week. It will be back in full force, better-than-ever, next week.

--Jacob

^M is a Delphi code construct that compiles, but I haven't found it documented anywhere. The ^M is character - analogue to #13#10 (or \n in c parlance). The + operators aren't even necessary. You can do 'string1'^M'string2' and get the same result.

I wouldn't encourage using this in code, but it's good to know that it exists.