public override async Task <string> Part2Async(string input)
{
var memory = IntMachineBase.ParseProgram(input);
memory[0] = 2; // Wake up
var intMachine = new SynchronousIntMachine(memory);
var map = await GetMap(intMachine);
await UpdateProgressAsync(.5, 1);
var(robotPos, robotChar) = map.First(x => RobotDirections.Contains(x.Value));
var robotDirection = Directions[Array.IndexOf(RobotDirections, robotChar)];
map[robotPos] = Scaffolding;
myGarbageCounter = char.MaxValue;
var path = await FollowPath(map, robotPos, robotDirection);
var commandData = await FindSlicing(path.ToArray());
var commands = commandData.Select(x => ConvertCommand(x.Command)).ToArray();
var movementRoutine = CreateMovementRoutine(commandData);
movementRoutine.ForEach(x => intMachine.InputQueue.Enqueue(x));
commands.SelectMany(x => x).ForEach(x => intMachine.InputQueue.Enqueue(x));
"n\n".ForEach(x => intMachine.InputQueue.Enqueue(x));
while (intMachine.RunUntilBlockOrComplete() != ReturnCode.Completed)
{
}
return(intMachine.OutputQueue.Last().ToString());
}
public override async Task <string> Part2Async(string input)
{
var stepRight = new Point(1, 0);
var stepDown = new Point(0, 1);
var memory = IntMachineBase.ParseProgram(input);
var startTop = GetStartPoint(memory);
var startBottom = startTop;
var margins = new List <(Point Top, Point Bottom)>();
var size = 100 - 1;
Point targetPoint;
while (true)
{
var top = GetTop(memory, startTop);
var bottom = GetBottom(memory, startBottom);
margins.Add((top, bottom));
startTop = top + stepRight;
startBottom = bottom + stepRight + stepDown;
if (IsUpdateProgressNeeded())
{
await UpdateProgressAsync(bottom.Y - top.Y, size * 2);
}
var currentMarginIndex = margins.Count - 1;
if (currentMarginIndex >= size && margins[currentMarginIndex - size].Bottom.Y >= top.Y + size)
{
targetPoint = new Point(margins[currentMarginIndex - size].Top.X, top.Y);
break;
}
}
return((targetPoint.X * 10000 + targetPoint.Y).ToString());
}
private static void SetupMachines(string input, out SynchronousIntMachine[] machines, out Queue <long>[] queues)
{
var memory = IntMachineBase.ParseProgram(input);
machines = Enumerable.Range(0, MachineCount).Select(_ => new SynchronousIntMachine(memory.ToArray())).ToArray();
queues = Enumerable.Range(0, MachineCount).Select(_ => new Queue <long>()).ToArray();
machines.WithIndex().ForEach(m => m.Item.InputQueue.Enqueue(m.Index));
}
public static async Task Run()
{
var input = (await File.ReadAllTextAsync("inputs\\19.txt"));
var mem = IntMachineBase.ParseProgram(input);
Dictionary <Point, bool> points = new Dictionary <Point, bool> ();
for (int y = 0; y < 50; y++)
{
for (int x = 0; x < 50; x++)
{
points.Add(new Point(x, y), IsPulling(mem, x, y));
}
}
Console.WriteLine("Part 1: " + points.Where(e => e.Value).Count());
Console.WriteLine("Part 2: " + CalcPart2(mem));
}
public override async Task <string> Part1Async(string input)
{
var memory = IntMachineBase.ParseProgram(input);
var sum = 0;
for (var y = 0; y < 50; y++)
{
for (var x = 0; x < 50; x++)
{
if (IsUpdateProgressNeeded())
{
await UpdateProgressAsync(x + y * 50, 50 * 50);
}
var isPulling = IsPulling(memory, x, y);
sum += isPulling ? 1 : 0;
}
}
return(sum.ToString());
}
public static async Task Run()
{
var input = (await File.ReadAllTextAsync("inputs\\23.txt"));
var machinecount = 50;
var addr = 255;
var memory = IntMachineBase.ParseProgram(input);
var machines = Enumerable.Range(0, machinecount).Select(_ => new SynchronousIntMachine(memory.ToArray())).ToArray();
var queues = Enumerable.Range(0, machinecount).Select(_ => new Queue <long> ()).ToArray();
machines.WithIndex().ForEach(m => m.Item.InputQueue.Enqueue(m.Index));
while (true)
{
foreach (var machine in machines)
{
foreach (var(address, _, y) in HandleOutgoingPackets(machine, queues, machinecount))
{
if (address == addr)
{
Console.WriteLine("Part 1: " + y.ToString());
goto part2;
}
}
}
HandleIncomingPackets(machines, queues);
}
part2:
machines = Enumerable.Range(0, machinecount).Select(_ => new SynchronousIntMachine(memory.ToArray())).ToArray();
queues = Enumerable.Range(0, machinecount).Select(_ => new Queue <long> ()).ToArray();
machines.WithIndex().ForEach(m => m.Item.InputQueue.Enqueue(m.Index));
(long X, long Y)natValue = default;
long?lastNatDeliveredY = null;
while (true)
{
var idleCount = 0;
foreach (var machine in machines)
{
if (machine.InputQueue.Count == 1 && machine.InputQueue.Single() == -1)
{
idleCount++;
}
foreach (var(address, x, y) in HandleOutgoingPackets(machine, queues, machinecount))
{
if (address == addr)
{
natValue = (x, y);
}
}
}
if (idleCount == machinecount)
{
if (natValue.Y == lastNatDeliveredY)
{
break;
}
queues [0].Enqueue(natValue.X);
queues [0].Enqueue(natValue.Y);
lastNatDeliveredY = natValue.Y;
}
HandleIncomingPackets(machines, queues);
}
Console.WriteLine("Part 2: " + lastNatDeliveredY.ToString());
}