public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day5/ProblemB/input.txt");
string text = File.ReadAllText(inputPath);
HashSet <char> chars = new HashSet <char>();
for (int i = 0; i < text.Length; i++)
{
char c = Char.ToLower(text[i]);
if (!chars.Contains(c))
{
chars.Add(c);
}
}
int bestVal = Int32.MaxValue;
char bestC = ' ';
foreach (var c in chars)
{
int len = TestReaction(text, c);
if (len < bestVal)
{
bestVal = len;
bestC = c;
}
}
Console.WriteLine("Best pair to remove is " + bestC + " and it creates a polymer of length " + bestVal);
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day1/ProblemA/input.txt");
String[] lines = File.ReadAllLines(inputPath);
int sum = 0;
foreach (var line in lines)
{
string trim = line.Trim();
if (!String.IsNullOrEmpty(trim))
{
bool isPos = trim[0] == '+';
int parsed;
if (Int32.TryParse(trim.Substring(1), out parsed))
{
if (isPos)
{
sum += parsed;
}
else
{
sum -= parsed;
}
}
}
}
Log.WriteLine("Sum is " + sum);
}
public static void Solve()
{
int sum = 0;
string inputPath = FileUtils.GetProjectFilePath("Days/Day3/ProblemB/input.txt");
using (var reader = new System.IO.StreamReader(inputPath))
{
string line;
List <Rect> allRects = new List <Rect>();
while ((line = reader.ReadLine()) != null)
{
string input = line.Trim();
if (!String.IsNullOrEmpty(input))
{
var rect = new Rect(input);
MarkUsage(rect);
allRects.Add(rect);
}
}
foreach (var rect in allRects)
{
if (IsIsolated(rect))
{
Console.WriteLine(rect.Id + " had no overlaps");
}
}
}
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day23/ProblemA/input.txt");
string[] lines = File.ReadAllLines(inputPath);
int count = 0;
foreach (var line in lines)
{
string l = line.Trim();
if (!string.IsNullOrEmpty(l))
{
AllBots.Add(new Nanobot(l, count));
count++;
}
}
Log.WriteLine("Loaded " + AllBots.Count + " bots");
foreach (var bot in AllBots)
{
foreach (var candidate in AllBots)
{
bot.AddNeighborIfInRange(candidate);
}
}
AllBots.Sort(CompareByRange);
Log.WriteLine("Strongest bot is " + AllBots[0].Debug());
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day25/ProblemA/input.txt");
string[] lines = File.ReadAllLines(inputPath);
int count = 0;
for (int i = 0; i < lines.Length; i++)
{
string l = lines[i].Trim();
if (!string.IsNullOrEmpty(l))
{
_allPoints.Add(new Point(l, count));
count++;
}
}
Log.WriteLine("Added " + _allPoints.Count + " points");
const int targetDistance = 3;
for (int i = 0; i < _allPoints.Count; i++)
{
for (int j = 0; j < _allPoints.Count; j++)
{
if (i != j)
{
long dist = _allPoints[i].Distance(_allPoints[j]);
if (dist <= targetDistance)
{
_allPoints[i].Neighbors.Add(_allPoints[j]);
}
}
}
}
int constellationCount = 0;
foreach (var point in _allPoints)
{
Constellation existing;
if (!_membership.TryGetValue(point, out existing))
{
BuildConstellation(point, constellationCount);
constellationCount++;
}
}
int nonDegenerateCount = 0;
foreach (var c in _allConstellations)
{
if (c.Contents.Count > 1)
{
nonDegenerateCount++;
}
}
Log.WriteLine("Found " + constellationCount + " constellations - " + nonDegenerateCount + " were non degenerate");
}
public static void Solve()
{
int sum = 0;
string inputPath = FileUtils.GetProjectFilePath("Days/Day2/ProblemA/input.txt");
int[] histogramBuffer = new int[26]; // Simplifying assumption, our input is all lower case and only alphabetical
int twoCountSum = 0;
int threeCountSum = 0;
bool foundTwoCount;
bool foundThreeCount;
using (var reader = new System.IO.StreamReader(inputPath))
{
string line;
while ((line = reader.ReadLine()) != null)
{
GenerateChecksumOutputs(line.Trim(), histogramBuffer, out foundTwoCount, out foundThreeCount);
if (foundTwoCount)
{
twoCountSum++;
}
if (foundThreeCount)
{
threeCountSum++;
}
}
}
Log.WriteLine("Checksum is " + twoCountSum * threeCountSum);
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day10/ProblemA/input.txt");
String[] lines = File.ReadAllLines(inputPath);
string outpath = "/scratch/Day10Images";
DirectoryInfo di = new DirectoryInfo(outpath);
if (!di.Exists)
{
di.Create();
}
List <Point> points = new List <Point>();
foreach (var line in lines)
{
string l = line.Trim();
if (!string.IsNullOrEmpty(l))
{
points.Add(new Point(l));
}
}
for (int i = 0; i < FramesToSimulate; i++)
{
string fileName = i + ".png";
RenderGameboard(points, Path.Combine(outpath, fileName));
foreach (var p in points)
{
p.Advance();
}
}
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day15/ProblemA/input.txt");
String[] lines = File.ReadAllLines(inputPath);
CombatSimulation sim = new CombatSimulation(lines);
sim.DoSimulation();
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day8/ProblemB/input.txt");
string text = File.ReadAllText(inputPath);
string[] parts = text.Split(' ');
Tree t = new Tree(parts);
Log.WriteLine("Total value is " + t.TotalValue);
}
public static void Solve()
{
const int targetSumDistance = 10000;
string inputPath = FileUtils.GetProjectFilePath("Days/Day6/ProblemB/input.txt");
string[] lines = File.ReadAllLines(inputPath);
List <Point> points = new List <Point>();
int minX = Int32.MaxValue;
int minY = Int32.MaxValue;
int maxX = Int32.MinValue;
int maxY = Int32.MinValue;
foreach (var line in lines)
{
var p = new Point(line);
if (p.X < minX)
{
minX = p.X;
}
if (p.Y < minY)
{
minY = p.Y;
}
if (p.X > maxX)
{
maxX = p.X;
}
if (p.Y > maxY)
{
maxY = p.Y;
}
points.Add(p);
}
Log.WriteLine("Grid is between " + minX + "," + minY + " and " + maxX + "," + maxY);
HashSet <int> distances = new HashSet <int>();
int region = 0;
for (int i = minX; i <= maxX; i++)
{
for (int j = minY; j <= maxY; j++)
{
int sumDist = 0;
foreach (var p in points)
{
sumDist += p.ManhattanDistance(i, j);
}
if (sumDist < targetSumDistance)
{
region++;
}
}
}
Log.WriteLine("Total region size is " + region);
}
public static void Solve()
{
int sum = 0;
string inputPath = FileUtils.GetProjectFilePath("Days/Day13/ProblemA/input.txt");
String[] lines = File.ReadAllLines(inputPath);
MinecartSystem ms = new MinecartSystem(lines);
ms.Simulate();
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day1/ProblemB/input.txt");
String[] lines = File.ReadAllLines(inputPath);
int sum = 0;
bool found = false;
int iter = 0;
while (!found)
{
foreach (var line in lines)
{
string trim = line.Trim();
if (!String.IsNullOrEmpty(trim))
{
bool isPos = trim[0] == '+';
int parsed;
if (Int32.TryParse(trim.Substring(1), out parsed))
{
if (isPos)
{
sum += parsed;
}
else
{
sum -= parsed;
}
if (_seen.Contains(sum))
{
Log.WriteLine("Found a duplicate at " + sum);
found = true;
break;
}
else
{
_seen.Add(sum);
}
}
}
}
iter++;
if (found)
{
break;
}
else
{
Log.WriteLine("No duplicates found after " + iter + " iterations");
}
}
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day20/ProblemA/input.txt");
string input = File.ReadAllText(inputPath).Trim();
input = input.Substring(1, input.Length - 2);
Log.WriteLine("Generating all paths for " + input);
List <string> allPaths = new List <string>();
string inProgress = "";
try
{
AllPaths(String.Empty, input, allPaths);
}
catch (Exception ex)
{
Log.WriteLine("Caught exception " + ex.Message + " at " + ex.StackTrace.Substring(0, 1000));
return;
}
allPaths.Sort(CompareStringsByLength);
Log.WriteLine("Found " + allPaths.Count + " total paths - longest path was " + allPaths[0].Length);
foreach (var path in allPaths)
{
//Log.WriteLine(path);
}
/*
* int programStartPoint = sets * 4;
* for (int i = programStartPoint; i < allLines.Length; i++)
* {
* string line = allLines[i].Trim();
* if (!string.IsNullOrEmpty(line))
* {
* int[] commandArgs = InstructionTestSet.ParseCommand(line);
* string opCode = _opCodeIds[commandArgs[0]][0];
* var op = _allOpCodes[opCode];
* if (!op.Execute(commandArgs, registers))
* {
* Log.WriteLine("Failed to execute line " + i);
* }
* }
* }*/
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day9/ProblemA/input.txt");
string text = File.ReadAllText(inputPath);
string[] parts = text.Split(';');
_numPlayers = Int32.Parse(_numericRgx.Replace(parts[0], ""));
_highestMarble = Int32.Parse(_numericRgx.Replace(parts[1], ""));
Log.WriteLine("Starting a game with " + _numPlayers + " players and highest marble value " + _highestMarble);
DoInitialSetup();
PlayGame();
LogWinner();
}
public static void Solve()
{
using (var timer = new Timer("Day 1A Problem"))
{
int sum = 0;
string inputPath = FileUtils.GetProjectFilePath("Days/Day1/ProblemAExtra/input.txt");
foreach (string readLine in File.ReadLines(inputPath))
{
int result = 0;
if (int.TryParse(readLine, out result))
{
sum += result;
}
}
Log.WriteLine("Sum is " + sum);
}
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day15/ProblemB/input.txt");
String[] lines = File.ReadAllLines(inputPath);
int startingPower = 3;
for (int i = startingPower; i <= 1000; i++)
{
// TODO - This should be doing a binary search, but this problem has exhausted me :p
CombatSimulation sim = new CombatSimulation(lines, i);
var result = sim.DoSimulation();
Log.WriteLine("Completed simulation for attack power " + i + " Winner: " + result.Victor + " with alive elves " + result.ElfAliveCount + "/" + result.ElfParticipantCount);
if (result.Victor == 'E' && result.ElfAliveCount == result.ElfParticipantCount)
{
Log.WriteLine("Finished! - Final power was " + i);
}
}
}
public static void Solve()
{
int sum = 0;
string inputPath = FileUtils.GetProjectFilePath("Days/Day3/ProblemA/input.txt");
using (var reader = new System.IO.StreamReader(inputPath))
{
string line;
while ((line = reader.ReadLine()) != null)
{
string input = line.Trim();
if (!String.IsNullOrEmpty(input))
{
MarkUsage(new Rect(input));
}
}
}
Log.WriteLine(Overlaps.Count + " tiles were overlapping");
}
public static void Solve()
{
int sum = 0;
string inputPath = FileUtils.GetProjectFilePath("Days/Day2/ProblemB/input.txt");
List <string> allStrings = new List <string>();
using (var reader = new System.IO.StreamReader(inputPath))
{
string line;
while ((line = reader.ReadLine()) != null)
{
allStrings.Add(line.Trim());
}
}
bool pairFound = false;
for (int i = 0; i < allStrings.Count; i++)
{
for (int j = i + 1; j < allStrings.Count; j++)
{
if (ApproximatelyEqual(allStrings[i], allStrings[j]))
{
Log.WriteLine("Match found - common substring is " + GenerateCommonSubstring(allStrings[i], allStrings[j]));
pairFound = true;
break;
}
}
if (pairFound)
{
break;
}
}
if (!pairFound)
{
Log.WriteLine("No checksum found in data set");
}
}
public static void Solve()
{
const int WorkSlice = 1000000;
using (var timer = new Timer("Day 1A Problem"))
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day1/ProblemAExtra/input.txt");
String[] lines = File.ReadAllLines(inputPath);
List <Task <int> > lst = new List <Task <int> >();
int startLine = 0;
bool foundEnd = false;
while (true)
{
int endLine = startLine + WorkSlice;
if (endLine >= lines.Length)
{
endLine = lines.Length - 1;
foundEnd = true;
}
lst.Add(CreateJob(lines, startLine, endLine));
if (foundEnd)
{
break;
}
startLine = endLine + 1;
}
Task <int>[] tasks = lst.ToArray();
Log.WriteLine("Awaiting " + tasks.Length + " tasks");
Task.WaitAll(tasks);
int sum = 0;
for (int i = 0; i < tasks.Length; i++)
{
sum += tasks[i].Result;
}
Log.WriteLine("Sum is " + sum);
}
}
public static void Solve()
{
int sum = 0;
string inputPath = FileUtils.GetProjectFilePath("Days/Day16/ProblemA/input.txt");
string[] allLines = File.ReadAllLines(inputPath);
List <InstructionTestSet> tests = new List <InstructionTestSet>();
int sets = 0;
for (int i = 0; i < allLines.Length; i++)
{
string line = allLines[i];
if (line.StartsWith("Before"))
{
tests.Add(InstructionTestSet.Parse(allLines[i], allLines[i + 1], allLines[i + 2], sets));
sets++;
}
}
Log.WriteLine("Beginning " + tests.Count + " tests");
BuildOpCodes();
foreach (var set in tests)
{
PerformTest(set);
}
int totalAmbigious = 0;
foreach (var set in tests)
{
if (set.NumMatchingOpCodes >= 3)
{
totalAmbigious++;
}
//Log.WriteLine("Test number " + set.TestNumber + " had " + set.NumMatchingOpCodes + " matching opcodes");
}
Log.WriteLine(totalAmbigious + " tests had ambigious op codes");
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day5/ProblemA/input.txt");
string text = File.ReadAllText(inputPath);
int index = 0;
bool didReact;
while (index < text.Length)
{
didReact = false;
if (index > 0)
{
if (DoesReact(text[index], text[index - 1]))
{
didReact = true;
text = text.Remove(index, 1);
index--;
text = text.Remove(index, 1);
}
}
else if (index < text.Length - 1)
{
if (DoesReact(text[index], text[index + 1]))
{
didReact = true;
text = text.Remove(index + 1, 1);
text = text.Remove(index, 1);
}
}
if (!didReact)
{
index++;
}
}
Log.WriteLine(text.Length);
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day12/ProblemA/input.txt");
String[] lines = File.ReadAllLines(inputPath);
string initialState = lines[0];
initialState = initialState.Split(':')[1].Trim();
// Buffer out room equal to the number of generations we want to simulate
List <char> initialBuffer = new List <char>();
for (int i = 0; i <= NumGenerations + 1; i++)
{
initialBuffer.Add(Dead);
}
initialBuffer.AddRange(initialState.ToCharArray());
for (int i = 0; i <= NumGenerations + 1; i++)
{
initialBuffer.Add(Dead);
}
CurrentGeneration = initialBuffer.ToArray();
NextGeneration = initialBuffer.ToArray();
for (int i = 1; i < lines.Length; i++)
{
string l = lines[i].Trim();
if (!string.IsNullOrEmpty(l))
{
string rule = l.Substring(0, l.IndexOf('=')).Trim();
char outcome = l.Substring(l.IndexOf('>') + 1).Trim()[0];
Ruleset[rule] = outcome;
}
}
Log.WriteLine("Beginning simulation for initial state of size " + initialState.Length + " num generations: " + NumGenerations);
StringBuilder sb = new StringBuilder();
Log.WriteLine("[" + 0 + "]" + new String(CurrentGeneration));
for (int g = 1; g <= NumGenerations; g++)
{
for (int i = 0; i < CurrentGeneration.Length; i++)
{
if (i < 2 || i > CurrentGeneration.Length - 3)
{
NextGeneration[i] = CurrentGeneration[i];
continue;
}
sb.Clear();
sb.Append(CurrentGeneration[i - 2]);
sb.Append(CurrentGeneration[i - 1]);
sb.Append(CurrentGeneration[i]);
sb.Append(CurrentGeneration[i + 1]);
sb.Append(CurrentGeneration[i + 2]);
char outcome;
if (Ruleset.TryGetValue(sb.ToString(), out outcome))
{
NextGeneration[i] = outcome;
}
else
{
Log.WriteLine(i + " No rule for " + sb.ToString());
NextGeneration[i] = Dead;
}
}
NextGeneration.CopyTo(CurrentGeneration, 0);
string turn = g.ToString();
if (g < 10)
{
turn = "0" + turn;
}
Log.WriteLine("[" + turn + "]" + new String(CurrentGeneration));
}
int sum = 0;
for (int i = 0; i < CurrentGeneration.Length; i++)
{
if (CurrentGeneration[i] == Alive)
{
sum += (i - (NumGenerations + 2));
}
}
Log.WriteLine("Simulation completed check sum is " + sum);
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day20/ProblemB/input.txt");
string input = File.ReadAllText(inputPath).Trim();
for (int i = 0; i < _bestTiles.Length; i++)
{
_bestTiles[i] = Int32.MaxValue;
}
input = input.Substring(1, input.Length - 2);
Log.WriteLine("Generating all paths for " + input);
List <string> allPaths = new List <string>();
string inProgress = "";
try
{
AllPaths(String.Empty, 0, 0, input, allPaths);
}
catch (Exception ex)
{
Log.WriteLine("Caught exception " + ex.Message + " at " + ex.StackTrace.Substring(0, 1000));
return;
}
//allPaths.Sort(CompareStringsByLength);
//Log.WriteLine("Found " + allPaths.Count + " total paths - longest path was " + allPaths[0].Length);
int tx;
int ty;
int pathable = 0;
int minLen = 1000;
for (int i = 0; i < _bestTiles.Length; i++)
{
int len = _bestTiles[i];
if (len < Int32.MaxValue && len >= minLen)
{
pathable++;
}
}
Log.WriteLine("Found " + pathable + " rooms with a minumum length of " + minLen);
/*
* int programStartPoint = sets * 4;
* for (int i = programStartPoint; i < allLines.Length; i++)
* {
* string line = allLines[i].Trim();
* if (!string.IsNullOrEmpty(line))
* {
* int[] commandArgs = InstructionTestSet.ParseCommand(line);
* string opCode = _opCodeIds[commandArgs[0]][0];
* var op = _allOpCodes[opCode];
* if (!op.Execute(commandArgs, registers))
* {
* Log.WriteLine("Failed to execute line " + i);
* }
* }
* }*/
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day23/ProblemB/input.txt");
string[] lines = File.ReadAllLines(inputPath);
int count = 0;
foreach (var line in lines)
{
string l = line.Trim();
if (!string.IsNullOrEmpty(l))
{
Nanobot bot = new Nanobot(l, count);
AllBots.Add(bot);
count++;
}
}
using (var ctx = new Context())
{
using (var opt = ctx.MkOptimize())
{
ArithExpr X = (ArithExpr)ctx.MkConst("x", ctx.MkIntSort());
ArithExpr Y = (ArithExpr)ctx.MkConst("y", ctx.MkIntSort());
ArithExpr Z = (ArithExpr)ctx.MkConst("z", ctx.MkIntSort());
ArithExpr zero = (ArithExpr)ctx.MkNumeral(0, ctx.IntSort);
ArithExpr one = (ArithExpr)ctx.MkNumeral(1, ctx.IntSort);
ArithExpr negOne = (ArithExpr)ctx.MkNumeral(-1, ctx.IntSort);
List <ArithExpr> signals = new List <ArithExpr>();
foreach (var bot in AllBots)
{
ArithExpr dX = ctx.MkSub(X, (ArithExpr)ctx.MkNumeral(bot.X, ctx.MkIntSort()));
ArithExpr dY = ctx.MkSub(Y, (ArithExpr)ctx.MkNumeral(bot.Y, ctx.MkIntSort()));
ArithExpr dZ = ctx.MkSub(Z, (ArithExpr)ctx.MkNumeral(bot.Z, ctx.MkIntSort()));
ArithExpr aDX = (ArithExpr)ctx.MkITE(ctx.MkGe(dX, zero), dX, ctx.MkMul(dX, negOne));
ArithExpr aDY = (ArithExpr)ctx.MkITE(ctx.MkGe(dY, zero), dY, ctx.MkMul(dY, negOne));
ArithExpr aDZ = (ArithExpr)ctx.MkITE(ctx.MkGe(dZ, zero), dZ, ctx.MkMul(dZ, negOne));
ArithExpr dist = ctx.MkAdd(aDX, aDY, aDZ);
signals.Add((ArithExpr)ctx.MkITE(ctx.MkLe(dist, ctx.MkInt(bot.Range)), one, zero));
}
var totalSignals = ctx.MkAdd(signals);
opt.MkMaximize(totalSignals);
ArithExpr DX = (ArithExpr)ctx.MkITE(ctx.MkGe(X, zero), X, ctx.MkMul(X, negOne));
ArithExpr DY = (ArithExpr)ctx.MkITE(ctx.MkGe(Y, zero), Y, ctx.MkMul(Y, negOne));
ArithExpr DZ = (ArithExpr)ctx.MkITE(ctx.MkGe(Z, zero), Z, ctx.MkMul(Z, negOne));
ArithExpr distFromOrigin = ctx.MkAdd(DX, DY, DZ);
opt.MkMinimize(distFromOrigin);
opt.Check();
var model = opt.Model;
Log.WriteLine(model.ToString());
}
}
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day7/ProblemB/input.txt");
string[] lines = File.ReadAllLines(inputPath);
const int DepPivot = 5;
const int SubPivot = 36;
const int MaxRunningJobs = 5;
Job[] queue = new Job[26];
Job[] runnableQueue = new Job[26];
Job[] runningQueue = new Job[26];
int queuedJobs = 0;
int runnableJobs = 0;
int runningJobs = 0;
foreach (var line in lines)
{
string l = line.Trim();
if (string.IsNullOrEmpty(l))
{
continue;
}
char dep = line[DepPivot];
char subject = line[SubPivot];
Job depJob = queue[dep - CharIntegerOffset];
if (depJob == null)
{
depJob = new Job(dep);
queue[depJob.LetterId] = depJob;
queuedJobs++;
}
Job j = queue[subject - CharIntegerOffset];
if (j == null)
{
j = new Job(subject);
queue[j.LetterId] = j;
queuedJobs++;
}
j.AddDependency(depJob);
}
int totalSeconds = 0;
StringBuilder sb = new StringBuilder();
while (queuedJobs > 0 || runnableJobs > 0 || runningJobs > 0)
{
if (queuedJobs > 0)
{
for (int i = 0; i < queue.Length; i++)
{
if (queue[i] != null)
{
if (queue[i].Runnable)
{
var j = queue[i];
queue[i] = null;
runnableQueue[i] = j;
queuedJobs--;
runnableJobs++;
}
}
}
}
if (runnableJobs > 0 && runningJobs < MaxRunningJobs)
{
for (int i = 0; i < runnableQueue.Length; i++)
{
if (runnableQueue[i] != null)
{
var j = runnableQueue[i];
runnableQueue[i] = null;
runningQueue[i] = j;
runnableJobs--;
runningJobs++;
if (runningJobs >= MaxRunningJobs)
{
break;
}
}
}
}
if (runningJobs > 0)
{
for (int i = 0; i < runningQueue.Length; i++)
{
if (runningQueue[i] != null)
{
runningQueue[i].DoWork(totalSeconds);
if (runningQueue[i].IsComplete)
{
var completedJob = runningQueue[i];
runningQueue[i] = null;
runningJobs--;
for (int j = 0; j < queue.Length; j++)
{
if (queue[j] != null)
{
queue[j].MarkDependencyCompleted(completedJob);
}
}
}
}
}
totalSeconds++;
}
}
Log.WriteLine("Took " + MaxRunningJobs + " workers a total of " + totalSeconds + " seconds to complete");
}
public static void Solve()
{
int sum = 0;
string inputPath = FileUtils.GetProjectFilePath("Days/Day16/ProblemB/input.txt");
string[] allLines = File.ReadAllLines(inputPath);
List <InstructionTestSet> tests = new List <InstructionTestSet>();
int sets = 0;
for (int i = 0; i < allLines.Length; i++)
{
string line = allLines[i];
if (line.StartsWith("Before"))
{
tests.Add(InstructionTestSet.Parse(allLines[i], allLines[i + 1], allLines[i + 2], sets));
sets++;
}
}
BuildOpCodes();
//Log.WriteLine("Stage 1 - Figure out the minimum set of commands supported by the data");
foreach (var set in tests)
{
PerformTest(set);
int instructionId = set.Command[0];
List <string> existing;
if (_opCodeIds.TryGetValue(instructionId, out existing))
{
List <string> cp = new List <string>();
foreach (var str in existing)
{
if (set.MatchingOpCodes.Contains(str)) // Check to see if our hypothesis is still supported
{
cp.Add(str);
}
}
_opCodeIds[instructionId] = cp;
}
else
{
existing = new List <string>(); // This is the first time we have encountered this command, include all possible options
existing.AddRange(set.MatchingOpCodes);
_opCodeIds[instructionId] = existing;
}
}
//DumpOpCodeState();
//Log.WriteLine("Stage 2 - Repeatedly remove unique commands until we have everything disambiguated");
HashSet <string> removalList = new HashSet <string>();
while (OpCodesAreAmbiguous())
{
string toRemove = null;
foreach (var kvp in _opCodeIds)
{
if (kvp.Value.Count == 1 && !removalList.Contains(kvp.Value[0]))
{
toRemove = kvp.Value[0];
removalList.Add(kvp.Value[0]);
break;
}
}
if (toRemove == null)
{
break;
}
foreach (var kvp in _opCodeIds)
{
if (kvp.Value.Count > 1 && kvp.Value.Contains(toRemove))
{
kvp.Value.Remove(toRemove);
}
}
}
//Log.WriteLine("Finished figuring out commands");
//DumpOpCodeState();
int[] registers = new int[4];
int programStartPoint = sets * 4;
for (int i = programStartPoint; i < allLines.Length; i++)
{
string line = allLines[i].Trim();
if (!string.IsNullOrEmpty(line))
{
int[] commandArgs = InstructionTestSet.ParseCommand(line);
string opCode = _opCodeIds[commandArgs[0]][0];
var op = _allOpCodes[opCode];
if (!op.Execute(commandArgs, registers))
{
Log.WriteLine("Failed to execute line " + i);
}
}
}
Log.WriteLine("Program finished, register state is " + DumpRegisters(registers));
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day6/ProblemA/input.txt");
string[] lines = File.ReadAllLines(inputPath);
List <Point> points = new List <Point>();
int minX = Int32.MaxValue;
int minY = Int32.MaxValue;
int maxX = Int32.MinValue;
int maxY = Int32.MinValue;
foreach (var line in lines)
{
var p = new Point(line);
if (p.X < minX)
{
minX = p.X;
}
if (p.Y < minY)
{
minY = p.Y;
}
if (p.X > maxX)
{
maxX = p.X;
}
if (p.Y > maxY)
{
maxY = p.Y;
}
points.Add(p);
}
Log.WriteLine("Grid is between " + minX + "," + minY + " and " + maxX + "," + maxY);
Point bestPoint = null;
HashSet <int> distances = new HashSet <int>();
for (int i = minX; i <= maxX; i++)
{
for (int j = minY; j <= maxY; j++)
{
int closestDistance = Int32.MaxValue;
Point winningPoint = null;
//distances.Clear();
foreach (var p in points)
{
int dist = p.ManhattanDistance(i, j);
if (dist == closestDistance) // Bounce out if one or more distancs is duped
{
winningPoint = null;
continue;
}
//distances.Add(dist);
if (dist < closestDistance)
{
winningPoint = p;
closestDistance = dist;
}
}
if (winningPoint != null)
{
winningPoint.OwnedTerritory++;
if (bestPoint == null || bestPoint.OwnedTerritory < winningPoint.OwnedTerritory)
{
bestPoint = winningPoint;
}
}
}
}
Log.WriteLine("best point is " + bestPoint.X + "," + bestPoint.Y + " with territory " + bestPoint.OwnedTerritory);
}
public static void Solve()
{
_maxX = 2000;
string inputPath = FileUtils.GetProjectFilePath("Days/Day17/ProblemA/input.txt");
String[] lines = File.ReadAllLines(inputPath);
List <Vein> veins = new List <Vein>();
Int32 deepestY = Int32.MinValue;
_smallestYPoint = Int32.MaxValue;
foreach (var line in lines)
{
var l = line.Trim();
if (!string.IsNullOrEmpty(l) && !l.StartsWith('/'))
{
Vein v = new Vein(l);
if (v.MaxY > deepestY)
{
deepestY = v.MaxY;
}
if (v.MinY < _smallestYPoint)
{
_smallestYPoint = v.MinY;
}
veins.Add(v);
}
}
Log.WriteLine("Parsed " + veins.Count + " lowest vein was " + deepestY);
_maxY = deepestY + 1;
_largestYPoint = deepestY;
_tiles = new Tile[_maxX * _maxY];
for (int i = 0; i < _maxX; i++)
{
for (int j = 0; j < _maxY; j++)
{
Tile t = new Tile();
t.TileIndex = GetTileIndex(i, j);
t.X = i;
t.Y = j;
t.TileType = TileType.Sand;
_tiles[t.TileIndex] = t;
}
}
for (int i = 0; i < _tiles.Length; i++)
{
var t = _tiles[i];
t.Left = GetTile(t.X - 1, t.Y);
t.Bottom = GetTile(t.X, t.Y + 1);
t.Right = GetTile(t.X + 1, t.Y);
}
foreach (var vein in veins)
{
for (int i = vein.MinX; i <= vein.MaxX; i++)
{
for (int j = vein.MinY; j <= vein.MaxY; j++)
{
GetTile(i, j).TileType = TileType.Clay;
}
}
}
var fountain = GetTile(500, 0);
fountain.TileType = TileType.Fountain;
Flood(fountain, null);
RenderGameBoard();
Log.WriteLine("Total tiles flooded: " + FloodCount);
}
public static void Solve()
{
string inputPath = FileUtils.GetProjectFilePath("Days/Day12/ProblemB/input.txt");
String[] lines = File.ReadAllLines(inputPath);
string initialState = lines[0];
initialState = initialState.Split(':')[1].Trim();
// Buffer out room equal to the number of generations we want to simulate
List <char> initialBuffer = new List <char>();
for (int i = 0; i <= NumGenerations + 1; i++)
{
initialBuffer.Add(Dead);
}
initialBuffer.AddRange(initialState.ToCharArray());
for (int i = 0; i <= NumGenerations + 1; i++)
{
initialBuffer.Add(Dead);
}
CurrentGeneration = initialBuffer.ToArray();
NextGeneration = initialBuffer.ToArray();
for (int i = 1; i < lines.Length; i++)
{
string l = lines[i].Trim();
if (!string.IsNullOrEmpty(l))
{
string rule = l.Substring(0, l.IndexOf('=')).Trim();
char outcome = l.Substring(l.IndexOf('>') + 1).Trim()[0];
Ruleset[rule] = outcome;
}
}
Log.WriteLine("Beginning simulation for initial state of size " + initialState.Length + " num generations: " + NumGenerations);
StringBuilder sb = new StringBuilder();
int prevGenSum = 0;
int prevDelta = Int32.MaxValue;
const int targetSimilarFrames = 100;
int numSimFrames = 0;
//Log.WriteLine("["+0+"]" + new String(CurrentGeneration));
for (int g = 1; g <= NumGenerations; g++)
{
for (int i = 0; i < CurrentGeneration.Length; i++)
{
if (i < 2 || i > CurrentGeneration.Length - 3)
{
NextGeneration[i] = CurrentGeneration[i];
continue;
}
sb.Clear();
sb.Append(CurrentGeneration[i - 2]);
sb.Append(CurrentGeneration[i - 1]);
sb.Append(CurrentGeneration[i]);
sb.Append(CurrentGeneration[i + 1]);
sb.Append(CurrentGeneration[i + 2]);
char outcome;
if (Ruleset.TryGetValue(sb.ToString(), out outcome))
{
NextGeneration[i] = outcome;
}
else
{
Log.WriteLine(i + " No rule for " + sb.ToString());
NextGeneration[i] = Dead;
}
}
NextGeneration.CopyTo(CurrentGeneration, 0);
int currSum = GetCheckSum();
int delta = currSum - prevGenSum;
if (delta == prevDelta)
{
numSimFrames++;
if (numSimFrames == targetSimilarFrames)
{
Log.WriteLine("Convergence detected at generation " + g + " : " + delta);
long finalChecksum = currSum + (ProjectedGeneration - g) * delta;
Log.WriteLine("Projected checksum after " + ProjectedGeneration + " is " + finalChecksum);
break;
}
}
else
{
numSimFrames = 0;
}
prevGenSum = currSum;
prevDelta = delta;
}
//Log.WriteLine("Simulation completed check sum is " + sum);
}
public static void Solve()
{
int sum = 0;
string inputPath = FileUtils.GetProjectFilePath("Days/Day19/ProblemB/input.txt");
string[] allLines = File.ReadAllLines(inputPath);
/* NOTE - Leaving this with a description of how we arrived at the solution vs actual code (which will never really terminate)
*
* - Looked at assembly and register state
* - Converted into pseudo code
* - Converted pseudo code into C#
* - Dumped register state at various points
* - Deduced it was a sloppy way of calculating a sum of factors of a number
* - Factorized number by hand and summed in excel :)
*
* long r0 = 0;
* long r1 = 1;
* long r2 = 10551428;
* long r3 = 10550400;
* long r4 = 1;
*
* while(r1 < r2){
* r3 = r1 * r4;
* if(r3 == r2){
* r0 += r1;
* }
* r4++;
* if(r4 > r2){
* r1++;
* if (r1 % 100000 == 0)
* {
* Log.WriteLine("Iter register state " + r0 + "," + r1 + "," + r2 + "," + r3 + "," + r4);
* }
* }
* }
* Log.WriteLine("Final register state " + r0 + "," + r1 + "," + r2 + "," + r3 + "," + r4); */
/*
* List<Instruction> instructions = new List<Instruction>();
* int ip = -1;
* for(int i = 0; i < allLines.Length; i++)
* {
* string line = allLines[i].Trim();
* if (line.StartsWith("#ip"))
* {
* ip = Int32.Parse(line.Split(' ')[1]);
* }
* else
* {
* instructions.Add(Instruction.Parse(line));
* }
* }
*
*
* BuildOpCodes();
*
* int[] registers = new int[6];
* registers[0] = 1;
* Log.WriteLine("Beginning a program of " + instructions.Count + " length. Instruction pointer is at " + ip + " register state is " + DumpRegisters(registers));
*
*
* long instructionCount = 0;
* while (true)
* {
* int ipVal = registers[ip];
* if (ipVal < 0 || ipVal > instructions.Count)
* {
* break;
* }
*
*
*
* Instruction next = instructions[ipVal];
* var op = _allOpCodes[next.OpCode];
* if (!op.Execute(next.Arguments, registers))
* {
* Log.WriteLine("Failed to execute line " + ipVal);
* }
* instructionCount++;
* registers[ip]++;
* if (ipVal == 7)
* {
* Log.WriteLine("Executed " + op.Name + " line " + ipVal + " register state is " + DumpRegisters(registers));
* //break;
* }
* }
*
* /*
* int programStartPoint = sets * 4;
* for (int i = programStartPoint; i < allLines.Length; i++)
* {
* string line = allLines[i].Trim();
* if (!string.IsNullOrEmpty(line))
* {
* int[] commandArgs = InstructionTestSet.ParseCommand(line);
* string opCode = _opCodeIds[commandArgs[0]][0];
* var op = _allOpCodes[opCode];
* if (!op.Execute(commandArgs, registers))
* {
* Log.WriteLine("Failed to execute line " + i);
* }
* }
* }*/
//Log.WriteLine("Program finished, register state is " + DumpRegisters(registers) + " executed " + instructionCount);
}