trackler 2.2.1.107 → 2.2.1.108

data/tracks/delphi/exercises/perfect-numbers/uPerfectNumbersExample.pas

@@ -1,8 +1,11 @@
 unit uPerfectNumbers;
 
 interface
+uses System.SysUtils;
 
 type
+  ENotNaturalNumber = class(Exception);
+
   NumberType = (Perfect, Abundant, Deficient);
 
   PerfectNumber = class
@@ -16,6 +19,9 @@ class function PerfectNumber.Classify(aNumber: Integer): NumberType;
 var sumOfFactors: integer;
     i: integer;
 begin
+  if aNumber < 1 then
+    raise ENotNaturalNumber.Create('Classification is only possible for natural numbers.');
+
   sumOfFactors := 0;
 
   for i := 1 to aNumber - 1 do

data/tracks/delphi/exercises/perfect-numbers/uPerfectNumbersTest.pas

@@ -4,94 +4,145 @@ interface
 uses
   DUnitX.TestFramework;
 
+const
+  CanonicalVersion = '1.1.0';
+
 type
 
   [TestFixture]
-  PerfectNumbersTest = class(TObject) 
+  PerfectNumbersTest = class(TObject)
   public
     [Test]
-//  [Ignore('Comment the "[Ignore]" statement to run the test')]
-    procedure Can_classify_3_as_deficient;
+//    [Ignore('Comment the "[Ignore]" statement to run the test')]
+    procedure Smallest_perfect_number_is_classified_correctly;
+
+    [Test]
+    [Ignore]
+    procedure Medium_perfect_number_is_classified_correctly;
+
+    [Test]
+    [Ignore]
+    procedure Large_perfect_number_is_classified_correctly;
+
+    [Test]
+    [Ignore]
+    procedure Smallest_abundant_number_is_classified_correctly;
 
     [Test]
     [Ignore]
-    procedure Can_classify_7_as_deficient;
+    procedure Medium_abundant_number_is_classified_correctly;
 
     [Test]
     [Ignore]
-    procedure Can_classify_13_as_deficient;
+    procedure Large_abundant_number_is_classified_correctly;
 
     [Test]
     [Ignore]
-    procedure Can_classify_6_as_perfect;
+    procedure Smallest_prime_deficient_number_is_classified_correctly;
 
     [Test]
     [Ignore]
-    procedure Can_classify_28_as_perfect;
+    procedure Smallest_non_prime_deficient_number_is_classified_correctly;
 
     [Test]
     [Ignore]
-    procedure Can_classify_496_as_perfect;
+    procedure Medium_deficient_number_is_classified_correctly;
 
     [Test]
     [Ignore]
-    procedure Can_classify_12_as_abundant;
+    procedure Large_deficient_number_is_classified_correctly;
 
     [Test]
     [Ignore]
-    procedure Can_classify_18_as_abundant;
+    procedure Edge_case_no_factors_other_than_itself_is_classified_correctly;
 
     [Test]
     [Ignore]
-    procedure Can_classify_20_as_abundant;
+    procedure Zero_is_rejected_not_a_natural_number;
+
+    [Test]
+    [Ignore]
+    procedure Negative_integer_is_rejected_not_a_natural_number;
   end;
 
 implementation
 uses uPerfectNumbers;
 
-procedure PerfectNumbersTest.Can_classify_3_as_deficient;
+procedure PerfectNumbersTest.Smallest_prime_deficient_number_is_classified_correctly;
 begin
-  Assert.AreEqual(Deficient, PerfectNumber.Classify(3));
+  Assert.AreEqual(Deficient, PerfectNumber.Classify(2));
 end;
 
-procedure PerfectNumbersTest.Can_classify_7_as_deficient;
+procedure PerfectNumbersTest.Smallest_non_prime_deficient_number_is_classified_correctly;
 begin
-  Assert.AreEqual(Deficient, PerfectNumber.Classify(7));
+  Assert.AreEqual(Deficient, PerfectNumber.Classify(4));
 end;
 
-procedure PerfectNumbersTest.Can_classify_13_as_deficient;
+procedure PerfectNumbersTest.Medium_deficient_number_is_classified_correctly;
 begin
-  Assert.AreEqual(Deficient, PerfectNumber.Classify(13));
+  Assert.AreEqual(Deficient, PerfectNumber.Classify(32));
 end;
 
