private long RunCode(List <long> code, long valueAt1, long valueAt2) { var computer = new IntCode(code); if (valueAt1 >= 0) { computer.Poke(1, valueAt1); } if (valueAt2 >= 0) { computer.Poke(2, valueAt2); } computer.Run(); var valAt0 = computer.Peek(0); return(valAt0); }
object PartOne(string input) { var vm = new IntCode(input); vm.RunToNextInputOrFinished(); var i = 0; var items = new Dictionary <Point, int>(); while (i < vm.AllOutputs.Count) { var x = (int)vm.AllOutputs[i++]; var y = (int)vm.AllOutputs[i++]; var type = (int)vm.AllOutputs[i++]; items[new Point(x, y)] = type; } return(items.Count(kvp => kvp.Value == 2)); }
protected override object SolvePartOne() { IntCode cpu = IntCode.Create(Input.SplitByNewline().First()); int i = 0; int blocks = 0; cpu.Output += (s, e) => { if (i == 2 && e == 2) { blocks++; } i = ++i % 3; }; cpu.Run(); return(blocks.ToString()); }
object PartOne(string input) { var affectedSquares = 0L; foreach (var y in Enumerable.Range(0, 50)) { foreach (var x in Enumerable.Range(0, 50)) { var vm = new IntCode(input); vm.ProvideInput(x); vm.ProvideInput(y); var result = vm.RunToNextInputOrFinishedCollectOutput(); affectedSquares += result[result.Length - 1]; } } return(affectedSquares); }
long PlayGame() { var intCode = new IntCode(4096); var instructions = Instructions.ToList(); instructions[0] = 2; var score = 0L; while (true) { if (intCode.IsPaused) { intCode.Resume(); } else { intCode.Execute(instructions); } var tiles = GetTiles(intCode.Outputs.ToList()); intCode.ClearOutput(); var paddle = (Tile?)tiles.FirstOrDefault(x => x.TileType == TileType.Paddle); var ball = (Tile?)tiles.FirstOrDefault(x => x.TileType == TileType.Ball); var scoreInfo = (Tile?)tiles.FirstOrDefault(x => x.IsScore); if (scoreInfo.HasValue) { score = scoreInfo.Value.Score; } if (!intCode.IsPaused) { break; } var nextInput = paddle.HasValue && ball.HasValue ? GetInput(paddle.Value, ball.Value) : 0; intCode.SetInputs(nextInput); } return(score); }
string RunPart1(InputAnswer puzzleData) { var phaseValues = new long[] { 0, 1, 2, 3, 4 }; var answer = 0L; foreach (var phase in GetPhases(phaseValues, puzzleData.Phase)) { var ampA = new IntCode(puzzleData.Code); var ampB = new IntCode(puzzleData.Code); var ampC = new IntCode(puzzleData.Code); var ampD = new IntCode(puzzleData.Code); var ampE = new IntCode(puzzleData.Code); var outputValue = 0L; ampA.Output += (s, e) => outputValue = e.OutputValue; ampB.Output += (s, e) => outputValue = e.OutputValue; ampC.Output += (s, e) => outputValue = e.OutputValue; ampD.Output += (s, e) => outputValue = e.OutputValue; ampE.Output += (s, e) => outputValue = e.OutputValue; ampA.AddInput(phase[0], outputValue); ampA.Run(); ampB.AddInput(phase[1], outputValue); ampB.Run(); ampC.AddInput(phase[2], outputValue); ampC.Run(); ampD.AddInput(phase[3], outputValue); ampD.Run(); ampE.AddInput(phase[4], outputValue); ampE.Run(); if (outputValue > answer) { answer = outputValue; } } return(Helper.GetPuzzleResultText($"Highest signal that can be sent to the thrusters: {answer}", answer, puzzleData.ExpectedAnswer)); }
object PartTwo(string input) { var ampSettings = Enumerable.Range(5, 5).Permutate(); var maxOutput = long.MinValue; foreach (var ampSetting in ampSettings) { // Need to run all 5 computers, entering the output from each one // into the input of the next, until they stop. var computers = new IntCode[5]; for (var index = 0; index < 5; index++) { computers[index] = new IntCode(input); computers[index].ProvideInput(ampSetting[index]); } computers[0].ProvideInput(0); // Run each computer until it is either finished or it is waiting for input int computerRunning = -1; ProgramState state = ProgramState.Running; do { computerRunning = ++computerRunning % 5; var currentComputer = computers[computerRunning]; // Provide the input to the computer. var previousComputer = computers[(computerRunning + 4) % 5]; if (previousComputer.HasOutput) { currentComputer.ProvideInput(previousComputer.ReadOutput()); } do { state = currentComputer.ExecuteInstruction(); }while(state != ProgramState.WaitingForInput && state != ProgramState.Finished); }while(computers[4].State != ProgramState.Finished); maxOutput = Math.Max(maxOutput, computers[4].AllOutputs.Last()); } return(maxOutput); }
object PartOne(string input) { //var vm = new IntCode(input); //var currentPos = new Point(0, 0); //var currentStatus = Status.Empty; //var map = new Dictionary<Point, Status>(); ////var wayBack = new Dictionary<Point, Direction>(); //var shortestDistance = new Dictionary<Point, int>(); //shortestDistance[currentPos] = 0; //map[currentPos] = currentStatus; //var pointsToCheck = new Stack<Point>(); //pointsToCheck.Push(currentPos); //var g = new QuickGraph.BidirectionalGraph<Point, Edge<Point>>(); //g.AddVertex(currentPos); //FloodFill(vm, currentPos, shortestDistance, map, g); //var system = map.First(kvp => kvp.Value == Status.System).Key; //return shortestDistance[system]; var vm = new IntCode(input); var currentPos = new Point(0, 0); var currentStatus = Status.Empty; var map = new Dictionary <Point, Status>(); map[currentPos] = currentStatus; var pointsToCheck = new Stack <Point>(); pointsToCheck.Push(currentPos); var g = new BidirectionalGraph <Point, Edge <Point> >(); g.AddVertex(currentPos); FloodFill(vm, ref currentPos, map, g); var systemPoint = map.First(kvp => kvp.Value == Status.System).Key; g.ShortestPathsDijkstra(e => 1, new Point(0, 0))(systemPoint, out var path); return(path.Count()); }
public void Part2() { List <long> outputs = new List <long>(3); long score = 0; long ballX = 0; long paddleX = 0; IntCodeBase.OutputWriter writer = output => { outputs.Add(output); if (outputs.Count == 3) { if (outputs[0] == -1 && outputs[1] == 0) { score = outputs[2]; } else { Tile tile = (Tile)outputs[2]; long x = outputs[0]; if (tile == Tile.Ball) { ballX = x; } if (tile == Tile.Paddle) { paddleX = x; } } outputs.Clear(); } }; IntCode.InputReader reader = () => Math.Sign(ballX - paddleX); IntCode arcade = new IntCode(_program, reader, writer); arcade[0] = 2; arcade.Run(); Assert.Equal(8942, score); }
public static void SolvePartTwo() { for (int a = 0; a < 99; a++) { for (int b = 0; b < 99; b++) { input = new List <int>(); TakeInput(); input[1] = a; input[2] = b; if (IntCode.CalculateOpcode(input) != 19690720) { continue; } Console.WriteLine("a: " + a + " b: " + b); Console.WriteLine((100 * a) + b); return; } } }
int CheckThrustersByFeedbackLoop(string signalPhase) { var intCodes = new IntCode[signalPhase.Length]; var output = 0; var index = 0; while (true) { if (intCodes[index] == null) { intCodes[index] = new IntCode(); } var signal = int.Parse(signalPhase[index].ToString()); var intCode = intCodes[index]; if (intCode.IsPaused) { intCode.SetInputs(output); intCode.Resume(); } else { intCode.SetInputs(signal, output); intCode.Execute(Instructions); } output = (int)intCode.Outputs.Last(); if (intCodes.Where(x => x != null).All(x => !x.IsPaused)) { break; } else { index = (++index) % signalPhase.Length; } } return(output); }
string RunPart1(InputAnswer puzzleData, long inputValue, long?overrideExpectedAnswer = null) { if (overrideExpectedAnswer.HasValue) { puzzleData.ExpectedAnswer = overrideExpectedAnswer.Value; } var answer = 0L; var computer = new IntCode(puzzleData.Code); computer.Output += (s, e) => { answer = e.OutputValue; }; computer.Run(); if (computer.State == IntCodeState.NeedsInput) { computer.AddInput(inputValue); computer.Run(); } return(Helper.GetPuzzleResultText($"The diagnostic Code is: {answer}", answer, puzzleData.ExpectedAnswer)); }
private long RunAmplifiers(IEnumerable <long> code, IEnumerable <int> phaseSettings) { long answer = 0; Stack <long> inputs = new Stack <long>(); inputs.Push(0); foreach (int phaseSetting in phaseSettings) { inputs.Push(phaseSetting); IntCode amp = new IntCode( code, inputs.Pop, value => answer = value ); amp.Run(); inputs.Push(answer); } return(answer); }
object PartOne(string input) { var ampSettings = Enumerable.Range(0, 5).Permutate(); var maxOutput = long.MinValue; foreach (var ampSetting in ampSettings) { var ampInput = new long[5 + 1]; for (var index = 0; index < 5; index++) { var comp = new IntCode(input); comp.ProvideInput(ampSetting[index]); comp.ProvideInput(ampInput[index]); comp.Run(); ampInput[index + 1] = comp.ReadOutput(); } maxOutput = Math.Max(maxOutput, ampInput[5]); } return(maxOutput); }
private string Run(string input) { int index = 0; StringBuilder sb = new StringBuilder(); IntCode intCode = new IntCode( _program, () => input[index++], val => { if (val >= 0 && val <= 127) { sb.Append((char)val); } else { sb.Append(val.ToString()); } }); intCode.Run(); return(sb.ToString()); }
protected override object SolvePartTwo() { IntCode cpu = IntCode.Create(Input.Trim('\n')); for (int i = 0; i < 100; i++) { for (int j = 0; j < 100; j++) { cpu.Reset(); cpu.ByteCode[1] = i; cpu.ByteCode[2] = j; cpu.Run(); if (cpu.ByteCode[0] == 19690720) { return($"100 * {i} + {j} = {100 * i + j}"); } } } return(null); }
public Day17() { StringBuilder sb = new StringBuilder(); IntCode intCode = new IntCode( _program, null, value => { if (value == 10) { sb.AppendLine(); } else { sb.Append((char)value); } }); intCode.Run(); _map = sb.ToString().Split().Where(s => s != string.Empty).ToArray(); }
public void Part2() { const int target = 19690720; for (int i = 0; i < 100; i++) { for (int j = 0; j < 100; j++) { IntCode intCode = new IntCode(_program); intCode[1] = i; intCode[2] = j; intCode.Run(); if (intCode[0] == target) { int answer = 100 * i + j; Assert.Equal(6979, answer); return; } } } }
string RunPart2Example3(long inputValue) { var sb = new StringBuilder(); var inputList = InputHelper.LoadInputFile(5, "example3") .Select(l => l.Split(',').Select(v => v.ToInt64()).ToList()); sb.AppendLine($"Input: {inputValue}"); foreach (var input in inputList) { var computer = new IntCode(input); computer.Output += (s, e) => sb.AppendLine($"Output: {e.OutputValue}"); computer.Run(); if (computer.State == IntCodeState.NeedsInput) { computer.AddInput(inputValue); computer.Run(); } } sb.AppendLine(); return(sb.ToString()); }
public void Part2() { _intCodeOutput.Clear(); FindFunctions(); _intCodeInput = new Queue <long>(); QueueInput(_mainRoutine); QueueInput(_functionA); QueueInput(_functionB); QueueInput(_functionC); _intCodeInput.Enqueue('n'); _intCodeInput.Enqueue(10); _code[0] = 2; IntCode intCode = new IntCode("Day17", _code, IntCodeInput, IntCodeOutput); intCode.RunIntCode(); long rslt = _intCodeOutput[_intCodeOutput.Count - 1]; Console.WriteLine("Part2: {0}", rslt); }
static void Main(string[] args) { Console.WriteLine("Day 23"); Console.WriteLine("Star 1"); Console.WriteLine(); long[] regs = File.ReadAllText(inputFile).Split(',').Select(long.Parse).ToArray(); IntCode machine = new IntCode( name: "Star 1", regs: regs, fixedInputs: Array.Empty <long>(), output: x => Console.Write(x)); machine.SyncRun(); int output1 = 0; Console.WriteLine($"The answer is: {output1}"); Console.WriteLine(); Console.WriteLine("Star 2"); Console.WriteLine(); int output2 = 0; Console.WriteLine($"The answer is: {output2}"); Console.WriteLine(); Console.ReadKey(); }
protected override object SolvePartOne() { var panels = new Dictionary <Point, long>(); (Point location, Point direction) = (new Point(), Point.North); IntCode cpu = IntCode.Create(Input.SplitByNewline().First()); cpu.GetInput = (i) => { return(panels.TryGetValue(location, out var result) ? result : 0); }; int output = 0; cpu.Output += (s, e) => { if (output == 0) { panels[location] = e; } else { direction = e switch { 0 => new Point(direction.Y, -direction.X), 1 => new Point(-direction.Y, direction.X), _ => throw new System.Exception(), }; location += direction; } output = (output + 1) & 1; }; cpu.Run(); return(panels.Count.ToString()); }
static void TryTreeMethod(long[] regs) { // Ineffective Tree solution left for Posterity's sake var sw = System.Diagnostics.Stopwatch.StartNew(); MoveTree moveTree = new MoveTree(); while (true) { tileMap.Clear(); inputStage = 0; IntCode machine2 = new IntCode( name: "Star 2", regs: regs, fixedInputs: Array.Empty <long>(), input: moveTree.NextMove, output: RenderOutput1); machine2[0] = 2; machine2.SyncRun(); if (tileMap.Values.Where(x => x == 2).Count() == 0) { break; } else { moveTree.MarkFailure(); } } sw.Stop(); Console.WriteLine($"Tree Solution took: {sw.Elapsed}"); Console.WriteLine($"The answer is: {score}"); }
public void Part1() { int countBlocks = 0; List <long> outputs = new List <long>(3); IntCode arcade = new IntCode( _program, null, output => { outputs.Add(output); if (outputs.Count == 3) { if ((Tile)outputs[2] == Tile.Block) { countBlocks++; } outputs.Clear(); } }); arcade.Run(); Assert.Equal(173, countBlocks); }
private static int FindMatch(long[] initialRegs) { for (int noun = 0; noun < 100; noun++) { for (int verb = 0; verb < 100; verb++) { IntCode intCode = new IntCode( name: $"Star 2 Machine ({noun},{verb})", regs: initialRegs); intCode[1] = noun; intCode[2] = verb; intCode.Run().Wait(); if (intCode[0] == 19690720) { return(100 * noun + verb); } } } throw new Exception("Result not found"); }
private void MoveTo(Point target, ref Point currentPos, BidirectionalGraph <Point, Edge <Point> > g, IntCode vm, string because) { if (target == currentPos) { return; } var startingPoint = currentPos; var tryFunc = g.ShortestPathsDijkstra(e => 1, currentPos); if (!tryFunc(target, out var path)) { throw new Exception($"Unable to find path between {currentPos} and {target}."); } foreach (var edge in path) { var direction = edge.Source.GetDirectionTo(edge.Target); if (Move(ref currentPos, direction, vm, because) == Status.Wall) { throw new Exception("Simulation is wrong somewhere."); } } }
public static void Day7Main(string inputFile) { string[] opCodeList = System.IO.File.ReadAllText(inputFile).Split(","); string currOpCode = ""; decimal currIndexer = 0; int opCodeCheck = 0; List <decimal> input_list = new List <decimal>(); List <decimal> opCode = new List <decimal>(); List <List <char> > phaseListInput = new List <List <char> >(); string str = "56789"; char[] arr = str.ToCharArray(); phaseListInput = GetPer(phaseListInput, arr); foreach (string tempOpCode in opCodeList) { opCode.Add(int.Parse(tempOpCode)); } float maxOutput = 0; List <decimal> input = new List <decimal>(); List <char> maxPhaseInput = new List <char>(); //List<char> currPhaseList = new List<char> { '4', '3', '2', '1', '0' }; //List<char> currPhaseList = new List<char> { '0', '1', '2', '3', '4' }; //List<char> currPhaseList = new List<char> { '1', '0', '4', '3', '2' }; //List<char> currPhaseList = new List<char> { '9', '8', '7', '6', '5' }; //List<char> currPhaseList = new List<char> { '9', '7', '8', '5', '6' }; List <IntCode> ampList = new List <IntCode>(); foreach (List <char> currPhaseList in phaseListInput) { // Initialise IntCode setup ampList = new List <IntCode>(); // initialise each input with its phase setting. If it's the first input, tack a 0 on (very first input = 0!) foreach (char currPhase in currPhaseList) { input = new List <decimal>(); input.Add((int)Char.GetNumericValue(currPhase)); if (currPhase.Equals(currPhaseList[0])) { input.Add(0); } //Make our ampList of 5x amplifiers. ampList.Add(new IntCode(new List <decimal>(opCode), input)); } while (true) { for (int i = 0; i < ampList.Count; i++) { IntCode currIntCode = ampList[i]; while (true) { currIndexer = currIntCode.CurrIndex; currOpCode = currIntCode.OpCode[(int)currIndexer].ToString().PadLeft(5, '0'); opCodeCheck = Int32.Parse(currOpCode.Substring(3, 2)); if (opCodeCheck == 99) { break; } else if (opCodeCheck == 3 && currIntCode.Input.Count < 1) { //Add output to next IntCode's input list //Console.WriteLine("Input 3 and no valid input. Better keep going or I might die inside."); break; } else { currIntCode = IntCode.OpCodeForward(currIntCode); } } //we have escaped this intcode, save it! ampList[i] = currIntCode; if (i < (ampList.Count - 1)) { // If it's not our last input, make the output part of our next input :) ampList[i + 1].Input.Add(currIntCode.Output); } } // Will only get here on final amplifier if (opCodeCheck == 99) { // If we're done, let's check if our final output is the best ever if ((int)ampList.Last().Output > maxOutput) { maxOutput = (int)ampList.Last().Output; maxPhaseInput = new List <char>(currPhaseList); } break; } else { ampList[0].Input.Add(ampList.Last().Output); } } } Console.WriteLine("Final Input List is " + string.Join(",", maxPhaseInput)); Console.WriteLine("Maximum Output is " + maxOutput); Console.ReadLine(); }
static void Main(string[] args) { Console.WriteLine("Day 17 - Set and Forget"); Console.WriteLine("Star 1"); Console.WriteLine(); long[] regs = File.ReadAllText(inputFile).Split(',').Select(long.Parse).ToArray(); StringBuilder builder = new StringBuilder(); IntCode machine = new IntCode( name: "Star 1", regs: regs, fixedInputs: Array.Empty <long>(), output: x => builder.Append((char)x)); machine.SyncRun(); string text = builder.ToString(); string[] lines = text.Split('\n').Where(x => x.Length != 0).ToArray(); int alignmentParam = 0; for (int y = 1; y < lines.Length - 1; y++) { for (int x = 1; x < lines[0].Length - 1; x++) { if (lines[y][x] == '#') { if (lines[y - 1][x] == '#' && lines[y + 1][x] == '#' && lines[y][x + 1] == '#' && lines[y][x - 1] == '#') { alignmentParam += x * y; } } } } Console.WriteLine($"The answer is: {alignmentParam}"); Console.WriteLine(); Console.WriteLine("Star 2"); Console.WriteLine(); HashSet <Point2D> scaffold = new HashSet <Point2D>(); Point2D startingPoint = Point2D.Zero; for (int y = 0; y < lines.Length; y++) { for (int x = 0; x < lines[0].Length; x++) { if (lines[y][x] == '#') { scaffold.Add((x, y)); } else if (lines[y][x] == '^') { startingPoint = (x, y); } } } List <string> path = GetPath(startingPoint, scaffold); var compressed = Compress(path); IEnumerable <long> input = compressed.Seq.Select(x => (long)x).Append(10) .Concat(compressed.A.Select(x => (long)x)).Append(10) .Concat(compressed.B.Select(x => (long)x)).Append(10) .Concat(compressed.C.Select(x => (long)x)).Append(10) .Append((long)'n').Append(10); regs[0] = 2; long dust = 0; IntCode machine2 = new IntCode( name: "Star 2", regs: regs, fixedInputs: input, output: x => dust = x); machine2.SyncRun(); Console.WriteLine($"Dust collected: {dust}"); Console.WriteLine(); Console.ReadKey(); }
private void FloodFill(IntCode vm, ref Point currentPos, Dictionary <Point, Status> map, BidirectionalGraph <Point, Edge <Point> > g) { // Check all directions from this point. var pointsToCheck = new Stack <Point>(); pointsToCheck.Push(currentPos); var pointStatus = new Dictionary <Direction, Status>(); while (pointsToCheck.Count > 0) { var pointToCheck = pointsToCheck.Pop(); Log(string.Empty); Log($"Checking new point {pointToCheck}"); MoveTo(pointToCheck, ref currentPos, g, vm, $"new point to check {pointToCheck}"); var dirsToCheck = Enum.GetValues(typeof(Direction)).Cast <Direction>(); pointStatus.Clear(); foreach (var dir in dirsToCheck) { var targetPos = currentPos.GetLocation(dir); if (map.ContainsKey(targetPos)) { continue; } var currentStatus = Move(ref currentPos, dir, vm, $"checking out unknown position."); pointStatus.Add(dir, currentStatus); map[targetPos] = currentStatus; switch (currentStatus) { case Status.Wall: // The robot did not move, but it hit a wall. break; case Status.Empty: // We moved, and are now at the target position if (!g.ContainsVertex(targetPos)) { g.AddVertex(targetPos); } g.AddEdge(new Edge <Point>(pointToCheck, targetPos)); g.AddEdge(new Edge <Point>(targetPos, pointToCheck)); // Add it as a point to check. pointsToCheck.Push(targetPos); // Then go back to the pointToCheck. MoveTo(pointToCheck, ref currentPos, g, vm, $"point checked. Moving back to {pointToCheck}"); break; case Status.System: // We moved, and are now at the target position if (!g.ContainsVertex(targetPos)) { g.AddVertex(targetPos); } // We found the oxygen system. No need to check any further in this path. (No other way will be shorter than this). // We just go back to the current position. g.AddEdge(new Edge <Point>(pointToCheck, targetPos)); g.AddEdge(new Edge <Point>(targetPos, pointToCheck)); MoveTo(pointToCheck, ref currentPos, g, vm, $"point checked (System found). Moving back to {pointToCheck}"); break; } } Log($"Finished with {pointToCheck}:"); foreach (var kvp in pointStatus) { Log($" {kvp.Key}: {kvp.Value}"); } } }
public Challenge() { _intCode = new IntCode(); _intCode.Load(inputList[0]); }