Example #1
0
        public static void Execute()
        {
            var input = InputGetter.GetTransformedSplitInputForDay(5, new[] { ',' }, InputTransformDay5.ParseLines).ToArray();

            //Part1((int[])input.Clone());
            Part2(input);
        }
Example #2
0
        public static void Execute()
        {
            var input = InputGetter.GetTransformedSplitInputForDay(7, new[] { ',' }, InputTransformDay7.ParseLines).ToArray();

            Part1(input.ToArray()).GetAwaiter().GetResult();
            Part2(input.ToArray()).GetAwaiter().GetResult();
        }
Example #3
0
        public static void Execute()
        {
            var input = InputGetter.GetTransformedSplitInputForDay(1, new[] { '\n' }, InputTransformDay1.ParseLines);

            Part1(input);
            Part2(input);
        }
Example #4
0
        public static void Execute()
        {
            var input = InputGetter.GetTransformedSplitInputForDay(13, new[] { ',' }, InputTransformDay13.ParseItems).ToArray();

            Part1(ref input);
            Console.Clear();
            Part2(ref input);
        }
Example #5
0
        public static void Execute()
        {
            var input = InputGetter.GetTransformedSplitInputForDay(14, new[] { '\n' }, InputTransformDay14.ParseLine).ToArray();
            var store = DoIt(input);

            Console.WriteLine(store["ORE"]);
            Console.WriteLine(DoItPart2(input));
        }
Example #6
0
        public static void Execute()
        {
            var instance = new Day6();
            var input    = InputGetter.GetTransformedSplitInputForDay(6, new[] { '\n' }, InputTransformDay6.ParseLines).ToArray();
            Dictionary <string, Planet> orbits = BuildOrbitalMap(input);

            Console.WriteLine("Part 1:" + Part1(orbits).ToString());
            Console.WriteLine("Part 2:" + Part2(orbits).ToString());
        }
Example #7
0
        public static void Execute()
        {
            Console.CursorVisible = false;
            var input = InputGetter.GetTransformedSplitInputForDay(15, new[] { ',' }, InputTransformDay15.ParseItems).ToArray();

            Part1(ref input);

            /*Console.Clear();
             * Part2(ref input);*/

            Console.CursorVisible = true;
        }
Example #8
0
        public static void Execute()
        {
            var  moons = InputGetter.GetTransformedSplitInputForDay(12, new[] { '\n' }, Moon.Parse).ToArray();
            var  original = InputGetter.GetTransformedSplitInputForDay(12, new[] { '\n' }, Moon.Parse).ToArray();
            long xPeriod = 0, yPeriod = 0, zPeriod = 0;

            for (long count = 1; xPeriod == 0 || yPeriod == 0 || zPeriod == 0; count++)
            {
                Step(moons);
                if (count == 1000)
                {
                    Console.WriteLine(GetTotalEnergy(moons));
                }
                if (xPeriod == 0 &&
                    moons[0].Velocity.X == 0 && moons[0].Position.X == original[0].Position.X &&
                    moons[1].Velocity.X == 0 && moons[1].Position.X == original[1].Position.X &&
                    moons[2].Velocity.X == 0 && moons[2].Position.X == original[2].Position.X &&
                    moons[3].Velocity.X == 0 && moons[3].Position.X == original[3].Position.X)
                {
                    xPeriod = count;
                    Console.WriteLine("X period = " + count);
                }
                if (yPeriod == 0 &&
                    moons[0].Velocity.Y == 0 && moons[0].Position.Y == original[0].Position.Y &&
                    moons[1].Velocity.Y == 0 && moons[1].Position.Y == original[1].Position.Y &&
                    moons[2].Velocity.Y == 0 && moons[2].Position.Y == original[2].Position.Y &&
                    moons[3].Velocity.Y == 0 && moons[3].Position.Y == original[3].Position.Y)
                {
                    yPeriod = count;
                    Console.WriteLine("Y period = " + count);
                }
                if (zPeriod == 0 &&
                    moons[0].Velocity.Z == 0 && moons[0].Position.Z == original[0].Position.Z &&
                    moons[1].Velocity.Z == 0 && moons[1].Position.Z == original[1].Position.Z &&
                    moons[2].Velocity.Z == 0 && moons[2].Position.Z == original[2].Position.Z &&
                    moons[3].Velocity.Z == 0 && moons[3].Position.Z == original[3].Position.Z)
                {
                    zPeriod = count;
                    Console.WriteLine("Z period = " + count);
                }
            }
            var lcmXY = lcm(xPeriod, yPeriod);

            Console.WriteLine(lcm(lcmXY, zPeriod));
        }
