private static void Part2(string value)
{
/*
* Now, the jumps are even stranger: after each jump, if the offset
* was three or more, instead decrease it by 1. Otherwise, increase
* it by 1 as before.
*
* Using this rule with the above example, the process now takes
* 10 steps, and the offset values after finding the exit are
* left as 2 3 2 3 -1.
*
* How many steps does it now take to reach the exit?
*/
var args = new TraverseArgs()
{
Max = 3
};
var output = new NullOutput();
Test.Verify <string, TraverseArgs, int>(output, Traverse, Input.Part2TestInput, args, Input.Part2Test1Answer);
var result = Traverse(Input.Value, args);
Write.ColorLine($"Result: {result}", ConsoleColor.Cyan);
Console.WriteLine();
}
static void Part2(string input)
{
/*
* Now, instead of considering the next digit, it wants you to consider the digit halfway
* around the circular list. That is, if your list contains 10 items, only include a digit
* in your sum if the digit 10/2 = 5 steps forward matches it.
* Fortunately, your list has an even number of elements.
*
* For example:
*
* - 1212 produces 6: the list contains 4 items, and all four digits match the digit 2 items ahead.
* - 1221 produces 0, because every comparison is between a 1 and a 2.
* - 123425 produces 4, because both 2s match each other, but no other digit has a match.
* - 123123 produces 12.
* - 12131415 produces 4.
*/
Write.ColorLine("Part 2", ConsoleColor.Yellow);
var output = new NullOutput();
Test.Verify <string, int>(output, SolvePart2, "1212", 6);
Test.Verify <string, int>(output, SolvePart2, "1221", 0);
Test.Verify <string, int>(output, SolvePart2, "123425", 4);
Test.Verify <string, int>(output, SolvePart2, "123123", 12);
Test.Verify <string, int>(output, SolvePart2, "12131415", 4);
var answer = SolvePart2(input);
Write.ColorLine($"Solution: {answer}", ConsoleColor.Cyan);
}
public void BeginDay(int day)
{
Write.ColorLine(string.Empty, ConsoleColor.Blue, ConsoleColor.Gray, true /*fillLine*/);
Write.ColorLine($"Day {day}", ConsoleColor.Blue, ConsoleColor.Gray, true /*fillLine*/);
Write.ColorLine(string.Empty, ConsoleColor.Blue, ConsoleColor.Gray, true /*fillLine*/);
Console.WriteLine();
}
public void EndDay()
{
Console.WriteLine();
Write.ColorLine(string.Empty, ConsoleColor.DarkGreen, ConsoleColor.Gray, true /*fillLine*/);
Write.ColorLine("Press any key to exit", ConsoleColor.DarkGreen, ConsoleColor.Gray, true /*fillLine*/);
Write.ColorLine(string.Empty, ConsoleColor.DarkGreen, ConsoleColor.Gray, true /*fillLine*/);
Console.ReadKey(true /*intercept*/);
}
private static void Part1()
{
/*
* The message includes a list of the offsets for each jump. Jumps are
* relative: -1 moves to the previous instruction, and 2 skips the next
* one. Start at the first instruction in the list. The goal is to
* follow the jumps until one leads outside the list.
*
* In addition, these instructions are a little strange; after each jump,
* the offset of that instruction increases by 1. So, if you come across
* an offset of 3, you would move three instructions forward, but change
* it to a 4 for the next time it is encountered.
*
* For example, consider the following list of jump offsets:
* 0
* 3
* 0
* 1
* -3
*
* Positive jumps ("forward") move downward; negative jumps move upward.
* For legibility in this example, these offset values will be written all
* on one line, with the current instruction marked in parentheses. The
* following steps would be taken before an exit is found:
*
* (0) 3 0 1 -3 - before we have taken any steps.
*
* (1) 3 0 1 -3 - jump with offset 0 (that is, don't jump at all).
* Fortunately, the instruction is then incremented
* to 1.
*
* 2 (3) 0 1 -3 - step forward because of the instruction we just
* modified. The first instruction is incremented
* again, now to 2.
*
* 2 4 0 1 (-3) - jump all the way to the end; leave a 4 behind.
*
* 2 (4) 0 1 -2 - go back to where we just were; increment -3 to -2.
*
* 2 5 0 1 -2 - jump 4 steps forward, escaping the maze.
*
* In this example, the exit is reached in 5 steps.
*
* How many steps does it take to reach the exit?
*/
var args = new TraverseArgs();
var output = new NullOutput();
Test.Verify <string, TraverseArgs, int>(output, Traverse, Input.Part1Test1Input, args, Input.Part1Test1Answer);
var result = Traverse(Input.Value, args);
Write.ColorLine($"Result: {result}", ConsoleColor.Cyan);
Console.WriteLine();
}
static void Main(string[] args)
{
Write.ColorLine("Day 5: Part 1", ConsoleColor.Cyan);
Console.WriteLine("-------", ConsoleColor.Cyan);
Part1();
Console.WriteLine();
Write.ColorLine("Day 5: Part 2", ConsoleColor.Cyan);
Console.WriteLine("-------", ConsoleColor.Cyan);
Part2(Input.Value);
Console.ReadLine();
}
public void EndTest(bool success, object result, object expected)
{
if (success)
{
Write.ColorLine("Success", ConsoleColor.Green);
}
else
{
Write.ColorLine("Failed", ConsoleColor.Red);
}
Console.WriteLine($"Result: {result}; Expected: {expected}");
}
static void Part1(string input)
{
Write.ColorLine("Part 1", ConsoleColor.Yellow);
var output = new NullOutput();
Test.Verify(output, SolveCaptcha, "1122", 3);
Test.Verify(output, SolveCaptcha, "1111", 4);
Test.Verify(output, SolveCaptcha, "1234", 0);
Test.Verify(output, SolveCaptcha, "91212129", 9);
Console.WriteLine();
var answer = SolveCaptcha(input);
Write.ColorLine($"Solution: {answer}", ConsoleColor.Cyan);
}
public void BeginPart(int part)
{
Write.ColorLine($"Part {part}", ConsoleColor.Cyan);
}
