# Down the drain it goes

I once encountered this (mini) game where you had 4 or more vertical pipes that were connected by a number of horizontal pipes and you have to drop a ball or water into the vertical pipes.
There are 2 kinds I know of:

• Get the object into a bucket/basket under one of the exits (guess what pipe to throw it in)
• Guess what pipe the object will come from.

### Sample pipes:

|       |       |-------|
|-------|       |-------|
|       |-------|       |
|-------|-------|-------|
|       |-------|       |
|-------|       |-------|
|-------|       |-------|
|       |-------|       |


### Basic rules:

• When moving through a horizontal pipe the object will go down when possible
• When moving through a vertical pipe the object will turn into a horizontal pipe when possible.

• Write a program that will create a random grid of pipes(see sample pipes).
• There should be at least 4 vertical pipes and a fair amount of horizontal pipes at least 10.
• The length of the vertical pipes is up to you.
• Show the path that the object took to reach the bottom and show how many turns it took to get there.
• (Optional) input to deterimine starting point, pipes numbered 1..N from left to right.

### Display:

 | vertical pipe
- horizontal pipe
: vertical pipe used by the object
= horizontal pipe used by the object
V Object starting point
^ Object ending point


### Example:

V
:       |       |-------|
:=======:       |-------|
|       :=======:       |
|-----!-:=======:       |
|       :=======:-------|
|-------|       :=======:
|-------|       :=======:
|       :=======:       |
^
14 turns were taken to get to the end.


Detail
The object enters pipe 1 and starts moving down, goes left into the first horizontal pipe.
Back down and into the second pipe followed by a U-turn into the third pipe.
At the end of the third pipe you see an exclamation mark,
shouldnt be in your result but I used this to show you the object could have gone straight ahead.
However rule number 1 prevents that.

Winner will be determined by votes in 3 weeks from now 24-02-2014 (dd-mm).

Happy coding ^.^

• What happens if there the object is falling down and there is a pipe to the left and on the same height a pipe to the right? Feb 3, 2014 at 16:16
• Also since input and output is fixed I don't think it is a good idea to make it popularity-contest. Feb 3, 2014 at 16:18
• @Howard - what would you tag it as, then? "Winner will be determined by votes" seems like a popularity context to me -- there's certainly no golfing or other success criteria here, and it's not a fixed string output Feb 3, 2014 at 16:38
• @DavidCarraher - what about a pinball, rather than water? With each horizontal pipe being a little bit magnetic? And that magnetism being turned on when the ball reaches the end of the section of downpipe and off when it enters the horizontal pipe! By laser-tripwire. :-) (Magnets, how do they work?!) (Laser-tripwires, how to they work?!!) Feb 3, 2014 at 21:18
• @Fabinout - this better not be bloody homework! I've wasted far too much of a perfectly good working weekday knocking out my answer to this! Feb 3, 2014 at 21:20

# Mathematica

The 2D code generates a graph showing the path of the water. I displayed the vertex numbers for convenient cross-checking with the 3D display. Normally the vertex numbers would be hidden.

Input:

r=10;c=7;
result=flow2D[{r,c},3]


Actually, the result contains multiple objects. The first object, result[[1]], is the 2D graph shown here.

The 3 dimensional pipes are Tube's (3D lines) plotted in 3 space. The coordinates computed based on the vertices of the 2D graph along a 3rd coordinate that was randomly generated (This allows the pipes to assume different positions along y each time the code is run.)

The axes are displayed to help the reader convince herself that the 3D rendering is indeed based on the 2D rendering.

The 3D input of interest here is:

Graphics3D[{CapForm[None],verticalPipes,allRungs,Darker@Red,connections},
ImageSize->600,Axes-> True,Ticks->{Range[1,2 r,2],Range[c],Range[10]},ViewPoint->{0,-2,1.5}]


The number or rows, columns and entry column are taken from the 2D code. They do not have to be re-entered.

## 2D Code

In the coming days I will document and tidy up the code for 2D and 3D.

