Update all new Tasks

Task/Solve-a-Hopido-puzzle/D/solve-a-hopido-puzzle-1.d

@@ -0,0 +1,114 @@
+import std.stdio, std.conv, std.string, std.range, std.algorithm, std.typecons;
+
+
+struct HopidoPuzzle {
+    private alias InputCellBaseType = char;
+    private enum InputCell : InputCellBaseType { available = '#', unavailable = '.' }
+    private alias Cell = uint;
+    private enum : Cell { unknownCell = 0, unavailableCell = Cell.max } // Special Cell values.
+
+    // Neighbors, [shift row, shift column].
+    private static immutable int[2][8] shifts = [[-2, -2], [2, -2], [-2, 2], [2, 2],
+                                                 [ 0, -3], [0,  3], [-3, 0], [3, 0]];
+
+    private immutable size_t gridWidth, gridHeight;
+    private immutable Cell nAvailableCells;
+    private /*immutable*/ const InputCell[] flatPuzzle;
+    private Cell[] grid; // Flattened mutable game grid.
+
+    @disable this();
+
+
+    this(in string[] rawPuzzle) pure @safe
+    in {
+        assert(!rawPuzzle.empty);
+        assert(!rawPuzzle[0].empty);
+        assert(rawPuzzle.all!(row => row.length == rawPuzzle[0].length)); // Is rectangular.
+
+        // Has at least one start point.
+        assert(rawPuzzle.join.representation.canFind(InputCell.available));
+    } body {
+        //immutable puzzle = rawPuzzle.to!(InputCell[][]);
+        immutable puzzle = rawPuzzle.map!representation.array.to!(InputCell[][]);
+
+        gridWidth = puzzle[0].length;
+        gridHeight = puzzle.length;
+        flatPuzzle = puzzle.join;
+        nAvailableCells = flatPuzzle.representation.count!(ic => ic == InputCell.available);
+
+        grid = flatPuzzle
+               .representation
+               .map!(ic => ic == InputCell.available ? unknownCell : unavailableCell)
+               .array;
+    }
+
+
+    Nullable!(string[][]) solve() pure /*nothrow*/ @safe
+    out(result) {
+        if (!result.isNull)
+            assert(!grid.canFind(unknownCell));
+    } body {
+        // Try all possible start positions.
+        foreach (immutable r; 0 ..  gridHeight) {
+            foreach (immutable c; 0 .. gridWidth) {
+                immutable pos = r * gridWidth + c;
+                if (grid[pos] == unknownCell) {
+                    immutable Cell startCell = 1; // To lay the first cell value.
+                    grid[pos] = startCell;        // Try.
+                    if (search(r, c, startCell + 1)) {
+                        auto result = zip(flatPuzzle, grid)
+                                      //.map!({p, c} => ...
+                                      .map!(pc => (pc[0] == InputCell.available) ?
+                                                  pc[1].text :
+                                                  InputCellBaseType(pc[0]).text)
+                                      .array
+                                      .chunks(gridWidth)
+                                      .array;
+                        return typeof(return)(result);
+                    }
+                    grid[pos] = unknownCell; // Restore.
+                }
+            }
+        }
+
+        return typeof(return)();
+    }
+
+
+    private bool search(in size_t r, in size_t c, in Cell cell) pure nothrow @safe @nogc {
+        if (cell > nAvailableCells)
+            return true; // One solution found.
+
+        foreach (immutable sh; shifts) {
+            immutable r2 = r + sh[0],
+                      c2 = c + sh[1],
+                      pos = r2 * gridWidth + c2;
+            // No need to test for >= 0 because uint wraps around.
+            if (c2 < gridWidth && r2 < gridHeight && grid[pos] == unknownCell) {
+                grid[pos] = cell;        // Try.
+                if (search(r2, c2, cell + 1))
+                    return true;
+                grid[pos] = unknownCell; // Restore.
+            }
+        }
+
+        return false;
+    }
+}
+
+
+void main() @safe {
+    // enum HopidoPuzzle to catch malformed puzzles at compile-time.
+    enum puzzle = ".##.##.
+                   #######
+                   #######
+                   .#####.
+                   ..###..
+                   ...#...".split.HopidoPuzzle;
+
+    immutable solution = puzzle.solve; // Solved at run-time.
+    if (solution.isNull)
+        writeln("No solution found.");
+    else
+        writefln("One solution:\n%(%-(%2s %)\n%)", solution);
+}

