int[] ParseLayers(string filename)
{
var intermediate = new List <Tuple <int, int> >();
FileIterator.ForEachLine <string>(filename, line =>
{
var spec = line.Split(new char[] { ':', ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (spec.Length != 2)
{
Oh.ForFucksSake();
}
var range = int.Parse(spec[0]);
var depth = int.Parse(spec[1]);
intermediate.Add(new Tuple <int, int>(range, depth));
});
var r = new int[intermediate.Last().Item1 + 1];
foreach (var t in intermediate)
{
r[t.Item1] = t.Item2;
}
return(r);
}
void ExecInstruction(VM vm)
{
var command = vm.prog[vm.ip].Split(' ');
switch (command[0])
{
case "set":
set(vm, command);
break;
case "sub":
sub(vm, command);
break;
case "mul":
mul(vm, command);
break;
case "jnz":
jnz(vm, command);
break;
default:
Oh.WhatTheFuck();
break;
}
}
int CharToInt(char c)
{
switch (c)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
return(c - '0');
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
return(10 + (c - 'a'));
}
Oh.ShttingHell();
return(-1);
}
public GuardEvent(string details)
{
var matches = details.Match(@"\[(.+)\] (.+)");
if (matches.Groups.Count != 3)
{
Oh.Bugger();
}
Time = DateTime.ParseExact(matches.Groups[1].Value, "yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture);
var desription = matches.Groups[2].Value;
if (desription == "falls asleep")
{
Type = GuardEventType.Asleep;
Id = -1;
}
else if (desription == "wakes up")
{
Type = GuardEventType.Awake;
Id = -1;
}
else
{
Type = GuardEventType.BeginShift;
Id = int.Parse(desription.Match(@"#(\d+)").Groups[1].Value);
}
}
int SkipGarbage(string input, int start)
{
var offset = start + 1;
while (true)
{
if (offset == input.Length)
{
Oh.Bollocks();
}
switch (input[offset])
{
case '>':
removeCharacters += (offset - start) - 1;
return(offset - start);
case '!':
removeCharacters -= 2;
offset += 2;
break;
default:
offset++;
break;
}
}
}
static int CalcJolts(string input)
{
var prevJolt = 0;
var jump1 = 0;
var jump3 = 1; // Include the final 3 jolt jump up front
foreach (var jolt in FileIterator.Lines <int>(input).OrderBy((v) => v))
{
switch (jolt - prevJolt)
{
case 1:
jump1++;
break;
case 2:
break;
case 3:
jump3++;
break;
default:
Oh.Bugger();
break;
}
prevJolt = jolt;
}
return(jump1 * jump3);
}
public void Execute(Instruction[] prog, bool part2)
{
foreach (var instuction in prog)
{
switch (instuction.Op)
{
case Operation.Mem:
if (part2)
{
SetMemRecursive(0, 0, instuction.OperandA, instuction.OperandB);
}
else
{
var value = instuction.OperandB;
value &= AndMask;
value |= OrMask;
Mem[instuction.OperandA] = value;
}
break;
case Operation.Mask:
AndMask = instuction.OperandA;
OrMask = instuction.OperandB;
Mask = instuction.Mask;
break;
default:
Oh.Bugger();
break;
}
}
}
CellState[,] LoadEnvironment(string inputFile)
{
var lines = FileIterator.LoadLines <string>(inputFile);
var environment = new CellState[lines[0].Length, lines.Length];
foreach (var(x, y) in environment.Rectangle())
{
switch (lines[y][x])
{
case '.':
environment[x, y] = CellState.Clear;
break;
case '|':
environment[x, y] = CellState.Tree;
break;
case '#':
environment[x, y] = CellState.LumberYard;
break;
default:
Oh.Bugger();
break;
}
}
return(environment);
}
GridWriter CreateWriter(string pattern)
{
return((grid, x, y) =>
{
var cX = x;
var cY = y;
foreach (var c in pattern)
{
switch (c)
{
case '.':
grid[cX++, cY] = false;
break;
case '#':
grid[cX++, cY] = true;
break;
case '/':
cX = x;
cY++;
break;
default:
Oh.Bollocks();
break;
}
}
});
}
void ParseRule(GridRules rules, string rule)
{
var fromTo = rule.Replace(" => ", "|").Split('|');
var rotations = CreateRotations(fromTo[0]);
var writer = CreateWriter(fromTo[1]);
foreach (var rotation in rotations)
{
if (rules.ContainsKey(rotation))
{
Oh.Bugger();
}
rules[rotation] = writer;
}
}
public void Problem1(string input, long expected)
{
var vmState = new VmState();
var prog = LoadProgram(input);
try
{
ExecuteUntilLoop(vmState, prog);
Oh.Bugger();
}
catch (Utils.VM.Halt)
{
vmState.Acc.Should().Be(expected);
}
}
char[] NextPos(string action, char[] current)
{
switch (action[0])
{
case 's':
return(Shift(int.Parse(action.Substring(1)), current));
case 'x':
return(Exchange(action.Substring(1), current));
case 'p':
return(ExchangeByName(action.Substring(1), current));
}
Oh.ShttingHell();
return(null);
}
static string Reduce(int[] input)
{
if (input.Length != 256)
{
Oh.ForFucksSake();
}
var reduced = new byte[16];
for (var i = 0; i < 16; i++)
{
for (var j = 0; j < 16; j++)
{
reduced[i] ^= (byte)input[(i * 16) + j];
}
}
return(BitConverter.ToString(reduced).Replace("-", "").ToLower());
}
string FollowPath(Map map, int entryPoint, out int numSteps)
{
var result = "";
var x = entryPoint;
var y = 0;
var dX = 0;
var dY = 1;
numSteps = 0;
while (true)
{
var c = map.GetCell(x, y);
switch (c)
{
case '|':
case '-':
break;
case '+':
ChangeDirection(map, x, y, ref dX, ref dY);
break;
case ' ':
return(result);
default:
if (IsLetter(c))
{
result += c;
}
else
{
Oh.Bollocks();
}
break;
}
x += dX;
y += dY;
numSteps++;
}
}
public void Step(char currentLocation)
{
switch (currentLocation)
{
case '/':
if (dX == 0)
{
TurnRight();
}
else
{
TurnLeft();
}
break;
case '\\':
if (dX == 0)
{
TurnLeft();
}
else
{
TurnRight();
}
break;
case '+':
UpdateCrossing();
break;
case '.':
break;
default:
Oh.ShttingHell();
break;
}
x += dX;
y += dY;
}
void ChangeDirection(Map map, int x, int y, ref int dX, ref int dY)
{
if (dX == 0)
{
var left = map.GetCell(x - 1, y);
var right = map.GetCell(x + 1, y);
if (left == '-' || IsLetter(left))
{
dX = -1;
dY = 0;
}
else if (right == '-' || IsLetter(right))
{
dX = 1;
dY = 0;
}
else
{
Oh.WhatTheFuck();
}
}
else
{
var up = map.GetCell(x, y - 1);
var down = map.GetCell(x, y + 1);
if (up == '|' || IsLetter(up))
{
dX = 0;
dY = -1;
}
else if (down == '|' || IsLetter(down))
{
dX = 0;
dY = 1;
}
else
{
Oh.Bugger();
}
}
}
public Request(string request)
{
var split = request.Split('@', ',', ':', 'x');
if (split.Length != 5)
{
Oh.Bugger();
}
Id = int.Parse(split[0].Substring(1));
Pos = new int[]
{
int.Parse(split[1]),
int.Parse(split[2])
};
Size = new int[]
{
int.Parse(split[3]),
int.Parse(split[4])
};
}
void ExecInstruction(VM vm)
{
var command = vm.prog[vm.ip].Split(' ');
switch (command[0])
{
case "snd":
snd(vm, command);
break;
case "set":
set(vm, command);
break;
case "add":
add(vm, command);
break;
case "mul":
mul(vm, command);
break;
case "mod":
mod(vm, command);
break;
case "rcv":
rcv(vm, command);
break;
case "jgz":
jgz(vm, command);
break;
default:
Oh.WhatTheFuck();
break;
}
}
public Cart(int x, int y, char initialDirection)
{
this.x = x;
this.y = y;
switch (initialDirection)
{
case '<':
dX = -1;
dY = 0;
break;
case '>':
dX = 1;
dY = 0;
break;
case '^':
dX = 0;
dY = -1;
break;
case 'v':
case 'V':
dX = 0;
dY = 1;
break;
default:
Oh.Bugger();
break;
}
crossingAction = new Action[]
{
TurnLeft,
() => { },
TurnRight
};
}
public Stroke(string input)
{
var match = input.Match(@"(.)=(\d+), .=(\d+)\.\.(\d+)");
if (match.Groups.Count != 5)
{
Oh.Bugger();
}
Horizontal = match.Groups[1].Value == "y";
if (Horizontal)
{
StartY = int.Parse(match.Groups[2].Value);
StartX = int.Parse(match.Groups[3].Value);
}
else
{
StartX = int.Parse(match.Groups[2].Value);
StartY = int.Parse(match.Groups[3].Value);
}
Extent = int.Parse(match.Groups[4].Value);
}
Graph <int> BuildGraph(string key)
{
var graph = new Graph <int>();
for (var y = 0; y < GridSize; y++)
{
var rowKey = $"{key}-{y}";
var hash = Hash(rowKey);
if (hash.Length != 32)
{
Oh.ShttingHell();
}
var x = 0;
foreach (var ic in hash)
{
var c = CharToInt(ic);
for (var bit = 0; bit < 4; bit++)
{
if ((c & 8) == 8)
{
var id = GetNodeId(x, y);
graph.AddNode(id);
var children = GetChildren(x, y, graph);
foreach (var linkId in children)
{
graph.AddTwoWayLink(id, linkId);
}
}
c <<= 1;
x++;
}
}
}
return(graph);
}
int Solve(string[] steps)
{
var x = 0;
var y = 0;
// Follow path
for (var i = 0; i < steps.Length; i++)
{
switch (steps[i])
{
case "nw":
if ((x & 1) == 0)
{
y--;
}
x--;
break;
case "n":
y--;
break;
case "ne":
if ((x & 1) == 0)
{
y--;
}
x++;
break;
case "sw":
if ((x & 1) == 1)
{
y++;
}
x--;
break;
case "s":
y++;
break;
case "se":
if ((x & 1) == 1)
{
y++;
}
x++;
break;
default:
Oh.PissingNora();
break;
}
if (Math.Abs(maxX) < Math.Abs(x))
{
maxX = x;
}
if (Math.Abs(maxY) < Math.Abs(y))
{
maxY = y;
}
}
return(WalkBack(x, y));
}