-procedure PerfectNumbersTest.Can_classify_6_as_perfect;
+procedure PerfectNumbersTest.Large_deficient_number_is_classified_correctly;
+begin
+  Assert.AreEqual(Deficient, PerfectNumber.Classify(33550337));
+end;
+
+procedure PerfectNumbersTest.Edge_case_no_factors_other_than_itself_is_classified_correctly;
+begin
+  Assert.AreEqual(Deficient, PerfectNumber.Classify(1));
+end;
+
+procedure PerfectNumbersTest.Smallest_perfect_number_is_classified_correctly;
 begin
   Assert.AreEqual(Perfect, PerfectNumber.Classify(6));
 end;
 
-procedure PerfectNumbersTest.Can_classify_28_as_perfect;
+procedure PerfectNumbersTest.Medium_perfect_number_is_classified_correctly;
 begin
   Assert.AreEqual(Perfect, PerfectNumber.Classify(28));
 end;
 
-procedure PerfectNumbersTest.Can_classify_496_as_perfect;
+procedure PerfectNumbersTest.Large_perfect_number_is_classified_correctly;
 begin
-  Assert.AreEqual(Perfect, PerfectNumber.Classify(496));
+  Assert.AreEqual(Perfect, PerfectNumber.Classify(33550336));
 end;
 
-procedure PerfectNumbersTest.Can_classify_12_as_abundant;
+procedure PerfectNumbersTest.Smallest_abundant_number_is_classified_correctly;
 begin
   Assert.AreEqual(Abundant, PerfectNumber.Classify(12));
 end;
 
-procedure PerfectNumbersTest.Can_classify_18_as_abundant;
+procedure PerfectNumbersTest.Medium_abundant_number_is_classified_correctly;
 begin
-  Assert.AreEqual(Abundant, PerfectNumber.Classify(18));
+  Assert.AreEqual(Abundant, PerfectNumber.Classify(30));
 end;
 
-procedure PerfectNumbersTest.Can_classify_20_as_abundant;
+procedure PerfectNumbersTest.Large_abundant_number_is_classified_correctly;
 begin
-  Assert.AreEqual(Abundant, PerfectNumber.Classify(20));
+  Assert.AreEqual(Abundant, PerfectNumber.Classify(33550335));
+end;
+
+procedure PerfectNumbersTest.Zero_is_rejected_not_a_natural_number;
+var MyProc: TTestLocalMethod;
+begin
+  MyProc := procedure
+            begin
+              PerfectNumber.Classify(0);
+            end;
+
+  assert.WillRaiseWithMessage(MyProc, ENotNaturalNumber, 'Classification is only possible for natural numbers.');
+end;
+
+procedure PerfectNumbersTest.Negative_integer_is_rejected_not_a_natural_number;
+var MyProc: TTestLocalMethod;
+begin
+  MyProc := procedure
+            begin
+              PerfectNumber.Classify(-1);
+            end;
+
+  assert.WillRaiseWithMessage(MyProc, ENotNaturalNumber, 'Classification is only possible for natural numbers.');
 end;
 
 initialization

data/tracks/delphi/exercises/pig-latin/README.md

@@ -7,10 +7,10 @@ confusing. It obeys a few simple rules (below), but when it's spoken
 quickly it's really difficult for non-children (and non-native speakers)
 to understand.
 
-- **Rule 1**: If a word begins with a vowel sound, add an "ay" sound to
-  the end of the word.
-- **Rule 2**: If a word begins with a consonant sound, move it to the
-  end of the word, and then add an "ay" sound to the end of the word.
+- **Rule 1**: If a word begins with a vowel sound, add an "ay" sound to the end of the word. Please note that "xr" and "yt" at the beginning of a word make vowel sounds (e.g. "xray" -> "xrayay", "yttria" -> "yttriaay").
+- **Rule 2**: If a word begins with a consonant sound, move it to the end of the word and then add an "ay" sound to the end of the word. Consonant sounds can be made up of multiple consonants, a.k.a. a consonant cluster (e.g. "chair" -> "airchay").
+- **Rule 3**: If a word starts with a consonant sound followed by "qu", move it to the end of the word, and then add an "ay" sound to the end of the word (e.g. "square" -> "aresquay").
+- **Rule 4**: If a word contains a "y" after a consonant cluster or as the second letter in a two letter word it makes a vowel sound (e.g. "rhythm" -> "ythmrhay", "my" -> "ymay").
 
 There are a few more rules for edge cases, and there are regional
 variants too.

data/tracks/delphi/exercises/pig-latin/uTestPigLatin.pas

