Esempio n. 1
0
        protected override void Solve()
        {
            var amp = new Amplifier(ReadText());

            // amp.Input.Enqueue(1);
            amp.Input("NOT A J");
            amp.Input("NOT B T");
            amp.Input("OR T J");
            amp.Input("NOT C T");
            amp.Input("OR T J");

            amp.Input("AND D J");

            amp.Input("NOT E T");
            amp.Input("NOT T T");
            amp.Input("OR H T");

            amp.Input("AND T J");

            amp.Input("RUN");
            amp.Run();
            while (amp.Output.Count > 0)
            {
                var outp = amp.GetAsciiOutputIfInRange();
                Console.Write(outp);
            }
        }
Esempio n. 2
0
        private static long Run(string str, int x, int y)
        {
            var amp = new Amplifier(str);

            amp.Input.Enqueue(x);
            amp.Input.Enqueue(y);
            amp.Run();
            var outp = amp.Output.Dequeue();

            return(outp);
        }
Esempio n. 3
0
        protected override void Solve()
        {
            var amp    = new Amplifier(ReadText());
            var halted = false;

            while (!halted)
            {
                halted = amp.Run();
                while (amp.Output.Count > 0)
                {
                    Console.Write(amp.GetAsciiOutputIfInRange());
                }

                amp.Input(Console.ReadLine() !);
            }
        }
Esempio n. 4
0
        protected override void Solve()
        {
            var N    = 200;
            var grid = new bool[N + 1 + N, N + 1 + N];
            var dir  = (R :  -1, c : 0);
            var pos  = (R :  N, c : N);

            grid.At(pos) = true;
            var halted = false;
            var amp    = new Amplifier(ReadText());

            // var painted = new HashSet<(int r, int c)>();
            while (!halted)
            {
                amp.Input.Enqueue(grid.At(pos) ? 1 : 0);
                halted       = amp.Run();
                grid.At(pos) = amp.Output.Dequeue() == 1;
                // painted.Add(pos);
                dir = amp.Output.Dequeue() == 1 ? dir.Right() : dir.Left();
                pos = pos.Plus(dir);
            }

            // Console.WriteLine(painted.Count);

            grid.Iter((_, j, b) =>
            {
                if (b)
                {
                    Console.Write('#');
                }
                else
                {
                    Console.Write('.');
                }
                if (j == grid.R() - 1)
                {
                    Console.WriteLine();
                }
            });
        }