Task/Solve-a-Hopido-puzzle/D/solve-a-hopido-puzzle-2.d

@@ -0,0 +1,98 @@
+global nCells, cMap, best
+record Pos(r,c)
+
+procedure main(A)
+    puzzle := showPuzzle("Input",readPuzzle())
+    QMouse(puzzle,findStart(puzzle),&null,0)
+    showPuzzle("Output", solvePuzzle(puzzle)) | write("No solution!")
+end
+
+procedure readPuzzle()
+    # Start with a reduced puzzle space
+    p := [[-1],[-1]]
+    nCells := maxCols := 0
+    every line := !&input do {
+        put(p,[: -1 | -1 | gencells(line) | -1 | -1 :])
+        maxCols <:= *p[-1]
+        }
+    every put(p, [-1]|[-1])
+    # Now normalize all rows to the same length
+    every i := 1 to *p do p[i] := [: !p[i] | (|-1\(maxCols - *p[i])) :]
+    return p
+end
+
+procedure gencells(s)
+    static WS, NWS
+    initial {
+        NWS := ~(WS := " \t")
+        cMap := table()     # Map to/from internal model
+        cMap["#"] := -1;  cMap["_"] :=  0
+        cMap[-1]  := " "; cMap[0]   := "_"
+        }
+
+    s ? while not pos(0) do {
+            w := (tab(many(WS))|"", tab(many(NWS))) | break
+            w := numeric(\cMap[w]|w)
+            if -1 ~= w then nCells +:= 1
+            suspend w
+            }
+end
+
+procedure showPuzzle(label, p)
+    write(label," with ",nCells," cells:")
+    every r := !p do {
+        every c := !r do writes(right((\cMap[c]|c),*nCells+1))
+        write()
+        }
+    return p
+end
+
+procedure findStart(p)
+    if \p[r := !*p][c := !*p[r]] = 1 then return Pos(r,c)
+end
+
+procedure solvePuzzle(puzzle)
+    if path := \best then {
+        repeat {
+            loc := path.getLoc()
+            puzzle[loc.r][loc.c] := path.getVal()
+            path := \path.getParent() | break
+            }
+        return puzzle
+        }
+end
+
+class QMouse(puzzle, loc, parent, val)
+
+    method getVal(); return val; end
+    method getLoc(); return loc; end
+    method getParent(); return parent; end
+    method atEnd(); return nCells = val; end
+
+    method visit(r,c)
+        if /best & validPos(r,c) then return Pos(r,c)
+    end
+
+    method validPos(r,c)
+        v := val+1
+        xv := (0 <= puzzle[r][c]) | fail
+        if xv = (v|0) then {  # make sure this path hasn't already gone there
+            ancestor := self
+            while xl := (ancestor := \ancestor.getParent()).getLoc() do
+                if (xl.r = r) & (xl.c = c) then fail
+            return
+            }
+    end
+
+initially
+    val := val+1
+    if atEnd() then return best := self
+    QMouse(puzzle, visit(loc.r-3,loc.c),   self, val)
+    QMouse(puzzle, visit(loc.r-2,loc.c-2), self, val)
+    QMouse(puzzle, visit(loc.r,  loc.c-3), self, val)
+    QMouse(puzzle, visit(loc.r+2,loc.c-2), self, val)
+    QMouse(puzzle, visit(loc.r+3,loc.c),   self, val)
+    QMouse(puzzle, visit(loc.r+2,loc.c+2), self, val)
+    QMouse(puzzle, visit(loc.r,  loc.c+3), self, val)
+    QMouse(puzzle, visit(loc.r-2,loc.c+2), self, val)
+end