public virtual string Solve()
{
var directions = _parser.GetData().Split(", ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
var q = 0;
var r = 0;
foreach (var direction in directions)
{
switch (direction)
{
case "n": q++; break;
case "nw": q++; r--; break;
case "ne": r++; break;
case "s": q--; break;
case "sw": r--; break;
case "se": q--; r++; break;
}
}
return(new AxialHexCoordinate(q, r)
.GetDistanceTo(new AxialHexCoordinate(0, 0))
.ToString());
}
public virtual string Solve()
{
foreach (var line in _parser.GetData().ToArray())
{
var parts = line.Split(' ');
var commandRegister = parts[0];
var command = parts[1];
var commandValue = int.Parse(parts[2]);
var evalRegister = parts[4];
var evalOperator = parts[5];
var evalValue = int.Parse(parts[6]);
if (!Registers.ContainsKey(commandRegister))
{
Registers[commandRegister] = 0;
}
if (!Registers.ContainsKey(evalRegister))
{
Registers[evalRegister] = 0;
}
if (EvaluateCondition(evalRegister, evalOperator, evalValue))
{
UpdateRegister(commandRegister, command, commandValue);
}
}
return(Registers.Values.Max().ToString());
}
public virtual string Solve()
{
var lines = Parser.GetData();
var adjacencyList = BuildAdjacencyList(lines);
return(GetNumberOfNodesThatRouteToZero(adjacencyList).ToString());
}
public virtual string Solve()
{
var lines = _parser.GetData();
var mapping = new Dictionary <string, string>();
foreach (var line in lines)
{
var parts = line.Split(new [] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var name = parts[0];
//var weight = parts[1].Remove(0).Remove(parts[1].Length - 1);
if (parts.Length > 2)
{
for (var i = 3; i < parts.Length; i++)
{
var discAbove = parts[i];
if (discAbove.EndsWith(","))
{
discAbove = discAbove.Remove(discAbove.Length - 1);
}
mapping.Add(discAbove, name);
}
}
}
foreach (var holder in mapping.Values)
{
if (!mapping.ContainsKey(holder))
{
return(holder);
}
}
return("nope");
}
public virtual string Solve()
{
var computer = new Computer(Parser.GetData().ToArray());
computer.Run();
return(computer.LastRecovered.ToString());
}
public virtual string Solve()
{
var computer = new Computer(Parser.GetData().ToArray());
computer.Run();
return(computer.MultiplyCount.ToString());
}
public virtual string Solve()
{
var stream = _parser.GetData();
var garbage = false;
var garbageCount = 0;
for (var index = 0; index < stream.Length; index++)
{
var c = stream[index];
if (c == '!')
{
index++;
continue;
}
if (garbage)
{
if (c == '>')
{
garbage = false;
}
else
{
garbageCount++;
}
}
else if (c == '<')
{
garbage = true;
}
}
return(garbageCount.ToString());
}
public virtual string Solve()
{
var data = _parser.GetData().Split(',').Select(int.Parse).ToArray();
List <int> program;
var max = int.MinValue;
foreach (var phaseSetting in EnumeratePhaseSettings())
{
var input = 0;
var output = 0;
for (var i = 0; i < 5; i++)
{
program = data.ToList();
output = IntcodeProcessor.Compute(program, input, phaseSetting[i]);
input = output;
}
if (output > max)
{
max = output;
}
}
return(max.ToString());
}
public virtual string Solve()
{
var input = Parser.GetData().ToCharArray();
// 25 x 6
var numPixels = 25 * 6;
var numLayers = input.Length / numPixels;
var minZeroes = int.MaxValue;
var result = 0;
for (var i = 0; i < numLayers; i++)
{
var layerCounts = new Dictionary <char, int> {
{ '0', 0 }, { '1', 0 }, { '2', 0 }
};
for (var j = numPixels * i; j < numPixels * i + numPixels; j++)
{
layerCounts[input[j]]++;
}
if (layerCounts['0'] < minZeroes)
{
minZeroes = layerCounts['0'];
result = layerCounts['2'] * layerCounts['1'];
}
}
return(result.ToString());
}
public virtual string Solve()
{
var input = Parser.GetData();
var scannerRanges = new Dictionary <int, int>();
var max = 0;
foreach (var depth in input)
{
var parts = depth
.Split(new[] { ": " }, StringSplitOptions.RemoveEmptyEntries)
.Select(int.Parse)
.ToArray();
scannerRanges.Add(parts[0], parts[1]);
max = parts[0];
}
var scannerLocations = new List <int>(new int[max + 1]);
var severity = 0;
for (var layer = 0; layer < scannerLocations.Count; layer++)
{
if (scannerRanges.ContainsKey(layer) && scannerLocations[layer] == 0)
{
severity += scannerRanges[layer] * layer;
}
//Console.WriteLine($"{layer}: {string.Join(", ", scannerLocations)}");
AdvanceScanners(scannerLocations, scannerRanges);
}
return(severity.ToString());
}
public virtual string Solve()
{
var orbits = new Dictionary <string, string>();
var orbitsInputs = _parser.GetData();
var bodies = new List <string>();
foreach (var orbit in orbitsInputs)
{
var parts = orbit.Split(')');
orbits.Add(parts[1], parts[0]);
if (!bodies.Contains(parts[0]))
{
bodies.Add(parts[0]);
}
if (!bodies.Contains(parts[1]))
{
bodies.Add(parts[1]);
}
}
var orbitCount = new Dictionary <string, int>();
orbitCount.Add("COM", 0);
foreach (var body in bodies)
{
if (body == "COM")
{
continue;
}
var found = false;
var count = 1;
var current = body;
while (!found)
{
if (orbits.ContainsKey(current))
{
var next = orbits[current];
if (orbitCount.ContainsKey(next))
{
count += orbitCount[next];
found = true;
}
else
{
count++;
}
current = next;
}
else
{
found = true;
}
}
orbitCount[body] = count;
}
return(orbitCount.Values.Sum().ToString());
}
public virtual string Solve()
{
var program = _parser.GetData().Split(',').Select(int.Parse).ToList();
var output = IntcodeProcessor.Compute(program, 1);
return(output.ToString());
}
public virtual string Solve()
{
var moves = Parser.GetData().Split(',');
DanceMoves = GetDanceMoves(moves, Programs);
PerformDance();
return(new string(Programs));
}
public virtual string Solve()
{
var program = Parser.GetData().Split(',').Select(long.Parse).ToList();
var arcade = new ArcadeGame(program);
arcade.Go();
return(arcade.BlockTileCount.ToString());
}
public virtual string Solve()
{
var lengths = Parser.GetData().ParseDelimitedInts(',').ToList();
var skipSize = 0;
var head = Enumerable.Range(0, 256).ToArray().BuildCircularList();
var current = head;
KnotHasher.KnotHash(lengths, ref current, ref skipSize);
return(GetProduct(head).ToString());
}
public virtual string Solve()
{
var program = Parser.GetData().Split(',').Select(long.Parse).ToList();
var robot = new PaintingRobot(program);
robot.Go();
return(robot.PaintedCells.ToString());
}
public virtual string Solve()
{
var data = _parser.GetData().Split(',').Select(long.Parse).ToArray();
var input = 1;
var program = data.ToList();
var amp = new IntcodeComputer(program, input);
amp.Compute();
return(amp.Output.ToString());
}
public virtual string Solve()
{
var total = 0;
foreach (var line in _parser.GetData())
{
var numbers = line.ParseDelimitedInts('\t');
numbers.MinMax(out int min, out int max);
total += max - min;
}
return(total.ToString());
}
public virtual string Solve()
{
var number = int.Parse(_parser.GetData());
var mapping = new Dictionary <int, Coordinate>(number);
var current = 1;
foreach (var coordinate in SpiralCoordinates.GenerateCounterClockwise(number))
{
mapping.Add(current++, coordinate);
}
return((Math.Abs(mapping[number].X - mapping[1].X) + Math.Abs(mapping[number].Y - mapping[1].Y)).ToString());
}
public virtual string Solve()
{
var input = Parser.GetData();
var count = 0;
for (var i = 0; i < 128; i++)
{
var hash = KnotHasher.ComputeKnotHash($"{input}-{i}");
var binary = hash.FromHexStringToBinaryString();
count += binary.Count(b => b == '1');
}
return(count.ToString());
}
public virtual string Solve()
{
var noun = 12;
var verb = 2;
var program = _parser.GetData().Split(',').Select(int.Parse).ToList();
program[1] = noun;
program[2] = verb;
var output = IntcodeProcessor.Compute(program, 1);
return(program[0].ToString());
}
public virtual string Solve()
{
var phrases = _parser.GetData().ToArray();
var count = 0;
foreach (var phrase in phrases)
{
if (!ContainsAnagrams(phrase))
{
count++;
}
}
return(count.ToString());
}
public virtual string Solve()
{
var range = _parser.GetData().Split('-').Select(int.Parse).ToArray();
var count = 0;
for (var i = range[0]; i < range[1]; i++)
{
if (IsValid(i))
{
count++;
}
}
return(count.ToString());
}
public virtual string Solve()
{
var lines = _parser.GetData();
var mapping = new Dictionary <string, List <string> >();
var discWeights = new Dictionary <string, int>();
foreach (var line in lines)
{
var parts = line.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var discHolding = parts[0];
var weightPart = parts[1].Remove(parts[1].Length - 1, 1).Remove(0, 1);
var weight = int.Parse(weightPart);
discWeights.Add(discHolding, weight);
if (parts.Length > 2)
{
for (var i = 3; i < parts.Length; i++)
{
var discBeingHeld = parts[i];
if (discBeingHeld.EndsWith(","))
{
discBeingHeld = discBeingHeld.Remove(discBeingHeld.Length - 1);
}
if (!mapping.ContainsKey(discHolding))
{
mapping[discHolding] = new List <string>();
}
mapping[discHolding].Add(discBeingHeld);
}
}
}
var result = "";
try
{
var top = "dgoocsw";
GetWeight(top, mapping, discWeights);
}
catch (Exception ex)
{
result = ex.Message;
}
return(result);
}
public virtual string Solve()
{
var number = int.Parse(_parser.GetData());
int current = 0;
foreach (var coordinate in SpiralCoordinates.GenerateCounterClockwise(number))
{
current = Math.Max(1, GetValueForCoordinates(coordinate.X, coordinate.Y));
if (current > number)
{
break;
}
_mapping.Add(coordinate, current);
}
return(current.ToString());
}
public virtual string Solve()
{
var input = _parser.GetData().Select(int.Parse).ToArray();
var nextInstruction = 0;
var steps = 0;
while (nextInstruction < input.Length)
{
var offset = input[nextInstruction];
input[nextInstruction]++;
nextInstruction += offset;
steps++;
}
return(steps.ToString());
}
public virtual string Solve()
{
var banks = FileParser.GetData().ParseDelimitedInts('\t').ToArray();
var seen = new HashSet <int>();
var hash = banks.CreateHash();
var count = 0;
while (!seen.Contains(hash))
{
seen.Add(hash);
hash = GetNextHash(banks);
count++;
}
return(count.ToString());
}
public virtual string Solve()
{
var spin = int.Parse(Parser.GetData());
var current = new Node <int>(0);
current.Next = current;
for (var i = 1; i <= Spins; i++)
{
for (var spinCount = 0; spinCount < spin; spinCount++)
{
current = current.Next;
}
current.Next = new Node <int>(i, current.Next);
current = current.Next;
}
return(current.Next.Value.ToString());
}
public string Solve()
{
var input = _parser.GetData().Trim();
var sum = 0;
var offset = input.Length / 2;
for (var i = 0; i < input.Length; i++)
{
var opposite = (i + offset) % input.Length;
if (input[i] == input[opposite])
{
sum += input[i] - '0';
}
}
return(sum.ToString());
}
public virtual string Solve()
{
var stream = _parser.GetData();
var depth = 0;
var garbage = false;
var score = 0;
for (var index = 0; index < stream.Length; index++)
{
var c = stream[index];
if (c == '!')
{
index++;
continue;
}
if (!garbage)
{
switch (c)
{
case '{':
depth++;
break;
case '}':
score += depth;
depth--;
break;
case '<':
garbage = true;
break;
}
}
else if (c == '>')
{
garbage = false;
}
}
return(score.ToString());
}