Data commit

Task/Longest-increasing-subsequence/D/longest-increasing-subsequence-1.d

@@ -0,0 +1,15 @@
+import std.stdio, std.algorithm, power_set2;
+
+T[] lis(T)(T[] items) pure nothrow {
+    //return items.powerSet.filter!isSorted.max!q{ a.length };
+    return items
+           .powerSet
+           .filter!isSorted
+           .minPos!q{ a.length > b.length }
+           .front;
+}
+
+void main() {
+    [3, 2, 6, 4, 5, 1].lis.writeln;
+    [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15].lis.writeln;
+}

Task/Longest-increasing-subsequence/D/longest-increasing-subsequence-2.d

@@ -0,0 +1,38 @@
+import std.stdio, std.algorithm, std.array;
+
+/// Return one of the Longest Increasing Subsequence of
+/// items using patience sorting.
+T[] lis(T)(in T[] items) pure nothrow
+if (__traits(compiles, T.init < T.init))
+out(result) {
+    assert(result.length <= items.length);
+    assert(result.isSorted);
+    assert(result.all!(x => items.canFind(x)));
+} body {
+    if (items.empty)
+        return null;
+
+    static struct Node { T val; Node* back; }
+    auto pile = [[new Node(items[0])]];
+
+    OUTER: foreach (immutable di; items[1 .. $]) {
+        foreach (immutable j, ref pj; pile)
+            if (pj[$ - 1].val > di) {
+                pj ~= new Node(di, j ? pile[j - 1][$ - 1] : null);
+                continue OUTER;
+            }
+        pile ~= [new Node(di, pile[$ - 1][$ - 1])];
+    }
+
+    T[] result;
+    for (auto ptr = pile[$ - 1][$ - 1]; ptr != null; ptr = ptr.back)
+        result ~= ptr.val;
+    result.reverse();
+    return result;
+}
+
+void main() {
+    foreach (d; [[3,2,6,4,5,1],
+                 [0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15]])
+        d.lis.writeln;
+}

Task/Longest-increasing-subsequence/D/longest-increasing-subsequence-3.d

@@ -0,0 +1,50 @@
+import std.stdio, std.algorithm, std.range, std.array;
+
+T[] lis(T)(in T[] items) pure nothrow
+if (__traits(compiles, T.init < T.init))
+out(result) {
+    assert(result.length <= items.length);
+    assert(result.isSorted);
+    assert(result.all!(x => items.canFind(x)));
+} body {
+    if (items.empty)
+        return null;
+
+    static struct Node {
+        T value;
+        Node* pointer;
+    }
+    Node*[] pileTops;
+    auto nodes = minimallyInitializedArray!(Node[])(items.length);
+
+    // Sort into piles.
+    foreach (idx, x; items) {
+        auto node = &nodes[idx];
+        node.value = x;
+        immutable i = pileTops.length -
+                      pileTops.assumeSorted!q{a.value < b.value}
+                      .upperBound(node)
+                      .length;
+        if (i != 0)
+            node.pointer = pileTops[i - 1];
+        if (i != pileTops.length)
+            pileTops[i] = node;
+        else
+            pileTops ~= node;
+    }
+
+    // Extract LIS from nodes.
+    size_t count = 0;
+    for (auto n = pileTops[$ - 1]; n != null; n = n.pointer)
+        count++;
+    auto result = minimallyInitializedArray!(T[])(count);
+    for (auto n = pileTops[$ - 1]; n != null; n = n.pointer)
+        result[--count] = n.value;
+    return result;
+}
+
+void main() {
+    foreach (d; [[3,2,6,4,5,1],
+                 [0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15]])
+        d.writeln;
+}