trackler 2.2.1.100 → 2.2.1.101

data/tracks/delphi/exercises/clock/uClockExample.pas

@@ -12,6 +12,7 @@ type
   public
     constructor SetHands(aHours: integer; aMinutes: integer=0);
     function Add(minutesToAdd: integer): Clock;
+    function Subtract(minutesToSubtract: integer): Clock;
     function ToString: string;
     function Equal(aClock: Clock): Boolean;
   End;
@@ -25,6 +26,11 @@ begin
   minutes := fltMod(aMinutes, 60);
 end;
 
+function Clock.Subtract(minutesToSubtract: integer): Clock;
+begin
+  result := Clock.SetHands(hours, minutes - minutesToSubtract);
+end;
+
 function Clock.Add(minutesToAdd: Integer): Clock;
 begin
   result := Clock.SetHands(hours, minutes + minutesToAdd);
@@ -43,7 +49,6 @@ end;
 class function Clock.fltMod(x, y: double): integer;
 var intX, intY: integer;
     tmpFloat: double;
-    xDy: double;
 begin
   intX := trunc(x);
   tmpFloat := x - intX;

data/tracks/delphi/exercises/clock/uClockTest.pas

@@ -4,6 +4,9 @@ interface
 uses
   DUnitX.TestFramework;
 
+const
+  CanonicalVersion = '2.2.1';
+
 type
 
   [TestFixture('Create a new clock with an initial time')]
@@ -77,6 +80,10 @@ type
     [Ignore]
     procedure Negative_minutes_roll_over_continuously;
 
+    [Test]
+    [Ignore]
+    procedure Negative_hour_and_minutes_both_roll_over;
+
     [Test]
     [Ignore]
     procedure Negative_hour_and_minutes_both_roll_over_continuously;
@@ -141,10 +148,6 @@ type
     [Ignore]
     procedure Subtract_more_than_two_hours;
 
-    [Test]
-    [Ignore]
-    procedure Midnight_is_zero_hundred_hours;
-
     [Test]
     [Ignore]
     procedure Subtract_more_than_two_hours_with_borrow;
@@ -167,7 +170,7 @@ type
 
     [Test]
     [Ignore]
-    procedure Clocks_a_minutes_apart;
+    procedure Clocks_a_minute_apart;
 
     [Test]
     [Ignore]
@@ -311,6 +314,11 @@ begin
   Assert.AreEqual('16:40', Clock.SetHands(1, -4820).ToString);
 end;
 
+procedure TClockTest.Negative_hour_and_minutes_both_roll_over;
+begin
+  Assert.AreEqual('20:20', Clock.SetHands(-25, -160).ToString);
+end;
+
 procedure TClockTest.Negative_hour_and_minutes_both_roll_over_continuously;
 begin
   Assert.AreEqual('22:10', Clock.SetHands(-121, -5810).ToString);
@@ -362,47 +370,42 @@ end;
 {$region 'TSubtractMinutes'}
 procedure TSubtractMinutes.Subtract_minutes;
 begin
-  Assert.AreEqual('10:00', Clock.SetHands(10, 3).Add(-3).ToString);
+  Assert.AreEqual('10:00', Clock.SetHands(10, 3).Subtract(3).ToString);
 end;
 
 procedure TSubtractMinutes.Subtract_to_previous_hour;
 begin
-  Assert.AreEqual('09:33', Clock.SetHands(10, 3).Add(-30).ToString);
+  Assert.AreEqual('09:33', Clock.SetHands(10, 3).Subtract(30).ToString);
 end;
 
 procedure TSubtractMinutes.Subtract_more_than_one_hour;
 begin
-  Assert.AreEqual('08:53', Clock.SetHands(10, 3).Add(-70).ToString);
+  Assert.AreEqual('08:53', Clock.SetHands(10, 3).Subtract(70).ToString);
 end;
 
 procedure TSubtractMinutes.Subtract_across_midnight;
 begin
-  Assert.AreEqual('23:59', Clock.SetHands(0, 3).Add(-4).ToString);
+  Assert.AreEqual('23:59', Clock.SetHands(0, 3).Subtract(4).ToString);
 end;
 
 procedure TSubtractMinutes.Subtract_more_than_two_hours;
 begin
