part 2

2022/10/part1.js

@@ -15,49 +15,48 @@ export const sample = readInput(import.meta.url, "sample");
 export const sample2 = readInput(import.meta.url, "sample.2");
 
 export const comsys = () => {
-    let cycle = 1;
-    let register = 1;
-    const scheduled = [];
-
-    return (instr) => {
-        if( instr && (instr[0] === 'addx') ) {
-                scheduled.push(0,instr[1]);
-        } else {
-            scheduled.push(0);
-        }
-        cycle++;
-        register += scheduled.shift() ?? 0;
-        return { cycle, register };
+  let cycle = 1;
+  let register = 1;
+  const scheduled = [];
+
+  return (instr) => {
+    if (instr && instr[0] === "addx") {
+      scheduled.push(0, instr[1]);
+    } else if (instr) {
+      scheduled.push(0);
     }
-
-}
+    cycle++;
+    register += scheduled.shift() ?? 0;
+    return { cycle, register };
+  };
+};
 
 export const gatherStrength = () => {
-    let strength = 0;
-    return ({cycle, signal, register}) => {
-        if( (cycle - 20) % 40 === 0 ) {
-            strength += signal;
-        }
-        return { strength, cycle, signal, register };
+  let strength = 0;
+  return ({ cycle, signal, register }) => {
+    if ((cycle - 20) % 40 === 0) {
+      strength += signal;
     }
-}
+    return { strength, cycle, signal, register };
+  };
+};
 
 export const addSignal = (input) => ({
-    ...input,
-    signal: input.cycle*input.register
+  ...input,
+  signal: input.cycle * input.register,
 });
 
-
 export default (instructions) => {
-    const sys = comsys();
+  const sys = comsys();
 
-    return R.pipe(
-        R.range(0,220),
-        R.map( () => sys(instructions.shift()) ),
-        R.map( addSignal ),
-        R.map( gatherStrength() ),
-        R.last,
-        R.prop('strength')
-    )
+  instructions = [...instructions];
 
+  return R.pipe(
+    R.range(0, 220),
+    R.map(() => sys(instructions.shift())),
+    R.map(addSignal),
+    R.map(gatherStrength()),
+    R.last,
+    R.prop("strength")
+  );
 };

2022/10/part2.js

@@ -1,13 +1,35 @@
 import * as R from "remeda";
-import { comsys  } from './part1.js';
 
