ðŸŽ‰ Exercism Research is now launched. Help Exercism, help science and have some fun at research.exercism.io ðŸŽ‰

# iepsenn's solution

## to Space Age in the Delphi Pascal Track

Published at Apr 15 2021 · 0 comments
Instructions
Test suite
Solution

Given an age in seconds, calculate how old someone would be on:

• Mercury: orbital period 0.2408467 Earth years
• Venus: orbital period 0.61519726 Earth years
• Earth: orbital period 1.0 Earth years, 365.25 Earth days, or 31557600 seconds
• 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.

## Testing

In order to run the tests for this track, you will need to install DUnitX. Please see the installation instructions for more information.

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 support room on 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

## Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you may request help from a mentor.

### uSpaceAgeTests.pas

``````unit uSpaceAgeTests;

interface
uses
DUnitX.TestFramework;

const
CanonicalVersion = '1.2.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(2129871239);
expectedAge := 35.88;
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(1821023456);
expectedAge := 0.35;
Assert.AreEqual(expectedAge, MyAge.OnNeptune);
end;

procedure SpaceAgeTests.Age_on_saturn;
var
MyAge: ISpaceAge;
expectedAge: double;
begin
MyAge := NewSpaceAge(2000000000);
expectedAge := 2.15;
Assert.AreEqual(expectedAge, MyAge.OnSaturn);
end;

procedure SpaceAgeTests.Age_on_uranus;
var
MyAge: ISpaceAge;
expectedAge: double;
begin
MyAge := NewSpaceAge(1210123456);
expectedAge := 0.46;
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.``````
``````unit uSpaceAge;

interface

type
ISpaceAge = interface(IInvokable)

function OnMercury: Double;
function OnVenus: Double;
function OnEarth: Double;
function OnMars: Double;
function OnJupiter: Double;
function OnSaturn: Double;
function OnUranus: Double;
function OnNeptune: Double;
end;

function NewSpaceAge(age: Double): ISpaceAge;

function RoundNumber(number: Double; places: Integer = 2): Double;

implementation

uses
System.Math;

type
TSpaceAge = class(TInterfacedObject, ISpaceAge)

private
const
EARTH_DAYS_IN_A_YEAR = 365.25;
EARTH_HOURS_IN_A_DAY = 24;
EARTH_MINUTES_IN_A_HOUR = 60;
EARTH_SECONDS_IN_A_MINUTE = 60;

ONE_EARTH_YEAR_IN_MERCURY = 0.2408467;
ONE_EARTH_YEAR_IN_VENUS = 0.61519726;
ONE_EARTH_YEAR_IN_MARS = 1.8808158;
ONE_EARTH_YEAR_IN_JUPITER = 11.862615;
ONE_EARTH_YEAR_IN_SATURN = 29.447498;
ONE_EARTH_YEAR_IN_URANUS = 84.016846;
ONE_EARTH_YEAR_IN_NEPTUNE = 164.79132;

var
age: Double;

constructor Create(age: Double);

public
function OnMercury: Double;
function OnVenus: Double;
function OnEarth: Double;
function OnMars: Double;
function OnJupiter: Double;
function OnSaturn: Double;
function OnUranus: Double;
function OnNeptune: Double;
end;

constructor TSpaceAge.Create(age: Double);
begin
self.age := age;
end;

function TSpaceAge.OnEarth: Double;
begin
result := RoundNumber(self.age /
EARTH_SECONDS_IN_A_MINUTE /
EARTH_MINUTES_IN_A_HOUR /
EARTH_HOURS_IN_A_DAY /
EARTH_DAYS_IN_A_YEAR);
end;

function TSpaceAge.OnMercury: Double;
begin
result := RoundNumber(self.OnEarth * ONE_EARTH_YEAR_IN_MERCURY);
end;

function TSpaceAge.OnVenus: Double;
begin
result := RoundNumber(self.OnEarth * ONE_EARTH_YEAR_IN_VENUS);
end;

function TSpaceAge.OnMars: Double;
begin
result := RoundNumber(self.OnEarth * ONE_EARTH_YEAR_IN_MARS);
end;

function TSpaceAge.OnJupiter: Double;
begin
result := RoundNumber(self.OnEarth * ONE_EARTH_YEAR_IN_JUPITER);
end;

function TSpaceAge.OnSaturn: Double;
begin
result := RoundNumber(self.OnEarth * ONE_EARTH_YEAR_IN_SATURN);
end;

function TSpaceAge.OnUranus: Double;
begin
result := RoundNumber(self.OnEarth * ONE_EARTH_YEAR_IN_URANUS);
end;

function TSpaceAge.OnNeptune: Double;
begin
result := RoundNumber(self.OnEarth * ONE_EARTH_YEAR_IN_NEPTUNE);
end;

function NewSpaceAge(age: Double): ISpaceAge;
begin
result := TSpaceAge.Create(age);
end;

function RoundNumber(number: Double; places: Integer = 2): Double;
begin
result := SimpleRoundTo(number, -places);
end;

end.``````