Implement new exercise rational-numbers (#1274)

* Initial

* Extract certain logic to methods

* Implement and add tests

* Use 'One' and 'Zero' in test method names instead of '1' and '0'

* Change spacing

* Add remaining tests

* Fix indentation

* Use better method for calculating rth root of x

* Move reference implementation to .meta

* Include exercise in settings.gradle

* Add README

* Add reference to config.js

* Add UUID and unlocked-by

* Make methods package-private; Ignore all but first test

* Add 'algorithms' to topics because of gcd

* Give @Ignores the proper message and put in the proper order

* Generate README using configlet

* Add version file

* Remove 'classes' from topics

* Make class package private

* Make class package private

* Use equals method and assertEquals (and toString) for comparing Rationals

* Stub out Rational with equals and toString

* Stub out methods

* Remove comment

config.json

@@ -1119,6 +1119,18 @@
     {
       "core": false,
       "difficulty": 8,
+      "slug": "rational-numbers",
+      "topics": [
+        "floating_point_numbers",
+        "mathematics",
+        "algorithms"
+      ],
+      "unlocked_by": "triangle",
+      "uuid": "50ed54ce-3047-4590-9fda-0a7e9aeeba30"
+    },
+    {
+      "core": false,
+      "difficulty": 8,
       "slug": "list-ops",
       "topics": [
         "filtering",

exercises/rational-numbers/.meta/src/reference/java/Rational.java

@@ -0,0 +1,118 @@
+class Rational {
+    private int numerator;
+    private int denominator;
+
+    Rational(final int numerator, final int denominator) {
+        if (denominator == 0) {
+            throw new IllegalArgumentException("Denominator must not be zero.");
+        }
+
+        this.numerator = numerator;
+        this.denominator = denominator;
+
+        this.reduce();
+        this.ensureSignInNumerator();
+    }
+
+    private void reduce() {
+        final int commonDivisor = gcd(this.numerator, this.denominator);
+
+        this.numerator /= commonDivisor;
+        this.denominator /= commonDivisor;
+    }
+
+    private int gcd(int a, int b) {
+        while (b != 0) {
+            final int t = b;
+            b = a % b;
+            a = t;
+        }
+        return a;
+    }
+
+    private void ensureSignInNumerator() {
+        if (this.denominator < 0) {
+            this.denominator = -this.denominator;
+            this.numerator = -this.numerator;
+        }
+    }
+
+    int getNumerator() {
+        return this.numerator;
+    }
+
+    int getDenominator() {
+        return this.denominator;
+    }
+
+    Rational abs() {
+        return new Rational(abs(this.numerator), abs(this.denominator));
+    }
+
+    private int abs(int x) {
+        final int mask = x >> 31;
+        return (mask ^ x) - mask;
+    }
+
+    Rational add(Rational that) {
+        final int commonDenominator = this.denominator * that.denominator;
+
+        return new Rational(
+                this.numerator * that.denominator + that.numerator * this.denominator,
+                commonDenominator);
+    }
+
+    Rational subtract(Rational that) {
+        final int commonDenominator = this.denominator * that.denominator;
+
+        return new Rational(
+                this.numerator * that.denominator - that.numerator * this.denominator,
+                commonDenominator);
+    }
+
+    Rational multiply(Rational that) {
+        return new Rational(this.numerator * that.numerator, this.denominator * that.denominator);
+    }
+
+    Rational divide(Rational that) {
+        return new Rational(this.numerator * that.denominator, this.denominator * that.numerator);
+    }
+
+    Rational pow(int n) {
+        return new Rational(pow(this.numerator, n), pow(this.denominator, n));
+    }
+
+    double pow(double x) {
+        return Math.pow(this.numerator, x) / Math.pow(this.denominator, x);
+    }
+
+    private int pow(final int base, final int exponent) {
+        int product = 1;
+
+        for (int i = 0; i < exponent; i++) {
+            product *= base;
+        }
+
+        return product;
+    }
+
+    double exp(double base) {
+        return Math.pow(10.0, Math.log10(Math.pow(base, this.numerator)) / this.denominator);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%d/%d", this.getNumerator(), this.getDenominator());
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null || !this.getClass().isAssignableFrom(obj.getClass())) {
+            return false;
+        }
+
+        Rational other = (Rational) obj;
+        return this.getNumerator() == other.getNumerator()
+            && this.getDenominator() == other.getDenominator();
+    }
+}

exercises/rational-numbers/.meta/version

@@ -0,0 +1 @@
+1.0.0

exercises/rational-numbers/README.md

@@ -0,0 +1,47 @@
+# Rational Numbers
+
+A rational number is defined as the quotient of two integers `a` and `b`, called the numerator and denominator, respectively, where `b != 0`.
+
+The absolute value `|r|` of the rational number `r = a/b` is equal to `|a|/|b|`.
+
+The sum of two rational numbers `r1 = a1/b1` and `r2 = a2/b2` is `r1 + r2 = a1/b1 + a2/b2 = (a1 * b2 + a2 * b1) / (b1 * b2)`.
+
+The difference of two rational numbers `r1 = a1/b1` and `r2 = a2/b2` is `r1 - r2 = a1/b1 - a2/b2 = (a1 * b2 - a2 * b1) / (b1 * b2)`.
+
+The product (multiplication) of two rational numbers `r1 = a1/b1` and `r2 = a2/b2` is `r1 * r2 = (a1 * a2) / (b1 * b2)`.
+
+Dividing a rational number `r1 = a1/b1` by another `r2 = a2/b2` is `r1 / r2 = (a1 * b2) / (a2 * b1)` if `a2 * b1` is not zero.
+
+Exponentiation of a rational number `r = a/b` to a non-negative integer power `n` is `r^n = (a^n)/(b^n)`.
+
+Exponentiation of a rational number `r = a/b` to a negative integer power `n` is `r^n = (b^m)/(a^m)`, where `m = |n|`.
+
+Exponentiation of a rational number `r = a/b` to a real (floating-point) number `x` is the quotient `(a^x)/(b^x)`, which is a real number.
+
+Exponentiation of a real number `x` to a rational number `r = a/b` is `x^(a/b) = root(x^a, b)`, where `root(p, q)` is the `q`th root of `p`.
+
+Implement the following operations:
+ - addition, subtraction, multiplication and division of two rational numbers,
+ - absolute value, exponentiation of a given rational number to an integer power, exponentiation of a given rational number to a real (floating-point) power, exponentiation of a real number to a rational number.
+
+Your implementation of rational numbers should always be reduced to lowest terms. For example, `4/4` should reduce to `1/1`, `30/60` should reduce to `1/2`, `12/8` should reduce to `3/2`, etc. To reduce a rational number `r = a/b`, divide `a` and `b` by the greatest common divisor (gcd) of `a` and `b`. So, for example, `gcd(12, 8) = 4`, so `r = 12/8` can be reduced to `(12/4)/(8/4) = 3/2`.
+
+Assume that the programming language you are using does not have an implementation of rational numbers.
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Rational_number](https://en.wikipedia.org/wiki/Rational_number)
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/rational-numbers/build.gradle

@@ -0,0 +1,17 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile "junit:junit:4.12"
+}
+test {
+    testLogging {
+        exceptionFormat = 'full'
+        events = ["passed", "failed", "skipped"]
+    }
+}

exercises/rational-numbers/src/main/java/Rational.java

@@ -0,0 +1,30 @@
+class Rational {
+
+    Rational(int numerator, int denominator) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    int getNumerator() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    int getDenominator() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%d/%d", this.getNumerator(), this.getDenominator());
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null || !this.getClass().isAssignableFrom(obj.getClass())) {
+            return false;
+        }
+
+        Rational other = (Rational) obj;
+        return this.getNumerator() == other.getNumerator()
+            && this.getDenominator() == other.getDenominator();
+    }
+}