flow2D[{rows_,columns_},startColumn_]:=
Module[{r=rows,c=columns,g,j,h,ends,middle,midcuts,direction="down",turns=0,path,rungs},

(*complete gridgraph*)
g=GridGraph[{r,c},VertexSize-> Medium,GraphStyle->"Prototype",EdgeStyle->"Thick",

(*horizontal pipes that must be removed*)
ends=Table[r(c1-1)+r1\[UndirectedEdge] r(c1)+r1,{c1,1,c-1},{r1,{1,r}}];

(*horizontal pipes to consider removing *)
middle=Table[r(c1-1)+r1\[UndirectedEdge] r(c1)+r1,{c1,1,c-1},{r1,2,r-1}];
midcuts=RandomSample[#,RandomInteger[Round[{r/15,2r/5}]]]&/@middle;

rungs=Flatten[midcuts(*Join[ends,midcuts]*)];

j=EdgeDelete[g,Flatten[Join[ends,midcuts]]];

h[path_]:= Module[{start=path[[-1]],right,left,up,down,newnodes},
VertexList[v]};newnodes=Complement[VertexList[v],path];
If[newnodes=={},path,
h[Append[path,
Switch[direction,
"down",Which[
MemberQ[newnodes,start+r],(turns++;direction="right";start+r),
MemberQ[newnodes,start-r],(turns++;direction="left";start-r),
MemberQ[newnodes,start-1],start-1],
"right",Which[
MemberQ[newnodes,start-1],(turns++;direction="down";start-1),
MemberQ[newnodes,start+r],start+r],
"left",Which[
MemberQ[newnodes,start-1],(turns++;direction="down";start-1),
MemberQ[newnodes,start-r],start-r]
]]]]];
{HighlightGraph[j,path=h[{r*startColumn}],ImageSize->300],path,rungs,ends,midcuts}]

convert[node_,r_,c_]:=Append[footing[[Quotient[node-1,r]+1]],Mod[node-1,r]+1(*Mod[node,r]*)]
connect[a_\[UndirectedEdge]b_,r_,c_]:=Tube[Line[{convert[a,r,c],convert[b,r,c]}],0.2]


# 3D Code and results

r=10;c=7;
result=flow2D[{r,c},3];
g2D=result[[1]];
path2D=result[[2]];
\[AliasDelimiter]
xScale=2;
footing = {#, RandomInteger[{1, 6}]} & /@ Range[1,xScale c, xScale];
verticalPipes=Tube[Line[{Append[#,1],Append[#,r]}],.19]&/@footing;
Graphics3D[{CapForm[None],verticalPipes},ImageSize->600,Axes->True,AxesEdge->Automatic,ViewPoint->{0,-2,1.5},
Ticks->{Range[1,2 r,2],Range[c],Range[10]}];

path3D=UndirectedEdge@@@Partition[Riffle[stops=path2D,Rest@stops],2];
allRungs=connect[#,r,c]&/@rungs;
connections=connect[#,r,c]&/@path3D;

path2D;
g2D
Graphics3D[{CapForm[None],verticalPipes,allRungs,Darker@Red,connections},
ImageSize->600,Axes-> True,Ticks->{Range[1,2 r,2],Range[c],Range[10]},ViewPoint->{0,-2,1.5}]

• If you can render the pathway, this will surely win hands-down! Can you alter the colour of the pipes, based on whether the vertices are "touched"? Feb 3, 2014 at 21:32
• I think I can alter the pipe color to show the path taken. I'm not sure how to decide which connecting (horizontal) pipes should be "taken" and which should be avoided. At present all connecting pipes are "open". Feb 3, 2014 at 21:50
• Pick one randomly, or make it definable like I did in mine? Still going to win -- the output is too pretty not to!! Feb 3, 2014 at 22:00
• Right now, you seem to take several horizontal pipes on the same level. I believe this violates the Basic Rule #1. Feb 5, 2014 at 0:36
• Timwi, Thanks. That oversight has been corrected. Feb 5, 2014 at 3:11

# C#

(via LINQPad, in "C# Program" mode; )

Going to have to apply Equitable Stroke Control, as far as any golfing might go, but this is my approach in C# (well, LINQPad, but who wants all the boilerplate that goes into making a full C# app work?).

Grid definitions are variable, with a number of vertical pipes and height of overall structure, and are repeatably-random by passing a seed (see the PipeGrid constructor).

In the absence of a definitive answer as to which way the object would flow if either direction was possible, I have allowed you to specify a behaviour from a number of options (see SolveBehavior enumeration / PipeSolver constructor).

Starting vertical is definable (see PipeSolver.Solve).

I have assumed that the horizontal pipes are always between two adjacent vertical pipes, i.e. no horizontal can bypass a horizontal pipe.

///<summary>Entry point</summary>
void Main()
{
var grid = new PipeGrid(vertical:10, height:10, seed:5);
var solver = new PipeSolver(grid, SolveBehavior.FlipFlop);
solver.Solve(start:2);
}

///<summary>Represents the direction the object is travelling</summary>
enum Direction
{
Down = 0,
Left = 1,
Right = 2
}

///<summary>Determines the route to take if a junction yields both horizontal directions</summary>
enum SolveBehavior
{
///<summary>Throws an <see cref="InvalidOperationException" /></summary>
Fail = 0,

///<summary>Prefers the left-most direction (screen-relative)</summary>
FavorLeft = 1,

///<summary>Prefers the right-most direction (screen-relative)</summary>
FavorRight = 2,

///<summary>Alternates preferred direction, based on the number of turns</summary>
FlipFlop = 3,

///<summary>Prefers the same direction the object travelled, on its last horizontal movement</summary>
SameDirection = 4,

///<summary>Prefers the opposite direction the object travelled, on its last horizontal movement</summary>
Uturn = 5
}

///<summary>Provides the logic for solving a <see cref="PipeGrid" /></summmary>
class PipeSolver
{
///<summary>Creates a new <see cref="PipeSolver" /> for the supplied <paramref name="grid" />,
///with the given <paramref name="behavior" /> used to resolve junctions with both horizontal
///paths</summary>
public PipeSolver(PipeGrid grid, SolveBehavior behavior = SolveBehavior.FlipFlop)
{
if (grid == null) throw new ArgumentNullException("grid");
_grid = grid;
_behavior = behavior;
}

///<summary>Simulate the dropping of an object to run through the grid, at the top of a
///given <paramref name="start" /> vertical pipe</summary>
public void Solve(int start = 1, bool dumpFrames = false, string tag = "Result")
{
if (start < 1) start = 1;
if (start > _grid.Verticals) start = _grid.Verticals;

int x, y;

Direction?[,] path = new Direction?[_grid.Width, _grid.Height];

x = (start - 1) * 2;
y = 0;
Direction dir = Direction.Down, lastDir = Direction.Down;

int turns = 0;
do
{
path[x, y] = dir;       // we moved through this pipe

// rule 1: when moving through horizontal pipe, object will go down when possible
if ((dir == Direction.Left || dir == Direction.Right) && (x % 2 == 0))
{
lastDir = dir;
dir = Direction.Down;
++turns;
}
// rule 2: when moving through start pipe, object will turn into horizontal pipe when possible
else if (dir == Direction.Down)
{
bool hasLeft  = (x > 0 && _grid[x - 1, y]);
bool hasRight = (x < _grid.Width - 1 && _grid[x + 1, y]);

if (hasLeft && hasRight)
{
switch (_behavior)
{
case SolveBehavior.FavorLeft:
hasRight = false;       // "forget" about right pipe
break;
case SolveBehavior.FavorRight:
hasLeft = false;        // "forget" about left pipe
break;
case SolveBehavior.FlipFlop:
if (turns % 2 == 0) hasLeft = false;
else hasRight = false;  // "forget" about left on the even moves, or right on the odd moves
break;
case SolveBehavior.SameDirection:   // force staying in the same direction
if (lastDir == Direction.Left)       hasRight = false;
else if (lastDir == Direction.Right) hasLeft = false;
else goto case SolveBehavior.FlipFlop;  // use the flip-flop behaviour to determine first turn
break;
case SolveBehavior.Uturn:   // force turning back on itself
if (lastDir == Direction.Left)       hasLeft = false;
else if (lastDir == Direction.Right) hasRight = false;
else goto case SolveBehavior.FlipFlop;  // use the flip-flop behaviour to determine first turn
break;
default: throw new InvalidOperationException(
"Failed to find distinct path, with no resolving behavior defined"
);
}
}

if (hasLeft)        dir = Direction.Left;
else if (hasRight)  dir = Direction.Right;

if (hasLeft || hasRight) ++turns;
}

switch (dir)    // update position, based on current direction
{
case Direction.Left:  if (x > 0) --x; break;
case Direction.Right: if (x < _grid.Width - 1) ++x; break;
default: ++y; break;
}
if (dumpFrames)
{
DumpFrame(path, start, tag:string.Concat("Frame #", turns, " (", _grid.Seed, ")"));
DrawFrame(path, start, tag:string.Concat("Frame #", turns));
}
}
while (y < _grid.Height);

int end = (x / 2) + 1;
DumpFrame(path, start, end, turns, tag);
DrawFrame(path, start, end, turns, tag);
}

///<summary>Internal method for drawing a given frame</summary>
private void DumpFrame(Direction?[,] path, int start, int? end = null, int? turns = null, string tag = null)
{
var builder = new StringBuilder();

builder.Append(' ', --start * 5).AppendLine("v");
for (int y = 0; y < _grid.Height; y++)
{
for (int x = 0; x < _grid.Width; x++)
{
builder.Append(
(x % 2 == 0)
? path[x, y].HasValue ? ":"    : _grid[x, y] ? "|"    : " "
: path[x, y].HasValue ? "====" : _grid[x, y] ? "----" : "    "
);
}
builder.AppendLine();
}
if (end.HasValue)   builder.Append(' ', (end.Value - 1) * 5).AppendLine("^");

if (turns.HasValue) builder.Append(turns.Value)
.Append(" turns were taken to get to ")
.AppendLine(end.HasValue ? "the end." : "this point.");

builder.ToString().Dump(string.IsNullOrWhiteSpace(tag) ? "Frame" : tag);
}

///<summary>Internal method for rendering a frame as a bitmap</summary>
private void DrawFrame(Direction?[,] path, int start, int? end = null, int? turns = null, string tag = null)
{
using (var sprites = new Sprites())
using (var canvas = new Bitmap(16 * _grid.Width, 16 * (_grid.Height + 3)))
using (var graphics = Graphics.FromImage(canvas))
{
graphics.FillRectangle(Brushes.Green, 0, 16, 16 * _grid.Width, 16 * _grid.Height);
_grid.Draw(graphics, sprites, offsetX:0, offsetY:16);

// draw the start position
start = (start - 1) * 32;
graphics.DrawImageUnscaled(sprites.CarVertical,  start, 0);
graphics.DrawImageUnscaled(sprites.StartFlag,    start, 0);

// draw the path
for (int y = 0; y < _grid.Height; y++)
for (int x = 0; x < _grid.Width;  x++)
{
if (path[x, y].HasValue)
{
Image car;

switch (path[x, y])
{
case Direction.Left:
// if even, then on a vertical, so turning left; otherwise travelling left
car = (x % 2 == 0) ? sprites.CarTurnLeft : sprites.CarLeft;
break;
case Direction.Right:
// if even, then on a vertical, so turning right; otherwise travelling right
car = (x % 2 == 0) ? sprites.CarTurnRight: sprites.CarRight;
break;
default:
car = sprites.CarVertical;
if (x == 0 && path[x + 1, y].HasValue)                            // far-left and will move right = turn-right
car = sprites.CarTurnRight;
else if (x == _grid.Width - 1 && path[x - 1, y].HasValue)         // far-right and will move left = turn-left
car = sprites.CarTurnLeft;
else if (x > 0 && x < _grid.Width - 1)
{
car = sprites.CarVertical;                                    // if not right or left, then down
if (path[x + 1, y].HasValue && !path[x - 1, y].HasValue)      // if came from the left, then turn right
car = sprites.CarTurnRight;
else if (path[x - 1, y].HasValue && !path[x + 1, y].HasValue) // if came from the right, then turn left
car = sprites.CarTurnLeft;
}
break;
}

graphics.DrawImageUnscaled(car, 16 * x, 16 * (y + 1));
}
}

// draw the end position, if we are at the end
if (end.HasValue)
{
end = (end - 1) * 32;
graphics.DrawImageUnscaled(sprites.RoadVertical, end.Value, 16 * (_grid.Height + 1));
graphics.DrawImageUnscaled(sprites.CarVertical,  end.Value, 16 * (_grid.Height + 1));
graphics.DrawImageUnscaled(sprites.EndFlag,      end.Value, 16 * (_grid.Height + 1));
}

if (turns.HasValue)
{
string s = string.Concat(turns.Value, " turns were taken to get to ",
end.HasValue ? "the end." : "this point.");

graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;
graphics.DrawString(s, SystemFonts.DefaultFont, Brushes.Black, 0, 16 * (_grid.Height + 2));
}

canvas.Dump(tag ?? "Bonus");
}
}
}

///<summary>Represents a configuration of pipes</summary>
class PipeGrid
{
///<summary>Creates a new <see cref="PipeGrid" />, of a given <paramref name="height" />
///with the given number of <paramref name="vertical" /> pipes, and randomly distributes
///horizontal pipes between them, based on a repeatable <paramref name="seed" />.</summary>
public PipeGrid(int vertical = 4, int height = 8, int? seed = null)
{
if (vertical < 2) vertical = 2;
if (height < 2) height = 2;

Width = (2 * vertical) - 1;
Height = height;
Verticals = vertical;

Seed = seed ?? Environment.TickCount;
var rnd = new Random(Seed);

_nodes = new bool[Width,Height];
for (int x = 0, xw = Width; x < xw; x++)
for (int y = 0; y < height; y++)
{
// place verticals in every even column, and randomly place horizontals in odd columns
if (x % 2 == 0 || rnd.Next(0, 2) == 1)
_nodes[x, y] = true;
}
}

public int Width { get; private set; }
public int Height { get; private set; }
public int Verticals { get; private set; }
public int Seed { get; private set; }

public bool this[int x, int y] { get { return _nodes[x, y]; } }

///<summary>Renders the grid to the LINQPad results pane, for inspection</summary>
public PipeGrid Dump(string tag = null)
{
var builder = new StringBuilder();

for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
builder.Append(
(x % 2 == 0)
? _nodes[x, y] ? "|"    : " "
: _nodes[x, y] ? "----" : "    "
);
}
builder.AppendLine();
}

builder.ToString().Dump(string.IsNullOrWhiteSpace(tag) ? "Grid" : tag);
return this;
}

///<summary>Render the grid as a bitmap image</summary>
public void Draw(Graphics g, Sprites s, int offsetX = 0, int offsetY = 0)
{
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
if (_nodes[x, y])
{
Image sprite = sprite = s.RoadVertical;

if (x % 2 != 0)
else if (x == 0 && _nodes[1, y])
sprite = s.JunctionTeeRight;
else if (x == Width - 1 && _nodes[x - 1, y])
sprite = s.JunctionTeeLeft;
else if (x > 0 && x < Width - 1)
{
if (_nodes[x - 1, y] && _nodes[x + 1, y])
sprite = s.JunctionCross;
else if (_nodes[x + 1, y] && !_nodes[x - 1, y])
sprite = s.JunctionTeeRight;
else if (_nodes[x - 1, y] && !_nodes[x + 1, y])
sprite = s.JunctionTeeLeft;
}

g.DrawImageUnscaled(sprite,
x:(16 * x) + offsetX,
y:(16 * y) + offsetY);
}
}
}
}

///<summary>Creates a <see cref="PipeGrid" /> with horizontal pipes at all possible positions</summary>
public static PipeGrid CreateAllOpen(int verticals = 4, int height = 8)
{
var grid = new PipeGrid(verticals, height, 0);
for (int y = 0; y < height; y++)
for (int x = 0, xw = grid.Width; x < xw; x++)
grid._nodes[x, y] = true;

return grid;
}
}

///<summary>Store tile sprites, to be used in the graphical rendering of the result</summary>
class Sprites : IDisposable
{
public Sprites()
{
byte[,] car = new byte[,] {
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 3, 3, 3, 3, 3, 3, 3, 3, 1, 0, 0, 0 },
{ 0, 0, 0, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0, 0, 0 },
{ 0, 0, 0, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0, 0, 0 },
{ 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 3, 1, 1, 1, 1, 1, 1, 3, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 3, 1, 1, 1, 1, 1, 1, 3, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 3, 1, 1, 1, 1, 1, 1, 3, 1, 0, 0, 0 },
{ 0, 0, 0, 1, 3, 3, 3, 3, 3, 3, 3, 3, 1, 0, 0, 0 },
{ 0, 0, 0, 1, 3, 3, 3, 3, 3, 3, 3, 3, 1, 0, 0, 0 },
{ 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0 },
{ 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
};
byte[,] road = new byte[,] {
{ 0, 6, 2, 2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 6, 6, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 0 },
};
byte[,] roadNESW = new byte[,] {
{ 0, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 0 },
{ 6, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 6 },
{ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 },
{ 2, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 2 },
{ 2, 2, 2, 2, 5, 5, 2, 5, 5, 2, 5, 5, 2, 2, 2, 2 },
{ 2, 2, 2, 2, 5, 5, 2, 5, 5, 2, 5, 5, 2, 2, 2, 2 },
{ 2, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 2 },
{ 2, 2, 2, 2, 5, 5, 2, 5, 5, 2, 5, 5, 2, 2, 2, 2 },
{ 2, 2, 2, 2, 5, 5, 2, 5, 5, 2, 5, 5, 2, 2, 2, 2 },
{ 2, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 2 },
{ 2, 2, 2, 2, 5, 5, 2, 5, 5, 2, 5, 5, 2, 2, 2, 2 },
{ 2, 2, 2, 2, 5, 5, 2, 5, 5, 2, 5, 5, 2, 2, 2, 2 },
{ 2, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 2 },
{ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 },
{ 6, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 6 },
{ 0, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 0 },
};
byte[,] roadNES = new byte[,] {
{ 0, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 0 },
{ 0, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 6 },
{ 0, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 },
{ 0, 6, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 2 },
{ 0, 6, 2, 2, 5, 5, 2, 5, 5, 2, 5, 5, 2, 2, 2, 2 },
{ 0, 6, 2, 2, 5, 5, 2, 5, 5, 2, 5, 5, 2, 2, 2, 2 },
{ 0, 6, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 2 },
{ 0, 6, 2, 2, 5, 5, 2, 5, 5, 2, 5, 5, 2, 2, 2, 2 },
{ 0, 6, 2, 2, 5, 5, 2, 5, 5, 2, 5, 5, 2, 2, 2, 2 },
{ 0, 6, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 2 },
{ 0, 6, 2, 2, 5, 5, 2, 5, 5, 2, 5, 5, 2, 2, 2, 2 },
{ 0, 6, 2, 2, 5, 5, 2, 5, 5, 2, 5, 5, 2, 2, 2, 2 },
{ 0, 6, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 5, 2, 2, 2 },
{ 0, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 },
{ 0, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 6 },
{ 0, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 0 },
};
byte[,] start = new byte[,] {
{ 0, 0, 1, 1, 1, 0, 4, 4, 4, 0, 0, 0, 4, 0, 0, 0 },
{ 0, 0, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0 },
{ 0, 0, 1, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0 },
{ 0, 0, 1, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0 },
{ 0, 0, 1, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0 },
{ 0, 0, 1, 1, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0 },
{ 0, 0, 1, 4, 4, 4, 0, 0, 0, 4, 4, 4, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
};
byte[,] end = new byte[,] {
{ 0, 0, 1, 1, 1, 0, 1, 1, 6, 0, 0, 0, 6, 0, 0, 0 },
{ 0, 0, 1, 6, 6, 6, 1, 1, 6, 6, 1, 1, 6, 0, 0, 0 },
{ 0, 0, 1, 1, 6, 6, 6, 6, 1, 6, 1, 1, 1, 0, 0, 0 },
{ 0, 0, 1, 1, 1, 1, 6, 6, 1, 1, 6, 6, 1, 0, 0, 0 },
{ 0, 0, 1, 1, 1, 1, 1, 1, 6, 1, 6, 6, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 6, 6, 1, 1, 6, 6, 1, 1, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 6, 6, 6, 6, 1, 6, 1, 1, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 1, 1, 6, 6, 1, 1, 6, 6, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 6, 6, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
};

JunctionTeeLeft  = FlipSprite(JunctionTeeRight, horizontal:true);
CarVertical      = Sprite(car);
CarLeft          = RotateSprite(CarVertical,  90);
CarRight         = FlipSprite(CarLeft, horizontal:true);
CarTurnLeft      = RotateSprite(CarVertical,  45);
CarTurnRight     = FlipSprite(CarTurnLeft, horizontal:true);
StartFlag        = Sprite(start);
EndFlag          = Sprite(end);
}

public Image RoadVertical     { get; private set; }
public Image RoadHorizontal   { get; private set; }
public Image JunctionCross    { get; private set; }
public Image JunctionTeeLeft  { get; private set; }
public Image JunctionTeeRight { get; private set; }
public Image CarVertical      { get; private set; }
public Image CarLeft          { get; private set; }
public Image CarRight         { get; private set; }
public Image CarTurnLeft      { get; private set; }
public Image CarTurnRight     { get; private set; }
public Image StartFlag        { get; private set; }
public Image EndFlag          { get; private set; }

///<summary>Create a sprite from the byte data</summary>
private Image Sprite(byte[,] data)
{
int width = data.GetLength(0);
int height = data.GetLength(1);

var image = new Bitmap(width, height);

for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++)
{
Color c;
switch (data[y,x])
{
case 1: c = Color.Black; break;
case 2: c = Color.DarkGray; break;
case 3: c = Color.Red; break;
case 4: c = Color.LimeGreen; break;
case 5: c = Color.Yellow; break;
case 6: c = Color.White; break;
default: continue;
}

image.SetPixel(x, y, c);
}

return image;
}

///<summary>Rotate an image by a number of <paramref name="degrees" /> around the centre</summary>
private Image RotateSprite(Image source, float deg)
{
var b = new Bitmap(source.Width, source.Height);

using (var g = Graphics.FromImage(b))
{
float tx = (float)source.Width / 2.0f;
float ty = (float)source.Height / 2.0f;

g.TranslateTransform(tx, ty);
g.RotateTransform(deg);
g.TranslateTransform(-tx, -ty);
g.DrawImageUnscaled(source, 0, 0);
}

return b;
}

///<summary>Flip an image about its centre</summary>
private Image FlipSprite(Image source, bool horizontal = false, bool vertical = false)
{
var b = new Bitmap(source);

RotateFlipType rft = ( horizontal &&  vertical) ? RotateFlipType.RotateNoneFlipXY
: ( horizontal && !vertical) ? RotateFlipType.RotateNoneFlipX
: (!horizontal &&  vertical) ? RotateFlipType.RotateNoneFlipY
: RotateFlipType.RotateNoneFlipNone;

b.RotateFlip(rft);
return b;
}

#region IDisposable implementation
public void Dispose() { Dispose(true); }
~Sprites() { Dispose(false); }
protected void Dispose(bool disposing)
{
if (disposing)
{
GC.SuppressFinalize(this);
using (JunctionCross) { }
using (JunctionTeeLeft) { }
using (JunctionTeeRight) { }
using (CarVertical) { }
using (CarLeft) { }
using (CarRight) { }
using (CarTurnLeft) { }
using (CarTurnRight) { }
using (StartFlag) { }
using (EndFlag) { };
}
JunctionCross = null;
JunctionTeeLeft = null;
JunctionTeeRight = null;
CarVertical = null;
CarLeft = null;
CarRight = null;
CarTurnLeft = null;
CarTurnRight = null;
StartFlag = null;
EndFlag = null;
}
#endregion
}


## Update:

Fearing my plain old text output might be a little drab for this popularity context, I offer up an extended version that also draws the path taken as an image. I've modelled it as car, driving through a horrible road network, trying to get to the bottom, but with the world's-worst GPS that forces you to make a turn at every junction.

As a bonus, this also makes it clearer to see the 'turns'.

Enjoy -- vroom vroom!!

## Example results:

(verticals: 10, height: 10, random seed:5, start pipe: 2, solve behaviour: FlipFlop})

## C#

Fun times! :-)

This code ensures there is at least some straight pipe at either end of each pipe. It also ensures there are no ambiguous turns.

using System;

namespace Experiment.DownTheDrain
{
class Program
{
static void Main(string[] args)
{
var program = new Program();
program.Width = 19;
program.Height = 17;
program.SpanCount = program.Width * program.Height / 4;
program.Spacing = 3;
program.Run();
}

public int Width { get; set; }
public int Height { get; set; }
public int SpanCount { get; set; }
public int Spacing { get; set; }
public bool[,] Spans { get; private set; }

public void Run()
{
GenerateSpans();
DrawPipes();
var turns = DrawPath(pipe);
WriteTurns(turns);
}

private void GenerateSpans()
{
Random random = new Random();
Spans = new bool[Width, Height];

int x, y;
for (int i = 0; i < SpanCount; i++)
{
do
{
x = random.Next(Width);
y = random.Next(Height);
}
while (SpanAt(x - 1, y) || SpanAt(x, y) || SpanAt(x + 1, y));
Spans[x, y] = true;
}
}

private void DrawPipes()
{
const string Junction = "│┤├┼";

Console.CursorLeft = 0;
Console.CursorTop = 0;
DrawLabels();
for (int y = -1; y <= Height; y++)
{
for (int x = 0; x <= Width; x++)
{
Console.Write(Junction[(SpanAt(x-1,y) ? 1 : 0) + (SpanAt(x,y) ? 2 : 0)]);
Console.Write(x == Width ? Environment.NewLine : new string(SpanAt(x, y) ? '─' : ' ', Spacing));
}
}
DrawLabels();
}

private void DrawLabels()
{
for (int x = 0; x <= Width; x++)
Console.Write("{0}{1}",
(char)(x + 65),
x == Width ? Environment.NewLine : new string(' ', Spacing)
);
}

{
Console.WriteLine();
Console.Write("Please select a start pipe: ");
int pipe;
do
{
pipe = (int)char.ToUpper(key.KeyChar) - 65;
}
while (pipe < 0 || pipe > Width);
Console.WriteLine((char)(pipe + 65));
return pipe;
}

private int DrawPath(int x)
{
int turns = 0;
Console.CursorTop = 1;
for (int y = -1; y <= Height; y++)
{
if (SpanAt(x - 1, y))
{
x--;
Console.CursorLeft = x * (Spacing + 1);
Console.WriteLine("╔{0}╝", new string('═', Spacing));
turns += 2;
}
else if (SpanAt(x, y))
{
Console.CursorLeft = x * (Spacing + 1);
Console.WriteLine("╚{0}╗", new string('═', Spacing));
x++;
turns += 2;
}
else
{
Console.CursorLeft = x * (Spacing + 1);
Console.WriteLine("║");
}
}

return turns;
}

private void WriteTurns(int turns)
{
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("{0} turns taken to reach the bottom.", turns);
}

private bool SpanAt(int x, int y)
{
return x >= 0
&& x < Width
&& y >= 0
&& y < Height
&& Spans[x, y];
}
}
}


Output:

• Damn, I also had the idea of using the box-drawing characters, you beat me to it :) Feb 4, 2014 at 14:12
• Also, I like the idea of making sure not to generate pipes with ambiguous turns. I didn’t think of that! Feb 4, 2014 at 19:03

# Funciton

As if Funciton wasn’t already among the most pointless languages in the world, this is certainly the most useless program I’ve written in it so far.

Since this looks ugly in StackExchange due to the extra line spacing, consider running the following in your browser’s JavaScript console to fix that:

$('pre').each(function(){$(this).css('line-height',1)})

Since Funciton doesn’t have a random number generator, I decided to let you enter the pipe pattern. Since the pattern encoding is unobvious, banging the digit keys on your keyboard randomly is as good as a random number generator.

The input is expected to be three decimal numbers separated by spaces. The first number is the width (one less than the number of vertical pipes); the second is the index of the starting pipe, and the last is any number that encodes the horizontal pipe pattern; you can make it as large as you want. If the width is negative or the pipe index is out of range, the output is Impossiburu.

The program automatically ensures that there are never two horizontal pipes next to each other, which could cause ambiguous turns.

                            ┌───╖
┌────────────┤ ♯ ╟───────────┬───────────────┐
╔════╗  ┌─┴─╖  ┌────╖  ╘═══╝  ╔═══╗  ┌─┴─╖  ╔════╗     │
║ 21 ║  │ × ╟──┤ >> ╟─────────╢   ╟──┤ ʘ ╟──╢ 32 ║     │
╚═╤══╝  ╘═╤═╝  ╘═╤══╝         ╚═══╝  ╘═══╝  ╚════╝     │
└───────┘  ┌───┴───┐                                 │
╔════╗  ┌───╖  │   ┌───┴──────────────────┐              │
║ 32 ╟──┤ ʘ ╟──┘   │          ╔═══╗       │              │
╚════╝  ╘═╤═╝    ┌─┴─╖        ║ 0 ╟───┐   │              │
┌───────┴──────┤ · ╟────┐   ╚═══╝ ┌─┴─╖ │              │
│              ╘═╤═╝    └─────────┤ ʃ ╟─┘              │
│     ┌──────────┘                ╘═╤═╝                │
┌─┴─╖ ┌─┴──╖  ┌─────────╖        ┌────┴────╖             │
│ ♯ ║ │ >> ╟──┤ str→int ╟────┐   │ str→int ║             │
╘═╤═╝ ╘═╤══╝  ╘═════════╝  ┌─┴─╖ ╘════╤════╝           ┌─┴─╖
│   ┌─┴─╖ ╔════╗         │ ░ ║   ┌──┴────────────────┤ · ╟────────────┐
└───┤ × ╟─╢ 21 ║         ╘═╤═╝ ┌─┴─╖                 ╘═╤═╝            │
╘═══╝ ╚════╝┌─────┐    └───┤ ▒ ╟───┐ ┌─────────╖ ┌─┴─╖            │
┌─────────╖  ┌─┴─╖   │        ╘═╤═╝   ├─┤ str→int ╟─┤ ʃ ╟─┐          │
┌──┤ int→str ╟──┤ · ╟─┐ └──────────┘     │ ╘═════════╝ ╘═╤═╝ │          │
│  ╘═════════╝  ╘═╤═╝ │ ╔══════════════╗ │ ╔═══╗  ┌──────┘   │          │
│ ╔══════════╗  ┌─┴─╖ │ ║ 158740358500 ║ │ ║   ╟──┘ ┌───╖  ╔═╧═╗  ┌───╖ │
│ ║ 20971533 ╟──┤   ╟─┘ ║ 305622435610 ║ │ ╚═══╝  ┌─┤ ≤ ╟──╢ 0 ╟──┤ ≥ ╟─┴─┐
│ ╚════╤═════╝  └─┬─╜   ║ 491689778976 ║ └────────┤ ╘═╤═╝  ╚═══╝  ╘═╤═╝   │
│    ┌─┴─╖  ┌───╖ │     ║ 886507240727 ║          │   └──────┬──────┘     │
│    │ ‼ ╟──┤ ‼ ╟─┘     ║ 896192890374 ║          │         ┌┴┐           │
│    ╘═╤═╝  ╘═╤═╝       ║ 899130957897 ╟───┐      │         └┬┘           │
└──────┘    ┌─┴─╖       ╚══════════════╝ ┌─┴─╖  ┌─┴─╖        │            │
│ ‼ ╟────────────────────────┤ ? ╟──┤ · ╟────────┤            │
╘═╤═╝                        ╘═╤═╝  ╘═╤═╝      ┌─┴─╖          │
╔═══════════════╧════════════════════════╗   │      └────────┤ ≥ ╟──────────┘
║ 83139057126481738391428729850811584337 ║       ┌────╖      ╘═══╝
║ 75842912478026089564602018574355013746 ║  ┌────┤ >> ╟──┐
║ 85373033606532129933858395805642598753 ║  │    ╘══╤═╝  │
║ 19381927245726769973108298347355345088 ║  │     ┌─┴─╖  │       ╓───╖
║ 84932603219463911206052446527634696060 ║  │     │ ░ ║  │       ║ ░ ║
║ 230797436494578049782495796264992      ║  │     ╘═╤═╝  │       ╙─┬─╜
╚════════════════════════════════════════╝  │    ┌──┴──┐ └─────────┴────────┐
│    │   ┌─┴──╖ ┌┐   ┌┐         │
│    │   │ << ╟─┤├─┬─┤├─────┐   │
┌────╖  ╔═══╗                             │    │   ╘═╤══╝ └┘ │ └┘   ╔═╧═╗ │
┌─┤ << ╟──╢ 1 ║                             │    │   ╔═╧═╗     │      ║ 1 ║ │
│ ╘═╤══╝  ╚═══╝      ┌───────────────────┐  │    │   ║ 2 ║     │      ╚═╤═╝ │
│   └─────┬──────────┴─────────┐         │  │ ┌──┴─╖ ╚═══╝   ┌─┴─╖ ┌┐   │   │
│         │           ┌───┐  ┌─┴─╖       │  │ │ << ╟─────────┤ ? ╟─┤├───┤   │
│         │           │   ├──┤ · ╟─┐     │  │ ╘══╤═╝         ╘═╤═╝ └┘   ├───┘
│ ┌───┐ ┌─┴─╖ ┌───╖   └─┬─┘  ╘═╤═╝ ├───┐ │  │  ╔═╧═╗  ╔═══╗  ┌─┴─╖      │
├─┤   ├─┤ · ╟─┤ ♯ ╟─────┘    ┌─┴─╖ │   │ │  └──╢ 1 ║  ║ 0 ╟──┤ ? ╟──────┘
│ └───┘ ╘═╤═╝ ╘═══╝  ┌───────┤ · ╟─┴─┐ │ │     ╚═══╝  ╚═══╝  ╘═╤═╝
│       ┌─┴─╖      ┌─┴─╖     ╘═╤═╝   │ │ └─────────────────┐   │
│  ┌────┤ · ╟──────┤ · ╟──┐    │     │ └────────┐          │
│  │    ╘═╤═╝      ╘═╤═╝  │    │     └────┐     │          │
│  └───┬──┴──┐       │    │    │        ┌─┴──╖  │          │
│      │    ┌┴┐      │    │    └─────┬──┤ << ║  │          │
│      │    └┬┘      │    │         ┌┴┐ ╘═╤══╝  │          │
│    ┌─┴─╖ ┌─┴─╖   ┌─┴─╖  │         └┬┘ ╔═╧═╗   │          │
└────┤ · ╟─┤ ? ╟─┐ │ ♯ ║  ├──────────┤  ║ 1 ║   │          │
╘═╤═╝ ╘═╤═╝ │ ╘═╤═╝ ┌┴┐         │  ╚═══╝   │          │
│     │   │ ┌─┴─╖ └┬┘         │          │          │
│     │   └─┤ ? ╟──┘        ┌─┴─╖        │          │
│     │     ╘═╤═╝     ┌─────┤ > ╟─────┬──┘          │
│     │     ┌─┴─╖   ┌─┴─╖   ╘═══╝     ├─────────┐   │
┌─┴─╖   └─────┤ · ╟───┤ · ╟─────────────┘         │   │
┌─┤ · ╟─────┐   ╘═╤═╝   ╘═╤═╝                       │   │
│ ╘═╤═╝  ┌──┴─╖ ┌─┴─╖     │                         │   │
│   │    │ >> ╟─┤ ▒ ╟──┐  ├─────────────┐         ┌─┴─╖ │
│   │    ╘══╤═╝ ╘═╤═╝  ├──┘             │ ╓───╖ ┌─┤ · ╟─┤
│   │       │   ┌─┴─╖  │                ├─╢ ▒ ╟─┤ ╘═╤═╝ │
│   │       └───┤ · ╟──┘                │ ╙─┬─╜ │   │   │
│   │           ╘═╤═╝                   │   │ ┌─┴─╖ │   │
│   │           ┌─┴─╖                   │   └─┤ · ╟─┤   │
│   │        ┌──┤   ╟────────────┐      │     ╘═╤═╝ │   │
│   │        │  └─┬─╜  ┌───╖   ┌─┴─╖  ┌─┴─╖   ┌─┴─╖ │   │
│   └──────┐ │    └────┤ ‼ ╟───┤ · ╟──┤ · ╟───┤ ▓ ╟─┘   │
│          │ │         ╘═╤═╝   ╘═╤═╝  ╘═╤═╝   ╘═╤═╝     │
│          │ │  ╔═══╗  ┌─┴─╖     │      └───────┘       │
│          │ └──╢ 0 ╟──┤ ? ╟─┐   │                      │
│          │    ╚═══╝  ╘═╤═╝ │ ┌─┴─╖                    │
│ ╔═══╗    │           ┌─┴─╖ ├─┤ · ╟─┐                  │
│ ║ 2 ║    │      ┌────┤ · ╟─┘ ╘═╤═╝ ├──────────────────┘
│ ╚═╤═╝    │      │    ╘═╤═╝     │   │
│ ┌─┴─╖  ┌─┴─╖  ┌─┴─╖  ╔═╧═╕ ┌─┐ │   │
│ │ + ╟──┤ ? ╟──┤ ? ╟──╢   ├─┴─┘ │   │
│ ╘═╤═╝  ╘═╤═╝  ╘═╤═╝  ╚═╤═╛     │   │
│   └──┬───┘    ╔═╧═╗    │       │   │
│      │        ║ 0 ║            │   │
│      │        ╚═══╝            │   │
│      └─────────────────────────┘   │
└────────────────────────────────────┘        ╓┬──╖
┌────────────────────────────────────────────────╫┘▓ ╟────────────┐
│ ╔═══════════╗        ╔════════════════════╗    ╙─┬─╜            │
│ ║ 387759291 ║        ║ 385690484238253342 ║      │              │
│ ║ 565251600 ║    ┌───╢ 839653020379129116 ║      │    ┌────┐    │
│ ║ 199735775 ║  ┌─┴─╖ ╚════════════════════╝      │    │   ┌┴┐   │
│ ║ 904933210 ╟──┤ ? ╟────────────────┐            │    │   └┬┘   │
│ ╚═══════════╝  ╘═╤═╝    ┌──────┐    ├────────────┴────┘  ┌─┴─╖  │
│ ╔═══════════╗  ┌─┴─╖  ┌─┴─╖  ╔═╧═╗  │  ╔════╗    ╔═══╗   │ ♯ ║  │
│ ║ 388002680 ╟──┤ ? ╟──┤ ≠ ║  ║ 1 ║  │  ║ 21 ║  ┌─╢ 1 ║   ╘═╤═╝  │
│ ║ 480495420 ║  ╘═╤═╝  ╘═╤═╝  ╚═══╝  │  ╚═╤══╝  │ ╚═══╝    ┌┴┐   │
│ ║ 244823142 ║    │      ├───────────┘    │     │          └┬┘   │
│ ║ 920365396 ║    │    ┌─┴─╖  ┌───╖     ┌─┴──╖  │ ┌────╖  ┌─┴─╖  │
│ ╚═══════════╝    └────┤ · ╟──┤ ‡ ╟─────┤ >> ║  └─┤ >> ╟──┤ · ╟──┴─┐
│ ╔═══════════╗ ┌───┐   ╘═╤═╝  ╘═╤═╝     ╘═╤══╝    ╘═╤══╝  ╘═╤═╝    │
│ ║ 618970314 ╟─┘ ┌─┴─╖ ┌─┘      │         │       ┌─┴─╖     │      │
│ ║ 790736054 ║ ┌─┤ ? ╟─┴─┐      │         ├───────┤ ▓ ╟─────┘      │
│ ║ 357861634 ║ │ ╘═╤═╝   │      │     ┌───┘       ╘═╤═╝            │
│ ╚═══════════╝ │ ┌─┴─╖ ┌─┴─╖  ┌─┴─╖ ┌─┴─╖         ┌─┴─╖     ╔═══╗  │
│ ╔═══════════╗ │ │ ‼ ╟─┤ · ╟──┤ ? ╟─┤ · ╟─────────┤ · ╟──┐  ║ 1 ║  │
│ ║ 618970314 ╟─┘ ╘═╤═╝ ╘═╤═╝  ╘═╤═╝ ╘═╤═╝         ╘═╤═╝  │  ╚═╤═╝  │
│ ║ 790736054 ║     │   ┌─┴─╖  ┌─┴─╖   │   ╓┬──╖    ┌┴┐  ┌┴┐   │    │
│ ║ 357861713 ║     └───┤ · ╟──┤ · ╟───┘ ┌─╫┘‡ ╟─┐  └┬┘  └┬┘   │    │
│ ╚═══════════╝         ╘═╤═╝  ╘═╤═╝     │ ╙───╜ │ ┌─┴─╖  └────┤    │
│ ╔════════════════╗    ┌─┴─╖  ┌─┴─╖     │ ┌───╖ │ │ ♯ ║       └────┘
│ ║ 43980492383490 ╟────┤ ? ╟──┤ ? ╟───┐ └─┤ ‼ ╟─┘ ╘═╤═╝
│ ╚════════════════╝    ╘═╤═╝  ╘═╤═╝   │   ╘═╤═╝    ┌┴┐
│ ╔════════════════╗      │      │     │     │      └┬┘
│ ║ 43980492383569 ╟──────┘            └──────┬──────┘
│ ╚════════════════╝                          │
└─────────────────────────────────────────────┘


## Explanation

• The main program finds the first two spaces and splits out the numbers. It runs the third (the pipe pattern) through ░ and then calls ▒ with the result, which returns the output as well as the number of turns taken. It then adds the text n turns were taken to get to the end., where n is the number of turns calculated by ▒.

• ░ takes a number and inserts a 0-bit after every 1-bit, thus ensuring there are never two horizontal pipes in succession.

• ▒ generates the output by successively calling ▓ and then shifting out the right number of bits from the pipe pattern until it is zero. It also increments or decrements the “current pipe” appropriately.

• ▓ generates one line of the output. In each iteration, it shifts out one bit from the pipe pattern and then decides whether to output │ (+ 4 spaces), ║ (+ 4 spaces), ├────┤, ╔════╝ or ╚════╗; in the latter three cases, it removes the first character from the next iteration. The last iteration generates │\r\n or ║\r\n as appropriate.

## Example output

Input:

6 3 73497529294753

Output:

├────┤    │    ║    │    │    │
├────┤    │    ╚════╗    ├────┤
│    ├────┤    ╔════╝    ├────┤
│    ├────┤    ║    │    │    │
│    │    │    ║    │    ├────┤
│    │    │    ║    ├────┤    │
│    ├────┤    ╚════╗    ├────┤
│    ├────┤    │    ║    │    │
│    ├────┤    ╔════╝    │    │
├────┤    ╔════╝    │    ├────┤
│    │    ║    │    │    ├────┤

10 turns were taken to get to the end.


Input:

3 0 65536

Output:

║    │    │    │
║    │    │    │
║    │    ├────┤

0 turns were taken to get to the end.


Input:

3 7 75203587360867 (pipe index out of range)

Output:

Impossiburu.


# Groovy, 311

t=System.in.text.collect{it.collect{it}};s=t.size();d=0;c=0;y=0;x=t[0].indexOf('|');println' '*x+'V'
while(y<s){t[y][x]=t[y][x]=='|'?':':'='
if(d){x+=d}else y++
if(y<s)if(d){if(t[y][x]=='|'){d=0;c++}}else if(t[y][x+1]=='-'){d=1;c++} else if(t[y][x-1]=='-'){d=-1;c++}}
t.each{println it.join()}println' '*x+'^'+c

• line 1: setup and find first |
• line 2: swap out replacement : or =
• line 3: move x/y to next pos (d=0=down,d=-1=left,d=1=right)
• line 4: find next direction
• line 5: print out results

Here it is formatted:

t=System.in.text.split('\n').collect{it.collect{it}}; s=t.size()
d=0; c=0; y=0; x=t[0].indexOf('|')
println ' '*x + 'V'
while (y<s) {
t[y][x] = t[y][x] == '|' ? ':' : '='
if (d) {x += d} else y++
if (y<s)
if (d) {if (t[y][x]=='|') {d = 0; c++}}
else if(t[y][x+1]=='-') {d = 1; c++}
else if(t[y][x-1]=='-') {d = -1; c++}
}
t.each {println it.join()}
println ' '*x + '^'+c


Output from the sample:

V
:       |       |-------|
:=======:       |-------|
|       :=======:       |
|-------|-------:=======:
|       |-------|       :
|-------|       :=======:
|-------|       :=======:
|       |-------|       :
^10


Other output:

V
:       |       |-------|       |
:=======:       |-------|       |
|       :=======:       |-------|
|-------|-------:=======:       |
|       |-------|       :=======:
|-------|       |-------|       :
|-------|       |-------|       :
|       |-------|       :=======:
|       |-------|       :       |
|       |       :=======:       |
|-------|       :       |       |
|       :=======:       |       |
|       :       |-------|       |
|       :=======:       |       |
^16


(I know I did code-golf instead of popularity, but that's just my style)

JavaScript

The HTML canvas listens for click events and finds the nearest row of pipes and uses that for the starting point. Output is drawn on the canvas and there is also a textarea containing the ASCII output defined by the OP.

The algorithm will ensure that there are never two connecting horizontal pipes. Other than that restriction, a probability is defined in the initial variables and that is used to randomly determine whether a horizontal pipe should occur or not.

JSFIDDLE

<html>
<script type="text/javascript">
var     WIDTH       = 20,
HEIGHT      = 15,
JUNCTIONS   = [],
PROBABILITY = 0.2,
COLOR1      = '#00DD00',
COLOR2      = '#DD0000',
SPACING     = 20,
turns       = 0,
pipe        = 10,
canvas,
context;

function Junction( x, y ){
this.x = x;
this.y = y;
this.l = null;
this.r = null;

if ( y == 0 )
JUNCTIONS[x] = [];

JUNCTIONS[x][y] = this;

var l = this.left();
if ( x > 0 && l.l == null && Math.random() <= PROBABILITY )
{
this.l = l;
l.r = this;
}
}

Junction.prototype.left = function(){
return this.x == 0?null:JUNCTIONS[this.x-1][this.y];
}
Junction.prototype.right= function(){
return this.x == WIDTH-1?null:JUNCTIONS[this.x+1][this.y];
}
Junction.prototype.down = function(){
return this.y == HEIGHT-1?null:JUNCTIONS[this.x][this.y+1];
}
Junction.prototype.reset = function(){
this.entry = null;
this.exit = null;
}

Junction.prototype.followPipe = function( prev ){
this.entry = prev;
if ( prev === this.l || prev === this.r ) {
this.exit = this.down() || true;
turns++;
} else if ( this.l !== null ) {
this.exit = this.l;
turns++;
} else if ( this.r !== null ) {
this.exit = this.r;
turns++;
} else
this.exit = this.down() || true;
console.log( this.exit );
if ( this.exit !== true )
this.exit.followPipe( this );
}

Junction.prototype.toString = function(){
if ( this.entry === null ){
if ( this.r === null )  return '|  ';
return '|--';
} else {
if ( this.r === null )  return ':  ';
return ':==';
}
}

function init(){
for ( var x = 0; x < WIDTH; ++x )
for ( var y = 0; y < HEIGHT; ++y )
new Junction( x, y );

canvas  = document.getElementById('canvas');
context = canvas.getContext('2d');

draw();
}

function draw( evt ){
for ( var x = 0; x < WIDTH; ++x )
for ( var y = 0; y < HEIGHT; ++y )
JUNCTIONS[x][y].reset();

if ( evt ){
pipe = Math.round((evt.clientX - canvas.getBoundingClientRect().left)/SPACING)-1;
if ( pipe < 0 )     pipe = 0;
if ( pipe >= WIDTH )    pipe = WIDTH - 1;
}

turns = 0;
JUNCTIONS[pipe][0].followPipe( true );

context.clearRect(0, 0, canvas.width, canvas.height);
context.lineWidth = 2;

for ( var y = 0; y < HEIGHT; ++y ) {
for ( var x = 0; x < WIDTH; ++x ) {
var j = JUNCTIONS[x][y];
e = j.entry;

if ( j.r !== null ){
context.beginPath();
context.strokeStyle = e===null?COLOR1:COLOR2;
context.moveTo(SPACING*(x+1), SPACING*(y+1));
context.lineTo(SPACING*(x+2), SPACING*(y+1));
context.stroke();
}

if ( y > 0 ){
context.beginPath();
context.strokeStyle = (e===JUNCTIONS[x][y-1])?COLOR2:COLOR1;
context.moveTo(SPACING*(x+1), SPACING*(y));
context.lineTo(SPACING*(x+1), SPACING*(y+1));
context.stroke();
}
}
}

for ( var y = 0; y < HEIGHT; ++y ) {
for ( var x = 0; x < WIDTH; ++x ) {
context.beginPath();
context.arc(SPACING*(x+1), SPACING*(y+1), RADIUS, 0, 2*Math.PI, false);
context.fillStyle = JUNCTIONS[x][y].entry===null?COLOR1:COLOR2;
context.fill();
}
}

var h = [];
for ( var x = 0; x < WIDTH; ++x )
h.push( x!=pipe?'   ':'v  ' );
h.push( '\n' );
for ( var y = 0; y < HEIGHT; ++y ) {
for ( var x = 0; x < WIDTH; ++x )
h.push( JUNCTIONS[x][y].toString() )
h.push( '\n' );
}
for ( var x = 0; x < WIDTH; ++x )
h.push( JUNCTIONS[x][HEIGHT-1].exit!==true?'   ':'^  ' );
h.push( '\n' );
h.push( turns + ' turns were taken to get to the end.' );
document.getElementById( 'output' ).value = h.join( '' );
}