Example #9
0
        public static void Execute()
        {
            var input        = InputGetter.GetTransformedSplitInputForDay(17, new[] { ',' }, long.Parse).ToArray();
            var stringStream = new MemoryStream();
            var computer     = new Computer(input, ConsoleIn.Default, new StreamOutput(new StreamWriter(stringStream)));

            computer.Wait().GetAwaiter().GetResult();

            string secondaryInput = string.Join("", stringStream.GetBuffer().Select(_ => (char)_));

            Console.WriteLine("   0123456789|123456789|123456789|123456789");
            Console.WriteLine(string.Join("\r\n", secondaryInput.Split("\n").Select((line, index) => $"{index,-2}:{line}")));
            bool[][] splitBothWays = secondaryInput.Substring(0, secondaryInput.IndexOf("\n\n")).Split('\n').Select(s => s.Select(c => c != '.').ToArray()).ToArray();
            var      crossings     = new List <Point>();
            var      corners       = new List <Point>();
            var      ends          = new List <Point>();

            int rows    = splitBothWays.Length;
            int columns = splitBothWays[0].Length;

            for (int row = 0; row < rows; row++)
            {
                for (int column = 0; column < columns; column++)
                {
                    if (!splitBothWays[row][column])
                    {
                        continue;
                    }
                    if (ShouldCheckCrossing(row, column, rows, columns) && splitBothWays[row - 1][column] && splitBothWays[row + 1][column] && splitBothWays[row][column - 1] && splitBothWays[row][column + 1])
                    {
                        crossings.Add(new Point(column, row));
                        continue;
                    }
                    if ((ShouldCheckNW(row, column, rows, columns) && splitBothWays[row - 1][column] && splitBothWays[row][column - 1]) ||
                        (ShouldCheckSE(row, column, rows, columns) && splitBothWays[row][column + 1] && splitBothWays[row + 1][column]) ||
                        (ShouldCheckSW(row, column, rows, columns) && splitBothWays[row][column - 1] && splitBothWays[row + 1][column]) ||
                        (ShouldCheckNE(row, column, rows, columns) && splitBothWays[row][column + 1] && splitBothWays[row - 1][column])
                        )
                    {
                        corners.Add(new Point(column, row));
                    }
                    if (ShouldCheckCrossing(row, column, rows, columns) && new[] { splitBothWays[row - 1][column], splitBothWays[row + 1][column], splitBothWays[row][column - 1], splitBothWays[row][column + 1] }.Count(_ => _) == 1)
                    {
                        ends.Add(new Point(column, row));
                        continue;
                    }
                }
            }

            /*Console.WriteLine(crossings.Select(_ => _.x * _.y).Sum());
            *  Console.WriteLine("crossings");
            *  Console.WriteLine(string.Join(Environment.NewLine, crossings));
            *  Console.WriteLine("corners");
            *  Console.WriteLine(string.Join(Environment.NewLine, corners));
            *  Console.WriteLine("ends");
            *  Console.WriteLine(string.Join(Environment.NewLine, ends));*/

            var lines = new List <Line>();

            Console.WriteLine("lines");
            var point1   = new Point(x: 8, y: 18);
            var lastLine = new Line(new Point(0, 0), new Point(0, 1));

            while (corners.Count() > 0)
            {
                var possibleLines = corners.Where(_ => _.x == point1.x || _.y == point1.y).Select(_ => new Line(point1, _)).Where(_ => _.IsHorizontal != lastLine.IsHorizontal);


                Line item = possibleLines.OrderBy(_ => _.Length).First(_ => splitBothWays[_.NextToA.y][_.NextToA.x]);
                Console.WriteLine(item);
                lines.Add(item);
                point1 = item.b;
                corners.Remove(point1);
                lastLine = item;
            }

            lines.Add(new Line(point1, new Point(22, 14)));

            Console.WriteLine(string.Join(Environment.NewLine, lines));
            input[0] = 2;
            string commands  = "A,A,B,C,A,C,B,C,A,B\nL,4,L,10,L,6\nL,6,L,4,R,8,R,8\nL,6,R,8,L,10,L,8,L,8\ny\n";
            var    computer2 = new Computer(input, new Stringinput(commands), new StreamOutput(Console.Out));

            Console.Read();
            Console.Clear();

            computer2.Wait().GetAwaiter().GetResult();
        }