feat: Solving day2 part two

Author: truggeri

docs/day2.md

@@ -40,3 +40,24 @@ In the example above, the reports can be found safe or unsafe by checking those
 So, in this example, `2` reports are safe.
 
 Analyze the unusual data from the engineers. How many reports are safe?
+
+### Part Two
+
+The engineers are surprised by the low number of safe reports until they realize they forgot to tell you about the Problem Dampener.
+
+The Problem Dampener is a reactor-mounted module that lets the reactor safety systems tolerate a single bad level in what would otherwise be a safe report. It's like the bad level never happened!
+
+Now, the same rules apply as before, except if removing a single level from an unsafe report would make it safe, the report instead counts as safe.
+
+More of the above example's reports are now safe:
+
+* `7 6 4 2 1`: Safe without removing any level.
+* `1 2 7 8 9`: Unsafe regardless of which level is removed.
+* `9 7 6 2 1`: Unsafe regardless of which level is removed.
+* `1 3 2 4 5`: Safe by removing the second level, `3`.
+* `8 6 4 4 1`: Safe by removing the third level, `4`.
+* `1 3 6 7 9`: Safe without removing any level.
+
+Thanks to the Problem Dampener, `4` reports are actually safe!
+
+Update your analysis by handling situations where the Problem Dampener can remove a single level from unsafe reports. How many reports are now safe?

src/day2/day2.go

@@ -13,7 +13,11 @@ type level uint
 type report []level
 
 func Solve(input string) uint {
-	return solve(parseInput(input))
+	return solve(parseInput(input), 0)
+}
+
+func PartTwo(input string) uint {
+	return solve(parseInput(input), 1)
 }
 
 func parseInput(input string) []report {
@@ -33,32 +37,55 @@ func parseInput(input string) []report {
 	return result
 }
 
-func solve(input []report) uint {
+func solve(input []report, tolerance uint) uint {
 	var result uint = 0
 	for _, report := range input {
-		if isValidReport(report) {
+		if isValidReport(report, tolerance) {
 			result += 1
 		}
 	}
 	return result
 }
 
-func isValidReport(report report) bool {
+func isValidReport(report report, tolerance uint) bool {
 	if len(report) < 2 {
 		return true
 	}
 
-	prev := report[0]
+	var violations uint = 0
 	ascending := report[1] > report[0]
-	for i, level := range report {
-		if i == 0 {
-			continue
+	i := 0
+	for {
+		i++
+		if i > len(report)-1 {
+			break
 		}
 
-		if !isValidDelta(level, prev) || !isValidTrajectory(ascending, level, prev) {
-			return false
+		if !isValidDelta(report[i], report[i-1]) || !isValidTrajectory(ascending, report[i], report[i-1]) {
+			violations++
+			if violations > tolerance {
+				return false
+			}
+
+			selfRemoved := slices.Concat(report[0:i], report[i+1:])
+			valid := isValidReport(selfRemoved, tolerance-violations)
+			if valid {
+				return true
+			}
+
+			prevRemoved := slices.Concat(report[0:i-1], report[i:])
+			valid = isValidReport(prevRemoved, tolerance-violations)
+			if valid {
+				return true
+			}
+
+			if i == 1 {
+				return false
+			}
+			twoBackRemoved := slices.Concat(report[0:i-2], report[i-1:])
+			valid = isValidReport(twoBackRemoved, tolerance-violations)
+			return valid
 		}
-		prev = level
 	}
 	return true
 }

src/day2/day2_test.go

@@ -16,3 +16,64 @@ func TestSample(t *testing.T) {
 		t.Errorf("Calculated solution was not expected")
 	}
 }
+
+func TestSamplePartTwo(t *testing.T) {
+	input := `7 6 4 2 1
+1 2 7 8 9
+9 7 6 2 1
+1 3 2 4 5
+8 6 4 4 1
+1 3 6 7 9`
+	result := PartTwo(input)
+	if result != 4 {
+		t.Errorf("Calculated solution was not expected")
+	}
+}
+
+func TestPartTwoFirstTooLarge(t *testing.T) {
+	input := `1 5 6 7 8`
+	result := PartTwo(input)
+	if result != 1 {
+		t.Errorf("Calculated solution was not expected")
+	}
+}
+
+func TestPartTwoFirstThrowsTraj(t *testing.T) {
+	input := `4 5 4 3 2`
+	result := PartTwo(input)
+	if result != 1 {
+		t.Errorf("Calculated solution was not expected")
+	}
+}
+
+func TestPartTwoLastTooLarge(t *testing.T) {
+	input := `1 2 3 4 9`
+	result := PartTwo(input)
+	if result != 1 {
+		t.Errorf("Calculated solution was not expected")
+	}
+}
+
+func TestPartTwoLastThrowsTraj(t *testing.T) {
+	input := `5 4 3 2 3`
+	result := PartTwo(input)
+	if result != 1 {
+		t.Errorf("Calculated solution was not expected")
+	}
+}
+
+func TestPartTwo2ndLastTooLarge(t *testing.T) {
+	input := `9 8 7 4 5`
+	result := PartTwo(input)
+	if result != 1 {
+		t.Errorf("Calculated solution was not expected")
+	}
+}
+
+func TestPartTwo2ndLastThrowsTraj(t *testing.T) {
+	input := `5 4 3 4 1`
+	result := PartTwo(input)
+	if result != 1 {
+		t.Errorf("Calculated solution was not expected")
+	}
+}