Merged with upstream and merged conflicts

config.json

@@ -51,6 +51,7 @@
     "series",
     "robot-simulator",
     "bracket-push",
+    "pythagorean-triplet",
     "binary-search"
   ],
   "exercises": [
@@ -290,6 +291,11 @@
       "topics": []
     },
     {
+      "slug": "pythagorean-triplet",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
       "slug": "binary-search",
       "difficulty": 1,
       "topics": []

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"]
+  }
+}

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;
+        }
+    }
+}

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

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

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);
+    }
+}

exercises/settings.gradle

@@ -35,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'