@@ -4,6 +4,9 @@ interface
 uses
   DUnitX.TestFramework;
 
+const
+  CanonicalVersion = '1.2.0';
+
 type
   [TestFixture]
   PigLatinTest = class(TObject)
@@ -32,15 +35,6 @@ type
     [Ignore]
     procedure Word_beginning_with_k;
 
-    [Ignore]
-    procedure y_is_treated_like_a_consonant_at_the_beginning_of_a_word;
-
-    [Ignore]
-    procedure y_is_treated_like_a_vowel_at_the_end_of_a_consonant_cluster;
-
-    [Ignore]
-    procedure y_as_second_letter_in_two_letter_word;
-
     [Ignore]
     procedure Word_beginning_with_x;
 
@@ -71,6 +65,15 @@ type
     [Ignore]
     procedure Word_beginning_with_xr;
 
+    [Ignore]
+    procedure y_is_treated_like_a_consonant_at_the_beginning_of_a_word;
+
+    [Ignore]
+    procedure y_is_treated_like_a_vowel_at_the_end_of_a_consonant_cluster;
+
+    [Ignore]
+    procedure y_as_second_letter_in_two_letter_word;
+
     [Ignore]
     procedure A_whole_phrase;
   end;

data/tracks/delphi/exercises/poker/uPokerExample.pas

@@ -12,18 +12,22 @@ type
                Rank,
                Suit: integer;
              end;
+      Scores = record
+                 Score: integer;
+                 TieBreakerScore: integer;
+      end;
       Hand = record
                Input: string;
-               Score: integer;
+               handResult: Scores;
              end;
-    class function ParseHand(aHand: string): Hand; static;
-    class function ParseCards(aHand: string): TArray<Card>; static;
-    class function ParseCard(aCard: string): Card; static;
-    class function ParseRank(aCard: string): integer; static;
-    class function ParseSuit(aCard: string): integer; static;
-    class function ScoreHand(aCards: TArray<Card>): integer; static;
+    class function ParseHand(aHand: string): Hand;
+    class function ParseCards(aHand: string): TArray<Card>;
+    class function ParseCard(aCard: string): Card;
+    class function ParseRank(aCard: string): integer;
+    class function ParseSuit(aCard: string): integer;
+    class function ScoreHand(aCards: TArray<Card>): Scores;
   public
-    class function BestHands(aHands: TList<String>): TList<string>; static;
+    class function BestHands(aHands: TList<String>): TList<string>;
   end;
 
 implementation
@@ -38,8 +42,8 @@ class function Poker.BestHands(aHands: TList<String>): TList<string>;
   begin
     lResult := 0;
     for aItem in aList do
-      if aItem.Score > lResult then
-        lResult := aItem.score;
+      if aItem.handResult.Score > lResult then
+        lResult := aItem.handResult.Score;
     result := lResult;
   end;
 
@@ -52,33 +56,61 @@ class function Poker.BestHands(aHands: TList<String>): TList<string>;
   end;
 
   function ListOfWinningHands(const aTarget: integer; aList: IList<Hand>): IList<string>;
+
+    function MaxTieBreakerScore: integer;
+    var
+      aItem: Hand;
+      lResult: integer;
+    begin
+      lResult := 0;
+      for aItem in aList do
+        if aItem.handResult.TieBreakerScore > lResult then
+          lResult := aItem.handResult.TieBreakerScore;
+      result := lResult;
+    end;
+
   var aItem: Hand;
+      lmaxTieBreakerScore: integer;
   begin
     result := TCollections.CreateList<string>;
+    lmaxTieBreakerScore := MaxTieBreakerScore;
     for aItem in aList do
-      if aItem.Score = aTarget then
+      if aItem.handResult.TieBreakerScore = lmaxTieBreakerScore then
         result.Add(aItem.Input);
   end;
+
+  function MaxHands(aScoredHands: IList<Hand>; aMaxScore: integer): IList<Hand>;
+  var
+    lHand: Hand;
+  begin
+    result := TCollections.CreateList<Hand>;
+    for lHand in aScoredHands do
+      if lHand.handResult.Score = aMaxScore then
+        result.Add(lHand);
+  end;
 {$endregion}
 
 var scoredHands: IList<Hand>;
     lmaxScore: integer;
+    lmaxHands: IList<Hand>;
 begin
   scoredHands := ScoreHands(aHands);
   lMaxScore := MaxScore(scoredHands);
+  lmaxHands := MaxHands(scoredHands, lMaxScore);
 
   result := TList<string>.Create;