-  Assert.AreEqual('21:20', Clock.SetHands(0, 0).Add(-160).ToString);
-end;
-
-procedure TSubtractMinutes.Midnight_is_zero_hundred_hours;
-begin
-  Assert.AreEqual('00:00', Clock.SetHands(24).ToString);
+  Assert.AreEqual('21:20', Clock.SetHands(0, 0).Subtract(160).ToString);
 end;
 
 procedure TSubtractMinutes.Subtract_more_than_two_hours_with_borrow;
 begin
-  Assert.AreEqual('03:35', Clock.SetHands(6, 15).Add(-160).ToString);
+  Assert.AreEqual('03:35', Clock.SetHands(6, 15).Subtract(160).ToString);
 end;
 
 procedure TSubtractMinutes.Subtract_more_than_one_day;
 begin
-  Assert.AreEqual('04:32', Clock.SetHands(5, 32).Add(-1500).ToString);
+  Assert.AreEqual('04:32', Clock.SetHands(5, 32).Subtract(1500).ToString);
 end;
 
 procedure TSubtractMinutes.Subtract_more_than_two_days;
 begin
-  Assert.AreEqual('00:20', Clock.SetHands(2, 20).Add(-3000).ToString);
+  Assert.AreEqual('00:20', Clock.SetHands(2, 20).Subtract(3000).ToString);
 end;
 {$endregion}
 
@@ -416,7 +419,7 @@ begin
   Assert.IsTrue(Clock1.Equal(Clock2));
 end;
 
-procedure TCompareClocks.Clocks_a_minutes_apart;
+procedure TCompareClocks.Clocks_a_minute_apart;
 var Clock1, Clock2: Clock;
 begin
   Clock1 := Clock.SetHands(15, 36);

data/tracks/delphi/exercises/isbn-verifier/README.md