+export const comsys = () => {
+  let cycle = 0;
+  let register = 1;
+  const scheduled = [];
 
-export default (instructions) => {
-    const sys = comsys();
+  return (instr) => {
+    if (instr && instr[0] === "addx") {
+      scheduled.push(0, instr[1]);
+    } else if (instr) {
+      scheduled.push(0);
+    }
+    cycle++;
+    register += scheduled.shift() ?? 0;
+    return { cycle, register };
+  };
+};
 
-    return R.pipe(
-        R.range(0,3),
-        R.map( () => sys(instructions.shift()) ),
-    )
+const toPixel = (entry, i) => {
+  if (entry.register >= i - 1 && entry.register <= i + 1) return "#";
+  else return ".";
+};
+
+export default (instructions) => {
+  const sys = comsys();
 
+  instructions = [...instructions];
+  return R.pipe(
+    [sys(), ...R.range(0, 239).map(() => sys(instructions.shift()))],
+    R.chunk(40),
+    R.map((line) => line.map(toPixel).join("") + "\n"),
+    (lines) => lines.join("")
+  );
 };

2022/10/puzzle.md

@@ -1,5 +1,4 @@
-\--- Day 10: Cathode-Ray Tube ---
-----------
+## \--- Day 10: Cathode-Ray Tube ---
 
 You avoid the ropes, plunge into the river, and swim to shore.
 
@@ -7,12 +6,12 @@ The Elves yell something about meeting back up with them upriver, but the river
 
 Situations like this must be why the Elves prioritized getting the communication system on your handheld device working. You pull it out of your pack, but the amount of water slowly draining from a big crack in its screen tells you it probably won't be of much immediate use.
 
-*Unless*, that is, you can design a replacement for the device's video system! It seems to be some kind of [cathode-ray tube](https://en.wikipedia.org/wiki/Cathode-ray_tube) screen and simple CPU that are both driven by a precise *clock circuit*. The clock circuit ticks at a constant rate; each tick is called a *cycle*.
+_Unless_, that is, you can design a replacement for the device's video system! It seems to be some kind of [cathode-ray tube](https://en.wikipedia.org/wiki/Cathode-ray_tube) screen and simple CPU that are both driven by a precise _clock circuit_. The clock circuit ticks at a constant rate; each tick is called a _cycle_.
 
 Start by figuring out the signal being sent by the CPU. The CPU has a single register, `X`, which starts with the value `1`. It supports only two instructions:
 
-* `addx V` takes *two cycles* to complete. *After* two cycles, the `X` register is increased by the value `V`. (`V` can be negative.)
-* `noop` takes *one cycle* to complete. It has no other effect.
+- `addx V` takes _two cycles_ to complete. _After_ two cycles, the `X` register is increased by the value `V`. (`V` can be negative.)
+- `noop` takes _one cycle_ to complete. It has no other effect.
 
 The CPU uses these instructions in a program (your puzzle input) to, somehow, tell the screen what to draw.
 
@@ -27,13 +26,13 @@ addx -5
 
 Execution of this program proceeds as follows:
 
-* At the start of the first cycle, the `noop` instruction begins execution. During the first cycle, `X` is `1`. After the first cycle, the `noop` instruction finishes execution, doing nothing.
-* At the start of the second cycle, the `addx 3` instruction begins execution. During the second cycle, `X` is still `1`.
-* During the third cycle, `X` is still `1`. After the third cycle, the `addx 3` instruction finishes execution, setting `X` to `4`.
-* At the start of the fourth cycle, the `addx -5` instruction begins execution. During the fourth cycle, `X` is still `4`.
-* During the fifth cycle, `X` is still `4`. After the fifth cycle, the `addx -5` instruction finishes execution, setting `X` to `-1`.
+- At the start of the first cycle, the `noop` instruction begins execution. During the first cycle, `X` is `1`. After the first cycle, the `noop` instruction finishes execution, doing nothing.
+- At the start of the second cycle, the `addx 3` instruction begins execution. During the second cycle, `X` is still `1`.
+- During the third cycle, `X` is still `1`. After the third cycle, the `addx 3` instruction finishes execution, setting `X` to `4`.
+- At the start of the fourth cycle, the `addx -5` instruction begins execution. During the fourth cycle, `X` is still `4`.
+- During the fifth cycle, `X` is still `4`. After the fifth cycle, the `addx -5` instruction finishes execution, setting `X` to `-1`.
 
-Maybe you can learn something by looking at the value of the `X` register throughout execution. For now, consider the *signal strength* (the cycle number multiplied by the value of the `X` register) *during* the 20th cycle and every 40 cycles after that (that is, during the 20th, 60th, 100th, 140th, 180th, and 220th cycles).
+Maybe you can learn something by looking at the value of the `X` register throughout execution. For now, consider the _signal strength_ (the cycle number multiplied by the value of the `X` register) _during_ the 20th cycle and every 40 cycles after that (that is, during the 20th, 60th, 100th, 140th, 180th, and 220th cycles).
 
 For example, consider this larger program:
 
@@ -189,19 +188,19 @@ noop
 
 The interesting signal strengths can be determined as follows:
 
-* During the 20th cycle, register `X` has the value `21`, so the signal strength is 20 \* 21 = *420*. (The 20th cycle occurs in the middle of the second `addx -1`, so the value of register `X` is the starting value, `1`, plus all of the other `addx` values up to that point: 1 + 15 - 11 + 6 - 3 + 5 - 1 - 8 + 13 + 4 = 21.)
-* During the 60th cycle, register `X` has the value `19`, so the signal strength is 60 \* 19 = `*1140*`.
-* During the 100th cycle, register `X` has the value `18`, so the signal strength is 100 \* 18 = `*1800*`.
-* During the 140th cycle, register `X` has the value `21`, so the signal strength is 140 \* 21 = `*2940*`.
-* During the 180th cycle, register `X` has the value `16`, so the signal strength is 180 \* 16 = `*2880*`.
-* During the 220th cycle, register `X` has the value `18`, so the signal strength is 220 \* 18 = `*3960*`.
+- During the 20th cycle, register `X` has the value `21`, so the signal strength is 20 \* 21 = _420_. (The 20th cycle occurs in the middle of the second `addx -1`, so the value of register `X` is the starting value, `1`, plus all of the other `addx` values up to that point: 1 + 15 - 11 + 6 - 3 + 5 - 1 - 8 + 13 + 4 = 21.)
+- During the 60th cycle, register `X` has the value `19`, so the signal strength is 60 \* 19 = `*1140*`.
+- During the 100th cycle, register `X` has the value `18`, so the signal strength is 100 \* 18 = `*1800*`.
+- During the 140th cycle, register `X` has the value `21`, so the signal strength is 140 \* 21 = `*2940*`.
+- During the 180th cycle, register `X` has the value `16`, so the signal strength is 180 \* 16 = `*2880*`.
+- During the 220th cycle, register `X` has the value `18`, so the signal strength is 220 \* 18 = `*3960*`.
 
 The sum of these signal strengths is `*13140*`.
 
-Find the signal strength during the 20th, 60th, 100th, 140th, 180th, and 220th cycles. *What is the sum of these six signal strengths?*
+Find the signal strength during the 20th, 60th, 100th, 140th, 180th, and 220th cycles. _What is the sum of these six signal strengths?_
 
 To begin, [get your puzzle input](10/input).
 
 Answer:
 
-You can also [Shareon [Twitter](https://twitter.com/intent/tweet?text=%22Cathode%2DRay+Tube%22+%2D+Day+10+%2D+Advent+of+Code+2022&url=https%3A%2F%2Fadventofcode%2Ecom%2F2022%2Fday%2F10&related=ericwastl&hashtags=AdventOfCode) [Mastodon](javascript:void(0);)] this puzzle.
+You can also [Shareon [Twitter](https://twitter.com/intent/tweet?text=%22Cathode%2DRay+Tube%22+%2D+Day+10+%2D+Advent+of+Code+2022&url=https%3A%2F%2Fadventofcode%2Ecom%2F2022%2Fday%2F10&related=ericwastl&hashtags=AdventOfCode) [Mastodon](<javascript:void(0);>)] this puzzle.

2022/10/test.js

@@ -2,41 +2,55 @@ import { test, expect, describe } from "vitest";
 import * as R from "remeda";
 
 import { expectSolution } from "../01/main.js";
-import part1, { comsys, sample, sample2, puzzleInput, addSignal } from "./part1.js";
+import part1, {
+  comsys,
+  sample,
+  sample2,
+  puzzleInput,
+  addSignal,
+} from "./part1.js";
 import part2 from "./part2.js";
 
 describe("part 1", () => {
-    test( "comsys", () => {
-       let sys = comsys();
-        const result = sample.map( sys).map(R.prop('register'));
+  test("comsys", () => {
+    let sys = comsys();
+    const result = sample.map(sys).map(R.prop("register"));
 
-        expect(result).toEqual([1,1,4]);
-
-       sys = comsys();
-        expect(sample.map(  sys ).map(R.prop('cycle'))
-
-        ).toEqual([2,3,4] )
-
-    });
-    test( "signal strength", () => {
-        expect(addSignal({cycle: 3, register: 2})).toMatchObject({signal: 6});
-
-    });
-    test( "sample2", () => {
+    expect(result).toEqual([1, 1, 4]);
 
+    sys = comsys();
+    expect(sample.map(sys).map(R.prop("cycle"))).toEqual([2, 3, 4]);
+  });
+  test("signal strength", () => {
+    expect(addSignal({ cycle: 3, register: 2 })).toMatchObject({ signal: 6 });
+  });
+  test("sample2", () => {
     expect(part1(sample2)).toEqual(13140);
-
-    });
+  });
   test("solution", () => {
     expectSolution(part1(puzzleInput)).toEqual(15020);
   });
 });
 
-describe.only("part 2", () => {
+describe("part 2", () => {
   test("sample", () => {
-    expectSolution(part2(sample2)).toEqual("TODO");
+    expect(part2(sample2)).toEqual(`##..##..##..##..##..##..##..##..##..##..
+###...###...###...###...###...###...###.
+####....####....####....####....####....
+#####.....#####.....#####.....#####.....
+######......######......######......####
+#######.......#######.......#######.....
+`);
   });
-  test.todo("solution", () => {
-    expectSolution(part2(puzzleInput)).toEqual("TODO");
+  test("solution", () => {
+    expectSolution(part2(puzzleInput)).toEqual(
+      `####.####.#..#..##..#....###...##..###..
+#....#....#..#.#..#.#....#..#.#..#.#..#.
+###..###..#..#.#....#....#..#.#..#.#..#.
+#....#....#..#.#.##.#....###..####.###..
+#....#....#..#.#..#.#....#....#..#.#....
+####.#.....##...###.####.#....#..#.#....
+`
+    );
   });
 });