Part 1

To solve this problem we have to process lines / arrays / reports and determine whether our report is safe.

A safe report follows these rules:

    • The levels are either all increasing or all decreasing.
    • Any two adjacent levels differ by at least one and at most three.

Simple enough, first we determine whether we’re increasing or decreasing. Then we just iterate over the report to make sure the difference satisfies this inequality $1 <= difference <= 3$

Here’s a snippet from my solution:

def is_valid_report_v1(report: list[int], comparison: Callable) -> bool:
    """
    A report is valid if all numbers are either ascending or descending,
    and the difference between every value is at most 3 and at least 1.
    """
    i = 0
    j = 1
    N = len(report)

    # We can assume a report of 1 is valid.
    if N == 0 and N == 1:
        return True
    # A size of 2 will be valid as long as the difference is tolerable.
    # We now have an invariant that the report will have a length greater than 2.
    elif N == 2:
        difference = abs(report[i] - report[j])
        return 3 >= difference > 0

    while j < len(report):
        difference = abs(report[i] - report[j])

        if (not (3 >= difference > 0)) or (not comparison(report[i], report[j])):
            return False
        i += 1
        j += 1

    return True

After that, it’s just a matter of iterating over all the reports.

Part 2

For part 2, it gets slightly more complicated because now we can tolerate a single error within our report, as in either the difference not fitting in the inequality or it is neither ascending or descending.

In my solution, I have two similar solutions, one simpler and the other a bit more complicated.

The simple solution is to just determine whether our report would be valid if we removed one one of the indices.

    while j < N:
        difference = abs(report[i] - report[j])

        if (not (3 >= difference > 0)) or (not comparison(report[i], report[j])):

            without_i = copy.deepcopy(report)
            without_i.pop(i)

            without_j = copy.deepcopy(report)
            without_j.pop(j)

            return is_valid_report_v1(without_i, comparison) or is_valid_report_v1(
                without_j, comparison
            )

This is pretty straightforward and easy to implement.

The more complicated version uses slicing to check whether our report would be valid instead of making deep copies of the list.

    while j < N:
        difference = abs(report[i] - report[j])

        if (not (3 >= difference > 0)) or (not comparison(report[i], report[j])):

            without_i = copy.deepcopy(report)
            without_i.pop(i)

            without_j = copy.deepcopy(report)
            without_j.pop(j)

            return is_valid_report_v1(without_i, comparison) or is_valid_report_v1(
                without_j, comparison
            )

Conclusion

I think practically speaking, the first solution I came up would be acceptable but both of them are fine. Writing it in C++ was straightforward.