Update all new Tasks

Task/ABC-Problem/D/abc-problem-1.d

@@ -0,0 +1,22 @@
+import std.stdio, std.algorithm, std.string;
+
+bool canMakeWord(in string word, in string[] blocks) pure /*nothrow*/ @safe {
+    auto bs = blocks.dup;
+    outer: foreach (immutable ch; word.toUpper) {
+        foreach (immutable block; bs)
+            if (block.canFind(ch)) {
+                bs = bs.remove(bs.countUntil(block));
+                continue outer;
+            }
+        return false;
+    }
+    return true;
+}
+
+void main() @safe {
+    immutable blocks = "BO XK DQ CP NA GT RE TG QD FS JW HU VI
+                        AN OB ER FS LY PC ZM".split;
+
+    foreach (word; "" ~ "A BARK BoOK TrEAT COmMoN SQUAD conFUsE".split)
+        writefln(`"%s" %s`, word, canMakeWord(word, blocks));
+}

Task/ABC-Problem/D/abc-problem-2.d

@@ -0,0 +1,39 @@
+import std.ascii, core.stdc.stdlib;
+
+bool canMakeWord(in string word, in string[] blocks) nothrow @nogc
+in {
+    foreach (immutable char ch; word)
+        assert(ch.isASCII);
+    foreach (const block; blocks)
+        assert(block.length == 2 && block[0].isASCII && block[1].isASCII);
+} body {
+    auto ptr = cast(string*)alloca(blocks.length * string.sizeof);
+    if (ptr == null)
+        exit(1);
+    auto blocks2 = ptr[0 .. blocks.length];
+    blocks2[] = blocks[];
+
+    outer: foreach (immutable i; 0 .. word.length) {
+        immutable ch = word[i].toUpper;
+        foreach (immutable j; 0 .. blocks2.length) {
+            if (blocks2[j][0] == ch || blocks2[j][1] == ch) {
+                if (blocks2.length > 1)
+                    blocks2[j] = blocks2[$ - 1];
+                blocks2 = blocks2[0 .. $ - 1];
+                continue outer;
+            }
+        }
+        return false;
+    }
+    return true;
+}
+
+void main() {
+    import std.stdio, std.string;
+
+    immutable blocks = "BO XK DQ CP NA GT RE TG QD FS JW HU VI
+                        AN OB ER FS LY PC ZM".split;
+
+    foreach (word; "" ~ "A BARK BoOK TrEAT COmMoN SQUAD conFUsE".split)
+        writefln(`"%s" %s`, word, canMakeWord(word, blocks));
+}

Task/ABC-Problem/D/abc-problem-3.d

@@ -0,0 +1,38 @@
+import std.stdio, std.ascii, std.algorithm, std.array;
+
+alias Block = char[2];
+
+// Modifies the order of the given blocks.
+bool canMakeWord(Block[] blocks, in string word) pure nothrow
+in {
+    assert(blocks.all!(w => w[].all!isAlpha));
+    assert(word.all!isAlpha);
+} body {
+    if (word.empty)
+        return true;
+
+    immutable c = word[0].toUpper;
+    foreach (ref b; blocks) {
+        if (b[0].toUpper != c && b[1].toUpper != c)
+            continue;
+        blocks[0].swap(b);
+        if (blocks[1 .. $].canMakeWord(word[1 .. $]))
+            return true;
+        blocks[0].swap(b);
+    }
+
+    return false;
+}
+
+void main() {
+    enum Block[] blocks = "BO XK DQ CP NA GT RE TG QD FS
+                           JW HU VI AN OB ER FS LY PC ZM".split;
+
+    foreach (w; "" ~ "A BARK BoOK TrEAT COmMoN SQUAD conFUsE".split)
+        writefln(`"%s" %s`, w, blocks.canMakeWord(w));
+
+    // Extra test.
+    Block[] blocks2 = ["AB", "AB", "AC", "AC"];
+    immutable word = "abba";
+    writefln(`"%s" %s`, word, blocks2.canMakeWord(word));
+}

Task/ABC-Problem/D/abc-problem-4.d

@@ -0,0 +1,42 @@
+import std.stdio, std.ascii, std.algorithm, std.array, std.range;
+
+alias Block = char[2];
+
+bool canMakeWord(immutable Block[] blocks, in string word) pure nothrow
+in {
+    assert(blocks.all!(w => w[].all!isAlpha));
+    assert(word.all!isAlpha);
+} body {
+    bool inner(size_t[] indexes, in string w) pure nothrow {
+        if (w.empty)
+            return true;
+
+        immutable c = w[0].toUpper;
+        foreach (ref idx; indexes) {
+            if (blocks[idx][0].toUpper != c &&
+                blocks[idx][1].toUpper != c)
+                continue;
+            indexes[0].swap(idx);
+            if (inner(indexes[1 .. $], w[1 .. $]))
+                return true;
+            indexes[0].swap(idx);
+        }
+
+        return false;
+    }
+
+    return inner(blocks.length.iota.array, word);
+}
+
+void main() {
+    enum Block[] blocks = "BO XK DQ CP NA GT RE TG QD FS
+                           JW HU VI AN OB ER FS LY PC ZM".split;
+
+    foreach (w; "" ~ "A BARK BoOK TrEAT COmMoN SQUAD conFUsE".split)
+        writefln(`"%s" %s`, w, blocks.canMakeWord(w));
+
+    // Extra test.
+    immutable Block[] blocks2 = ["AB", "AB", "AC", "AC"];
+    immutable word = "abba";
+    writefln(`"%s" %s`, word, blocks2.canMakeWord(word));
+}