Esempio n. 5
0
        protected override void Solve()
        {
            var amp = new Amplifier(ReadText());

            amp.Prog[0] = 2;
            var grid = new int[49, 42];
            var p    = (R :  0, C : 0);

            amp.Run();
            while (amp.Output.Count > 0)
            {
                var o = amp.Output.Dequeue();
                if (o == 10)
                {
                    p = (p.R + 1, 0);
                    Console.WriteLine();
                }
                else
                {
                    if (!p.OutOfBounds(grid.R(), grid.C()))
                    {
                        grid.At(p) = (int)o;
                        if ((char)o == '^')
                        {
                        }
                    }
                    Console.Write((char)o);
                    p = (p.R, p.C + 1);
                }
            }

            var res =
                "A,C,C,B,A,C,B,A,C,B\nL,6,R,12,L,4,L,6\nL,6,L,10,L,10,R,6\nR,6,L,6,R,12\ny\n";
            var pathInt = res.Select(c => (long)c).ToArray();

            pathInt.ForEach(amp.Input.Enqueue);
            amp.Run();
            while (amp.Output.Count > 0)
            {
                var outp = amp.Output.Dequeue();
                if (outp > 200)
                {
                    Console.WriteLine(outp);
                }
                else
                {
                    var ch = (char)outp;
                    Console.Write(ch);
                }
            }
            // amp.Input.Enqueue();

            // bool[,] scaffold = new bool[grid.L1(), grid.L2()];
            // for (var i = 1; i < grid.L1() - 1; i++)
            // {
            //     for (var j = 1; j < grid.L2() - 1; j++)
            //     {
            //         if (grid.At((i, j - 1)) == (int) '#'
            //             && grid.At((i, j + 1)) == (int) '#'
            //             && grid.At((i + 1, j)) == (int) '#'
            //             && grid.At((i - 1, j)) == (int) '#'
            //             && grid.At((i, j)) == (int) '#')
            //         {
            //             scaffold.At((i, j)) = true;
            //         }
            //     }
            // }
            // var path = BuildPath(grid, robot, (-1, 0));
            // string BuildPath(int[,] grid, (int r, int c) robot, (int r, int c) dir)
            // {
            //     bool[,] visited = new bool[grid.L1(), grid.L2()];
            //     visited.At(robot) = true;
            //     var sb = new StringBuilder();
            //     while (true)
            //     {
            //         var left = robot.Plus(dir.Left());
            //         var right = robot.Plus(dir.Right());
            //         var front = robot.Plus(dir);
            //
            //         bool Correct((int r, int c) point)
            //         {
            //             return !point.OutOfBounds(grid.L1(), grid.L2())
            //                    && grid.At(point) == '#'
            //                    && (scaffold.At(point) || !visited.At(point));
            //         }
            //
            //         (int r, int c) GetCorrectPoint()
            //         {
            //             if (Correct(front)) return front;
            //             if (Correct(left))
            //             {
            //                 sb.Append('L');
            //                 dir = dir.Left();
            //                 return left;
            //             }
            //
            //             if (Correct(right))
            //             {
            //                 sb.Append('R');
            //                 dir = dir.Right();
            //                 return right;
            //             }
            //
            //             return (-100, -100);
            //         }
            //
            //         var correct = GetCorrectPoint();
            //         if (correct == (-100, -100))
            //         {
            //             sb.Remove(sb.Length - 1, 1);
            //             return sb.ToString();
            //         }
            //         var count = 0;
            //         while (Correct(correct))
            //         {
            //             count++;
            //             visited.At(correct) = true;
            //             correct = correct.Plus(dir);
            //         }
            //
            //         robot = correct.Minus(dir);
            //
            //         sb.Append(count);
            //         sb.Append(',');
            //     }
            // }
            //
            // Console.WriteLine(path);
            // var sum = 0;
            // for (var i = 1; i < grid.L1() - 1; i++)
            // {
            //     for (var j = 1; j < grid.L2() - 1; j++)
            //     {
            //         if (grid.At((i, j - 1)) == (int) '#'
            //             && grid.At((i, j + 1)) == (int) '#'
            //             && grid.At((i + 1, j)) == (int) '#'
            //             && grid.At((i - 1, j)) == (int) '#'
            //             && grid.At((i, j)) == (int) '#')
            //         {
            //             sum += i * j;
            //         }
            //     }
            // }

            // Console.WriteLine(sum);
        }
Esempio n. 6
0
        protected override void Solve()
        {
            var amp    = new Amplifier(ReadText());
            var grid   = new int[40, 24];
            var halted = false;

            amp.Prog[0] = 2;
            var score   = 0;
            var v       = (x : 0, y : 0);
            var lastPos = (x : 0, y : 0);
            // amp.Input.Enqueue(0);
            // amp.Input.Enqueue(0);
            var tilePos = (x : -1, y : -1);

            while (!halted)
            {
                var move = 0;
                if (tilePos.x == -1)
                {
                    move = int.Parse(Console.ReadLine() !);
                }
                else
                {
                    if (tilePos.x == lastPos.x && tilePos.y == lastPos.y + 1)
                    {
                        move = 0;
                    }
                    else
                    {
                        move = (lastPos.x + v.x) - tilePos.x;
                    }
                }

                Console.WriteLine("move: " + move);
                amp.Input.Enqueue(move);
                halted = amp.Run();
                while (amp.Output.Count >= 3)
                {
                    var x    = (int)amp.Output.Dequeue();
                    var y    = (int)amp.Output.Dequeue();
                    var type = (int)amp.Output.Dequeue();

                    if (x == -1 && y == 0)
                    {
                        score = type;
                    }
                    else
                    {
                        grid[x, y] = type;

                        if (type == 3)
                        {
                            tilePos = (x, y);
                        }
                        else if (type == 4)
                        {
                            v       = (x, y).Minus(lastPos);
                            lastPos = (x, y);
                        }
                    }
                }
                grid.Print(lastPos);
                lastPos.ToString().Print();
                score.ToString().Print();
            }
            // '▮'
            Console.WriteLine("score: " + score);
            // var c = 0;
            // for (var i = 0; i < grid.L1(); i++)
            // {
            //     for (var j = 0; j < grid.L2(); j++)
            //     {
            //         if (grid[i, j] == 2) c++;
            //     }
            // }
            // grid.Count(tile => tile == 2);
            // Console.WriteLine(c);
        }