trackler 2.0.3.0 → 2.0.3.1

data/tracks/java/exercises/binary-search-tree/src/test/java/BSTTest.java

@@ -0,0 +1,163 @@
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class BSTTest {
+
+    @Test
+    public void dataIsRetained() {
+        BST<Integer> sut = new BST();
+        final int actual = 4;
+        sut.insert(actual);
+        final BST.Node<Integer> root = sut.getRoot();
+        assertNotNull(root);
+        final int expected = root.getData();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void insertsLess() {
+        BST<Integer> sut = new BST();
+        final int expectedRoot = 4;
+        final int expectedLeft = 2;
+
+        sut.insert(expectedRoot);
+        sut.insert(expectedLeft);
+
+        final BST.Node<Integer> root = sut.getRoot();
+        assertNotNull(root);
+        final BST.Node<Integer> left = root.getLeft();
+        assertNotNull(left);
+
+        final int actualRoot = root.getData();
+        final int actualLeft = left.getData();
+        assertEquals(expectedLeft, actualLeft);
+        assertEquals(expectedRoot, actualRoot);
+    }
+
+    @Test
+    @Ignore
+    public void insertsSame() {
+        BST<Integer> sut = new BST();
+        final int expectedRoot = 4;
+        final int expectedLeft = 4;
+
+        sut.insert(expectedRoot);
+        sut.insert(expectedLeft);
+
+        final BST.Node<Integer> root = sut.getRoot();
+        assertNotNull(root);
+        final BST.Node<Integer> left = root.getLeft();
+        assertNotNull(left);
+
+        final int actualRoot = root.getData();
+        final int actualLeft = left.getData();
+        assertEquals(expectedLeft, actualLeft);
+        assertEquals(expectedRoot, actualRoot);
+    }
+
+    @Test
+    @Ignore
+    public void insertsRight() {
+        BST<Integer> sut = new BST();
+        final int expectedRoot = 4;
+        final int expectedRight = 5;
+
+        sut.insert(expectedRoot);
+        sut.insert(expectedRight);
+
+        final BST.Node<Integer> root = sut.getRoot();
+        assertNotNull(root);
+        final BST.Node<Integer> right = root.getRight();
+        assertNotNull(right);
+
+        final int actualRoot = root.getData();
+        final int actualRight = right.getData();
+        assertEquals(expectedRight, actualRight);
+        assertEquals(expectedRoot, actualRoot);
+    }
+
+    @Test
+    @Ignore
+    public void createsComplexTree() {
+        BST<Integer> sut = new BST<>();
+        List<Integer> expected = Collections.unmodifiableList(
+                Arrays.asList(4, 2, 6, 1, 3, 5, 7)
+        );
+
+        List<Integer> treeData = Collections.unmodifiableList(
+                Arrays.asList(4, 2, 6, 1, 3, 7, 5)
+        );
+        treeData.forEach(value -> sut.insert(value));
+
+        List<Integer> actual = sut.getAsLevelOrderList();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void sortsSingleElement() {
+        BST<Integer> sut = new BST<>();
+        List<Integer> expected = Collections.unmodifiableList(
+                Arrays.asList(4)
+        );
+
+        sut.insert(4);
+
+        List<Integer> actual = sut.getAsSortedList();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void sortsCollectionOfTwoIfSecondInsertedIsSmallerThanFirst() {
+        BST<Integer> sut = new BST<>();
+        List<Integer> expected = Collections.unmodifiableList(
+                Arrays.asList(2, 4)
+        );
+
+        sut.insert(4);
+        sut.insert(2);
+
+        List<Integer> actual = sut.getAsSortedList();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void sortsCollectionOfTwoIfSecondInsertedIsBiggerThanFirst() {
+        BST<Integer> sut = new BST<>();
+        List<Integer> expected = Collections.unmodifiableList(
+                Arrays.asList(4, 5)
+        );
+
+        sut.insert(4);
+        sut.insert(5);
+
+        List<Integer> actual = sut.getAsSortedList();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void iteratesOverComplexTree() {
+        BST<Integer> sut = new BST<>();
+        List<Integer> expected = Collections.unmodifiableList(
+                Arrays.asList(1, 2, 3, 4, 5, 6, 7)
+        );
+
+        List<Integer> treeData = Collections.unmodifiableList(
+                Arrays.asList(4, 2, 1, 3, 6, 7, 5)
+        );
+        treeData.forEach(value -> sut.insert(value));
+
+        List<Integer> actual = sut.getAsSortedList();
+        assertEquals(expected, actual);
+    }
+}

data/tracks/java/exercises/pythagorean-triplet/build.gradle

@@ -0,0 +1,18 @@
+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"]
+  }
+}

data/tracks/java/exercises/pythagorean-triplet/src/example/java/PythagoreanTriplet.java

@@ -0,0 +1,117 @@
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class PythagoreanTriplet {
+
+    private int a;
+    private int b;
+    private int c;
+
+    public PythagoreanTriplet(final int a, final int b, final int c) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+    }
+
+    public static TripletListBuilder makeTripletsList() {
+        return new TripletListBuilder();
+    }
+
+    public int calculateSum() {
+        return this.a + this.b + this.c;
+    }
+
+    public long calculateProduct() {
+        return this.a * this.b * this.c;
+    }
+
+    public boolean isPythagorean() {
+        return this.a * this.a + this.b * this.b == this.c * this.c;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(a, b, c);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final PythagoreanTriplet other = (PythagoreanTriplet) obj;
+        if (this.a != other.a) {
+            return false;
+        }
+        if (this.b != other.b) {
+            return false;
+        }
+        if (this.c != other.c) {
+            return false;
+        }
+        return true;
+    }
+
+    public static class TripletListBuilder {
+
+        private static final int MAX_FACTOR_DEFAULT_VALUE = 0;
+        private static final int SUM_DEFAULT_VALUE = -1;
+
+        private int maxFactor = MAX_FACTOR_DEFAULT_VALUE;
+        private int minFactor = 1;
+        private int sum = SUM_DEFAULT_VALUE;
+
+        public TripletListBuilder() {
+        }
+
+        public TripletListBuilder withFactorsLessThanOrEqualTo(
+                final int maxFactor) {
+            this.maxFactor = maxFactor;
+            return this;
+        }
+
+        public TripletListBuilder withFactorsGreaterThanOrEqualTo(
+                final int minFactor) {
+            this.minFactor = minFactor;
+            return this;
+        }
+
+        public TripletListBuilder thatSumTo(final int sum) {
+            this.sum = sum;
+            return this;
+        }
+
+        public List<PythagoreanTriplet> build() {
+            List<PythagoreanTriplet> triplets = new ArrayList<>();
+            if (this.maxFactor == MAX_FACTOR_DEFAULT_VALUE) {
+                return triplets;
+            }
+            double sqrt;
+            int floor;
+            for (int n = minFactor; n < maxFactor; n++) {
+                for (int m = n + 1; m < maxFactor; m++) {
+                    sqrt = Math.sqrt(n * n + m * m);
+                    floor = (int) Math.floor(sqrt);
+                    if (sqrt == floor) {
+                        triplets.add(new PythagoreanTriplet(m, n, floor));
+                    }
+                }
+            }
+            if (sum != SUM_DEFAULT_VALUE) {
+                return triplets.stream()
+                        .filter(t -> t.calculateSum() == sum)
+                        .collect(Collectors.toList());
+            }
+            return triplets;
+        }
+    }
+}

data/tracks/java/exercises/pythagorean-triplet/src/main/java/PythagoreanTriplet.java

@@ -0,0 +1,3 @@
+
+public class PythagoreanTriplet {
+}

data/tracks/java/exercises/pythagorean-triplet/src/test/java/PythagoreanTripletTest.java

@@ -0,0 +1,95 @@
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+import org.junit.Ignore;
+
+public class PythagoreanTripletTest {
+
+    @Test
+    public void shouldCalculateSum() {
+        PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
+        final int expected = 12;
+        final int actual = sut.calculateSum();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldCalculateProduct() {
+        PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
+        final long expected = 60l;
+        final long actual = sut.calculateProduct();
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void testIsPythagoreanOK() {
+        PythagoreanTriplet sut = new PythagoreanTriplet(3, 4, 5);
+        assertTrue(sut.isPythagorean());
+    }
+
+    @Test
+    @Ignore
+    public void testIsPythagoreanFail() {
+        PythagoreanTriplet sut = new PythagoreanTriplet(5, 6, 7);
+        assertFalse(sut.isPythagorean());
+    }
+
+    @Test
+    @Ignore
+    public void shouldMakeTripletsUpToTen() {
+        final List<Long> actual
+                = PythagoreanTriplet
+                        .makeTripletsList()
+                        .withFactorsLessThanOrEqualTo(10)
+                        .build()
+                        .stream()
+                        .map(t -> t.calculateProduct())
+                        .sorted()
+                        .collect(Collectors.toList());
+        final List<Long> expected = Arrays.asList(60l, 480l);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldMakeTripletsElevenToTwenty() {
+        final List<Long> actual
+                = PythagoreanTriplet
+                        .makeTripletsList()
+                        .withFactorsGreaterThanOrEqualTo(11)
+                        .withFactorsLessThanOrEqualTo(20)
+                        .build()
+                        .stream()
+                        .map(t -> t.calculateProduct())
+                        .sorted((p1, p2) -> Double.compare(p1, p2))
+                        .collect(Collectors.toList());
+        final List<Long> expected = Arrays.asList(3840l);
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void shouldMakeTripletsAndFilterOnSum() {
+        final List<Long> actual
+                = PythagoreanTriplet
+                        .makeTripletsList()
+                        .withFactorsLessThanOrEqualTo(100)
+                        .thatSumTo(180)
+                        .build()
+                        .stream()
+                        .map(t -> t.calculateProduct())
+                        .sorted((p1, p2) -> Double.compare(p1, p2))
+                        .collect(Collectors.toList());
+        final List<Long> expected = Arrays.asList(118080l, 168480l, 202500l);
+        assertEquals(expected, actual);
+    }
+}

data/tracks/java/exercises/settings.gradle

@@ -5,6 +5,7 @@ include 'anagram'
 include 'atbash-cipher'
 include 'beer-song'
 include 'binary'
+include 'binary-search-tree'
 include 'bob'
 include 'bracket-push'
 include 'crypto-square'
@@ -34,6 +35,7 @@ include 'robot-name'
 include 'robot-simulator'
 include 'roman-numerals'
 include 'prime-factors'
+include 'pythagorean-triplet'
 include 'scrabble-score'
 include 'series'
 include 'sieve'

data/tracks/julia/README.md

@@ -9,3 +9,19 @@ _Document how to contribute to the Julia track._
 ## Contributing Guide
 
 Please see the [contributing guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md).
+
+## Working on the Exercises
+
+A pool of exercises can be found in the [x-Common repo](https://github.com/exercism/x-common).
+
+Exercises for the Julia track go in the `exercises` directory and should follow the following filename conventions: 
+
+`exercises/<slug>/<slug>.jl` Skeleton for the function that is called by the test suite. Provide (abstract) parameter and return types to ensure compatibility with the test suite.
+
+`exercises/<slug>/runtests.jl` Test suite for the exercise. Group related tests using [testsets](http://docs.julialang.org/en/release-0.5/stdlib/test/#working-with-test-sets).
+
+`exercises/<slug>/example.jl` Example solution for the exercise. It should follow the [Julia Style Guide](http://docs.julialang.org/en/release-0.5/manual/style-guide/).
+
+Replace `<slug>` with the exercise slug of the exercise you're working on.
+
+See [Issue #2](https://github.com/exercism/xjulia/issues/2) for discussion on the structure.

data/tracks/perl5/README.md

@@ -1,5 +1,7 @@
 # xPerl5
 
+[![Gitter](https://badges.gitter.im/exercism/xperl.svg)](https://gitter.im/exercism/xperl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
 Exercism exercises in Perl 5
 
 ## Dependencies