exercises/rational-numbers/src/test/java/RationalTest.java

@@ -0,0 +1,288 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class RationalTest {
+
+    // Helper methods
+
+    private static final double DOUBLE_EQUALITY_TOLERANCE = 1e-15;
+
+    private void assertDoublesEqual(double x, double y) {
+        assertEquals(x, y, DOUBLE_EQUALITY_TOLERANCE);
+    }
+
+    // Tests
+
+    @Test
+    public void testAddTwoPositiveRationalNumbers() {
+        Rational expected = new Rational(7, 6);
+        Rational actual = new Rational(1, 2).add(new Rational(2, 3));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAddAPositiveRationalNumberAndANegativeRationalNumber() {
+        Rational expected = new Rational(-1, 6);
+        Rational actual = new Rational(1, 2).add(new Rational(-2, 3));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAddTwoNegativeRationalNumbers() {
+        Rational expected = new Rational(-7, 6);
+        Rational actual = new Rational(-1, 2).add(new Rational(-2, 3));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAddARationalNumberToItsAdditiveInverse() {
+        Rational expected = new Rational(0, 1);
+        Rational actual = new Rational(1, 2).add(new Rational(-1, 2));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSubtractTwoPositiveRationalNumbers() {
+        Rational expected = new Rational(-1, 6);
+        Rational actual = new Rational(1, 2).subtract(new Rational(2, 3));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSubtractAPositiveRationalNumberAndANegativeRationalNumber() {
+        Rational expected = new Rational(7, 6);
+        Rational actual = new Rational(1, 2).subtract(new Rational(-2, 3));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSubtractTwoNegativeRationalNumbers() {
+        Rational expected = new Rational(1, 6);
+        Rational actual = new Rational(-1, 2).subtract(new Rational(-2, 3));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSubtractARationalNumberFromItself() {
+        Rational expected = new Rational(0, 1);
+        Rational actual = new Rational(1, 2).subtract(new Rational(1, 2));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testMultiplyTwoPositiveRationalNumbers() {
+        Rational expected = new Rational(1, 3);
+        Rational actual = new Rational(1, 2).multiply(new Rational(2, 3));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testMultiplyANegativeRationalNumberByAPositiveRationalNumber() {
+        Rational expected = new Rational(-1, 3);
+        Rational actual = new Rational(-1, 2).multiply(new Rational(2, 3));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testMultiplyTwoNegativeRationalNumbers() {
+        Rational expected = new Rational(1, 3);
+        Rational actual = new Rational(-1, 2).multiply(new Rational(-2, 3));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testMultiplyARationalNumberByItsReciprocal() {
+        Rational expected = new Rational(1, 1);
+        Rational actual = new Rational(1, 2).multiply(new Rational(2, 1));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testMultiplyARationalNumberByOne() {
+        Rational expected = new Rational(1, 2);
+        Rational actual = new Rational(1, 2).multiply(new Rational(1, 1));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testMultiplyARationalNumberByZero() {
+        Rational expected = new Rational(0, 1);
+        Rational actual = new Rational(1, 2).multiply(new Rational(0, 1));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDivideTwoPositiveRationalNumbers() {
+        Rational expected = new Rational(3, 4);
+        Rational actual = new Rational(1, 2).divide(new Rational(2, 3));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDivideAPositiveRationalNumberByANegativeRationalNumber() {
+        Rational expected = new Rational(-3, 4);
+        Rational actual = new Rational(1, 2).divide(new Rational(-2, 3));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDivideTwoNegativeRationalNumbers() {
+        Rational expected = new Rational(3, 4);
+        Rational actual = new Rational(-1, 2).divide(new Rational(-2, 3));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDivideARationalNumberByOne() {
+        Rational expected = new Rational(1, 2);
+        Rational actual = new Rational(1, 2).divide(new Rational(1, 1));
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAbsoluteValueOfAPositiveRationalNumber() {
+        Rational expected = new Rational(1, 2);
+        Rational actual = new Rational(1, 2).abs();
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAbsoluteValueOfANegativeRationalNumber() {
+        Rational expected = new Rational(1, 2);
+        Rational actual = new Rational(-1, 2).abs();
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAbsoluteValueOfZero() {
+        Rational expected = new Rational(0, 1);
+        Rational actual = new Rational(0, 1).abs();
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testRaiseAPositiveRationalNumberToAPositiveIntegerPower() {
+        Rational expected = new Rational(1, 8);
+        Rational actual = new Rational(1, 2).pow(3);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testRaiseANegativeRationalNumberToAPositiveIntegerPower() {
+        Rational expected = new Rational(-1, 8);
+        Rational actual = new Rational(-1, 2).pow(3);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testRaiseZeroToAnIntegerPower() {
+        Rational expected = new Rational(0, 1);
+        Rational actual = new Rational(0, 1).pow(5);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testRaiseOneToAnIntegerPower() {
+        Rational expected = new Rational(1, 1);
+        Rational actual = new Rational(1, 1).pow(4);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testRaiseAPositiveRationalNumberToThePowerOfZero() {
+        Rational expected = new Rational(1, 1);
+        Rational actual = new Rational(-1, 2).pow(0);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testRaiseARealNumberToAPositiveRationalNumber() {
+        double expected = 16.0;
+        double actual = new Rational(4, 3).exp(8.0);
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testRaiseARealNumberToANegativeRationalNumber() {
+        double expected = 1.0 / 3;
+        double actual = new Rational(-1, 2).exp(9);
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testReduceAPositiveRationalNumberToLowestTerms() {
+        Rational expected = new Rational(1, 2);
+        Rational actual = new Rational(2, 4);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testReduceANegativeRationalNumberToLowestTerms() {
+        Rational expected = new Rational(-2, 3);
+        Rational actual = new Rational(-4, 6);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testReduceARationalNumberWithANegativeDenominatorToLowestTerms() {
+        Rational expected = new Rational(-1, 3);
+        Rational actual = new Rational(3, -9);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testReduceZeroToLowestTerms() {
+        Rational expected = new Rational(0, 1);
+        Rational actual = new Rational(0, 6);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testReduceAnIntegerToLowestTerms() {
+        Rational expected = new Rational(-2, 1);
+        Rational actual = new Rational(-14, 7);
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testReduceOneToLowestTerms() {
+        Rational expected = new Rational(1, 1);
+        Rational actual = new Rational(13, 13);
+        assertEquals(expected, actual);
+    }
+}

exercises/settings.gradle

@@ -64,6 +64,7 @@ include 'pythagorean-triplet'
 include 'queen-attack'
 include 'rail-fence-cipher'
 include 'raindrops'
+include 'rational-numbers'
 include 'rectangles'
 include 'reverse-string'
 include 'rna-transcription'