Merge branch 'pr/43'

config.json

     "crypto-square",
     "trinary",
     "rna-transcription",
-    "sieve"
+    "sieve",
+    "pascals-triangle"	
   ],
   "deprecated": [
   ],

pascals-triangle/build.gradle

+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.10"
+}

pascals-triangle/example.java

+import java.util.Arrays;
+
+public class PascalsTriangle {
+
+    public static int[][] computeTriangle(int rows) {
+        if (rows < 0) {
+            throw new IllegalArgumentException("Rows can't be negative!");
+        }
+
+        int[][] triangle = new int[rows][];
+
+        for (int i = 0; i < rows; i++) {
+            triangle[i] = new int[i + 1];
+            triangle[i][0] = 1;
+            for (int j = 1; j < i; j++) {
+                triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j];
+            }
+            triangle[i][i] = 1;
+        }
+        return triangle;
+    }
+
+    public static boolean isTriangle(int[][] triangle) {
+        return Arrays.deepEquals(triangle, computeTriangle(triangle.length));
+    }
+}

pascals-triangle/src/main/java/PascalsTriangle.java

+public class PascalsTriangle {
+}

pascals-triangle/src/test/java/PascalsTriangleTest.java

+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+public class PascalsTriangleTest {
+
+    @Test
+    public void testTriangleWithFourRows() {
+        int[][] expectedOutput = new int[][]{
+                {1},
+                {1, 1},
+                {1, 2, 1},
+                {1, 3, 3, 1},
+        };
+
+        assertArrayEquals(expectedOutput, PascalsTriangle.computeTriangle(4));
+    }
+
+    @Test
+    public void testTriangleWithSixRows() {
+        int[][] expectedOutput = new int[][]{
+                {1},
+                {1, 1},
+                {1, 2, 1},
+                {1, 3, 3, 1},
+                {1, 4, 6, 4, 1},
+                {1, 5, 10, 10, 5, 1}
+        };
+
+        assertArrayEquals(expectedOutput, PascalsTriangle.computeTriangle(6));
+    }
+
+    @Test
+    public void testExpectEmptyTriangle() {
+        int[][] expectedOutput = new int[][]{
+
+        };
+
+        assertArrayEquals(expectedOutput, PascalsTriangle.computeTriangle(0));
+    }
+
+    @Test
+    public void testValidInput() {
+        int[][] input = new int[][]{
+                {1},
+                {1, 1},
+                {1, 2, 1},
+                {1, 3, 3, 1},
+                {1, 4, 6, 4, 1},
+        };
+
+        assertEquals(true, PascalsTriangle.isTriangle(input));
+    }
+
+    @Test
+    public void testInvalidInput() {
+        int[][] input = new int[][]{
+                {1},
+                {1, 1},
+                {1, 2, 1},
+                {1, 4, 4, 1},
+        };
+
+        assertEquals(false, PascalsTriangle.isTriangle(input));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testValidatesNotNegativeRows() {
+        PascalsTriangle.computeTriangle(-1);
+    }
+}