2022 day 10

Author: pvainio

2022/go/day10/day10.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	input, _ := os.ReadFile("../../input/day10.txt")
+	program := parseProgram(string(input))
+
+	fmt.Printf("part1 : %d\n", part1(program))
+	fmt.Printf("part2 :\n")
+	part2(program)
+}
+
+func part2(program []instruction) {
+	for cycle := 1; cycle <= 6*40; cycle++ {
+		sprite := getState(cycle, program).x
+		pos := (cycle - 1) % 40
+		if pos >= sprite-1 && pos <= sprite+1 {
+			fmt.Print("#")
+		} else {
+			fmt.Print(" ")
+		}
+		if cycle%40 == 0 {
+			fmt.Print("\n")
+		}
+	}
+}
+
+func part1(program []instruction) (sum int) {
+	for _, cycle := range []int{20, 60, 100, 140, 180, 220} {
+		sum += cycle * getState(cycle, program).x
+	}
+	return sum
+}
+
+func getState(atCycle int, program []instruction) state {
+	state := state{x: 1}
+	cycle := 1
+	for _, inst := range program {
+		cycles, new := run(inst, state)
+		cycle = cycle + cycles
+		if cycle > atCycle {
+			break
+		}
+		state = new
+	}
+	return state
+}
+
+func run(i instruction, old state) (int, state) {
+	switch i.op {
+	case "noop":
+		return 1, old
+	case "addx":
+		return 2, state{x: old.x + i.v}
+	}
+	panic("error")
+}
+
+type state struct {
+	x int
+}
+
+type instruction struct {
+	op string
+	v  int
+}
+
+func parseProgram(input string) (program []instruction) {
+	lines := strings.Split(input, "\n")
+	for _, line := range lines {
+		var i instruction
+		fmt.Sscanf(line, "%s %d", &i.op, &i.v)
+		program = append(program, i)
+	}
+	return program
+}

2022/input/day10.txt

@@ -0,0 +1,145 @@
+noop
+noop
+noop
+addx 6
+noop
+addx 30
+addx -26
+noop
+addx 5
+noop
+noop
+noop
+noop
+addx 5
+addx -5
+addx 6
+addx 5
+addx -1
+addx 5
+noop
+noop
+addx -14
+addx -18
+addx 39
+addx -39
+addx 25
+addx -22
+addx 2
+addx 5
+addx 2
+addx 3
+addx -2
+addx 2
+noop
+addx 3
+addx 2
+addx 2
+noop
+addx 3
+noop
+addx 3
+addx 2
+addx 5
+addx 4
+addx -18
+addx 17
+addx -38
+addx 5
+addx 2
+addx -5
+addx 27
+addx -19
+noop
+addx 3
+addx 4
+noop
+noop
+addx 5
+addx -1
+noop
+noop
+addx 4
+addx 5
+addx 2
+addx -4
+addx 5
+noop
+addx -11
+addx 16
+addx -36
+noop
+addx 5
+noop
+addx 28
+addx -23
+noop
+noop
+noop
+addx 21
+addx -18
+noop
+addx 3
+addx 2
+addx 2
+addx 5
+addx 1
+noop
+noop
+addx 4
+noop
+noop
+noop
+noop
+noop
+addx 8
+addx -40
+noop
+addx 7
+noop
+addx -2
+addx 5
+addx 2
+addx 25
+addx -31
+addx 9
+addx 5
+addx 2
+addx 2
+addx 3
+addx -2
+noop
+addx 3
+addx 2
+noop
+addx 7
+addx -2
+addx 5
+addx -40
+addx 20
+addx -12
+noop
+noop
+noop
+addx -5
+addx 7
+addx 7
+noop
+addx -1
+addx 1
+addx 5
+addx 3
+addx -2
+addx 2
+noop
+addx 3
+addx 2
+noop
+noop
+noop
+noop
+addx 7
+noop
+noop
+noop
+noop

2022/java/Day10.java

@@ -0,0 +1,63 @@
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+class Day10 {
+
+    public static void main(String ... args) throws Exception {
+        var program = parseProgram(Files.readString(Path.of("../input/day10.txt")));
+        System.out.printf("part1: %d\n", part1(program));
+        System.out.printf("part2:\n%s", part2(program));
+    }
+
+    static String part2(List<Instruction> program) {
+        return IntStream.range(1, 6*40+1)
+            .mapToObj(cycle -> pixelAtCycle(cycle, program) + (cycle%40 == 0 ? "\n" : ""))
+            .collect(Collectors.joining());
+    }
+
+    static String pixelAtCycle(int cycle, List<Instruction> program) {
+        var middle = getState(cycle, program).x;
+        var sprite = Set.of(middle, middle-1, middle+1);
+        return sprite.contains((cycle-1) % 40) ? "#" : " ";
+    }
+    
+    static int part1(List<Instruction> program) {
+        return IntStream.of(20,60,100,140,180,220).map(c -> c * getState(c, program).x).sum();
+    }
+    
+    static State getState(int atCycle, List<Instruction> program) {
+        var state = new State(1, 1);
+        for (var i : program) {
+            var newState = run(i, state);
+            if (newState.cycle > atCycle) {
+                break;
+            }
+            state = newState;
+        }
+        return state;
+    }
+
+    static State run(Instruction i, State state) {
+        return switch (i.op) {
+            case "noop" -> new State(state.cycle+1, state.x);
+            case "addx" -> new State(state.cycle+2, state.x + i.value);
+            default -> throw new IllegalArgumentException("invalid operation");
+        };
+    }
+
+    static List<Instruction> parseProgram(String input) {
+        return input.lines().map(l -> Instruction.parse(l.split(" "))).toList();
+    }
+
+    record State(int cycle, int x) {}
+
+    record Instruction(String op, int value) {
+        static Instruction parse(String ... parts) {
+            return new Instruction(parts[0], parts[0].equals("noop") ? 0 : Integer.parseInt(parts[1]));
+        }
+    }
+}