Data commit

Task/Pascals-triangle/D/pascals-triangle-1.d

@@ -0,0 +1,25 @@
+int[][] pascalsTriangle(in int rows) pure nothrow {
+    auto tri = new int[][rows];
+    foreach (r; 0 .. rows) {
+        int v = 1;
+        foreach (c; 0 .. r+1) {
+            tri[r] ~= v;
+            v = (v * (r - c)) / (c + 1);
+        }
+    }
+    return tri;
+}
+
+void main() {
+    immutable t = pascalsTriangle(10);
+    assert(t == [[1],
+                [1, 1],
+               [1, 2, 1],
+             [1, 3, 3, 1],
+           [1, 4, 6, 4, 1],
+         [1, 5, 10, 10, 5, 1],
+       [1, 6, 15, 20, 15, 6, 1],
+     [1, 7, 21, 35, 35, 21, 7, 1],
+    [1, 8, 28, 56, 70, 56, 28, 8, 1],
+  [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]]);
+}

Task/Pascals-triangle/D/pascals-triangle-2.d

@@ -0,0 +1,11 @@
+import std.stdio, std.algorithm, std.range;
+
+auto pascal() pure nothrow {
+    return [1].recurrence!q{ zip(a[n - 1] ~ 0, 0 ~ a[n - 1])
+                             .map!q{ a[0] + a[1] }
+                             .array };
+}
+
+void main() {
+    pascal.take(5).writeln;
+}

Task/Pascals-triangle/D/pascals-triangle-3.d

@@ -0,0 +1,42 @@
+import std.stdio, std.string, std.array, std.format;
+
+string Pascal(alias dg, T, T initValue)(int n) {
+    string output;
+
+    void append(in T[] l) {
+        output ~= " ".replicate((n - l.length + 1) * 2);
+        foreach (e; l)
+            output ~= format("%4s", format("%4s", e));
+        output ~= "\n";
+    }
+
+    if (n > 0) {
+        T[][] lines = [[initValue]];
+        append(lines[0]);
+        foreach (i; 1 .. n) {
+            lines ~= lines[i - 1] ~ initValue; // length + 1
+            foreach (int j; 1 .. lines[i-1].length)
+                lines[i][j] = dg(lines[i-1][j], lines[i-1][j-1]);
+            append(lines[i]);
+        }
+    }
+    return output;
+}
+
+string delegate(int n) genericPascal(alias dg, T, T initValue)() {
+    mixin Pascal!(dg, T, initValue);
+    return &Pascal;
+}
+
+void main() {
+    auto pascal = genericPascal!((int a, int b) => a + b, int, 1)();
+    static char xor(char a, char b) { return a == b ? '_' : '*'; }
+    auto sierpinski = genericPascal!(xor, char, '*')();
+
+    foreach (i; [1, 5, 9])
+        writef(pascal(i));
+    // an order 4 sierpinski triangle is a 2^4 lines generic
+    // Pascal triangle with xor operation
+    foreach (i; [16])
+        writef(sierpinski(i));
+}