@@ -1,4 +1,4 @@
-# Isbn Verifier
+# ISBN Verifier
 
 The [ISBN-10 verification process](https://en.wikipedia.org/wiki/International_Standard_Book_Number) is used to validate book identification
 numbers. These normally contain dashes and look like: `3-598-21508-8`

data/tracks/delphi/exercises/reverse-string/README.md

@@ -1,4 +1,4 @@
-# reverse-string
+# Reverse String
 
 Reverse a string
 

data/tracks/delphi/exercises/rna-transcription/README.md

@@ -40,7 +40,7 @@ For example, if you're submitting `ubob.pas` for the Bob exercise, the submit co
 
 ## Source
 
-Rosalind [http://rosalind.info/problems/rna](http://rosalind.info/problems/rna)
+Hyperphysics [http://hyperphysics.phy-astr.gsu.edu/hbase/Organic/transcription.html](http://hyperphysics.phy-astr.gsu.edu/hbase/Organic/transcription.html)
 
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/delphi/exercises/roman-numerals/uRomanNumeralsTest.pas

@@ -4,6 +4,9 @@ interface
 uses
   DUnitX.TestFramework;
 
+const
+  CanonicalVersion = '1.2.0';
+
 type
 
   [TestFixture]
@@ -45,6 +48,10 @@ type
     [Ignore]
     procedure Fourty_eight_is_not_50_minus_2_but_rather_40_plus_8;
 
+    [Test]
+    [Ignore]
+    procedure Fourty_nine_is_not_40_plus_5_plus_4_but_rather_50_minus_10_plus_10_minus_1;
+
     [Test]
     [Ignore]
     procedure Fifty_is_a_single_L;
@@ -148,6 +155,13 @@ begin
   Assert.AreEqual('XLVIII', arabicNumeral.ToRoman);
 end;
 
+procedure RomanNumeralsTest.Fourty_nine_is_not_40_plus_5_plus_4_but_rather_50_minus_10_plus_10_minus_1;
+var arabicNumeral: integer;
+begin
+  arabicNumeral := 49;
+  Assert.AreEqual('XLIX',arabicNumeral.ToRoman);
+end;
+
 procedure RomanNumeralsTest.Fifty_is_a_single_L;
 var arabicNumeral: integer;
 begin

data/tracks/delphi/exercises/space-age/README.md

@@ -0,0 +1,45 @@
+# Space Age
+
+Given an age in seconds, calculate how old someone would be on:
+
+   - Earth: orbital period 365.25 Earth days, or 31557600 seconds
+   - Mercury: orbital period 0.2408467 Earth years
+   - Venus: orbital period 0.61519726 Earth years
+   - Mars: orbital period 1.8808158 Earth years
+   - Jupiter: orbital period 11.862615 Earth years
+   - Saturn: orbital period 29.447498 Earth years
+   - Uranus: orbital period 84.016846 Earth years
+   - Neptune: orbital period 164.79132 Earth years
+
+So if you were told someone were 1,000,000,000 seconds old, you should
+be able to say that they're 31.69 Earth-years old.
+
+If you're wondering why Pluto didn't make the cut, go watch [this
+youtube video](http://www.youtube.com/watch?v=Z_2gbGXzFbs).
+
+## Testing
+
+In order to run the tests for this track, you will need to install
+DUnitX. Please see the [installation](http://www.exercism.io/languages/delphi/installation) instructions for more information.
+
+### Loading Exercises into Delphi
+
+If Delphi is properly installed, and `*.dpr` file types have been associated with Delphi, then double clicking the supplied `*.dpr` file will start Delphi and load the exercise/project.  `control + F9` is the keyboard shortcut to compile the project or pressing `F9` will compile and run the project.
+
+Alternatively you may opt to start Delphi and load your project via. the `File` drop down menu.
+
+### When Questions Come Up
+We monitor the [Pascal-Delphi](https://gitter.im/exercism/Pascal-Delphi) support room on [gitter.im](https://gitter.im) to help you with any questions that might arise.
+
+### Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the exercise file you're submitting is in the `exercism/delphi/<exerciseName>` directory.
+
+For example, if you're submitting `ubob.pas` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/delphi/bob/ubob.pas`.
+
+## Source
+
+Partially inspired by Chapter 1 in Chris Pine's online Learn to Program tutorial. [http://pine.fm/LearnToProgram/?Chapter=01](http://pine.fm/LearnToProgram/?Chapter=01)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/delphi/exercises/space-age/SpaceAge.dpr

@@ -0,0 +1,60 @@
+program SpaceAge;
+
+{$IFNDEF TESTINSIGHT}
+{$APPTYPE CONSOLE}
+{$ENDIF}{$STRONGLINKTYPES ON}
+uses
+  System.SysUtils,
+  {$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX,
+  {$ENDIF }
+  DUnitX.Loggers.Console,
+  DUnitX.Loggers.Xml.NUnit,
+  DUnitX.TestFramework,
+  uSpaceAgeTests in 'uSpaceAgeTests.pas',
+  uSpaceAge in 'uSpaceAge.pas';
+
+var
+  runner : ITestRunner;
+  results : IRunResults;
+  logger : ITestLogger;
+  nunitLogger : ITestLogger;
+begin
+{$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX.RunRegisteredTests;
+  exit;
+{$ENDIF}
+  try
+    //Check command line options, will exit if invalid
+    TDUnitX.CheckCommandLine;
+    //Create the test runner
+    runner := TDUnitX.CreateRunner;
+    //Tell the runner to use RTTI to find Fixtures
+    runner.UseRTTI := True;
+    //tell the runner how we will log things
+    //Log to the console window
+    logger := TDUnitXConsoleLogger.Create(true);
+    runner.AddLogger(logger);
+    //Generate an NUnit compatible XML File
+    nunitLogger := TDUnitXXMLNUnitFileLogger.Create(TDUnitX.Options.XMLOutputFile);
+    runner.AddLogger(nunitLogger);
+    runner.FailsOnNoAsserts := True; //When true, Assertions must be made during tests;
+
+    //Run tests
+    results := runner.Execute;
+    if not results.AllPassed then
+      System.ExitCode := EXIT_ERRORS;
+
+    {$IFNDEF CI}
+    //We don't want this happening when running under CI.
+    if TDUnitX.Options.ExitBehavior = TDUnitXExitBehavior.Pause then
+    begin
+      System.Write('Done.. press <Enter> key to quit.');
+      System.Readln;
+    end;
+    {$ENDIF}
+  except
+    on E: Exception do
+      System.Writeln(E.ClassName, ': ', E.Message);
+  end;
+end.

data/tracks/delphi/exercises/space-age/uSpaceAgeExample.pas

@@ -0,0 +1,120 @@
+unit uSpaceAge;
+
+interface
+
+type
+  ISpaceAge = interface(IInvokable)
+  ['{D2226242-6BFC-4C80-A9EB-D5A67FA406FE}']
+    function OnEarth: double;
+    function OnMercury: double;
+    function OnVenus: double;
+    function OnMars: double;
+    function OnJupiter: double;
+    function OnSaturn: double;
+    function OnUranus: double;
+    function OnNeptune: double;
+  end;
+
+  function NewSpaceAge(Seconds: Int64): ISpaceAge;
+
+implementation
+uses System.Generics.Collections, System.Math;
+
+{ TSpaceAge }
+type
+  TSpaceAge = class(TInterfacedObject, ISpaceAge)
+  private
+    const
+      cEarth_Orbit_In_Seconds = 31557600;
+    type
+      TPlanets = (Earth, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune);
+    var
+      earthYearToPlanetPeriod: TDictionary<TPlanets, double>;
+      fSeconds: Int64;
+    function CalculateAge(periodInEarthYears: double): double;
+    constructor Create(Seconds: Int64);
+    destructor Destroy; override;
+    function OnEarth: double;
+    function OnMercury: double;
+    function OnVenus: double;
+    function OnMars: double;
+    function OnJupiter: double;
+    function OnSaturn: double;
+    function OnUranus: double;
+    function OnNeptune: double;
+  end;
+
+function NewSpaceAge(Seconds: Int64): ISpaceAge;
+begin
+  result := TSpaceAge.Create(Seconds);
+end;
+
+function TSpaceAge.CalculateAge(periodInEarthYears: double): double;
+begin
+  result := SimpleRoundTo(fSeconds / (cEarth_Orbit_In_Seconds * periodInEarthYears), -2);
+end;
+
+constructor TSpaceAge.Create(Seconds: Int64);
+begin
+  fSeconds := Seconds;
+  earthYearToPlanetPeriod := TDictionary<TPlanets, double>.Create;
+  with earthYearToPlanetPeriod do
+  begin
+    add(Earth, 1);
+    add(Mercury, 0.2408467);
+    add(Venus, 0.61519726);
+    add(Mars, 1.8808158);
+    add(Jupiter, 11.862615);
+    add(Saturn, 29.447498);
+    add(Uranus, 84.016846);
+    add(Neptune, 164.79132);
+  end;
+end;
+
+destructor TSpaceAge.Destroy;
+begin
+  earthYearToPlanetPeriod.DisposeOf;
+  inherited;
+end;
+
+function TSpaceAge.OnEarth: double;
+begin
+  result := CalculateAge(earthYearToPlanetPeriod[Earth]);
+end;
+
+function TSpaceAge.OnJupiter: double;
+begin
+  result := CalculateAge(earthYearToPlanetPeriod[Jupiter]);
+end;
+
+function TSpaceAge.OnMars: double;
+begin
+  result := CalculateAge(earthYearToPlanetPeriod[Mars]);
+end;
+
+function TSpaceAge.OnMercury: double;
+begin
+  result := CalculateAge(earthYearToPlanetPeriod[Mercury]);
+end;
+
+function TSpaceAge.OnNeptune: double;
+begin
+  result := CalculateAge(earthYearToPlanetPeriod[Neptune]);
+end;
+
+function TSpaceAge.OnSaturn: double;
+begin
+  result := CalculateAge(earthYearToPlanetPeriod[Saturn]);
+end;
+
+function TSpaceAge.OnUranus: double;
+begin
+  result := CalculateAge(earthYearToPlanetPeriod[Uranus]);
+end;
+
+function TSpaceAge.OnVenus: double;
+begin
+  result := CalculateAge(earthYearToPlanetPeriod[Venus]);
+end;
+
+end.

data/tracks/delphi/exercises/space-age/uSpaceAgeTests.pas

@@ -0,0 +1,135 @@
+unit uSpaceAgeTests;
+
+interface
+uses
+  DUnitX.TestFramework;
+
+const
+  CanonicalVersion = '1.1.0';
+
+type
+
+  [TestFixture]
+  SpaceAgeTests = class(TObject)
+  public
+    [Test]
+//    [Ignore('Comment the "[Ignore]" statement to run the test')]
+    procedure Age_on_earth;
+
+    [Test]
+    [Ignore]
+    procedure Age_on_mercury;
+
+    [Test]
+    [Ignore]
+    procedure Age_on_venus;
+
+    [Test]
+    [Ignore]
+    procedure Age_on_mars;
+
+    [Test]
+    [Ignore]
+    procedure Age_on_jupiter;
+
+    [Test]
+    [Ignore]
+    procedure Age_on_saturn;
+
+    [Test]
+    [Ignore]
+    procedure Age_on_uranus;
+
+    [Test]
+    [Ignore]
+    procedure Age_on_neptune;
+  end;
+
+implementation
+uses uSpaceAge;
+
+{ SpaceAgeTests }
+
+procedure SpaceAgeTests.Age_on_earth;
+var
+  MyAge: ISpaceAge;
+  expectedAge: double;
+begin
+  MyAge := NewSpaceAge(1000000000);
+  expectedAge := 31.69;
+  Assert.AreEqual(expectedAge, MyAge.OnEarth);
+end;
+
+procedure SpaceAgeTests.Age_on_jupiter;
+var
+  MyAge: ISpaceAge;
+  expectedAge: double;
+begin
+  MyAge := NewSpaceAge(901876382);
+  expectedAge := 2.41;
+  Assert.AreEqual(expectedAge, MyAge.OnJupiter);
+end;
+
+procedure SpaceAgeTests.Age_on_mars;
+var
+  MyAge: ISpaceAge;
+  expectedAge: double;
+begin
+  MyAge := NewSpaceAge(2329871239);
+  expectedAge := 39.25;
+  Assert.AreEqual(expectedAge, MyAge.OnMars);
+end;
+
+procedure SpaceAgeTests.Age_on_mercury;
+var
+  MyAge: ISpaceAge;
+  expectedAge: double;
+begin
+  MyAge := NewSpaceAge(2134835688);
+  expectedAge := 280.88;
+  Assert.AreEqual(expectedAge, MyAge.OnMercury);
+end;
+
+procedure SpaceAgeTests.Age_on_neptune;
+var
+  MyAge: ISpaceAge;
+  expectedAge: double;
+begin
+  MyAge := NewSpaceAge(8210123456);
+  expectedAge := 1.58;
+  Assert.AreEqual(expectedAge, MyAge.OnNeptune);
+end;
+
+procedure SpaceAgeTests.Age_on_saturn;
+var
+  MyAge: ISpaceAge;
+  expectedAge: double;
+begin
+  MyAge := NewSpaceAge(3000000000);
+  expectedAge := 3.23;
+  Assert.AreEqual(expectedAge, MyAge.OnSaturn);
+end;
+
+procedure SpaceAgeTests.Age_on_uranus;
+var
+  MyAge: ISpaceAge;
+  expectedAge: double;
+begin
+  MyAge := NewSpaceAge(3210123456);
+  expectedAge := 1.21;
+  Assert.AreEqual(expectedAge, MyAge.OnUranus);
+end;
+
+procedure SpaceAgeTests.Age_on_venus;
+var
+  MyAge: ISpaceAge;
+  expectedAge: double;
+begin
+  MyAge := NewSpaceAge(189839836);
+  expectedAge := 9.78;
+  Assert.AreEqual(expectedAge, MyAge.OnVenus);
+end;
+
+initialization
+  TDUnitX.RegisterTestFixture(SpaceAgeTests);
+end.