public static ulong Solve(string text)
{
var memory = new ulong[64 * 1024];
var reader = new SpanStringReader(text);
while (!reader.IsEndOfFile())
{
var mask = CommonUtil.GetMask(ref reader);
while (!reader.IsEndOfFile() && !reader.PeekWord().SequenceEqual("mask"))
{
var(address, value) = CommonUtil.GetMemoryLine(ref reader);
value = ApplyMask(value, mask);
memory[address] = value;
}
}
var sum = 0UL;
for (var i = 0; i < memory.Length; ++i)
{
sum += memory[i];
}
return(sum);
}
public static int Solve(string text)
{
var buckets = new StackIntBucketSet(stackalloc int[2048]);
var reader = new SpanStringReader(text);
while (!reader.IsEndOfFile())
{
buckets.Add(int.Parse(reader.ReadWord(true)));
}
var differentials = new StackIntBucketSet(stackalloc int[4]);
var lastValue = buckets.HighestValue + 3;
var i = 0;
for (i = lastValue; i >= 0; i--)
{
if (buckets.Contains(i))
{
differentials.Add(lastValue - i);
lastValue = i;
}
}
differentials.Add(lastValue);
return(differentials[1] * differentials[3]);
}
public static ulong Solve(string text)
{
var memory = new Dictionary <ulong, ulong>();
var reader = new SpanStringReader(text);
while (!reader.IsEndOfFile())
{
var mask = CommonUtil.GetMask(ref reader);
while (!reader.IsEndOfFile() && !reader.PeekWord().SequenceEqual("mask"))
{
var(address, value) = CommonUtil.GetMemoryLine(ref reader);
foreach (var newAddress in ApplyPermutingMask((ulong)address, mask.ToArray()))
{
memory[newAddress] = value;
}
}
}
var sum = 0UL;
foreach (var value in memory.Values)
{
sum += value;
}
return(sum);
}
public static int Solve(string text)
{
var reader = new SpanStringReader(text);
const int cos90 = 0;
const int sin90 = 1;
(int X, int Y)pos = (0, 0);
(int X, int Y)waypoint = (10, 1);
while (!reader.IsEndOfFile())
{
var instruction = reader.ReadChar();
var magnitude = reader.ReadInt(true);
switch (instruction)
{
case 'N':
waypoint = (waypoint.X, waypoint.Y + magnitude);
break;
case 'S':
waypoint = (waypoint.X, waypoint.Y - magnitude);
break;
case 'E':
waypoint = (waypoint.X + magnitude, waypoint.Y);
break;
case 'W':
waypoint = (waypoint.X - magnitude, waypoint.Y);
break;
case 'L':
{
var count = magnitude / 90;
for (var i = 0; i < count; ++i)
{
waypoint = ((waypoint.X * cos90) - (waypoint.Y * sin90), (waypoint.X * sin90) + (waypoint.Y * cos90));
}
}
break;
case 'R':
{
var count = magnitude / 90;
for (var i = 0; i < count; ++i)
{
waypoint = ((waypoint.X * -cos90) - (waypoint.Y * -sin90), (waypoint.X * -sin90) + (waypoint.Y * -cos90));
}
}
break;
case 'F':
pos = (pos.X + (waypoint.X * magnitude), pos.Y + (waypoint.Y * magnitude));
break;
}
}
return(Math.Abs(pos.X) + Math.Abs(pos.Y));
}
public static (int Address, ulong Value) GetMemoryLine(ref SpanStringReader reader)
{
reader.ReadUntil('[', true);
var address = reader.ReadInt();
reader.ReadUntil('=', false);
reader.ReadChar(true);
var value = (ulong)reader.ReadInt(true);
return(address, value);
}
public static long Solve(string text)
{
var buckets = new StackIntBucketSet(stackalloc int[2048]);
var reader = new SpanStringReader(text);
while (!reader.IsEndOfFile())
{
buckets.Add(int.Parse(reader.ReadWord(true)));
}
var target = buckets.HighestValue;
buckets.Add(0);
buckets.Add(target + 3);
var routesAtNode = new StackLongBucketSet(stackalloc long[target + 5]);
routesAtNode.Add(0);
var combinations = 1L;
for (var i = 0; i <= target; i++)
{
if (!buckets.Contains(i))
{
continue;
}
var branches = 0;
var routesAtCurrentNode = routesAtNode[i];
if (buckets.Contains(i + 1))
{
routesAtNode.AddMultiple(i + 1, routesAtCurrentNode);
branches++;
}
if (buckets.Contains(i + 2))
{
routesAtNode.AddMultiple(i + 2, routesAtCurrentNode);
branches++;
}
if (buckets.Contains(i + 3))
{
routesAtNode.AddMultiple(i + 3, routesAtCurrentNode);
branches++;
}
combinations += routesAtCurrentNode * (branches - 1);
}
return(combinations);
}
public static long Solve(string text)
{
var backlog = new StackCircularBuffer <long>(stackalloc long[preambleSize]);
var reader = new SpanStringReader(text);
for (int i = 0; i < preambleSize; i++)
{
backlog.PushBack(long.Parse(reader.ReadWord(true)));
}
while (!reader.IsEndOfFile())
{
var num = long.Parse(reader.ReadWord(true));
bool found = false;
for (int i = 0; i < preambleSize; i++)
{
for (int j = 0; j < preambleSize; j++)
{
if (i != j && backlog[i] + backlog[j] == num)
{
found = true;
break;
}
}
if (found)
{
break;
}
}
if (found)
{
backlog.PushBack(num);
}
else
{
return(num);
}
}
return(-1);
}
public static void Solve(string text, long searchValue)
{
var backlog = new List <long>();
var reader = new SpanStringReader(text);
while (!reader.IsEndOfFile())
{
var num = long.Parse(reader.ReadWord(true));
backlog.Add(num);
}
var backlogCount = backlog.Count;
for (var i = 0; i < backlogCount; i++)
{
if (backlog[i] > searchValue)
{
continue;
}
var sum = backlog[i];
var min = backlog[i];
var max = backlog[i];
for (var j = i + 1; j < backlogCount; j++)
{
sum += backlog[j];
min = Math.Min(backlog[j], min);
max = Math.Max(backlog[j], max);
if (sum > searchValue)
{
break;
}
if (sum == searchValue)
{
Log.Information("Encryption weakness: {Value}", min + max);
return;
}
}
}
}
public static int Solve(string text)
{
var reader = new SpanStringReader(text);
Span <int> schedules = stackalloc int[2048];
var scheduleCount = 0;
var departure = reader.ReadInt(true);
while (!reader.IsEndOfFile())
{
var value = reader.ReadUntil(',', true);
if (value[0] == 'x')
{
continue;
}
schedules[scheduleCount++] = reader.ParseInt(value);
}
var closestScheduleValue = double.MaxValue;
var closestSchedule = -1;
for (var i = 0; i < scheduleCount; ++i)
{
var nextDepartureTime = Math.Ceiling(departure / (double)schedules[i]) * schedules[i];
var minutesToWait = nextDepartureTime - departure;
if (minutesToWait < closestScheduleValue)
{
closestScheduleValue = minutesToWait;
closestSchedule = i;
}
}
return(schedules[closestSchedule] * (int)closestScheduleValue);
}
public static ulong Solve(string text)
{
var reader = new SpanStringReader(text);
Span <(ulong Value, ulong Modulo)> schedules = stackalloc (ulong Value, ulong Modulo)[2048];
public static ReadOnlySpan <char> GetMask(ref SpanStringReader reader)
{
reader.ReadUntil('=', false);
reader.ReadChar(true);
return(reader.ReadWord(true));
}
public static int Solve(string text)
{
var reader = new SpanStringReader(text);
Span <(int Value, int Cell)> schedules = stackalloc (int Value, int Cell)[2048];