-  result.AddRange(ListOfWinningHands(lMaxScore, scoredHands).ToArray);
+  result.AddRange(ListOfWinningHands(lMaxScore, lmaxHands).ToArray);
 end;
 
 class function Poker.ParseHand(aHand: string): Hand;
 begin
   result.Input := aHand;
-  result.Score := ScoreHand(ParseCards(aHand));
+  result.handResult := ScoreHand(ParseCards(aHand));
 end;
 
 class function Poker.ParseCards(aHand: string): TArray<Card>;
 var lhand: TArray<string>;
+    lhandReplace10: string;
     lCardStr: string;
     lParsedHand: IList<Card>;
 begin
@@ -88,7 +120,8 @@ begin
       result := TComparer<integer>.Default.Compare(left.Rank, right.Rank);
     end);
 
-  lhand := aHand.Split([' ']);
+  lhandReplace10 := aHand.Replace('10', 'T');
+  lhand := lhandReplace10.Split([' ']);
   for lCardStr in lhand do
     lParsedHand.Add(ParseCard(lCardStr));
   lParsedHand.Sort;
@@ -122,7 +155,7 @@ begin
   result := lSuits.IndexOf(lCard[high(lCard)]);
 end;
 
-class function Poker.ScoreHand(aCards: TArray<Card>): integer;
+class function Poker.ScoreHand(aCards: TArray<Card>): Scores;
 
 {$region 'ScoreHand Workers'}
     function CardsByRankOccurance: IList<integer>;
@@ -139,11 +172,14 @@ class function Poker.ScoreHand(aCards: TArray<Card>): integer;
       result.Add(0);
       for rank := High(lRankOccurence) downto Low(lRankOccurence) + 2 do
       begin
-        if lRankOccurence[rank] >= currentOccurenceCount  then
+        if (lRankOccurence[rank] >= currentOccurenceCount) then
         begin
           result.Insert(0,rank);
           currentOccurenceCount := lRankOccurence[rank];
-        end;
+        end
+        else
+          if lRankOccurence[rank] > 0 then
+            result.Insert(1,rank);
       end;
     end;
 
@@ -222,31 +258,50 @@ begin
   flush := Distinct(Suits) = 1;
   straight := (Distinct(Ranks) = 5) and ((Ranks[0] - Ranks[4]) = 4);
 
+  fillchar(result, SizeOf(Scores), #0);
   if straight and flush then
-    result := 800 + Ranks.First
+    result.Score := 800 + Ranks.First
   else
     if listOfRankCounts.EqualsTo([4,1]) then   // 4 of a kind
-      result := 700 + listOfCardsByRank[0]
+    begin
+      result.Score := 700 + listOfCardsByRank[0];
+      result.TieBreakerScore := listOfCardsByRank[1];
+    end
     else
       if listOfRankCounts.EqualsTo([3,2]) then // full house
-        result := 600 + listOfCardsByRank[0]
+      begin
+        result.Score := 600 + listOfCardsByRank[0];
+        result.TieBreakerScore := listofCardsByRank[1];
+      end
       else
         if flush then
-          result := 500 + Ranks.First
+          result.Score := 500 + Ranks.First
         else
           if straight then
-            result := 400 + Ranks.First
+            result.Score := 400 + Ranks.First
           else
             if listOfRankCounts.EqualsTo([3,1,1]) then  //3 of a kind
-              result := 300 + listOfCardsByRank[0]
+            begin
+              result.Score := 300 + listOfCardsByRank[0];
+              result.TieBreakerScore := listOfCardsByRank[2];
+            end
             else
               if listOfRankCounts.EqualsTo([2,2,1]) then  // 2 pair
-                result := 200 + Math.Max(listOfCardsByRank[0], listOfCardsByRank[1])
+              begin
+                result.Score := 200 + listOfCardsByRank[0] + listOfCardsByRank[1];
+                result.TieBreakerScore := Ranks.Min;
+              end
               else
                 if listOfRankCounts.EqualsTo([2,1,1,1]) then // 1 pair
-                  result := 100 + listOfCardsByRank[0]
+                begin
+                  result.Score := 100 + listOfCardsByRank[0];
+                  result.TieBreakerScore := 0;
+                end
                 else
-                  result := Ranks.Max;  // high card
+                begin
+                  result.Score := Ranks.Max;  // high card
+                  result.TieBreakerScore := Ranks.Min;
+                end;
 
 end;