private static int Traverse(string input, TraverseArgs args) { using (var offsets = new DelayParsedStringArray(input)) { int i = 0; int count = 0; while (true) { if (!offsets.GetItem(i, out int offset)) { return(count); } int newOffset; if (offset >= args.Max) { newOffset = offset - 1; } else { newOffset = offset + 1; } offsets.SetItem(i, newOffset); i += offset; count++; } } }
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(); }
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(); }