public async Task <BigInteger> Part2()
{
var results = new List <BigInteger>();
foreach (var setting in new[] { 5, 6, 7, 8, 9 }.Permutations())
{
var channel = Channel.CreateUnbounded <BigInteger>();
var feedback = channel;
var intcodes = new List <Task>();
for (int i = 0, count = setting.Count(); i < count; i++)
{
await channel.Writer.WriteAsync(setting.ElementAt(i));
var input = channel.Reader;
channel = Channel.CreateUnbounded <BigInteger>();
var output = (i == count - 1) ? feedback.Writer : channel.Writer;
var intcode = new IntcodeComputer(_input.ToArray())
{
Input = () => input.ReadAsync().AsTask(),
Output = value => output.WriteAsync(value).AsTask(),
};
intcodes.Add(intcode.RunAsync());
}
await feedback.Writer.WriteAsync(0);
await Task.WhenAll(intcodes);
results.Add(await feedback.Reader.ReadAsync());
}
return(results.Max());
}
private async Task <bool> ScanAsync(int x, int y)
{
Debug.Assert(x >= 0);
Debug.Assert(y >= 0);
var first = true;
var output = 0;
var intcode = new IntcodeComputer(_input.ToArray())
{
Input = () =>
{
if (first)
{
first = false;
return(Task.FromResult <BigInteger>(x));
}
else
{
return(Task.FromResult <BigInteger>(y));
}
},
Output = value =>
{
output = (int)value;
return(Task.CompletedTask);
},
};
await intcode.RunAsync();
return(output == 1);
}
public async Task AddressingMode()
{
var intcode = new IntcodeComputer(new BigInteger[] { 1002, 4, 3, 4, 33 });
await intcode.RunAsync();
Assert.AreEqual(99, intcode.Get(4));
}
private async Task <BigInteger> RunScriptAsync(string[] lines, bool debug = false)
{
var input = new Queue <BigInteger>();
var output = new List <BigInteger>();
var intcode = new IntcodeComputer(_input)
{
Input = () => Task.FromResult(input.Dequeue()),
Output = value => { output.Add(value); return(Task.CompletedTask); },
};
foreach (var line in lines)
{
foreach (var c in Encoding.ASCII.GetBytes(line))
{
input.Enqueue(c);
}
input.Enqueue((byte)'\n');
}
await intcode.RunAsync();
if (debug)
{
foreach (var c in output)
{
Console.Write((char)c);
}
}
return(output[^ 1]);
public async Task <BigInteger> Part1()
{
var results = new List <BigInteger>();
foreach (var setting in new[] { 0, 1, 2, 3, 4 }.Permutations())
{
var stack = new Stack <BigInteger>();
stack.Push(0);
for (int i = 0, count = setting.Count(); i < count; i++)
{
stack.Push(setting.ElementAt(i));
var intcode = new IntcodeComputer(_input.ToArray())
{
Input = () => Task.FromResult(stack.Pop()),
Output = value => { stack.Push(value); return(Task.CompletedTask); },
};
await intcode.RunAsync();
}
results.Add(stack.Peek());
}
return(results.Max());
}
public async Task Computer(string memory, int address, int expected)
{
var intcode = new IntcodeComputer(memory);
await intcode.RunAsync();
Assert.AreEqual(expected, intcode.Get(address));
}
public async Task <BigInteger> Part1()
{
var intcode = new IntcodeComputer(_input);
intcode.Set(1, 12);
intcode.Set(2, 2);
await intcode.RunAsync();
return(intcode.Get(0));
}
public async Task <BigInteger> Part1()
{
var outputs = new List <BigInteger>();
var intcode = new IntcodeComputer(_input)
{
Input = () => Task.FromResult((BigInteger)1),
Output = value => { outputs.Add(value); return(Task.CompletedTask); },
};
await intcode.RunAsync();
return(outputs[^ 1]);
public async Task AddressingModeAndBigInteger(string memory, string expected)
{
var results = new List <BigInteger>();
var intcode = new IntcodeComputer(memory)
{
Output = value => { results.Add(value); return(Task.CompletedTask); },
};
await intcode.RunAsync();
Assert.AreEqual(expected, String.Join(',', results));
}
public async Task InputOutput()
{
BigInteger result = -1;
var intcode = new IntcodeComputer(new BigInteger[] { 3, 0, 4, 0, 99 })
{
Input = () => Task.FromResult((BigInteger)42),
Output = value => { result = value; return(Task.CompletedTask); },
};
await intcode.RunAsync();
Assert.AreEqual(42, result);
}
public async Task ConditionalJumps(string memory, int input, int expected)
{
BigInteger result = -1;
var intcode = new IntcodeComputer(memory)
{
Input = () => Task.FromResult((BigInteger)input),
Output = value => { result = value; return(Task.CompletedTask); },
};
await intcode.RunAsync();
Assert.AreEqual(expected, result);
}
public async Task <int> Part1()
{
var signal = new SemaphoreSlim(0);
var input = Channel.CreateUnbounded <BigInteger>();
var output = new List <char>();
var intcode = new IntcodeComputer(_input)
{
Input = () => input.Reader.ReadAsync().AsTask(),
Output = value => { output.Add((char)value); return(Task.CompletedTask); },
};
var commands = new[]
{
"east",
"take whirled peas",
"north",
"west",
"south",
"take antenna",
"north",
"east",
"south",
"east",
"north",
"take prime number",
"south",
"west",
"west",
"north",
"take fixed point",
"north",
"east",
"south",
};
foreach (var command in commands)
{
foreach (var c in Encoding.ASCII.GetBytes(command))
{
input.Writer.TryWrite(c);
}
input.Writer.TryWrite('\n');
}
await intcode.RunAsync();
return(Int32.Parse(Regex.Match(new string(output.ToArray()), @"(\d{7})").Value));
}
public async Task <int> Part1()
{
var outputs = new List <int>();
var intcode = new IntcodeComputer(_input)
{
Output = value => { outputs.Add((int)value); return(Task.CompletedTask); }
};
await intcode.RunAsync();
return(outputs
.Select((o, i) => (o, i))
.GroupBy(v => v.i % 3)
.First(g => g.Key == 2)
.Count(v => v.o == 2));
}
public async Task <BigInteger> Part2()
{
var(map, bot) = await GetMapAsync();
var dir = bot.dir;
var cardinal = PathToEnd(map, bot.pos)
.GroupWhile((prev, item) => prev == item)
.Select(steps => (dir: steps.First(), num: steps.Count()));
var relative = new List <(char, int)>();
foreach (var step in cardinal)
{
relative.Add((ToRelative(dir, step.dir), step.num));
dir = step.dir;
}
var(main, a, b, c) = GetRoutines(relative);
var input = Channel.CreateUnbounded <BigInteger>();
var output = default(BigInteger);
var intcode = new IntcodeComputer(_input)
{
Input = () => input.Reader.ReadAsync().AsTask(),
Output = value => { output = value; return(Task.CompletedTask); },
};
await InputAsync(main);
await InputAsync(a);
await InputAsync(b);
await InputAsync(c);
await InputAsync("n");
intcode.Set(0, 2);
await intcode.RunAsync();
return(output);
async Task InputAsync(string value)
{
foreach (var c in Encoding.ASCII.GetBytes(value))
{
await input.Writer.WriteAsync(c);
}
await input.Writer.WriteAsync('\n');
}
}
public async Task LargeExample(int input, int expected)
{
var memory = new BigInteger[]
{
3, 21, 1008, 21, 8, 20, 1005, 20, 22, 107, 8, 21, 20, 1006, 20, 31, 1106, 0, 36, 98, 0, 0, 1002, 21,
125, 20, 4, 20, 1105, 1, 46, 104, 999, 1105, 1, 46, 1101, 1000, 1, 20, 4, 20, 1105, 1, 46, 98, 99,
};
BigInteger result = -1;
var intcode = new IntcodeComputer(memory)
{
Input = () => Task.FromResult((BigInteger)input),
Output = value => { result = value; return(Task.CompletedTask); },
};
await intcode.RunAsync();
Assert.AreEqual(expected, result);
}
public async Task <int> Part2()
{
for (int noun = 0; noun < 100; noun++)
{
for (int verb = 0; verb < 100; verb++)
{
var intcode = new IntcodeComputer(_input);
intcode.Set(1, noun);
intcode.Set(2, verb);
await intcode.RunAsync();
if (intcode.Get(0) == 19690720)
{
return((noun * 100) + verb);
}
}
}
throw new Exception("not found");
}
public async Task <int> Part2()
{
var score = 0;
var input = Channel.CreateUnbounded <BigInteger>();
var output = Channel.CreateUnbounded <BigInteger>();
var intcode = new IntcodeComputer(_input)
{
Input = () => input.Reader.ReadAsync().AsTask(),
Output = value => output.Writer.WriteAsync(value).AsTask(),
};
intcode.Set(0, 2);
await Task.WhenAll(new[]
{
Task.Run(async() =>
{
await intcode.RunAsync();
output.Writer.Complete();
}),
Task.Run(async() =>
{
int?bx = null;
int?px = null;
while (await output.Reader.WaitToReadAsync())
{
var x = (int)await output.Reader.ReadAsync();
var y = (int)await output.Reader.ReadAsync();
var v = (int)await output.Reader.ReadAsync();
if (x == -1 && y == 0)
{
score = v;
}
else
{
if (v == 3)
{
px = x;
}
else if (v == 4)
{
bx = x;
}
}
if (bx.HasValue && px.HasValue)
{
var direction = Math.Clamp(bx.Value.CompareTo(px.Value), -1, 1);
if (px != bx)
{
bx = null;
px = null;
}
else
{
bx = null;
}
await input.Writer.WriteAsync(direction);
}
}
}),
});
return(score);
}
private async Task <(Dictionary <(int, int), char>, (int, int))> GetMapAsync()
{
var map = new Dictionary <(int, int), char>();
var pos = (0, 0);
var tar = pos;
var dir = N;
var input = Channel.CreateUnbounded <BigInteger>();
var intcode = new IntcodeComputer(_input)
{
Input = () => input.Reader.ReadAsync().AsTask()
};
intcode.Output = async status =>
{
switch ((int)status)
{
case 0: // hit wall
map[Step(pos, dir)] = '#';
dir = dir switch
{
N => W,
W => S,
S => E,
E => N,
_ => throw new Exception("dir?"),
};
await input.Writer.WriteAsync(dir);
break;
case 1: // moved
pos = Step(pos, dir);
map[pos] = '.';
dir = dir switch
{
N when !IsWall(Step(pos, E)) => E,
N => N,
W when !IsWall(Step(pos, N)) => N,
W => W,
S when !IsWall(Step(pos, W)) => W,
S => S,
E when !IsWall(Step(pos, S)) => S,
E => E,
_ => throw new Exception("dir?"),
};
await input.Writer.WriteAsync(dir);
if (pos == default && tar != default)
{
intcode.Halt();
}
break;
case 2: // found it
tar = Step(pos, dir);
goto case 1;
}
};
await input.Writer.WriteAsync(dir);
await intcode.RunAsync();
return(map, tar);
bool IsWall((int, int) pos) => map.TryGetValue(pos, out var c) && c == '#';
}
